Exemple #1
0
        public async Task GetNearSitesAsync_Success()
        {
            // Arrange
            var helper  = new TestHelper();
            var options = Options.Create(new GeocoderOptions()
            {
                Key = "test"
            });
            var mockRequestClient = new Mock <IHttpRequestClient>();
            var features          = new FeatureCollectionModel()
            {
                Type = "Feature"
            };
            var response      = new HttpResponseMessage(HttpStatusCode.OK);
            var clientFactory = helper.CreateHttpClientFactory(response);

            mockRequestClient.Setup(m => m.Client).Returns(clientFactory.CreateClient());
            mockRequestClient.Setup(m => m.GetAsync <FeatureCollectionModel>(It.IsAny <string>())).ReturnsAsync(features);
            var service    = helper.Create <GeocoderService>(options, mockRequestClient.Object);
            var parameters = new NearParameters()
            {
                Point = "123,456"
            };

            // Act
            var result = await service.GetNearSitesAsync(parameters);

            // Assert
            var url = "https://geocoder.api.gov.bc.ca/sites/near.json?maxResults=5&point=123,456&excludeUnits=false&onlyCivic=false&outputSRS=4326&locationDescriptor=any&setBack=0&brief=false";

            result.Should().NotBeNull();
            mockRequestClient.Verify(m => m.GetAsync <FeatureCollectionModel>(url), Times.Once());
            result.Should().Be(features);
        }
Exemple #2
0
        public async Task GetSiteAddressesAsync_StringAddress_Success()
        {
            // Arrange
            var helper  = new TestHelper();
            var options = Options.Create(new GeocoderOptions()
            {
                Sites =
                {
                    AddressesUrl = "/addresses"
                },
                Key = "test"
            });
            var mockRequestClient = new Mock <IHttpRequestClient>();
            var features          = new FeatureCollectionModel()
            {
                Type = "Feature"
            };
            var response      = new HttpResponseMessage(HttpStatusCode.OK);
            var clientFactory = helper.CreateHttpClientFactory(response);

            mockRequestClient.Setup(m => m.Client).Returns(clientFactory.CreateClient());
            mockRequestClient.Setup(m => m.GetAsync <FeatureCollectionModel>(It.IsAny <string>())).ReturnsAsync(features);
            var service = helper.Create <GeocoderService>(options, mockRequestClient.Object);

            // Act
            var result = await service.GetSiteAddressesAsync("address");

            // Assert
            var url = "https://geocoder.api.gov.bc.ca/addresses?ver=1.2&addressString=address&maxResults=5&interpolation=adaptive&echo=false&autoComplete=false&minScore=0&maxDistance=0&extrapolate=false&outputSRS=4326&locationDescriptor=any&setBack=0&brief=false";

            result.Should().NotBeNull();
            mockRequestClient.Verify(m => m.GetAsync <FeatureCollectionModel>(url), Times.Once());
            result.Should().Be(features);
        }
        public async void FindAddressesAsync_Success()
        {
            // Arrange
            var helper     = new TestHelper();
            var controller = helper.CreateController <GeocoderController>(Permissions.PropertyEdit);

            var addresses = new FeatureCollectionModel()
            {
                Features = new[]
                {
                    new FeatureModel()
                    {
                        Properties = new PropertyModel()
                        {
                            Score        = 1,
                            SiteID       = "test",
                            FullAddress  = "test",
                            ProvinceCode = "test",
                            CivicNumber  = "test",
                            StreetName   = "test",
                            LocalityName = "test",
                            LocalityType = "City"
                        },
                        Geometry = new GeometryModel()
                        {
                            Coordinates = new [] { 2d, 1d }
                        }
                    }
                }
            };

            var service = helper.GetService <Mock <IGeocoderService> >();

            service.Setup(m => m.GetSiteAddressesAsync(It.IsAny <AddressesParameters>(), It.IsAny <string>())).ReturnsAsync(addresses);

            // Act
            var result = await controller.FindAddressesAsync("test");

            // Assert
            JsonResult actionResult = Assert.IsType <JsonResult>(result);
            var        results      = Assert.IsAssignableFrom <IEnumerable <Model.AddressModel> >(actionResult.Value);

            results.Should().HaveCount(1);
            var first = results.First();

            first.Score.Should().Be(1);
            first.SiteId.Should().Be("test");
            first.FullAddress.Should().Be("test");
            first.ProvinceCode.Should().Be("test");
            first.Address1.Should().Be("test test");
            first.Latitude.Should().Be(1d);
            first.Longitude.Should().Be(2d);
        }