def test_wifi_permanent_blocked(self, geoip_db, http_session, session, source, stats): now = util.utcnow() last_week = now - timedelta(days=7) three_months = now - timedelta(days=90) four_months = now - timedelta(days=120) wifi = WifiShardFactory(radius=200) wifi2 = WifiShardFactory(lat=wifi.lat, lon=wifi.lon + 0.00001, radius=300, created=four_months, modified=now, block_first=three_months.date(), block_last=last_week.date(), block_count=4) session.flush() query = self.model_query(geoip_db, http_session, session, stats, wifis=[wifi, wifi2]) results = source.search(query) self.check_model_results(results, None)
def test_wifi(self, geoip_db, http_session, session, source, metricsmock): now = util.utcnow() region = GEOCODER.regions_for_mcc(235, metadata=True)[0] wifi1 = WifiShardFactory(samples=10) wifi2 = WifiShardFactory(samples=20) wifi3 = WifiShardFactory.build(region="DE", samples=100) session.flush() query = self.model_query( geoip_db, http_session, session, wifis=[wifi1, wifi2, wifi3] ) results = source.search(query) self.check_model_results(results, [region]) best_result = results.best() assert best_result.region_code == region.code assert best_result.score == station_score(wifi1, now) + station_score( wifi2, now ) assert metricsmock.has_record( "incr", self.api_type + ".source", value=1, tags=[ "key:test", "region:none", "source:internal", "accuracy:low", "status:hit", ], )
def test_region(self): obs = [] obs_factory = WifiObservationFactory wifi1 = WifiShardFactory(lat=46.2884, lon=6.77, region='FR') obs.extend( obs_factory.create_batch( 5, key=wifi1.mac, lat=wifi1.lat, lon=wifi1.lon + 0.05, )) wifi2 = WifiShardFactory(lat=46.2884, lon=7.4, region='FR') obs.extend( obs_factory.create_batch( 5, key=wifi2.mac, lat=wifi2.lat, lon=wifi2.lon + 0.05, )) self.session.commit() self._queue_and_update(obs) # position is really not in FR anymore, but still close enough # to not re-trigger region determination wifi1 = self.session.query(wifi1.__class__).get(wifi1.mac) self.assertEqual(wifi1.block_count, 0) self.assertEqual(wifi1.region, 'FR') wifi2 = self.session.query(wifi2.__class__).get(wifi2.mac) self.assertEqual(wifi1.block_count, 0) self.assertEqual(wifi2.region, 'CH')
def test_wifi(self): wifi = WifiShardFactory() offset = 0.00001 wifis = [ wifi, WifiShardFactory(lat=wifi.lat + offset), WifiShardFactory(lat=wifi.lat + offset * 2), WifiShardFactory(lat=None, lon=None), ] self.session.flush() query = self.model_query(wifis=wifis) wifi_query = query['wifi'] wifi_query[0]['channel'] = 6 wifi_query[0]['signal'] = -50 wifi_query[1]['frequency'] = 2437 wifi_query[2]['signal'] = -130 wifi_query[2]['signalToNoiseRatio'] = 13 wifi_query[3]['ssid'] = 'my-wifi' res = self._call(body=query) self.check_model_response(res, wifi, lat=wifi.lat + 0.000005) self.check_stats(counter=[ (self.metric_type + '.request', [self.metric_path, 'key:test']), (self.metric_type + '.result', [ 'key:test', 'region:none', 'fallback_allowed:false', 'accuracy:high', 'status:hit', 'source:internal' ]), (self.metric_type + '.source', [ 'key:test', 'region:none', 'source:internal', 'accuracy:high', 'status:hit' ]), ])
def test_wifi(self, geoip_db, http_session, session, source, stats): now = util.utcnow() region = GEOCODER.regions_for_mcc(235, metadata=True)[0] wifi1 = WifiShardFactory(samples=10) wifi2 = WifiShardFactory(samples=20) wifi3 = WifiShardFactory.build(region='DE', samples=100) session.flush() query = self.model_query(geoip_db, http_session, session, stats, wifis=[wifi1, wifi2, wifi3]) results = source.search(query) self.check_model_results(results, [region]) best_result = results.best() assert best_result.region_code == region.code assert (best_result.score == station_score(wifi1, now) + station_score(wifi2, now)) stats.check(counter=[ (self.api_type + '.source', [ 'key:test', 'region:none', 'source:internal', 'accuracy:low', 'status:hit' ]), ])
def test_update(self): utcnow = util.utcnow() obs = [] obs_factory = WifiObservationFactory # first wifi wifi1 = WifiShardFactory(lat=None, lon=None, samples=3) new_pos = WifiShardFactory.build() mac1, lat1, lon1 = (wifi1.mac, new_pos.lat, new_pos.lon) obs.extend([ obs_factory(lat=lat1, lon=lon1, key=mac1), obs_factory(lat=lat1 + 0.002, lon=lon1 + 0.003, key=mac1), obs_factory(lat=lat1 + 0.004, lon=lon1 + 0.006, key=mac1), ]) # second wifi wifi2 = WifiShardFactory(lat=lat1 + 1.0, lon=lon1 + 1.0, max_lat=lat1 + 1.0, min_lat=lat1 + 0.999, max_lon=lon1 + 1.0, min_lon=None, radius=20, samples=2, created=utcnow - timedelta(10), modified=utcnow - timedelta(10)) mac2, lat2, lon2 = (wifi2.mac, wifi2.lat, wifi2.lon) obs.extend([ obs_factory(lat=lat2 + 0.002, lon=lon2 + 0.004, key=mac2), obs_factory(lat=lat2 + 0.002, lon=lon2 + 0.004, key=mac2), ]) self.session.commit() self._queue_and_update(obs) shard = WifiShard.shard_model(mac1) found = self.session.query(shard).filter(shard.mac == mac1).one() self.assertAlmostEqual(found.lat, lat1 + 0.002) self.assertAlmostEqual(found.max_lat, lat1 + 0.004) self.assertAlmostEqual(found.min_lat, lat1) self.assertAlmostEqual(found.lon, lon1 + 0.003) self.assertAlmostEqual(found.max_lon, lon1 + 0.006) self.assertAlmostEqual(found.min_lon, lon1) self.assertEqual(found.modified.date(), utcnow.date()) self.assertEqual(found.radius, 304) self.assertEqual(found.region, 'GB') self.assertEqual(found.samples, 6) shard = WifiShard.shard_model(mac2) found = self.session.query(shard).filter(shard.mac == mac2).one() self.assertAlmostEqual(found.lat, lat2 + 0.001) self.assertAlmostEqual(found.max_lat, lat2 + 0.002) self.assertAlmostEqual(found.min_lat, lat2 - 0.001) self.assertAlmostEqual(found.lon, lon2 + 0.002) self.assertAlmostEqual(found.max_lon, lon2 + 0.004) self.assertAlmostEqual(found.min_lon, lon2) self.assertEqual(found.created.date(), utcnow.date() - timedelta(10)) self.assertEqual(found.modified.date(), utcnow.date()) self.assertEqual(found.radius, 260) self.assertEqual(found.region, 'GB') self.assertEqual(found.samples, 4)
def test_wifi_no_position(self): wifi = WifiShardFactory() wifi2 = WifiShardFactory(lat=wifi.lat, lon=wifi.lon) wifi3 = WifiShardFactory(lat=None, lon=wifi.lon, radius=None) self.session.flush() query = self.model_query(wifis=[wifi, wifi2, wifi3]) results = self.source.search(query) self.check_model_results(results, [wifi])
def test_wifi(self, app, data_queues, session): # Use manual mac to ensure we only use one shard. wifi1 = WifiShardFactory(mac="000000123456", samples=10) wifi2 = WifiShardFactory(mac="000000abcdef", samples=10) session.flush() query = self.model_query(wifis=[wifi1, wifi2]) res = self._call(app, body=query, ip="127.0.0.1") self.check_response(data_queues, res, wifi1)
def test_wifi(self): wifi1 = WifiShardFactory(mac='000000123456', samples=10) wifi2 = WifiShardFactory(mac='000000abcdef', samples=10) self.session.flush() query = self.model_query(wifis=[wifi1, wifi2]) res = self._call(body=query, ip='127.0.0.1') self.check_response(res, wifi1) self.check_db_calls(rw=0, ro=2)
def test_cluster_score_over_size(self, geoip_db, http_session, session, source): now = util.utcnow() yesterday = now - timedelta(days=1) last_week = now - timedelta(days=7) three_months = now - timedelta(days=90) four_months = now - timedelta(days=120) wifi11 = WifiShardFactory(samples=20, created=last_week, modified=yesterday) wifi12 = WifiShardFactory( lat=wifi11.lat + 0.00003, lon=wifi11.lon, samples=30, created=yesterday, modified=now, ) wifi13 = WifiShardFactory( lat=wifi11.lat - 0.00003, lon=wifi11.lon, samples=10, created=yesterday, modified=now, ) wifi21 = WifiShardFactory( lat=wifi11.lat + 1.0, lon=wifi11.lon + 1.0, samples=40, created=four_months, modified=three_months, ) wifi22 = WifiShardFactory( lat=wifi21.lat, lon=wifi21.lon, samples=50, created=three_months, modified=last_week, ) session.flush() query = self.model_query( geoip_db, http_session, session, wifis=[wifi11, wifi12, wifi13, wifi21, wifi22], ) results = source.search(query) assert len(results) == 2 best_result = results.best() assert round(best_result.lat, 7) == round(wifi21.lat, 7) assert round(best_result.lon, 7) == round(wifi21.lon, 7) assert round(best_result.accuracy, 2) == 10.0 assert round(best_result.score, 2) == round( station_score(wifi21, now) + station_score(wifi22, now), 2 ) other_result = [res for res in results if res.score < best_result.score][0] assert round(other_result.lat, 4) == round(wifi11.lat, 4) assert round(other_result.lon, 4) == round(wifi11.lon, 4)
def test_not_closeby(self): wifi = WifiShardFactory() wifis = [ WifiShardFactory(lat=wifi.lat + 0.00001, lon=wifi.lon), WifiShardFactory(lat=wifi.lat + 1.0, lon=wifi.lon), WifiShardFactory(lat=wifi.lat + 1.00001, lon=wifi.lon), ] self.session.flush() query = self.model_query(wifis=[wifi, wifis[1]]) results = self.source.search(query) self.check_model_results(results, None)
def test_wifi_permanent_blocked(self): wifi = WifiShardFactory(radius=200) wifi2 = WifiShardFactory(lat=wifi.lat, lon=wifi.lon + 0.00001, radius=300, block_count=PERMANENT_BLOCKLIST_THRESHOLD, block_last=None) self.session.flush() query = self.model_query(wifis=[wifi, wifi2]) results = self.source.search(query) self.check_model_results(results, None)
def test_wifi(self): wifi = WifiShardFactory(radius=50) wifi2 = WifiShardFactory(lat=wifi.lat, lon=wifi.lon + 0.00001, radius=30, block_count=1, block_last=None) self.session.flush() query = self.model_query(wifis=[wifi, wifi2]) result = self.source.search(query) self.check_model_result(result, wifi, lon=wifi.lon + 0.000005)
def test_wifi(self, geoip_db, http_session, session, source): wifi = WifiShardFactory(radius=5, samples=50) wifi2 = WifiShardFactory( lat=wifi.lat, lon=wifi.lon + 0.00001, radius=5, samples=100 ) session.flush() query = self.model_query(geoip_db, http_session, session, wifis=[wifi, wifi2]) query.wifi[0].signalStrength = -60 query.wifi[1].signalStrength = -80 results = source.search(query) self.check_model_results(results, [wifi], lon=wifi.lon + 0.000004) assert results.best().score > 1.0
def test_multiple_clusters(self): wifi11 = WifiShardFactory() wifi12 = WifiShardFactory(lat=wifi11.lat, lon=wifi11.lon) wifi21 = WifiShardFactory(lat=wifi11.lat + 1.0, lon=wifi11.lon + 1.0) wifi22 = WifiShardFactory(lat=wifi21.lat, lon=wifi21.lon) self.session.flush() query = self.model_query(wifis=[wifi11, wifi12, wifi21, wifi22]) query.wifi[0].signal = -100 query.wifi[1].signal = -80 query.wifi[2].signal = -100 query.wifi[3].signal = -54 results = self.source.search(query) self.check_model_results(results, [wifi11, wifi21])
def test_cluster_size_over_better_signal(self): wifi11 = WifiShardFactory() wifi12 = WifiShardFactory(lat=wifi11.lat + 0.0002, lon=wifi11.lon) wifi21 = WifiShardFactory(lat=wifi11.lat + 1.0, lon=wifi11.lon + 1.0) wifi22 = WifiShardFactory(lat=wifi21.lat + 0.0002, lon=wifi21.lon) self.session.flush() query = self.model_query(wifis=[wifi11, wifi12, wifi21, wifi22]) query.wifi[0].signal = -100 query.wifi[1].signal = -80 query.wifi[2].signal = -100 query.wifi[3].signal = -54 result = self.source.search(query) self.check_model_result(result, wifi21, lat=wifi21.lat + 0.0001)
def test_wifi_temp_blocked(self): today = util.utcnow().date() yesterday = today - timedelta(days=1) wifi = WifiShardFactory(radius=200) wifi2 = WifiShardFactory(lat=wifi.lat, lon=wifi.lon + 0.00001, radius=300, block_count=1, block_last=yesterday) self.session.flush() query = self.model_query(wifis=[wifi, wifi2]) results = self.source.search(query) self.check_model_results(results, None)
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))
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)
def test_weighted_update(self): wifi = WifiShardFactory(samples=2, weight=3.0) wifi_lat = wifi.lat wifi_lon = wifi.lon obs_factory = WifiObservationFactory obs = [ obs_factory(lat=wifi.lat, lon=wifi.lon - 0.002, accuracy=20.0, signal=-30, mac=wifi.mac), obs_factory(lat=wifi.lat, lon=wifi.lon - 0.004, accuracy=40.0, signal=-60, mac=wifi.mac), ] self.session.commit() self._queue_and_update_wifi(obs) shard = WifiShard.shard_model(wifi.mac) wifis = self.session.query(shard).all() self.assertEqual(len(wifis), 1) wifi = wifis[0] self.assertAlmostEqual(wifi.lat, wifi_lat) self.assertAlmostEqual(wifi.max_lat, wifi_lat) self.assertAlmostEqual(wifi.min_lat, wifi_lat) self.assertAlmostEqual(wifi.lon, wifi_lon - 0.0017709, 7) self.assertAlmostEqual(wifi.max_lon, wifi_lon) self.assertAlmostEqual(wifi.min_lon, wifi_lon - 0.004) self.assertEqual(wifi.radius, 154) self.assertEqual(wifi.samples, 4) self.assertAlmostEqual(wifi.weight, 15.53, 2)
def test_weight(self, geoip_db, http_session, session, source): wifi1 = WifiShardFactory.build() wifis = [] for i in range(4): wifis.append( WifiShardFactory( lat=wifi1.lat + i * 0.0001, lon=wifi1.lon + i * 0.00012 ) ) session.flush() query = self.model_query(geoip_db, http_session, session, wifis=wifis) query.wifi[0].signalStrength = -10 query.wifi[0].age = 0 query.wifi[1].signalStrength = -40 query.wifi[1].age = 8000 query.wifi[2].signalStrength = -70 query.wifi[2].age = 16000 query.wifi[3].signalStrength = -100 results = source.search(query) result = results.best() assert round(result.lat, 7) == wifi1.lat + 0.0000009 assert round(result.lon, 7) == wifi1.lon + 0.0000006 assert round(result.accuracy, 2) == 39.51
def test_temp_blocked(self): utcnow = util.utcnow() bad_wifi = WifiObservationFactory.build() good_wifi = WifiObservationFactory.build() WifiShardFactory(mac=bad_wifi.mac, lat=None, lon=None, created=utcnow, block_first=utcnow.date() - timedelta(days=10), block_last=utcnow.date(), block_count=1) obs = [good_wifi, bad_wifi, good_wifi] self.session.commit() self._queue_and_update(obs) shard = WifiShard.shard_model(good_wifi.mac) wifis = (self.session.query(shard).filter( shard.mac == good_wifi.mac)).all() self.assertEqual(len(wifis), 1) self.assertTrue(wifis[0].lat is not None) self.assertTrue(wifis[0].lon is not None) self.assertEqual(wifis[0].samples, 2) shard = WifiShard.shard_model(bad_wifi.mac) wifis = (self.session.query(shard).filter( shard.mac == bad_wifi.mac)).all() self.assertEqual(len(wifis), 1) self.assertTrue(wifis[0].block_first < utcnow.date()) self.assertTrue(wifis[0].lat is None) self.assertTrue(wifis[0].lon is None) self.check_statcounter(StatKey.wifi, 2) self.check_statcounter(StatKey.unique_wifi, 1)
def test_wifi(self): wifi = WifiShardFactory(radius=5, samples=50) wifi2 = WifiShardFactory(lat=wifi.lat, lon=wifi.lon + 0.00001, radius=5, block_count=1, block_last=None, samples=100) self.session.flush() query = self.model_query(wifis=[wifi, wifi2]) query.wifi[0].signal = -60 query.wifi[1].signal = -80 results = self.source.search(query) self.check_model_results(results, [wifi], lon=wifi.lon + 0.000004) self.assertTrue(results.best().score > 1.0)
def test_top_results_in_noisy_cluster(self): now = util.utcnow() # all these should wind up in the same cluster since # the WiFis are spaced in increments of (+0.1m, +0.12m) wifi1 = WifiShardFactory.build() wifis = [] for i in range(0, MAX_WIFIS_IN_CLUSTER + 10): wifis.append( WifiShardFactory(lat=wifi1.lat + i * 0.000001, lon=wifi1.lon + i * 0.0000012, samples=100 - i)) self.session.flush() # calculate expected result score = sum([wifi.score(now) for wifi in wifis]) query = self.model_query(wifis=wifis) for i, entry in enumerate(query.wifi): entry.signal = -50 - i results = self.source.search(query) result = results.best() self.assertAlmostEqual(result.lat, wifi1.lat, 4) self.assertAlmostEqual(result.lon, wifi1.lon, 4) self.assertAlmostEqual(result.score, score, 4)
def test_temp_blocked_admitted_again(self): now = util.utcnow() last_week = now - TEMPORARY_BLOCKLIST_DURATION - timedelta(days=1) obs = WifiObservationFactory() WifiShardFactory(mac=obs.mac, lat=None, lon=None, samples=0, created=last_week, modified=last_week, block_first=last_week.date(), block_last=last_week.date(), block_count=1) self.session.commit() # add a new entry for the previously blocked wifi self._queue_and_update([obs]) # the wifi was inserted again shard = WifiShard.shard_model(obs.mac) wifis = self.session.query(shard).all() self.assertEqual(len(wifis), 1) wifi = wifis[0] self.assertEqual(wifi.block_first, last_week.date()) self.assertEqual(wifi.block_last, last_week.date()) self.assertEqual(wifi.created.date(), last_week.date()) self.assertAlmostEqual(wifi.lat, obs.lat) self.assertAlmostEqual(wifi.lon, obs.lon) self.assertEqual(wifi.region, 'GB') self.assertEqual(wifi.samples, 1) self.check_statcounter(StatKey.unique_wifi, 0)
def test_cluster_score_over_size(self): now = util.utcnow() yesterday = now - timedelta(days=1) last_week = now - timedelta(days=7) three_months = now - timedelta(days=90) four_months = now - timedelta(days=120) wifi11 = WifiShardFactory(samples=20, created=last_week, modified=yesterday) wifi12 = WifiShardFactory(lat=wifi11.lat + 0.00003, lon=wifi11.lon, samples=30, created=yesterday, modified=now) wifi13 = WifiShardFactory(lat=wifi11.lat - 0.00003, lon=wifi11.lon, samples=10, created=yesterday, modified=now) wifi21 = WifiShardFactory(lat=wifi11.lat + 1.0, lon=wifi11.lon + 1.0, samples=40, created=four_months, modified=three_months) wifi22 = WifiShardFactory(lat=wifi21.lat, lon=wifi21.lon, samples=50, created=three_months, modified=last_week) self.session.flush() query = self.model_query( wifis=[wifi11, wifi12, wifi13, wifi21, wifi22]) results = self.source.search(query) self.assertEqual(len(results), 2) best_result = results.best() self.assertAlmostEqual(best_result.lat, wifi21.lat, 7) self.assertAlmostEqual(best_result.lon, wifi21.lon, 7) self.assertAlmostEqual(best_result.accuracy, 10.0, 2) self.assertAlmostEqual(best_result.score, wifi21.score(now) + wifi22.score(now), 4) other_result = [ res for res in results if res.score < best_result.score ][0] self.assertAlmostEqual(other_result.lat, wifi11.lat, 4) self.assertAlmostEqual(other_result.lon, wifi11.lon, 4)
def test_wifi_over_cell(self): now = util.utcnow() three_months = now - timedelta(days=90) wifi1 = WifiShardFactory(samples=1000, created=three_months, modified=now, region='US') wifi2 = WifiShardFactory(samples=1000, created=three_months, modified=now, region='US') cell = CellShardFactory(radio=Radio.gsm, samples=10) self.session.flush() query = self.model_query(cells=[cell], wifis=[wifi1, wifi2]) res = self._call(body=query, ip=self.test_ip) # wifi says US with a high score, cell and geoip say UK self.check_model_response(res, wifi1, region='US')
def test_wifi_temp_blocked(self, geoip_db, http_session, session, source): today = util.utcnow() yesterday = today - timedelta(days=1) wifi = WifiShardFactory(radius=200) wifi2 = WifiShardFactory( lat=wifi.lat, lon=wifi.lon + 0.00001, radius=300, created=yesterday, modified=today, block_first=yesterday.date(), block_last=yesterday.date(), block_count=1, ) session.flush() query = self.model_query(geoip_db, http_session, session, wifis=[wifi, wifi2]) results = source.search(query) self.check_model_results(results, None)
def test_ignore_outlier(self): wifi = WifiShardFactory() wifis = WifiShardFactory.create_batch(3, lat=wifi.lat, lon=wifi.lon) wifis[0].lat = wifi.lat + 0.0001 wifis[1].lat = wifi.lat + 0.0002 wifis[2].lat = wifi.lat + 1.0 self.session.flush() query = self.model_query(wifis=[wifi] + wifis) result = self.source.search(query) self.check_model_result(result, wifi, lat=wifi.lat + 0.0001)
def test_wifi(self): now = util.utcnow() region = GEOCODER.regions_for_mcc(235, metadata=True)[0] wifi1 = WifiShardFactory(samples=10) wifi2 = WifiShardFactory(samples=20) wifi3 = WifiShardFactory.build(region='DE', samples=100) self.session.flush() query = self.model_query(wifis=[wifi1, wifi2, wifi3]) results = self.source.search(query) self.check_model_results(results, [region]) best_result = results.best() self.assertEqual(best_result.region_code, region.code) self.assertAlmostEqual( best_result.score, wifi1.score(now) + wifi2.score(now), 4) self.check_stats(counter=[ (self.api_type + '.source', ['key:test', 'region:none', 'source:internal', 'accuracy:low', 'status:hit']), ])