def test_set_wifi_inconsistent(self): wifis1 = WifiShardFactory.build_batch(2) self.cache.set( Query(wifi=self.wifi_model_query(wifis1)), ExternalResult(wifis1[0].lat, wifis1[0].lon, 100, None)) # similar lat/lon, worse accuracy wifis2 = WifiShardFactory.build_batch( 2, lat=wifis1[0].lat + 0.0001, lon=wifis1[0].lon) self.cache.set( Query(wifi=self.wifi_model_query(wifis2)), ExternalResult(wifis2[0].lat, wifis2[0].lon, 200, None)) # check combined query, avg lat/lon, max accuracy query = Query(wifi=self.wifi_model_query(wifis1 + wifis2)) self.assertEqual( self.cache.get(query), ((wifis1[0].lat + wifis2[0].lat) / 2, wifis1[0].lon, 200, None)) # different lat/lon wifis3 = WifiShardFactory.build_batch(2, lat=wifis1[0].lat + 10.0) self.cache.set( Query(wifi=self.wifi_model_query(wifis3)), ExternalResult(wifis3[0].lat, wifis3[0].lon, 300, None)) # check combined query, inconsistent result query = Query(wifi=self.wifi_model_query(wifis1 + wifis2 + wifis3)) self.assertEqual(self.cache.get(query), None) self.check_stats(counter=[ ('locate.fallback.cache', 1, 1, ['status:hit']), ('locate.fallback.cache', 1, 1, ['status:inconsistent']), ])
def test_set_wifi_inconsistent(self): wifis1 = WifiShardFactory.build_batch(2) self.cache.set(self._query(wifi=self.wifi_model_query(wifis1)), ExternalResult(wifis1[0].lat, wifis1[0].lon, 100, None)) # similar lat/lon, worse accuracy wifis2 = WifiShardFactory.build_batch(2, lat=wifis1[0].lat + 0.0001, lon=wifis1[0].lon) self.cache.set(self._query(wifi=self.wifi_model_query(wifis2)), ExternalResult(wifis2[0].lat, wifis2[0].lon, 200, None)) # check combined query, avg lat/lon, max accuracy query = self._query(wifi=self.wifi_model_query(wifis1 + wifis2)) cached = self.cache.get(query) self.assertAlmostEqual(cached[0], (wifis1[0].lat + wifis2[0].lat) / 2) self.assertAlmostEqual(cached[1], wifis1[0].lon) self.assertAlmostEqual(cached[2], 205.56, 2) self.assertTrue(cached[3] is None) # different lat/lon wifis3 = WifiShardFactory.build_batch(2, lat=wifis1[0].lat + 10.0) self.cache.set(self._query(wifi=self.wifi_model_query(wifis3)), ExternalResult(wifis3[0].lat, wifis3[0].lon, 300, None)) # check combined query, inconsistent result query = self._query(wifi=self.wifi_model_query(wifis1 + wifis2 + wifis3)) self.assertEqual(self.cache.get(query), None) self.check_stats(counter=[ ('locate.fallback.cache', 1, 1, ['status:hit']), ('locate.fallback.cache', 1, 1, ['status:inconsistent']), ])
def test_set_wifi_inconsistent(self, cache, stats): wifis1 = WifiShardFactory.build_batch(2) cache.set(self._query(wifi=self.wifi_model_query(wifis1)), ExternalResult(wifis1[0].lat, wifis1[0].lon, 100, None)) # similar lat/lon, worse accuracy wifis2 = WifiShardFactory.build_batch(2, lat=wifis1[0].lat + 0.0001, lon=wifis1[0].lon) cache.set(self._query(wifi=self.wifi_model_query(wifis2)), ExternalResult(wifis2[0].lat, wifis2[0].lon, 200, None)) # check combined query, avg lat/lon, max accuracy query = self._query(wifi=self.wifi_model_query(wifis1 + wifis2)) cached = cache.get(query) assert cached[0] == (wifis1[0].lat + wifis2[0].lat) / 2.0 assert cached[1] == wifis1[0].lon assert round(cached[2], 2) == 205.56 assert cached[3] is None # different lat/lon wifis3 = WifiShardFactory.build_batch(2, lat=wifis1[0].lat + 10.0) cache.set(self._query(wifi=self.wifi_model_query(wifis3)), ExternalResult(wifis3[0].lat, wifis3[0].lon, 300, None)) # check combined query, inconsistent result query = self._query(wifi=self.wifi_model_query(wifis1 + wifis2 + wifis3)) assert cache.get(query) is None stats.check(counter=[ ('locate.fallback.cache', 1, 1, ['status:hit']), ('locate.fallback.cache', 1, 1, ['status:inconsistent']), ])
def test_set_wifi_inconsistent(self, cache, metricsmock): wifis1 = WifiShardFactory.build_batch(2) cache.set( self._query(wifi=self.wifi_model_query(wifis1)), ExternalResult(wifis1[0].lat, wifis1[0].lon, 100, None), ) # similar lat/lon, worse accuracy wifis2 = WifiShardFactory.build_batch( 2, lat=wifis1[0].lat + 0.0001, lon=wifis1[0].lon ) cache.set( self._query(wifi=self.wifi_model_query(wifis2)), ExternalResult(wifis2[0].lat, wifis2[0].lon, 200, None), ) # check combined query, avg lat/lon, max accuracy query = self._query(wifi=self.wifi_model_query(wifis1 + wifis2)) cached = cache.get(query) assert cached[0] == (wifis1[0].lat + wifis2[0].lat) / 2.0 assert cached[1] == wifis1[0].lon assert round(cached[2], 2) == 205.56 assert cached[3] is None # different lat/lon wifis3 = WifiShardFactory.build_batch(2, lat=wifis1[0].lat + 10.0) cache.set( self._query(wifi=self.wifi_model_query(wifis3)), ExternalResult(wifis3[0].lat, wifis3[0].lon, 300, None), ) # check combined query, inconsistent result query = self._query(wifi=self.wifi_model_query(wifis1 + wifis2 + wifis3)) assert cache.get(query) is None assert ( len( metricsmock.filter_records( "incr", "locate.fallback.cache", value=1, tags=[self.fallback_tag, "status:hit"], ) ) == 1 ) assert ( len( metricsmock.filter_records( "incr", "locate.fallback.cache", value=1, tags=[self.fallback_tag, "status:inconsistent"], ) ) == 1 )
def add_reports(self, num=1, blue_factor=0, cell_factor=1, wifi_factor=2, api_key='test', nickname=None, blue_key=None, cell_mcc=None, wifi_key=None, lat=None, lon=None): reports = [] for i in range(num): pos = CellShardFactory.build() report = { 'timestamp': time.time() * 1000.0, 'position': {}, 'bluetoothBeacons': [], 'cellTowers': [], 'wifiAccessPoints': [], } report['position']['latitude'] = lat or pos.lat report['position']['longitude'] = lon or pos.lon report['position']['accuracy'] = 17.0 + i blues = WifiShardFactory.build_batch(blue_factor, lat=pos.lat, lon=pos.lon) for blue in blues: blue_data = { 'macAddress': blue_key or blue.mac, 'signalStrength': -100 + i, } report['bluetoothBeacons'].append(blue_data) cells = CellShardFactory.build_batch(cell_factor, lat=pos.lat, lon=pos.lon) for cell in cells: cell_data = { 'radioType': cell.radio.name, 'mobileCountryCode': cell_mcc or cell.mcc, 'mobileNetworkCode': cell.mnc, 'locationAreaCode': cell.lac, 'cellId': cell.cid, 'primaryScramblingCode': cell.psc, 'signalStrength': -110 + i, } report['cellTowers'].append(cell_data) wifis = WifiShardFactory.build_batch(wifi_factor, lat=pos.lat, lon=pos.lon) for wifi in wifis: wifi_data = { 'macAddress': wifi_key or wifi.mac, 'signalStrength': -90 + i, 'ssid': 'my-wifi', } report['wifiAccessPoints'].append(wifi_data) reports.append(report) queue_reports.delay(reports=reports, api_key=api_key, nickname=nickname).get() return reports
def test_wifi(self): wifis = WifiShardFactory.build_batch(2) query = Query(wifi=[{ 'macAddress': wifi.mac, 'channel': 3, 'frequency': 2412, 'signalStrength': -70, 'signalToNoiseRatio': 13, 'ssid': 'wifi' } for wifi in wifis]) data = self._call(query.json()) assert (data == { 'wifi': [{ 'bssid': wifis[0].mac, 'channel': 3, 'frequency': 2412, 'signal': -70, 'signalToNoiseRatio': 13, }, { 'bssid': wifis[1].mac, 'channel': 3, 'frequency': 2412, 'signal': -70, 'signalToNoiseRatio': 13, }], 'fallbacks': { 'lacf': True }, 'token': None, })
def test_wifi(self): wifis = WifiShardFactory.build_batch(2) query = Query(wifi=[{ 'macAddress': wifi.mac, 'age': 2000, 'channel': 11, 'signalStrength': -90, 'signalToNoiseRatio': 13 } for wifi in wifis]) data = self._call(query.json()) assert (data == { 'wifiAccessPoints': [{ 'macAddress': wifis[0].mac, 'age': 2000, 'channel': 11, 'signalStrength': -90, 'signalToNoiseRatio': 13, }, { 'macAddress': wifis[1].mac, 'age': 2000, 'channel': 11, 'signalStrength': -90, 'signalToNoiseRatio': 13, }], 'considerIp': False, })
def test_mixed_cell_wifi(self): cells = CellShardFactory.build_batch(1) wifis = WifiShardFactory.build_batch(2) query = Query(cell=self.cell_model_query(cells), wifi=self.wifi_model_query(wifis)) self.assertEqual(query.expected_accuracy, DataAccuracy.high)
def test_high_hit(self): wifis = WifiShardFactory.build_batch(2) self._make_query(self._make_result(accuracy=1000.0), wifi=wifis) self.check_stats(counter=[ ('locate.result', ['key:key', 'country:none', 'accuracy:high', 'status:hit']), ])
def test_check_already_good_result(self): wifis = WifiShardFactory.build_batch(2) internal_pos = Position( source=DataSource.internal, lat=1.0, lon=1.0, accuracy=1.0) query = self.model_query(wifis=wifis) self.check_should_search(query, False, results=[internal_pos])
def test_high_hit(self, geoip_db, metricsmock): wifis = WifiShardFactory.build_batch(2) self._make_query(geoip_db, self._make_result(accuracy=500.0), wifi=wifis) metricsmock.assert_incr_once( "locate.result", tags=["key:test", "fallback_allowed:false", "accuracy:high", "status:hit"], )
def test_wifi(self): wifis = WifiShardFactory.build_batch(2) query = Query( wifi=[ { "macAddress": wifi.mac, "age": 2000, "signalStrength": -90, "ssid": "wifi", } for wifi in wifis ] ) data = self._call(query.json()) assert data == { "wifiAccessPoints": [ { "macAddress": wifis[0].mac, "age": 2000, "signalStrength": -90, "ssid": "wifi", }, { "macAddress": wifis[1].mac, "age": 2000, "signalStrength": -90, "ssid": "wifi", }, ], "fallbacks": {"lacf": True}, }
def test_wifi(self): wifis = WifiShardFactory.build_batch(2) query = Query(wifi=[{ 'macAddress': wifi.mac, 'age': 2000, 'signalStrength': -90, 'ssid': 'wifi' } for wifi in wifis]) data = OUTBOUND_SCHEMA.deserialize(query.json()) assert (data == { 'wifiAccessPoints': [{ 'macAddress': wifis[0].mac, 'age': 2000, 'signalStrength': -90, 'ssid': 'wifi', }, { 'macAddress': wifis[1].mac, 'age': 2000, 'signalStrength': -90, 'ssid': 'wifi', }], 'fallbacks': { 'lacf': True }, })
def test_get_wifi(self, cache, stats): wifis = WifiShardFactory.build_batch(2) query = self._query(wifi=self.wifi_model_query(wifis)) assert cache.get(query) is None stats.check(counter=[ ('locate.fallback.cache', 1, 1, ['status:miss']), ])
def test_wifi(self): wifis = WifiShardFactory.build_batch(2) query = Query( wifi=[ { "macAddress": wifi.mac, "age": 2000, "channel": 11, "signalStrength": -90, "signalToNoiseRatio": 13, } for wifi in wifis ] ) data = self._call(query.json()) assert data == { "wifiAccessPoints": [ { "macAddress": wifis[0].mac, "age": 2000, "channel": 11, "signalStrength": -90, "signalToNoiseRatio": 13, }, { "macAddress": wifis[1].mac, "age": 2000, "channel": 11, "signalStrength": -90, "signalToNoiseRatio": 13, }, ], "considerIp": False, }
def test_database_error(self, db_errors=0): for tablename in ('cell', 'cell_area', 'ocid_cell', 'ocid_cell_area'): self.session.execute(text('drop table %s;' % tablename)) for i in range(16): self.session.execute(text( 'drop table wifi_shard_%s;' % hex(i)[2:])) cells = CellFactory.build_batch(2) wifis = WifiShardFactory.build_batch(2) query = self.model_query(cells=cells, wifis=wifis) res = self._call(body=query, ip=self.test_ip) self.check_response(res, 'ok') self.check_stats(counter=[ ('request', [self.metric_path, 'method:post', 'status:200']), ], timer=[ ('request', [self.metric_path, 'method:post']), ]) if self.apikey_metrics: self.check_stats(counter=[ (self.metric_type + '.result', ['key:test', 'country:GB', 'accuracy:high', 'status:miss']), ]) self.check_raven([('ProgrammingError', db_errors)])
def test_wifi(self): wifis = WifiShardFactory.build_batch(2) query = Query(wifi=[{ "macAddress": wifi.mac, "channel": 3, "frequency": 2412, "signalStrength": -70, "signalToNoiseRatio": 13, "ssid": "wifi", } for wifi in wifis]) data = self._call(query.json()) assert data == { "wifi": [ { "bssid": wifis[0].mac, "channel": 3, "frequency": 2412, "signal": -70, "signalToNoiseRatio": 13, }, { "bssid": wifis[1].mac, "channel": 3, "frequency": 2412, "signal": -70, "signalToNoiseRatio": 13, }, ], "fallbacks": { "lacf": True }, "token": None, }
def test_database_error(self, db_errors=0): cells = [ CellShardFactory.build(radio=Radio.gsm), CellShardFactory.build(radio=Radio.wcdma), CellShardFactory.build(radio=Radio.lte), ] wifis = WifiShardFactory.build_batch(2) for model in (CellArea, CellOCID, CellAreaOCID): self.session.execute(text('drop table %s;' % model.__tablename__)) for name in set([cell.__tablename__ for cell in cells]): self.session.execute(text('drop table %s;' % name)) for name in set([wifi.__tablename__ for wifi in wifis]): self.session.execute(text('drop table %s;' % name)) query = self.model_query(cells=cells, wifis=wifis) res = self._call(body=query, ip=self.test_ip) self.check_response(res, 'ok') self.check_stats(counter=[ ('request', [self.metric_path, 'method:post', 'status:200']), ], timer=[ ('request', [self.metric_path, 'method:post']), ]) if self.apikey_metrics: self.check_stats(counter=[ (self.metric_type + '.result', ['key:test', 'region:GB', 'fallback_allowed:false', 'accuracy:high', 'status:miss']), ]) self.check_raven([('ProgrammingError', db_errors)])
def test_wifi(self): wifis = WifiShardFactory.build_batch(2) query = Query(wifi=[ {'macAddress': wifi.mac, 'channel': 3, 'frequency': 2412, 'signalStrength': -70, 'signalToNoiseRatio': 13, 'ssid': 'wifi'} for wifi in wifis]) data = self._call(query.json()) assert (data == { 'wifi': [{ 'bssid': wifis[0].mac, 'channel': 3, 'frequency': 2412, 'signal': -70, 'signalToNoiseRatio': 13, }, { 'bssid': wifis[1].mac, 'channel': 3, 'frequency': 2412, 'signal': -70, 'signalToNoiseRatio': 13, }], 'fallbacks': {'lacf': True}, 'token': None, })
def test_satisfies_fail(self): wifis = WifiShardFactory.build_batch(2) wifi_query = [{'macAddress': wifi.mac} for wifi in wifis] positions = PositionResultList( Position(lat=1.0, lon=1.0, accuracy=2500.0, score=2.0)) query = Query(api_type='locate', wifi=wifi_query) assert not positions.satisfies(query)
def test_wifi(self): wifis = WifiShardFactory.build_batch(2) query = Query(wifi=[{ 'mac': wifi.mac, 'age': 2000, 'signal': -90, 'ssid': 'wifi' } for wifi in wifis]) data = self.schema.deserialize(query.internal_query()) self.assertEqual( data, { 'wifiAccessPoints': [{ 'macAddress': wifis[0].mac, 'age': 2000, 'signalStrength': -90, 'ssid': 'wifi', }, { 'macAddress': wifis[1].mac, 'age': 2000, 'signalStrength': -90, 'ssid': 'wifi', }], 'fallbacks': { 'lacf': True }, })
def test_satisfies_fail(self): wifis = WifiShardFactory.build_batch(2) wifi_query = [{'mac': wifi.mac} for wifi in wifis] positions = PositionResultList( Position(lat=1.0, lon=1.0, accuracy=2500.0, score=2.0)) query = Query(api_type='locate', wifi=wifi_query) self.assertFalse(positions.satisfies(query))
def test_api_key_disallows(self): api_key = ApiKeyFactory.build(allow_fallback=False) cells = CellShardFactory.build_batch(2) wifis = WifiShardFactory.build_batch(2) query = self.model_query(cells=cells, wifis=wifis, api_key=api_key) self.check_should_search(query, False)
def test_database_error(self, db_errors=0): cells = [ CellShardFactory.build(radio=Radio.gsm), CellShardFactory.build(radio=Radio.wcdma), CellShardFactory.build(radio=Radio.lte), ] wifis = WifiShardFactory.build_batch(2) for model in (CellArea, CellOCID, CellAreaOCID): self.session.execute(text("drop table %s;" % model.__tablename__)) for name in set([cell.__tablename__ for cell in cells]): self.session.execute(text("drop table %s;" % name)) for name in set([wifi.__tablename__ for wifi in wifis]): self.session.execute(text("drop table %s;" % name)) query = self.model_query(cells=cells, wifis=wifis) res = self._call(body=query, ip=self.test_ip) self.check_response(res, "ok") self.check_stats( counter=[("request", [self.metric_path, "method:post", "status:200"])], timer=[("request", [self.metric_path, "method:post"])], ) if self.apikey_metrics: self.check_stats( counter=[ ( self.metric_type + ".result", ["key:test", "region:GB", "fallback_allowed:false", "accuracy:high", "status:miss"], ) ] ) self.check_raven([("ProgrammingError", db_errors)])
def test_wifi_miss(self, geoip_db, http_session, session, source): wifis = WifiShardFactory.build_batch(2, samples=10) session.flush() query = self.model_query(geoip_db, http_session, session, wifis=wifis) results = source.search(query) self.check_model_results(results, None)
def test_api_key_disallows(self): api_key = ApiKeyFactory.build(allow_fallback=False) cells = CellFactory.build_batch(2) wifis = WifiShardFactory.build_batch(2) query = self.model_query(cells=cells, wifis=wifis, api_key=api_key) self.check_should_search(query, False)
def test_get_wifi(self): wifis = WifiShardFactory.build_batch(2) query = Query(wifi=self.wifi_model_query(wifis)) self.assertEqual(self.cache.get(query), None) self.check_stats(counter=[ ('locate.fallback.cache', 1, 1, ['status:miss']), ])
def test_wifi_not_found(self, app, data_queues, metricsmock, logs): """A failed WiFi-based lookup emits several metrics.""" wifis = WifiShardFactory.build_batch(2) query = self.model_query(wifis=wifis) 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"] ) metricsmock.assert_incr_once( self.metric_type + ".query", tags=["key:test", "geoip:false", "blue:none", "cell:none", "wifi:many"], ) metricsmock.assert_incr_once( self.metric_type + ".result", tags=["key:test", "accuracy:high", "fallback_allowed:false", "status:miss"], ) metricsmock.assert_incr_once( self.metric_type + ".source", tags=["key:test", "source:internal", "accuracy:high", "status:miss"], ) assert logs.only_entry["wifi_valid"] == 2
def test_get_wifi(self): wifis = WifiShardFactory.build_batch(2) query = self._query(wifi=self.wifi_model_query(wifis)) self.assertEqual(self.cache.get(query), None) self.check_stats(counter=[ ('locate.fallback.cache', 1, 1, ['status:miss']), ])
def test_database_error(self, app, data_queues, raven, session, stats, restore_db): cells = [ CellShardFactory.build(radio=Radio.gsm), CellShardFactory.build(radio=Radio.wcdma), CellShardFactory.build(radio=Radio.lte), ] wifis = WifiShardFactory.build_batch(2) for model in (CellArea, ): session.execute(text('drop table %s;' % model.__tablename__)) for name in set([cell.__tablename__ for cell in cells]): session.execute(text('drop table %s;' % name)) for name in set([wifi.__tablename__ for wifi in wifis]): session.execute(text('drop table %s;' % name)) query = self.model_query(cells=cells, wifis=wifis) res = self._call(app, body=query, ip=self.test_ip) self.check_response(data_queues, res, 'ok', fallback='ipf') self.check_queue(data_queues, 0) stats.check(counter=[ ('request', [self.metric_path, 'method:post', 'status:200']), ], timer=[ ('request', [self.metric_path, 'method:post']), ]) if self.apikey_metrics: stats.check(counter=[ (self.metric_type + '.result', ['key:test', 'region:GB', 'fallback_allowed:false', 'accuracy:high', 'status:miss']), ]) raven.check([('ProgrammingError', 3)])
def test_wifi_not_found(self, app, data_queues, stats): wifis = WifiShardFactory.build_batch(2) query = self.model_query(wifis=wifis) 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']), (self.metric_type + '.query', [ 'key:test', 'region:none', 'geoip:false', 'blue:none', 'cell:none', 'wifi:many' ]), (self.metric_type + '.result', 'fallback_allowed:false', ['key:test', 'region:none', 'accuracy:high', 'status:miss']), (self.metric_type + '.source', [ 'key:test', 'region:none', 'source:internal', 'accuracy:high', 'status:miss' ]), ], timer=[ ('request', [self.metric_path, 'method:post']), ])
def test_wifi_miss(self): wifis = WifiShardFactory.build_batch(2, samples=10) self.session.flush() query = self.model_query(wifis=wifis) results = self.source.search(query) self.check_model_results(results, None)
def test_satisfies(self): wifis = WifiShardFactory.build_batch(2) wifi_query = [{'mac': wifi.mac} for wifi in wifis] positions = PositionResultList([ Position(lat=1.0, lon=1.0, accuracy=100.0, score=0.5), Position(lat=1.0, lon=1.0, accuracy=10000.0, score=0.6)]) query = Query(api_type='locate', wifi=wifi_query) self.assertTrue(positions.satisfies(query))
def test_gzip(self): wifis = WifiShardFactory.build_batch(2) query = self.model_query(wifis=wifis) body = util.encode_gzip(json.dumps(query)) headers = {"Content-Encoding": "gzip"} res = self._call(body=body, headers=headers, method="post", status=self.not_found.code) self.check_response(res, "not_found")
def test_check_empty_result(self, geoip_db, http_session, session, source, stats): wifis = WifiShardFactory.build_batch(2) query = self.model_query( geoip_db, http_session, session, stats, wifis=wifis) self.check_should_search(source, query, True)
def test_mixed_miss(self): wifis = WifiShardFactory.build_batch(2) self._make_query( self._make_result(accuracy=1001.0), wifi=wifis, ip=self.london_ip) self.check_stats(counter=[ ('locate.result', ['key:key', 'country:GB', 'accuracy:high', 'status:miss']), ])
def test_high_miss(self, geoip_db, metricsmock): wifis = WifiShardFactory.build_batch(2) results = self._make_results(accuracy=10000.0) self._make_query(geoip_db, DataSource.geoip, results, wifi=wifis) metricsmock.assert_incr_once( "locate.source", tags=["key:test", "source:geoip", "accuracy:high", "status:miss"], )
def test_get_wifi(self, cache, stats): wifis = WifiShardFactory.build_batch(2) query = self._query(wifi=self.wifi_model_query(wifis)) assert cache.get(query) is None stats.check(counter=[ ('locate.fallback.cache', 1, 1, [self.fallback_tag, 'status:miss']), ])
def test_high_hit(self): wifis = WifiShardFactory.build_batch(2) self._make_query(self._make_result(accuracy=1000.0), wifi=wifis) self.check_stats(counter=[ ('locate.result', ['key:key', 'region:none', 'fallback_allowed:false', 'accuracy:high', 'status:hit']), ])
def test_mixed_cell_wifi(self): cells = CellShardFactory.build_batch(1) wifis = WifiShardFactory.build_batch(2) query = Query( cell=self.cell_model_query(cells), wifi=self.wifi_model_query(wifis)) self.assertEqual(query.expected_accuracy, DataAccuracy.high)
def test_no_results(self, geoip_db, metricsmock): wifis = WifiShardFactory.build_batch(2) results = PositionResultList() self._make_query(geoip_db, DataSource.internal, results, wifi=wifis) metricsmock.assert_incr_once( "locate.source", tags=["key:test", "source:internal", "accuracy:high", "status:miss"], )
def test_mixed_cell_wifi(self): cells = CellShardFactory.build_batch(1) wifis = WifiShardFactory.build_batch(2) query = Query(cell=self.cell_model_query(cells), wifi=self.wifi_model_query(wifis)) assert query.expected_accuracy is DataAccuracy.high assert query.geoip_only is False
def test_high_miss(self): wifis = WifiShardFactory.build_batch(2) self._make_query(self._make_result(accuracy=2500.0), wifi=wifis) self.check_stats(counter=[ ('locate.result', ['key:key', 'region:none', 'fallback_allowed:false', 'accuracy:high', 'status:miss']), ])
def test_high_hit(self): wifis = WifiShardFactory.build_batch(2) self._make_query( DataSource.internal, self._make_result(accuracy=100.0), wifi=wifis) self.check_stats(counter=[ ('locate.source', ['key:key', 'region:none', 'source:internal', 'accuracy:high', 'status:hit']), ])
def test_mixed_cell_wifi(self): cells = CellShardFactory.build_batch(1) wifis = WifiShardFactory.build_batch(2) query = Query( cell=self.cell_model_query(cells), wifi=self.wifi_model_query(wifis)) assert query.expected_accuracy is DataAccuracy.high assert query.geoip_only is False
def test_satisfies(self): wifis = WifiShardFactory.build_batch(2) wifi_query = [{'mac': wifi.mac} for wifi in wifis] positions = PositionResultList([ Position(lat=1.0, lon=1.0, accuracy=100.0, score=0.5), Position(lat=1.0, lon=1.0, accuracy=10000.0, score=0.6) ]) query = Query(api_type='locate', wifi=wifi_query) self.assertTrue(positions.satisfies(query))
def test_many(self): cells = CellFactory.build_batch(2) wifis = WifiShardFactory.build_batch(3) self._make_query(cell=cells, wifi=wifis, ip=self.london_ip) self.check_stats(total=1, counter=[ ('locate.query', ['key:key', 'region:GB', 'cell:many', 'wifi:many']), ])
def test_mixed_miss(self): wifis = WifiShardFactory.build_batch(2) self._make_query( self._make_result(accuracy=2001.0), wifi=wifis, ip=self.london_ip) self.check_stats(counter=[ ('locate.result', ['key:key', 'region:GB', 'fallback_allowed:false', 'accuracy:high', 'status:miss']), ])
def test_api_key_disallows(self, geoip_db, http_session, session, source): api_key = KeyFactory(allow_fallback=False) cells = CellShardFactory.build_batch(2) wifis = WifiShardFactory.build_batch(2) query = self.model_query( geoip_db, http_session, session, cells=cells, wifis=wifis, api_key=api_key ) self.check_should_search(source, query, False)
def test_no_results(self): wifis = WifiShardFactory.build_batch(2) results = PositionResultList() self._make_query(DataSource.internal, results, wifi=wifis) self.check_stats(counter=[ ('locate.source', ['key:key', 'region:none', 'source:internal', 'accuracy:high', 'status:miss']), ])
def test_high_miss(self): wifis = WifiShardFactory.build_batch(2) results = self._make_results(accuracy=10000.0) self._make_query(DataSource.ocid, results, wifi=wifis) self.check_stats(counter=[ ('locate.source', ['key:key', 'region:none', 'source:ocid', 'accuracy:high', 'status:miss']), ])
def test_one(self): cells = CellFactory.build_batch(1) wifis = WifiShardFactory.build_batch(1) self._make_query(cell=cells, wifi=wifis, ip=self.london_ip) self.check_stats(total=1, counter=[ ('locate.query', ['key:key', 'country:GB', 'cell:one', 'wifi:one']), ])
def test_wifi(self): wifis = WifiShardFactory.build_batch(2) query = self.model_query(wifis=wifis) res = self._call( body=query, ip='127.0.0.1', status=404) self.check_response(res, 'not_found') self.check_db_calls(rw=0, ro=0)
def test_high_miss(self): wifis = WifiShardFactory.build_batch(2) self._make_query( DataSource.ocid, self._make_result(accuracy=10000.0), wifi=wifis) self.check_stats(counter=[ ('locate.source', ['key:key', 'region:none', 'source:ocid', 'accuracy:high', 'status:miss']), ])
def test_set_wifi(self, cache, metricsmock): wifis = WifiShardFactory.build_batch(2) wifi = wifis[0] query = self._query(wifi=self.wifi_model_query(wifis)) result = ExternalResult(wifi.lat, wifi.lon, wifi.radius, None) cache.set(query, result) assert cache.get(query) == result metricsmock.assert_incr_once("locate.fallback.cache", tags=[self.fallback_tag, "status:hit"])
def test_high_hit(self, geoip_db, stats): wifis = WifiShardFactory.build_batch(2) self._make_query( geoip_db, stats, self._make_result(accuracy=500.0), wifi=wifis) stats.check(counter=[ ('locate.result', ['key:test', 'region:none', 'fallback_allowed:false', 'accuracy:high', 'status:hit']), ])
def test_mixed_miss(self, geoip_db, stats): wifis = WifiShardFactory.build_batch(2) self._make_query( geoip_db, stats, self._make_result(accuracy=2001.0), wifi=wifis, ip=self.london_ip) stats.check(counter=[ ('locate.result', ['key:test', 'region:GB', 'fallback_allowed:false', 'accuracy:high', 'status:miss']), ])
def test_apikey_error(self, db_errors=0): cells = CellShardFactory.build_batch(2) wifis = WifiShardFactory.build_batch(2) self.session.execute(text('drop table %s;' % ApiKey.__tablename__)) query = self.model_query(cells=cells, wifis=wifis) res = self._call(body=query, ip=self.test_ip) self.check_response(res, 'ok') self.check_raven([('ProgrammingError', db_errors)])
def test_wifi_miss(self, geoip_db, http_session, session, source, stats): wifis = WifiShardFactory.build_batch(2, samples=10) session.flush() query = self.model_query( geoip_db, http_session, session, stats, wifis=wifis) results = source.search(query) self.check_model_results(results, None)