Example #1
0
class TestMapRegions:
    def setup(self):
        self.foo_id = 'foo_id'
        self.foo_query = 'foo'
        self.foo_name = 'Foo'
        self.foo = FeatureBuilder().set_query(self.foo_query).set_id(
            self.foo_id).set_name(self.foo_name)

        self.bar_id = 'bar_id'
        self.bar_query = 'bar'
        self.bar_name = 'Bar'
        self.bar = FeatureBuilder().set_query(self.bar_query).set_id(
            self.bar_id).set_name(self.bar_name)

        self.baz_id = 'baz_id'
        self.baz_query = 'baz'
        self.baz_name = 'Baz'
        self.baz = FeatureBuilder().set_query(self.baz_query).set_id(
            self.baz_id).set_name(self.baz_name)

    @mock.patch.object(GeocodingService, 'do_request')
    def test_boundaries(self, mock_request):
        try:
            self.make_regions().boundaries(resolution=RESOLUTION)
        except ValueError:
            pass  # response doesn't contain proper feature with ids - ignore

        mock_request.assert_called_with(
            ExplicitRequest(requested_payload=[PayloadKind.boundaries],
                            ids=[USA_ID, RUSSIA_ID],
                            resolution=_to_resolution(RESOLUTION)))

    @mock.patch.object(GeocodingService, 'do_request')
    def test_limits(self, mock_request):
        try:
            self.make_regions().limits()
        except ValueError:
            pass  # response doesn't contain proper feature with ids - ignore

        mock_request.assert_called_with(
            ExplicitRequest(requested_payload=[PayloadKind.limits],
                            ids=[USA_ID, RUSSIA_ID]))

    @mock.patch.object(GeocodingService, 'do_request')
    def test_centroids(self, mock_request):
        try:
            self.make_regions().centroids()
        except ValueError:
            pass  # response doesn't contain proper feature with ids - ignore

        mock_request.assert_called_with(
            ExplicitRequest(requested_payload=[PayloadKind.centroids],
                            ids=[USA_ID, RUSSIA_ID]))

    def test_to_dataframe(self):
        df = Regions([
            self.foo.set_query('').set_id('123').build_geocoded(),
            self.bar.set_query('').set_id('456').build_geocoded(),
        ]).to_data_frame()

        assert [self.foo.name, self.bar.name] == df[DF_REQUEST].tolist()

    def test_as_list(self):
        regions = Regions(
            [self.foo.build_geocoded(),
             self.bar.build_geocoded()]).as_list()

        assert 2 == len(regions)

        assert_region_df(self.foo, regions[0].to_data_frame())
        assert_region_df(self.bar, regions[1].to_data_frame())

    @mock.patch.object(GeocodingService, 'do_request')
    def test_df_request_when_query_is_empty_should_be_taken_from_found_name_column(
            self, mock_request):
        foo_id = '123'
        foo_name = 'foo'
        geocoding_result = Regions([
            FeatureBuilder().set_id(foo_id).set_query('').set_name(
                foo_name).build_geocoded()
        ])

        mock_request.return_value = make_success_response() \
            .set_geocoded_features(
            [
                FeatureBuilder().set_id(foo_id).set_query(foo_id).set_name(foo_name).set_centroid(GeoPoint(0, 1)).build_geocoded()
            ]
        ).build()

        df = geocoding_result.centroids()

        mock_request.assert_called_with(
            RequestBuilder() \
                .set_request_kind(RequestKind.explicit)
                .set_ids([foo_id]) \
                .set_requested_payload([PayloadKind.centroids]) \
                .build()
        )

        assert foo_name == df[DF_REQUEST][0]

    @mock.patch.object(GeocodingService, 'do_request')
    def test_df_rows_order(self, mock_request):

        geocoding_result = Regions([
            self.foo.set_query('').build_geocoded(),
            self.bar.set_query('').build_geocoded(),
            self.baz.set_query('').build_geocoded(),
        ])

        mock_request.return_value = make_success_response() \
            .set_geocoded_features(
            [
                self.foo.set_query(self.bar_id).set_centroid(GeoPoint(0, 1)).build_geocoded(),
                self.bar.set_query(self.foo_id).set_centroid(GeoPoint(0, 1)).build_geocoded(),
                self.baz.set_query(self.baz_id).set_centroid(GeoPoint(0, 1)).build_geocoded(),
            ]
        ).build()

        df = geocoding_result.centroids()

        mock_request.assert_called_with(
            RequestBuilder() \
                .set_request_kind(RequestKind.explicit) \
                .set_ids([self.foo.id, self.bar.id, self.baz.id]) \
                .set_requested_payload([PayloadKind.centroids]) \
                .build()
        )

        assert [self.foo.name, self.bar.name,
                self.baz.name] == df[DF_REQUEST].tolist()

    @mock.patch.object(GeocodingService, 'do_request')
    def test_df_rows_duplication_should_be_processed_correctly(
            self, mock_request):
        foo_id = '123'
        foo_name = 'foo'

        bar_id = '234'
        bar_name = 'bar'

        geocoding_result = Regions([
            self.foo.set_query('').build_geocoded(),
            self.bar.set_query('').build_geocoded(),
            self.foo.set_query('').build_geocoded()
        ])

        mock_request.return_value = make_success_response() \
            .set_geocoded_features(
            [
                self.foo.set_query(foo_id).set_centroid(GeoPoint(0, 1)).build_geocoded(),
                self.bar.set_query(bar_id).set_centroid(GeoPoint(0, 1)).build_geocoded()
            ]
        ).build()

        df = geocoding_result.centroids()

        mock_request.assert_called_with(
            RequestBuilder() \
                .set_request_kind(RequestKind.explicit) \
                .set_ids([self.foo.id, self.bar.id]) \
                .set_requested_payload([PayloadKind.centroids]) \
                .build()
        )

        assert [self.foo.name, self.bar.name,
                self.foo.name] == df[DF_REQUEST].tolist()

    def test_plot_should_has_meta_map_for_georeference(self):
        plotSpec = ggplot() + geom_polygon(map=self.make_regions())

        expected_map_data_meta = {'georeference': {}}

        assert expected_map_data_meta == get_map_data_meta(plotSpec, 0)

    def make_regions(self) -> Regions:
        regions = Regions([
            make_region(USA_REQUEST, USA_NAME, USA_ID, USA_HIGHLIGHTS),
            make_region(RUSSIA_REQUEST, RUSSIA_NAME, RUSSIA_ID,
                        RUSSIA_HIGHLIGHTS)
        ])
        return regions
Example #2
0
class TestMapRegions:

    def setup(self):
        self.foo_id = 'foo_id'
        self.foo_query = 'foo'
        self.foo_name = 'Foo'
        self.foo = FeatureBuilder().set_query(self.foo_query).set_id(self.foo_id).set_name(self.foo_name)

        self.bar_id = 'bar_id'
        self.bar_query = 'bar'
        self.bar_name = 'Bar'
        self.bar = FeatureBuilder().set_query(self.bar_query).set_id(self.bar_id).set_name(self.bar_name)

        self.baz_id = 'baz_id'
        self.baz_query = 'baz'
        self.baz_name = 'Baz'
        self.baz = FeatureBuilder().set_query(self.baz_query).set_id(self.baz_id).set_name(self.baz_name)

    @mock.patch.object(GeocodingService, 'do_request')
    def test_boundaries(self, mock_request):
        try:
            self.make_regions().boundaries(resolution=RESOLUTION)
        except ValueError:
            pass  # response doesn't contain proper feature with ids - ignore

        mock_request.assert_called_with(
            ExplicitRequest(
                requested_payload=[PayloadKind.boundaries],
                ids=[USA_ID, RUSSIA_ID],
                resolution=_coerce_resolution(RESOLUTION)
            )
        )

    @pytest.mark.parametrize('str,expected', [
        pytest.param('city', Resolution.city_medium),
        pytest.param('county', Resolution.county_medium),
        pytest.param('state', Resolution.state_medium),
        pytest.param('country', Resolution.country_medium),
        pytest.param('world', Resolution.world_medium),
        pytest.param('city_high', Resolution.city_high)
    ])
    def test_parse_resolution(self, str, expected):
        assert expected == _parse_resolution(str)

    @mock.patch.object(GeocodingService, 'do_request')
    def test_limits(self, mock_request):
        try:
            self.make_regions().limits()
        except ValueError:
            pass  # response doesn't contain proper feature with ids - ignore

        mock_request.assert_called_with(
            ExplicitRequest(
                requested_payload=[PayloadKind.limits],
                ids=[USA_ID, RUSSIA_ID]
            )
        )

    @mock.patch.object(GeocodingService, 'do_request')
    def test_centroids(self, mock_request):
        try:
            self.make_regions().centroids()
        except ValueError:
            pass  # response doesn't contain proper feature with ids - ignore

        mock_request.assert_called_with(
            ExplicitRequest(
                requested_payload=[PayloadKind.centroids],
                ids=[USA_ID, RUSSIA_ID]
            )
        )

    def test_to_dataframe(self):
        df = Regions(
            LevelKind.city,
            [
                self.foo.set_query('').set_id('123').build_geocoded(),
                self.bar.set_query('').set_id('456').build_geocoded(),
            ]
        ).to_data_frame()

        assert [self.foo.name, self.bar.name] == df[DF_REQUEST].tolist()

    def test_as_list(self):
        regions = Regions(
            LevelKind.city,
            [
                self.foo.build_geocoded(),
                self.bar.build_geocoded()
            ]
        ).as_list()

        assert 2 == len(regions)

        assert_region_df(self.foo, regions[0].to_data_frame())
        assert_region_df(self.bar, regions[1].to_data_frame())

    @mock.patch.object(GeocodingService, 'do_request')
    def test_df_request_when_query_is_empty_should_be_taken_from_found_name_column(self, mock_request):
        foo_id = '123'
        foo_name = 'foo'
        geocoding_result = Regions(
            LevelKind.city,
            [
                FeatureBuilder().set_id(foo_id).set_query('').set_name(foo_name).build_geocoded()
            ]
        )

        mock_request.return_value = make_success_response() \
            .set_geocoded_features(
            [
                FeatureBuilder().set_id(foo_id).set_query(foo_id).set_name(foo_name).set_centroid(
                    GeoPoint(0, 1)).build_geocoded()
            ]
        ).build()

        df = geocoding_result.centroids()

        mock_request.assert_called_with(
            RequestBuilder() \
                .set_request_kind(RequestKind.explicit)
                .set_ids([foo_id]) \
                .set_requested_payload([PayloadKind.centroids]) \
                .build()
        )

        assert foo_name == df[DF_REQUEST][0]

    @mock.patch.object(GeocodingService, 'do_request')
    def test_df_rows_order(self, mock_request):

        geocoding_result = Regions(
            LevelKind.city,
            [
                self.foo.set_query('').build_geocoded(),
                self.bar.set_query('').build_geocoded(),
                self.baz.set_query('').build_geocoded(),
            ]
        )

        mock_request.return_value = make_success_response() \
            .set_geocoded_features(
            [
                self.foo.set_query(self.bar_id).set_centroid(GeoPoint(0, 1)).build_geocoded(),
                self.bar.set_query(self.foo_id).set_centroid(GeoPoint(0, 1)).build_geocoded(),
                self.baz.set_query(self.baz_id).set_centroid(GeoPoint(0, 1)).build_geocoded(),
            ]
        ).build()

        df = geocoding_result.centroids()

        mock_request.assert_called_with(
            RequestBuilder() \
                .set_request_kind(RequestKind.explicit) \
                .set_ids([self.foo.id, self.bar.id, self.baz.id]) \
                .set_requested_payload([PayloadKind.centroids]) \
                .build()
        )

        assert [self.foo.name, self.bar.name, self.baz.name] == df[DF_REQUEST].tolist()

    @mock.patch.object(GeocodingService, 'do_request')
    def test_df_rows_duplication_should_be_processed_correctly(self, mock_request):
        foo_id = '123'
        foo_name = 'foo'

        bar_id = '234'
        bar_name = 'bar'

        geocoding_result = Regions(
            LevelKind.city,
            [
                self.foo.set_query('').build_geocoded(),
                self.bar.set_query('').build_geocoded(),
                self.foo.set_query('').build_geocoded()
            ]
        )

        mock_request.return_value = make_success_response() \
            .set_geocoded_features(
            [
                self.foo.set_query(foo_id).set_centroid(GeoPoint(0, 1)).build_geocoded(),
                self.bar.set_query(bar_id).set_centroid(GeoPoint(0, 1)).build_geocoded()
            ]
        ).build()

        df = geocoding_result.centroids()

        mock_request.assert_called_with(
            RequestBuilder() \
                .set_request_kind(RequestKind.explicit) \
                .set_ids([self.foo.id, self.bar.id]) \
                .set_requested_payload([PayloadKind.centroids]) \
                .build()
        )

        assert [self.foo.name, self.bar.name, self.foo.name] == df[DF_REQUEST].tolist()

    # python invokes geocoding functions when Regions objects detected in map
    # changed from previous version, where client invoked these functions
    @mock.patch.object(GeocodingService, 'do_request')
    def test_plot_should_have_geometries_when_regions_in_map_parameter(self, mock_request):

        mock_request.return_value = make_success_response() \
            .set_geocoded_features(
            [
                FeatureBuilder() \
                    .set_query(USA_REQUEST) \
                    .set_id(USA_ID) \
                    .set_name(USA_NAME) \
                    .set_boundary(GeoPoint(0, 1))
                    .build_geocoded(),
                FeatureBuilder() \
                    .set_query(RUSSIA_REQUEST) \
                    .set_id(RUSSIA_ID) \
                    .set_name(RUSSIA_NAME) \
                    .set_boundary(GeoPoint(0, 1))
                    .build_geocoded()

            ]
        ).build()

        plotSpec = ggplot() + geom_polygon(map=self.make_regions())

        # previous behaviour
        # expected_map_data_meta = {
        #    'georeference': {}
        # }

        expected_map_data_meta = {
            'geodataframe': {'geometry': 'geometry'}
        }

        assert expected_map_data_meta == get_map_data_meta(plotSpec, 0)

    def make_regions(self) -> Regions:
        regions = Regions(
            LevelKind.country,
            [
                make_region(USA_REQUEST, USA_NAME, USA_ID, USA_HIGHLIGHTS),
                make_region(RUSSIA_REQUEST, RUSSIA_NAME, RUSSIA_ID, RUSSIA_HIGHLIGHTS)
            ]
        )
        return regions