public async Task ImageUploadService_SendFails()
        {
            base.ClearAll();

            string       comment = _fixture.Create <string>();
            List <Image> photos  = _fixture.CreateMany <Image>().ToList();

            var imageUploadService = _fixture.Create <ImageUploadService>();

            MobileData mobileData = _fixture.Create <MobileData>();
            Driver     driver     = _fixture.Create <Driver>();

            var response = new Core.HttpResult <HttpResponseMessage>
            {
                StatusCode = System.Net.HttpStatusCode.InternalServerError,
            };

            _mockHttpService.Setup(mhs => mhs.SendAsyncPlainResponse <HttpResponseMessage>(It.IsAny <HttpRequestMessage>())).ReturnsAsync(response);

            await imageUploadService.SendPhotoAndCommentAsync(comment, photos, driver.ID, driver.DisplayName, null);

            _mockConfigRepo.Verify(mcr => mcr.GetAsync(), Times.Once);

            _mockGpsService.Verify(mgs => mgs.GetLongitude(), Times.Exactly(3));
            _mockGpsService.Verify(mgs => mgs.GetLatitude(), Times.Exactly(3));

            //This only gets logged when it has been successfully uploaded
            _mockUserInteraction.Verify(mui => mui.AlertAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()), Times.Once);

            _mockToast.Verify(mt => mt.Show(It.IsAny <string>()), Times.Once);
        }
        protected override void AdditionalSetup()
        {
            _fixture = new Fixture().Customize(new AutoMoqCustomization());
            _fixture.Register <IReachability>(() => Mock.Of <IReachability>(r => r.IsConnected() == true));
            _mockMobileConfig = _fixture.Build <MWFMobileConfig>().With(m => m.HEUrl, "http://demo.proteoenterprise.co.uk").Create <MWFMobileConfig>();

            _mockGpsService = _fixture.InjectNewMock <IGpsService>();
            _mockGpsService.Setup(mgs => mgs.GetLatitude()).Returns(1);
            _mockGpsService.Setup(mgs => mgs.GetLongitude()).Returns(2);

            _mockConfigRepo = _fixture.InjectNewMock <IConfigRepository>();
            _mockConfigRepo.Setup(mcr => mcr.GetAsync()).ReturnsAsync(_mockMobileConfig);

            _fixture.Inject <IRepositories>(_fixture.Create <Repositories>());

            var response = new Core.HttpResult <HttpResponseMessage>
            {
                StatusCode = System.Net.HttpStatusCode.OK,
            };

            _mockHttpService = _fixture.InjectNewMock <Core.Services.IHttpService>();
            _mockHttpService.Setup(mhs => mhs.SendAsyncPlainResponse <HttpResponseMessage>(It.IsAny <HttpRequestMessage>())).ReturnsAsync(response);

            _mockLoggingService = _fixture.InjectNewMock <ILoggingService>();

            _mockUserInteraction = Ioc.RegisterNewMock <ICustomUserInteraction>();

            _mockToast = Ioc.RegisterNewMock <IToast>();
        }
        protected override void AdditionalSetup()
        {
            _queueItems = new List <Core.Models.GatewayQueueItem>();
            _mockQueueItemRepository = new Mock <Core.Repositories.IGatewayQueueItemRepository>();
            _mockQueueItemRepository.Setup(m => m.GetAllInQueueOrderAsync()).ReturnsAsync(_queueItems);

            _mockQueueItemRepository.Setup(m => m.InsertAsync(It.IsAny <Core.Models.GatewayQueueItem>()))
            .Callback <Core.Models.GatewayQueueItem>(gqi => _queueItems.Add(gqi))
            .Returns(Task.FromResult(0));

            _mockQueueItemRepository.Setup(m => m.DeleteAsync(It.IsAny <Core.Models.GatewayQueueItem>()))
            .Callback <Core.Models.GatewayQueueItem>(gqi => _queueItems.Remove(gqi))
            .Returns(Task.FromResult(0));

            _fixture = new Fixture().Customize(new AutoMoqCustomization());


            IDeviceRepository repo  = Mock.Of <IDeviceRepository>(dr => dr.GetAllAsync() == Task.FromResult(_fixture.CreateMany <Device>()));
            IRepositories     repos = Mock.Of <IRepositories>(r => r.DeviceRepository == repo &&
                                                              r.GatewayQueueItemRepository == _mockQueueItemRepository.Object);

            _fixture.Register <IRepositories>(() => repos);

            // Mock a success response from the BlueSphere MWF Mobile gateway service
            var responseActions = new[] { new Core.Models.GatewayServiceResponse.ResponseAction {
                                              Ack = true
                                          } };

            var response = new Core.HttpResult <Core.Models.GatewayServiceResponse.Response>
            {
                StatusCode = System.Net.HttpStatusCode.Accepted,
                Content    = new Core.Models.GatewayServiceResponse.Response {
                    Actions = responseActions
                },
            };

            var mockHttpService = new Mock <Core.Services.IHttpService>();

            mockHttpService.Setup(m => m.PostJsonAsync <Core.Models.GatewayServiceResponse.Response>(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(response);
            _fixture.Register <Core.Services.IHttpService>(() => mockHttpService.Object);

            _fixture.Register <Core.Services.IDeviceInfo>(() => Mock.Of <Core.Services.IDeviceInfo>());

            var messenger = new MvxMessengerHub();

            _fixture.Register <IMvxMessenger>(() => messenger);

            // We don't have the GatewayQueueTimerService so replicate the trigger -> publish elapsed message functionality
            _token = messenger.Subscribe <GatewayQueueTimerCommandMessage>(m =>
            {
                if (m.Command == GatewayQueueTimerCommandMessage.TimerCommand.Trigger)
                {
                    messenger.Publish(new GatewayQueueTimerElapsedMessage(this));
                }
            });
        }
Beispiel #4
0
        public async Task GatewayService_GetDriversReturnsList()
        {
            base.ClearAll();

            var testDriverID = Guid.NewGuid();

            // Mimic the response that comes back from the MWF Mobile gateway service
            var responseActions = new[]
            {
                new Core.Models.GatewayServiceResponse.ResponseAction <Core.Models.GatewayServiceResponse.Drivers>
                {
                    Ack  = true,
                    Data = new Core.Models.GatewayServiceResponse.Drivers
                    {
                        List = new List <Core.Models.Driver> {
                            new Core.Models.Driver {
                                ID = testDriverID
                            }
                        }
                    }
                }
            };

            var response = new Core.HttpResult <Core.Models.GatewayServiceResponse.Response <Core.Models.GatewayServiceResponse.Drivers> >
            {
                StatusCode = System.Net.HttpStatusCode.Accepted,
                Content    = new Core.Models.GatewayServiceResponse.Response <Core.Models.GatewayServiceResponse.Drivers> {
                    Actions = responseActions
                },
            };

            var mockHttpService = new Mock <Core.Services.IHttpService>();

            mockHttpService.Setup(m => m.PostAsJsonAsync <Core.Models.GatewayServiceRequest.Content, Core.Models.GatewayServiceResponse.Response <Core.Models.GatewayServiceResponse.Drivers> >(It.IsAny <Core.Models.GatewayServiceRequest.Content>(), It.IsAny <string>())).ReturnsAsync(response);
            _fixture.Inject <Core.Services.IHttpService>(mockHttpService.Object);

            var service = _fixture.Create <Core.Services.GatewayService>();
            var drivers = await service.GetDriversAsync();

            Assert.Equal(drivers.Count(), 1);
            Assert.Equal(drivers.First().ID, testDriverID);
        }