예제 #1
0
    def test_remove(self):
        area = CellAreaFactory()
        self.session.flush()

        self.area_queue.enqueue([area.hashkey()])
        self.assertEqual(scan_areas.delay().get(), 1)
        self.assertEqual(self.session.query(CellArea).count(), 0)
예제 #2
0
    def test_update(self, celery, session):
        area = CellAreaFactory(radio=Radio.gsm, num_cells=1)
        area.region = None
        BlueShardFactory.create_batch(2, region='CA')
        BlueShardFactory.create_batch(3, region='GB')
        CellAreaFactory(radio=Radio.gsm, region='DE', num_cells=1)
        CellAreaFactory(radio=Radio.gsm, region='DE', num_cells=2)
        CellAreaFactory(radio=Radio.gsm, region='CA', num_cells=2)
        CellAreaFactory(radio=Radio.wcdma, region='DE', num_cells=3)
        CellAreaFactory(radio=Radio.lte, region='CA', num_cells=4)
        WifiShardFactory.create_batch(5, region='DE')
        WifiShardFactory.create_batch(6, region='US')
        wifi = WifiShardFactory()
        wifi.region = None
        session.add(RegionStat(region='US', blue=1, wifi=2))
        session.add(RegionStat(region='TW', wifi=1))
        session.flush()

        update_statregion.delay().get()
        stats = session.query(RegionStat).all()
        assert len(stats) == 4

        for stat in stats:
            values = (stat.gsm, stat.wcdma, stat.lte, stat.blue, stat.wifi)
            if stat.region == 'DE':
                assert values == (3, 3, 0, 0, 5)
            elif stat.region == 'CA':
                assert values == (2, 0, 4, 2, 0)
            elif stat.region == 'GB':
                assert values == (0, 0, 0, 3, 0)
            elif stat.region == 'US':
                assert values == (0, 0, 0, 0, 6)
예제 #3
0
    def test_update(self):
        area = CellAreaFactory(radio=Radio.gsm, num_cells=1)
        area.region = None
        CellAreaFactory(radio=Radio.gsm, region='DE', num_cells=1)
        CellAreaFactory(radio=Radio.gsm, region='DE', num_cells=2)
        CellAreaFactory(radio=Radio.gsm, region='CA', num_cells=2)
        CellAreaFactory(radio=Radio.wcdma, region='DE', num_cells=3)
        CellAreaFactory(radio=Radio.lte, region='CA', num_cells=4)
        WifiShardFactory.create_batch(5, region='DE')
        WifiShardFactory.create_batch(6, region='US')
        wifi = WifiShardFactory()
        wifi.region = None
        self.session.add(RegionStat(region='US', wifi=2))
        self.session.add(RegionStat(region='TW', wifi=1))
        self.session.flush()

        update_statregion.delay().get()
        stats = self.session.query(RegionStat).all()
        self.assertEqual(len(stats), 3)

        for stat in stats:
            values = (stat.gsm, stat.wcdma, stat.lte, stat.wifi)
            if stat.region == 'DE':
                self.assertEqual(values, (3, 3, 0, 5))
            elif stat.region == 'CA':
                self.assertEqual(values, (2, 0, 4, 0))
            elif stat.region == 'US':
                self.assertEqual(values, (0, 0, 0, 6))
예제 #4
0
    def test_smallest_area(self):
        area = CellAreaFactory(radius=25000)
        area2 = CellAreaFactory(radius=30000, lat=area.lat + 0.2)
        self.session.flush()

        query = self.model_query(cells=[area, area2])
        result = self.source.search(query)
        self.check_model_result(result, area)
예제 #5
0
    def test_scan_areas_remove(self):
        # create an orphaned lac entry
        area = CellAreaFactory()
        self.session.flush()
        self.area_queue.enqueue([area.hashkey()])

        # after scanning the orphaned record gets removed
        self.assertEqual(scan_areas.delay().get(), 1)
        areas = self.session.query(CellArea).all()
        self.assertEqual(areas, [])
예제 #6
0
    def test_smallest_area(self):
        now = util.utcnow()
        area = CellAreaFactory(radius=25000, num_cells=8)
        area2 = CellAreaFactory(radius=30000, lat=area.lat + 0.2, num_cells=6)
        self.session.flush()

        query = self.model_query(cells=[area, area2])
        results = self.source.search(query)
        self.check_model_results(results, [area])
        self.assertAlmostEqual(results.best().score, area.score(now), 4)
예제 #7
0
    def test_smallest_area(self, geoip_db, http_session, session, source):
        now = util.utcnow()
        area = CellAreaFactory(radius=25000, num_cells=8)
        area2 = CellAreaFactory(radius=30000, lat=area.lat + 0.2, num_cells=6)
        session.flush()

        query = self.model_query(geoip_db,
                                 http_session,
                                 session,
                                 cells=[area, area2])
        results = source.search(query)
        self.check_model_results(results, [area])
        assert results.best().score == area_score(area, now)
예제 #8
0
    def test_multiple_mcc(self):
        now = util.utcnow()
        region = GEOCODER.regions_for_mcc(235, metadata=True)[0]
        cell = CellAreaFactory(mcc=234, num_cells=6)
        cell2 = CellAreaFactory(mcc=235, num_cells=8)
        self.session.flush()

        query = self.model_query(cells=[cell, cell2])
        results = self.source.search(query)
        self.assertTrue(len(results) > 2)
        best_result = results.best(query.expected_accuracy)
        self.assertEqual(best_result.region_code, region.code)
        self.assertAlmostEqual(best_result.score, 1.25 + cell.score(now), 4)
예제 #9
0
    def test_multiple_mcc(self, geoip_db, http_session, session, source):
        now = util.utcnow()
        region = GEOCODER.regions_for_mcc(235, metadata=True)[0]
        area = CellAreaFactory(mcc=234, num_cells=6)
        area2 = CellAreaFactory(mcc=235, num_cells=8)
        session.flush()

        query = self.model_query(geoip_db, http_session, session, cells=[area, area2])
        results = source.search(query)
        assert len(results) > 2
        best_result = results.best()
        assert best_result.region_code == region.code
        assert best_result.score == 1.25 + area_score(area, now)
예제 #10
0
    def test_multiple_mcc(self):
        now = util.utcnow()
        region = GEOCODER.regions_for_mcc(235, metadata=True)[0]
        cell = CellAreaFactory(mcc=234, num_cells=6)
        cell2 = CellAreaFactory(mcc=235, num_cells=8)
        self.session.flush()

        query = self.model_query(cells=[cell, cell2])
        results = self.source.search(query)
        self.assertTrue(len(results) > 2)
        best_result = results.best()
        self.assertEqual(best_result.region_code, region.code)
        self.assertAlmostEqual(best_result.score, 1.25 + cell.score(now), 4)
예제 #11
0
    def test_smallest_area(self, geoip_db, http_session,
                           session, source, stats):
        now = util.utcnow()
        area = CellAreaFactory(radius=25000, num_cells=8)
        area2 = CellAreaFactory(radius=30000, lat=area.lat + 0.2, num_cells=6)
        session.flush()

        query = self.model_query(
            geoip_db, http_session, session, stats,
            cells=[area, area2])
        results = source.search(query)
        self.check_model_results(results, [area])
        assert results.best().score == area.score(now)
예제 #12
0
    def test_scan_areas_remove(self):
        session = self.session
        redis_client = self.redis_client

        # create an orphaned lac entry
        area = CellAreaFactory()
        session.flush()
        enqueue_areas(session, redis_client,
                      [area.hashkey()], UPDATE_KEY['cell_lac'])

        # after scanning the orphaned record gets removed
        self.assertEqual(scan_areas.delay().get(), 1)
        areas = session.query(CellArea).all()
        self.assertEqual(areas, [])
    def test_update(self, celery, session):
        area = CellAreaFactory(radio=Radio.gsm, num_cells=1)
        area.region = None
        BlueShardFactory.create_batch(2, region='CA')
        BlueShardFactory.create_batch(3, region='GB')
        CellAreaFactory(radio=Radio.gsm, region='DE', num_cells=1)
        CellAreaFactory(radio=Radio.gsm, region='DE', num_cells=2)
        CellAreaFactory(radio=Radio.gsm, region='CA', num_cells=2)
        CellAreaFactory(radio=Radio.wcdma, region='DE', num_cells=3)
        CellAreaFactory(radio=Radio.lte, region='CA', num_cells=4)
        WifiShardFactory.create_batch(5, region='DE')
        WifiShardFactory.create_batch(6, region='US')
        wifi = WifiShardFactory()
        wifi.region = None
        session.add(RegionStat(region='US', blue=1, wifi=2))
        session.add(RegionStat(region='TW', wifi=1))
        session.flush()

        update_statregion.delay().get()
        stats = session.query(RegionStat).all()
        assert len(stats) == 4

        for stat in stats:
            values = (stat.gsm, stat.wcdma, stat.lte, stat.blue, stat.wifi)
            if stat.region == 'DE':
                assert values == (3, 3, 0, 0, 5)
            elif stat.region == 'CA':
                assert values == (2, 0, 4, 2, 0)
            elif stat.region == 'GB':
                assert values == (0, 0, 0, 3, 0)
            elif stat.region == 'US':
                assert values == (0, 0, 0, 0, 6)
예제 #14
0
    def test_update(self):
        area = CellAreaFactory(radio=Radio.gsm, num_cells=1)
        area.region = None
        CellAreaFactory(radio=Radio.gsm, region='DE', num_cells=1)
        CellAreaFactory(radio=Radio.gsm, region='DE', num_cells=2)
        CellAreaFactory(radio=Radio.gsm, region='CA', num_cells=2)
        CellAreaFactory(radio=Radio.wcdma, region='DE', num_cells=3)
        CellAreaFactory(radio=Radio.lte, region='CA', num_cells=4)
        WifiShardFactory.create_batch(5, region='DE')
        WifiShardFactory.create_batch(6, region='US')
        wifi = WifiShardFactory()
        wifi.region = None
        self.session.add(RegionStat(region='US', wifi=2))
        self.session.add(RegionStat(region='TW', wifi=1))
        self.session.flush()

        update_statregion.delay().get()
        stats = self.session.query(RegionStat).all()
        self.assertEqual(len(stats), 3)

        for stat in stats:
            values = (stat.gsm, stat.wcdma, stat.lte, stat.wifi)
            if stat.region == 'DE':
                self.assertEqual(values, (3, 3, 0, 5))
            elif stat.region == 'CA':
                self.assertEqual(values, (2, 0, 4, 0))
            elif stat.region == 'US':
                self.assertEqual(values, (0, 0, 0, 6))
예제 #15
0
    def test_scan_areas_remove(self):
        session = self.session
        redis_client = self.redis_client

        # create an orphaned lac entry
        area = CellAreaFactory()
        session.flush()
        redis_key = self.celery_app.data_queues['cell_area_update']
        enqueue_areas(session, redis_client,
                      [area.hashkey()], redis_key)

        # after scanning the orphaned record gets removed
        self.assertEqual(scan_areas.delay().get(), 1)
        areas = session.query(CellArea).all()
        self.assertEqual(areas, [])
예제 #16
0
    def test_cellarea_with_different_fallback(self, app, session, metricsmock):
        cell = CellAreaFactory()
        session.flush()

        query = self.model_query(cells=[cell])
        query["fallbacks"] = {"ipf": True}

        res = self._call(app, body=query)
        self.check_model_response(res, cell, fallback="lacf")
        assert metricsmock.has_record(
            "incr",
            "request",
            value=1,
            tags=[self.metric_path, "method:post", "status:200"],
        )
        assert metricsmock.has_record(
            "incr",
            self.metric_type + ".request",
            value=1,
            tags=[self.metric_path, "key:test"],
        )
        assert metricsmock.has_record(
            "incr",
            self.metric_type + ".result",
            value=1,
            tags=[
                "key:test",
                "region:none",
                "fallback_allowed:false",
                "accuracy:low",
                "status:hit",
                "source:internal",
            ],
        )
예제 #17
0
    def test_cellarea_with_lacf(self, app, session, stats):
        cell = CellAreaFactory()
        session.flush()

        query = self.model_query(cells=[cell])
        query['fallbacks'] = {'lacf': True}

        res = self._call(app, body=query)
        self.check_model_response(res, cell, fallback='lacf')
        stats.check(counter=[
            ('request', [self.metric_path, 'method:post', 'status:200']),
            (self.metric_type + '.request', [self.metric_path, 'key:test']),
            (self.metric_type + '.query', [
                'key:test', 'region:none', 'geoip:false', 'blue:none',
                'cell:none', 'wifi:none'
            ]),
            (self.metric_type + '.result', [
                'key:test', 'region:none', 'fallback_allowed:false',
                'accuracy:low', 'status:hit', 'source:internal'
            ]),
            (self.metric_type + '.source', [
                'key:test', 'region:none', 'source:internal', 'accuracy:low',
                'status:hit'
            ]),
        ])
예제 #18
0
    def test_cellarea_without_lacf(self, app, data_queues, session,
                                   metricsmock):
        cell = CellAreaFactory()
        session.flush()

        query = self.model_query(cells=[cell])
        query["fallbacks"] = {"lacf": False}

        res = self._call(app, body=query, status=self.not_found.code)
        self.check_response(data_queues, res, "not_found")
        assert metricsmock.has_record(
            "incr",
            "request",
            value=1,
            tags=[
                self.metric_path, "method:post",
                "status:%s" % self.not_found.code
            ],
        )
        assert metricsmock.has_record(
            "incr",
            self.metric_type + ".request",
            value=1,
            tags=[self.metric_path, "key:test"],
        )
예제 #19
0
    def test_update(self):
        area = CellAreaFactory(num_cells=2, range=500, avg_cell_range=100)
        area_key = area.hashkey()
        cell = CellFactory(
            lat=area.lat, lon=area.lon, range=200, **area_key.__dict__)
        self.session.commit()

        self.area_queue.enqueue([area_key])
        self.assertEqual(scan_areas.delay().get(), 1)

        area = self.session.query(CellArea).one()
        self.assertAlmostEqual(area.lat, cell.lat)
        self.assertAlmostEqual(area.lon, cell.lon)
        self.assertEqual(area.range, 0)
        self.assertEqual(area.num_cells, 1)
        self.assertEqual(area.avg_cell_range, 200)
예제 #20
0
    def test_ambiguous_mcc(self, geoip_db, http_session, session, source,
                           stats):
        now = util.utcnow()
        regions = GEOCODER.regions_for_mcc(234, metadata=True)
        area = CellAreaFactory(mcc=234, num_cells=10)
        session.flush()

        query = self.model_query(geoip_db,
                                 http_session,
                                 session,
                                 stats,
                                 cells=[area])
        results = source.search(query)
        self.check_model_results(results, regions)
        assert results.best().region_code == 'GB'
        for result in results:
            score = 0.25
            if result.region_code == 'GB':
                score += area_score(area, now)
            assert result.score == score
        stats.check(counter=[
            (self.api_type + '.source', [
                'key:test', 'region:none', 'source:internal', 'accuracy:low',
                'status:hit'
            ]),
        ])
예제 #21
0
 def test_cell_area_region_no_fallback(self):
     cell = CellAreaFactory.build()
     cell_query = self.cell_model_query([cell])
     query = Query(cell=cell_query,
                   api_type='region',
                   fallback={'lacf': False})
     assert query.expected_accuracy is DataAccuracy.none
예제 #22
0
    def test_ambiguous_mcc(self, geoip_db, http_session, session, source, metricsmock):
        now = util.utcnow()
        regions = GEOCODER.regions_for_mcc(234, metadata=True)
        area = CellAreaFactory(mcc=234, num_cells=10)
        session.flush()

        query = self.model_query(geoip_db, http_session, session, cells=[area])
        results = source.search(query)
        self.check_model_results(results, regions)
        assert results.best().region_code == "GB"
        for result in results:
            score = 0.25
            if result.region_code == "GB":
                score += area_score(area, now)
            assert result.score == score
        assert metricsmock.has_record(
            "incr",
            self.api_type + ".source",
            value=1,
            tags=[
                "key:test",
                "region:none",
                "source:internal",
                "accuracy:low",
                "status:hit",
            ],
        )
예제 #23
0
    def test_cell_area_no_fallback(self):
        cell = CellAreaFactory.build()
        cell_query = self.cell_model_query([cell])
        query = Query(cell=cell_query, fallback={'lacf': False})

        self.assertEqual(len(query.cell), 0)
        self.assertEqual(len(query.cell_area), 0)
        self.assertEqual(query.expected_accuracy, DataAccuracy.none)
예제 #24
0
    def test_update_incomplete_cell(self):
        area = CellAreaFactory(range=500)
        area_key = area.hashkey()
        cell = CellFactory(
            lat=area.lat + 0.0002, lon=area.lon, **area_key.__dict__)
        CellFactory(lat=None, lon=None, **area_key.__dict__)
        CellFactory(lat=area.lat, lon=area.lon,
                    max_lat=None, min_lon=None, **area_key.__dict__)
        self.session.commit()

        self.area_queue.enqueue([area_key])
        self.assertEqual(scan_areas.delay().get(), 1)

        area = self.session.query(CellArea).one()
        self.assertAlmostEqual(area.lat, cell.lat - 0.0001)
        self.assertAlmostEqual(area.lon, cell.lon)
        self.assertEqual(area.num_cells, 2)
예제 #25
0
    def test_cell_area(self):
        cell = CellAreaFactory.build()
        cell_query = self.cell_model_query([cell])
        query = Query(cell=cell_query)

        self.assertEqual(len(query.cell), 0)
        self.assertEqual(len(query.cell_area), 1)
        self.assertEqual(query.expected_accuracy, DataAccuracy.low)
예제 #26
0
    def test_cell_area_no_fallback(self):
        cell = CellAreaFactory.build()
        cell_query = self.cell_model_query([cell])
        query = Query(cell=cell_query, fallback={'lacf': False})

        assert len(query.cell) == 0
        assert len(query.cell_area) == 0
        assert query.expected_accuracy is DataAccuracy.none
예제 #27
0
    def test_cell_area(self):
        cell = CellAreaFactory.build()
        cell_query = self.cell_model_query([cell])
        query = Query(cell=cell_query)

        self.assertEqual(len(query.cell), 0)
        self.assertEqual(len(query.cell_area), 1)
        self.assertEqual(query.expected_accuracy, DataAccuracy.low)
예제 #28
0
    def test_cell_area_no_fallback(self):
        cell = CellAreaFactory.build()
        cell_query = self.cell_model_query([cell])
        query = Query(cell=cell_query, fallback={'lacf': False})

        self.assertEqual(len(query.cell), 0)
        self.assertEqual(len(query.cell_area), 0)
        self.assertEqual(query.expected_accuracy, DataAccuracy.none)
예제 #29
0
    def test_cell_area(self):
        cell = CellAreaFactory.build()
        cell_query = self.cell_model_query([cell])
        query = Query(cell=cell_query)

        assert len(query.cell) == 0
        assert len(query.cell_area) == 1
        assert query.expected_accuracy is DataAccuracy.low
예제 #30
0
    def test_cell_area(self):
        cell = CellAreaFactory.build()
        cell_query = self.cell_model_query([cell])
        query = Query(cell=cell_query)

        assert len(query.cell) == 0
        assert len(query.cell_area) == 1
        assert query.expected_accuracy is DataAccuracy.low
        assert query.geoip_only is False
예제 #31
0
 def test_invalid_mcc(self, geoip_db, http_session,
                      session, source, stats):
     area = CellAreaFactory.build(mcc=235, num_cells=10)
     area.mcc = 999
     query = self.model_query(
         geoip_db, http_session, session, stats,
         cells=[area])
     results = source.search(query)
     self.check_model_results(results, None)
예제 #32
0
 def test_invalid_mcc(self, geoip_db, http_session, session, source, stats):
     area = CellAreaFactory.build(mcc=235, num_cells=10)
     area.mcc = 999
     query = self.model_query(geoip_db,
                              http_session,
                              session,
                              stats,
                              cells=[area])
     results = source.search(query)
     self.check_model_results(results, None)
예제 #33
0
    def test_minimum_range_returned(self):
        areas = CellAreaFactory.create_batch(2)
        areas[0].range = LAC_MIN_ACCURACY - 2000
        areas[1].range = LAC_MIN_ACCURACY + 3000
        areas[1].lat = areas[0].lat + 0.2
        self.session.flush()

        query = self.model_query(cells=areas)
        location = self.provider.locate(query)
        self.check_model_location(location, areas[0], accuracy=LAC_MIN_ACCURACY)
예제 #34
0
    def test_minimum_radius(self):
        areas = CellAreaFactory.create_batch(2)
        areas[0].radius = CELLAREA_MIN_ACCURACY - 2000
        areas[1].radius = CELLAREA_MIN_ACCURACY + 3000
        areas[1].lat = areas[0].lat + 0.2
        self.session.flush()

        query = self.model_query(cells=areas)
        results = self.source.search(query)
        self.check_model_results(
            results, [areas[0]], accuracy=CELLAREA_MIN_ACCURACY)
예제 #35
0
    def test_ambiguous_mcc(self):
        now = util.utcnow()
        regions = GEOCODER.regions_for_mcc(234, metadata=True)
        cell = CellAreaFactory(mcc=234, num_cells=10)
        self.session.flush()

        query = self.model_query(cells=[cell])
        results = self.source.search(query)
        self.check_model_results(results, regions)
        self.assertEqual(results.best().region_code, 'GB')
        for result in results:
            score = 0.25
            if result.region_code == 'GB':
                score += cell.score(now)
            self.assertAlmostEqual(result.score, score, 4)
        self.check_stats(counter=[
            (self.api_type + '.source',
                ['key:test', 'region:none', 'source:internal',
                 'accuracy:low', 'status:hit']),
        ])
예제 #36
0
    def test_minimum_radius(self, geoip_db, http_session, session, source):
        areas = CellAreaFactory.create_batch(2)
        areas[0].radius = CELLAREA_MIN_ACCURACY - 2000
        areas[1].radius = CELLAREA_MIN_ACCURACY + 3000
        areas[1].lat = areas[0].lat + 0.2
        session.flush()

        query = self.model_query(geoip_db, http_session, session, cells=areas)
        results = source.search(query)
        self.check_model_results(results, [areas[0]],
                                 accuracy=CELLAREA_MIN_ACCURACY)
예제 #37
0
    def test_incomplete_keys(self):
        cells = CellAreaFactory.build_batch(4)
        cells[0].radio = None
        cells[1].mcc = None
        cells[2].mnc = None
        cells[3].lac = None

        with self.db_call_checker() as check_db_calls:
            query = self.model_query(cells=cells)
            results = self.source.result_list()
            self.assertFalse(self.source.should_search(query, results))
            check_db_calls(rw=0, ro=0)
예제 #38
0
    def test_minimum_radius(self):
        areas = CellAreaFactory.create_batch(2)
        areas[0].radius = CELLAREA_MIN_ACCURACY - 2000
        areas[1].radius = CELLAREA_MIN_ACCURACY + 3000
        areas[1].lat = areas[0].lat + 0.2
        self.session.flush()

        query = self.model_query(cells=areas)
        result = self.source.search(query)
        self.check_model_result(
            result, areas[0],
            accuracy=CELLAREA_MIN_ACCURACY)
예제 #39
0
    def test_incomplete_keys(self):
        cells = CellAreaFactory.build_batch(4)
        cells[0].radio = None
        cells[1].mcc = None
        cells[2].mnc = None
        cells[3].lac = None

        with self.db_call_checker() as check_db_calls:
            query = self.model_query(cells=cells)
            results = self.source.result_type().new_list()
            self.assertFalse(self.source.should_search(query, results))
            check_db_calls(rw=0, ro=0)
예제 #40
0
    def test_incomplete_keys(self, geoip_db, http_session, session_tracker,
                             session, source):
        cells = CellAreaFactory.build_batch(4)
        cells[0].radio = None
        cells[1].mcc = None
        cells[2].mnc = None
        cells[3].lac = None

        query = self.model_query(geoip_db, http_session, session, cells=cells)
        results = source.result_list()
        assert not source.should_search(query, results)
        session_tracker(0)
예제 #41
0
    def test_minimum_range(self):
        areas = CellAreaFactory.create_batch(2)
        areas[0].range = LAC_MIN_ACCURACY - 2000
        areas[1].range = LAC_MIN_ACCURACY + 3000
        areas[1].lat = areas[0].lat + 0.2
        self.session.flush()

        query = self.model_query(cells=areas)
        result = self.source.search(query)
        self.check_model_result(
            result, areas[0],
            accuracy=LAC_MIN_ACCURACY)
예제 #42
0
    def test_incomplete_keys(self, geoip_db, http_session,
                             session_tracker, session, source, stats):
        cells = CellAreaFactory.build_batch(4)
        cells[0].radio = None
        cells[1].mcc = None
        cells[2].mnc = None
        cells[3].lac = None

        query = self.model_query(
            geoip_db, http_session, session, stats,
            cells=cells)
        results = source.result_list()
        assert not source.should_search(query, results)
        session_tracker(0)
    def test_cellarea_without_lacf(self, app, data_queues, session, stats):
        cell = CellAreaFactory()
        session.flush()

        query = self.model_query(cells=[cell])
        query['fallbacks'] = {'lacf': False}

        res = self._call(app, body=query, status=self.not_found.code)
        self.check_response(data_queues, res, 'not_found')
        stats.check(counter=[
            ('request', [self.metric_path, 'method:post',
                         'status:%s' % self.not_found.code]),
            (self.metric_type + '.request', [self.metric_path, 'key:test']),
        ])
예제 #44
0
    def test_from_mcc(self):
        region = GEOCODER.regions_for_mcc(235, metadata=True)[0]
        cell = CellAreaFactory(mcc=235, num_cells=10)
        self.session.flush()

        query = self.model_query(cells=[cell])
        results = self.source.search(query)
        self.check_model_results(results, [region])
        self.assertAlmostEqual(results[0].score, 1.0, 4)
        self.check_stats(counter=[
            (self.api_type + '.source',
                ['key:test', 'region:none', 'source:internal',
                 'accuracy:low', 'status:hit']),
        ])
예제 #45
0
    def test_from_mcc(self, geoip_db, http_session, session, source,
                      metricsmock):
        region = GEOCODER.regions_for_mcc(235, metadata=True)[0]
        area = CellAreaFactory(mcc=235, num_cells=10)
        session.flush()

        query = self.model_query(geoip_db, http_session, session, cells=[area])
        results = source.search(query)
        self.check_model_results(results, [region])
        assert results[0].score == 1.0
        metricsmock.assert_incr_once(
            self.api_type + ".source",
            tags=["key:test", "source:internal", "accuracy:low", "status:hit"],
        )
예제 #46
0
    def test_cellarea_with_different_fallback(self):
        cell = CellAreaFactory()
        self.session.flush()

        query = self.model_query(cells=[cell])
        query['fallbacks'] = {'ipf': True}

        res = self._call(body=query)
        self.check_model_response(res, cell, fallback='lacf')
        self.check_stats(counter=[
            ('request', [self.metric_path, 'method:post', 'status:200']),
            (self.metric_type + '.request', [self.metric_path, 'key:test']),
            (self.metric_type + '.result',
                ['key:test', 'region:none', 'fallback_allowed:false',
                 'accuracy:low', 'status:hit', 'source:internal']),
        ])
예제 #47
0
    def test_cellarea(self, app, session, metricsmock, fallback, logs):
        """
        A unknown cell in a known cell area can be a hit, with fallback enabled.

        The cell location area fallback (lacf) is on by default, or can be
        explicitly enabled.
        """
        cell = CellAreaFactory()
        session.flush()

        query = self.model_query(cells=[cell])
        if fallback == "explicit":
            query["fallbacks"] = {"lacf": True}
        elif fallback == "ipf":
            # Enabling IP fallback leaves lac fallback at default
            query["fallbacks"] = {"ipf": True}
        res = self._call(app, body=query)
        self.check_model_response(res, cell, fallback="lacf")
        metricsmock.assert_incr_once(
            "request", tags=[self.metric_path, "method:post", "status:200"])
        metricsmock.assert_incr_once(self.metric_type + ".request",
                                     tags=[self.metric_path, "key:test"])
        metricsmock.assert_incr_once(
            self.metric_type + ".query",
            tags=[
                "key:test", "geoip:false", "blue:none", "cell:none",
                "wifi:none"
            ],
        )
        metricsmock.assert_incr_once(
            self.metric_type + ".result",
            tags=[
                "key:test",
                "fallback_allowed:false",
                "accuracy:low",
                "status:hit",
                "source:internal",
            ],
        )
        metricsmock.assert_incr_once(
            self.metric_type + ".source",
            tags=["key:test", "source:internal", "accuracy:low", "status:hit"],
        )
        assert logs.only_entry["cell"] == 1
        assert logs.only_entry["cell_valid"] == 0
예제 #48
0
    def test_cellarea_without_lacf(self, app, data_queues, session,
                                   metricsmock, logs):
        """The cell location area fallback can be disabled."""
        cell = CellAreaFactory()
        session.flush()

        query = self.model_query(cells=[cell])
        query["fallbacks"] = {"lacf": False}

        res = self._call(app, body=query, status=404)
        self.check_response(data_queues, res, "not_found")
        metricsmock.assert_incr_once(
            "request", tags=[self.metric_path, "method:post", "status:404"])
        metricsmock.assert_incr_once(self.metric_type + ".request",
                                     tags=[self.metric_path, "key:test"])

        assert logs.only_entry["cell"] == 1
        assert logs.only_entry["cell_valid"] == 0
예제 #49
0
 def test_cell_area_region(self):
     cell = CellAreaFactory.build()
     cell_query = self.cell_model_query([cell])
     query = Query(cell=cell_query, api_type='region')
     self.assertEqual(query.expected_accuracy, DataAccuracy.low)
예제 #50
0
 def test_invalid_mcc(self):
     cell = CellAreaFactory.build(mcc=235, num_cells=10)
     cell.mcc = 999
     query = self.model_query(cells=[cell])
     results = self.source.search(query)
     self.check_model_results(results, None)
예제 #51
0
 def test_cell_area_region_no_fallback(self):
     cell = CellAreaFactory.build()
     cell_query = self.cell_model_query([cell])
     query = Query(cell=cell_query, api_type='region',
                   fallback={'lacf': False})
     assert query.expected_accuracy is DataAccuracy.none