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']),
])
