def test_check_invalid_wifi(self):
wifi = WifiShardFactory.build()
malformed_wifi = WifiShardFactory.build()
malformed_wifi.mac = 'abcd'
query = self.model_query(wifis=[wifi, malformed_wifi])
self.check_should_search(query, False)
def test_check_invalid_wifi(self):
wifi = WifiShardFactory.build()
malformed_wifi = WifiShardFactory.build()
malformed_wifi.mac = 'abcd'
query = self.model_query(wifis=[wifi, malformed_wifi])
self.check_should_search(query, False)
def test_check_invalid_wifi(self, geoip_db, http_session, session, source):
wifi = WifiShardFactory.build()
malformed_wifi = WifiShardFactory.build()
malformed_wifi.mac = "abcd"
query = self.model_query(
geoip_db, http_session, session, wifis=[wifi, malformed_wifi]
)
self.check_should_search(source, query, False)
def test_check_invalid_wifi(self, geoip_db, http_session,
session, source, stats):
wifi = WifiShardFactory.build()
malformed_wifi = WifiShardFactory.build()
malformed_wifi.mac = 'abcd'
query = self.model_query(
geoip_db, http_session, session, stats,
wifis=[wifi, malformed_wifi])
self.check_should_search(source, query, False)
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 (+1m, +1.2m)
wifi1 = WifiShardFactory.build()
wifis = []
for i in range(0, MAX_WIFIS_IN_CLUSTER + 10):
wifis.append(WifiShardFactory(lat=wifi1.lat + i * 0.00001,
lon=wifi1.lon + i * 0.000012,
samples=100 - i))
self.session.flush()
# calculate expected result
lat, lon = numpy.array(
[(wifi.lat, wifi.lon) for wifi in
wifis[:MAX_WIFIS_IN_CLUSTER]]).mean(axis=0)
score = sum([wifi.score(now) for wifi in wifis])
query = self.model_query(wifis=wifis)
for i, entry in enumerate(query.wifi):
entry.signal = -70 - i
results = self.source.search(query)
self.check_model_results(results, [wifi1], lat=lat, lon=lon)
self.assertAlmostEqual(
results.best(query.expected_accuracy).score, score, 4)
def test_bluetooth(self):
wifi = WifiShardFactory.build()
self._post(
[
{
"position": {"latitude": wifi.lat, "longitude": wifi.lon},
"bluetoothBeacons": [
{"macAddress": wifi.mac, "name": "my-beacon", "age": 3, "signalStrength": -90, "xtra_field": 4},
{"name": "beacon-2", "signalStrength": -92},
],
"wifiAccessPoints": [{"signalStrength": -52}],
}
]
)
self._assert_queue_size(1)
item = self.queue.dequeue(self.queue.queue_key())[0]
report = item["report"]
self.assertTrue("timestamp" in report)
position = report["position"]
self.assertEqual(position["latitude"], wifi.lat)
self.assertEqual(position["longitude"], wifi.lon)
blues = report["bluetoothBeacons"]
self.assertEqual(len(blues), 1)
self.assertEqual(blues[0]["macAddress"], wifi.mac)
self.assertEqual(blues[0]["age"], 3),
self.assertEqual(blues[0]["name"], "my-beacon"),
self.assertEqual(blues[0]["signalStrength"], -90),
self.assertFalse("xtra_field" in blues[0])
wifis = report["wifiAccessPoints"]
self.assertEqual(len(wifis), 0)
def test_minimal(self):
wifi = WifiShardFactory.build()
data = SUBMIT_V0_SCHEMA.deserialize(
{"items": [{"lat": wifi.lat, "lon": wifi.lon, "wifi": [{"key": "ab"}]}]}
)
assert "items" in data
assert len(data["items"]) == 1
def test_wifi(self):
wifi = WifiShardFactory.build()
self._post([{
'lat': wifi.lat,
'lon': wifi.lon,
'accuracy': 17.1,
'wifi': [{'key': wifi.mac.upper(),
'frequency': 2437,
'signal': -70,
'signalToNoiseRatio': 5,
'ssid': 'my-wifi',
}]
}])
self._assert_queue_size(1)
item = self.queue.dequeue(self.queue.queue_key())[0]
self.assertEqual(item['metadata']['api_key'], None)
report = item['report']
position = report['position']
self.assertEqual(position['latitude'], wifi.lat)
self.assertEqual(position['longitude'], wifi.lon)
self.assertEqual(position['accuracy'], 17.1)
self.assertFalse('altitude' in position)
self.assertFalse('altitudeAccuracy' in position)
wifis = report['wifiAccessPoints']
self.assertEqual(wifis[0]['macAddress'], wifi.mac.upper())
self.assertFalse('channel' in wifis[0])
self.assertEqual(wifis[0]['frequency'], 2437)
self.assertEqual(wifis[0]['signalStrength'], -70)
self.assertEqual(wifis[0]['signalToNoiseRatio'], 5)
self.assertEqual(wifis[0]['ssid'], 'my-wifi')
def test_minimal(self):
wifi = WifiShardFactory.build()
data = SUBMIT_V0_SCHEMA.deserialize(
{'items': [{'lat': wifi.lat, 'lon': wifi.lon,
'wifi': [{'key': 'ab'}]}]})
assert 'items' in data
assert len(data['items']) == 1
def test_error(self, app, celery, raven):
wifi = WifiShardFactory.build()
res = app.post_json(
'/v1/submit',
[{'lat': wifi.lat, 'lon': wifi.lon, 'cell': []}],
status=400)
assert res.json == ParseError.json_body()
def test_minimal(self):
wifi = WifiShardFactory.build()
data = self.schema.deserialize(
{'items': [{'lat': wifi.lat, 'lon': wifi.lon,
'wifi': [{'key': 'ab'}]}]})
self.assertTrue('items' in data)
self.assertEqual(len(data['items']), 1)
def test_minimal(self):
wifi = WifiShardFactory.build()
data = SUBMIT_V0_SCHEMA.deserialize(
{'items': [{'lat': wifi.lat, 'lon': wifi.lon,
'wifi': [{'key': 'ab'}]}]})
assert 'items' in data
assert len(data['items']) == 1
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_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_wifi(self):
wifi = WifiShardFactory.build()
self._post([{
'lat':
wifi.lat,
'lon':
wifi.lon,
'accuracy':
17.1,
'wifi': [{
'key': wifi.mac.upper(),
'frequency': 2437,
'signal': -70,
'signalToNoiseRatio': 5,
'ssid': 'my-wifi',
}]
}])
self._assert_queue_size(1)
item = self.queue.dequeue(self.queue.queue_key())[0]
self.assertEqual(item['metadata']['api_key'], None)
report = item['report']
position = report['position']
self.assertEqual(position['latitude'], wifi.lat)
self.assertEqual(position['longitude'], wifi.lon)
self.assertEqual(position['accuracy'], 17.1)
self.assertFalse('altitude' in position)
self.assertFalse('altitudeAccuracy' in position)
wifis = report['wifiAccessPoints']
self.assertEqual(wifis[0]['macAddress'], wifi.mac.upper())
self.assertFalse('channel' in wifis[0])
self.assertEqual(wifis[0]['frequency'], 2437)
self.assertEqual(wifis[0]['signalStrength'], -70)
self.assertEqual(wifis[0]['signalToNoiseRatio'], 5)
self.assertEqual(wifis[0]['ssid'], 'my-wifi')
def test_error(self):
wifi = WifiShardFactory.build()
self._post(
[{"position": {"latitude": wifi.lat, "longitude": wifi.lon}, "wifiAccessPoints": [{"macAddress": 10}]}],
status=400,
)
self._assert_queue_size(0)
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_minimal(self):
wifi = WifiShardFactory.build()
data = self.schema.deserialize(
{'items': [{'lat': wifi.lat, 'lon': wifi.lon,
'wifi': [{'key': 'ab'}]}]})
self.assertTrue('items' in data)
self.assertEqual(len(data['items']), 1)
def test_weight(self, geoip_db, http_session,
session, source, stats):
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, stats,
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_top_results_in_noisy_cluster(self, geoip_db, http_session,
session, source, stats):
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))
session.flush()
# calculate expected result
score = sum([wifi.score(now) for wifi in wifis])
query = self.model_query(
geoip_db, http_session, session, stats,
wifis=wifis)
for i, entry in enumerate(query.wifi):
entry.signalStrength = -50 - i
results = source.search(query)
result = results.best()
assert round(result.lat, 4) == round(wifi1.lat, 4)
assert round(result.lon, 4) == round(wifi1.lon, 4)
assert round(result.score, 4) == round(score, 4)
def test_error_missing_latlon(self, app, celery):
wifi = WifiShardFactory.build()
self._post(
app,
[
{
"lat": wifi.lat,
"lon": wifi.lon,
"accuracy": 17.0,
"wifi": [{
"key": wifi.mac
}],
},
{
"wifi": [{
"key": wifi.mac
}],
"accuracy": 16.0
},
{
"wifi": [{
"key": wifi.mac
}]
},
],
)
assert self.queue(celery).size() == 3
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_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_error_missing_latlon(self, app, celery):
wifi = WifiShardFactory.build()
self._post(
app,
[
{
"latitude": wifi.lat,
"longitude": wifi.lon,
"accuracy": 17.0,
"wifiAccessPoints": [{
"macAddress": wifi.mac
}],
},
{
"wifiAccessPoints": [{
"macAddress": wifi.mac
}],
"accuracy": 16.0
},
{
"wifiAccessPoints": [{
"macAddress": wifi.mac
}]
},
],
)
assert self.queue(celery).size() == 3
def test_error(self):
wifi = WifiShardFactory.build()
res = self.app.post_json(
'/v1/submit',
[{'lat': wifi.lat, 'lon': wifi.lon, 'cell': []}],
status=400)
self.assertEqual(res.json, ParseError.json_body())
self.check_raven(['ParseError'])
def test_wifi_duplicates(self):
wifi = WifiShardFactory.build()
query = Query(wifi=[
{'mac': wifi.mac, 'signal': -90},
{'mac': wifi.mac, 'signal': -82},
{'mac': wifi.mac, 'signal': -85},
])
self.assertEqual(len(query.wifi), 0)
def test_check_one_wifi(self, geoip_db, http_session,
session, source, stats):
wifi = WifiShardFactory.build()
query = self.model_query(
geoip_db, http_session, session, stats,
wifis=[wifi])
self.check_should_search(source, query, False)
def test_wifi_duplicates(self):
wifi = WifiShardFactory.build()
query = Query(wifi=[
{'mac': wifi.mac, 'signal': -90},
{'mac': wifi.mac, 'signal': -82},
{'mac': wifi.mac, 'signal': -85},
])
self.assertEqual(len(query.wifi), 0)
def test_wifi_duplicates(self):
wifi = WifiShardFactory.build()
query = Query(wifi=[
{'macAddress': wifi.mac, 'signalStrength': -90},
{'macAddress': wifi.mac, 'signalStrength': -82},
{'macAddress': wifi.mac, 'signalStrength': -85},
])
assert len(query.wifi) == 0
def test_error(self, app, celery, raven):
wifi = WifiShardFactory.build()
res = app.post_json(
'/v1/submit',
[{'lat': wifi.lat, 'lon': wifi.lon, 'cell': []}],
status=400)
assert res.json == ParseError.json_body()
raven.check(['ParseError'])
def test_error(self):
wifi = WifiShardFactory.build()
res = self.app.post_json(
'/v1/submit',
[{'lat': wifi.lat, 'lon': wifi.lon, 'cell': []}],
status=400)
self.assertEqual(res.json, ParseError.json_body())
self.check_raven(['ParseError'])
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_similar_many_found_clusters(self):
wifi = WifiShardFactory(mac='00000000001f')
wifi2 = WifiShardFactory(mac='000000000024',
lat=wifi.lat + 0.00004,
lon=wifi.lon + 0.00004)
other_wifi = [
WifiShardFactory.build(mac='000000000020'),
WifiShardFactory.build(mac='000000000021'),
WifiShardFactory.build(mac='000000000022'),
WifiShardFactory.build(mac='000000000023'),
]
self.session.flush()
query = self.model_query(wifis=[wifi, wifi2] + other_wifi)
result = self.source.search(query)
self.check_model_result(
result, wifi,
lat=wifi.lat + 0.00002, lon=wifi.lon + 0.00002)
def test_empty_wifi_entry(self):
wifi = WifiShardFactory.build()
data = SUBMIT_V0_SCHEMA.deserialize(
{"items": [{
"lat": wifi.lat,
"lon": wifi.lon,
"wifi": [{}]
}]})
assert data == {"items": []}
def test_error(self, app, celery, raven):
wifi = WifiShardFactory.build()
res = app.post_json("/v1/submit", [{
"lat": wifi.lat,
"lon": wifi.lon,
"cell": []
}],
status=400)
assert res.json == ParseError.json_body()
def test_check_one_wifi(self, geoip_db, http_session, session, source,
stats):
wifi = WifiShardFactory.build()
query = self.model_query(geoip_db,
http_session,
session,
stats,
wifis=[wifi])
self.check_should_search(source, query, False)
def test_error(self):
wifi = WifiShardFactory.build()
self._post([{
'latitude': wifi.lat,
'longitude': wifi.lon,
'wifiAccessPoints': [{
'macAddress': 10,
}],
}], status=400)
self._assert_queue_size(0)
def test_error(self, app, celery, raven):
wifi = WifiShardFactory.build()
self._post(app, [{
'latitude': wifi.lat,
'longitude': wifi.lon,
'wifiAccessPoints': [{
'macAddress': 10,
}],
}], status=400)
assert self.queue(celery).size() == 0
def test_error(self, app, celery, raven):
wifi = WifiShardFactory.build()
self._post(app, [{
'latitude': wifi.lat,
'longitude': wifi.lon,
'wifiAccessPoints': [{
'macAddress': 10,
}],
}],
status=400)
assert self.queue(celery).size() == 0
def test_error(self):
wifi = WifiShardFactory.build()
self._post([{
'latitude': wifi.lat,
'longitude': wifi.lon,
'wifiAccessPoints': [{
'macAddress': 10,
}],
}],
status=400)
self.assertEqual(self.queue.size(), 0)
def test_empty_wifi_entry(self):
wifi = WifiShardFactory.build()
data = self.schema.deserialize(
{'items': [
{
'lat': wifi.lat,
'lon': wifi.lon,
'wifi': [{}]
},
]})
self.assertEqual(data, {'items': []})
def test_error_missing_latlon(self):
wifi = WifiShardFactory.build()
self._post([
{'lat': wifi.lat,
'lon': wifi.lon,
'accuracy': 17.0,
'wifi': [{'key': wifi.mac}],
},
{'wifi': [{'key': wifi.mac}],
'accuracy': 16.0},
])
self._assert_queue_size(2)
def test_error(self):
wifi = WifiShardFactory.build()
self._post([{
'position': {
'latitude': wifi.lat,
'longitude': wifi.lon,
},
'wifiAccessPoints': [{
'macAddress': 10,
}],
}], status=400)
self.assertEqual(self.queue.size(), 0)
def test_error_not_dict(self, app, celery, raven):
wifi = WifiShardFactory.build()
res = app.post_json(
"/v1/submit", [{"lat": wifi.lat, "lon": wifi.lon, "cell": []}], status=400
)
detail = {
"": (
"\"[{'lat': 51.5, 'lon': -0.1, 'cell': []}]\" is not a mapping"
" type: Does not implement dict-like functionality."
)
}
assert res.json == ParseError({"validation": detail}).json_body()
def test_error_missing_latlon(self):
wifi = WifiShardFactory.build()
self._post([
{'lat': wifi.lat,
'lon': wifi.lon,
'accuracy': 17.0,
'wifi': [{'key': wifi.mac}],
},
{'wifi': [{'key': wifi.mac}],
'accuracy': 16.0},
])
self.assertEqual(self.queue.size(), 2)
def test_timestamp(self):
wifi = WifiShardFactory.build()
data = SUBMIT_V0_SCHEMA.deserialize(
{"items": [{"time": "2016-04-07T03:33:20", "wifi": [{"key": wifi.mac}]}]}
)
assert data["items"][0]["timestamp"] == 146 * 10 ** 10
data = SUBMIT_V0_SCHEMA.deserialize(
{"items": [{"time": "1710-02-28", "wifi": [{"key": wifi.mac}]}]}
)
# 1710 was discarded and replaced by 'now'
assert data["items"][0]["timestamp"] > 10 ** 12
def test_timestamp(self):
wifi = WifiShardFactory.build()
data = SUBMIT_V0_SCHEMA.deserialize(
{'items': [{'time': '2016-04-07T03:33:20',
'wifi': [{'key': wifi.mac}]}]})
assert data['items'][0]['timestamp'] == 146 * 10 ** 10
data = SUBMIT_V0_SCHEMA.deserialize(
{'items': [{'time': '1710-02-28',
'wifi': [{'key': wifi.mac}]}]})
# 1710 was discarded and replaced by 'now'
assert data['items'][0]['timestamp'] > 10 ** 12
def test_error_missing_latlon(self, app, celery):
wifi = WifiShardFactory.build()
self._post(app, [
{'lat': wifi.lat,
'lon': wifi.lon,
'accuracy': 17.0,
'wifi': [{'key': wifi.mac}],
},
{'wifi': [{'key': wifi.mac}],
'accuracy': 16.0},
{'wifi': [{'key': wifi.mac}]},
])
assert self.queue(celery).size() == 3
def test_timestamp(self):
wifi = WifiShardFactory.build()
data = self.schema.deserialize(
{'items': [{'time': '2016-04-07T03:33:20',
'wifi': [{'key': wifi.mac}]}]})
self.assertEqual(data['items'][0]['timestamp'], 1460000000000.0)
data = self.schema.deserialize(
{'items': [{'time': '1710-02-28',
'wifi': [{'key': wifi.mac}]}]})
# 1710 was discarded and replaced by 'now'
self.assertTrue(data['items'][0]['timestamp'] > 0.0)
def test_timestamp(self):
wifi = WifiShardFactory.build()
data = SUBMIT_V0_SCHEMA.deserialize(
{'items': [{'time': '2016-04-07T03:33:20',
'wifi': [{'key': wifi.mac}]}]})
assert data['items'][0]['timestamp'] == 146 * 10 ** 10
data = SUBMIT_V0_SCHEMA.deserialize(
{'items': [{'time': '1710-02-28',
'wifi': [{'key': wifi.mac}]}]})
# 1710 was discarded and replaced by 'now'
assert data['items'][0]['timestamp'] > 10 ** 12
def test_error_missing_latlon(self, app, celery):
wifi = WifiShardFactory.build()
self._post(app, [
{'latitude': wifi.lat,
'longitude': wifi.lon,
'accuracy': 17.0,
'wifiAccessPoints': [{'macAddress': wifi.mac}],
},
{'wifiAccessPoints': [{'macAddress': wifi.mac}],
'accuracy': 16.0},
{'wifiAccessPoints': [{'macAddress': wifi.mac}]},
])
assert self.queue(celery).size() == 3
def test_error_missing_latlon(self, app, celery):
wifi = WifiShardFactory.build()
self._post(app, [
{'lat': wifi.lat,
'lon': wifi.lon,
'accuracy': 17.0,
'wifi': [{'key': wifi.mac}],
},
{'wifi': [{'key': wifi.mac}],
'accuracy': 16.0},
{'wifi': [{'key': wifi.mac}]},
])
assert self.queue(celery).size() == 3
def test_timestamp(self):
wifi = WifiShardFactory.build()
data = SUBMIT_V1_SCHEMA.deserialize(
{'items': [{'timestamp': 146 * 10 ** 10,
'wifiAccessPoints': [{'macAddress': wifi.mac}]}]})
assert data['items'][0]['timestamp'] == 146 * 10 ** 10
data = SUBMIT_V1_SCHEMA.deserialize(
{'items': [{'timestamp': 146 * 10 ** 9,
'wifiAccessPoints': [{'macAddress': wifi.mac}]}]})
# value was discarded and replaced by 'now'
assert data['items'][0]['timestamp'] > 10 ** 12
def test_timestamp(self):
wifi = WifiShardFactory.build()
data = self.schema.deserialize(
{'items': [{'timestamp': 1460000000000.0,
'wifiAccessPoints': [{'macAddress': wifi.mac}]}]})
self.assertEqual(data['items'][0]['timestamp'], 1460000000000.0)
data = self.schema.deserialize(
{'items': [{'timestamp': -10000.0,
'wifiAccessPoints': [{'macAddress': wifi.mac}]}]})
# 1710 was discarded and replaced by 'now'
self.assertTrue(data['items'][0]['timestamp'] > 0.0)
def test_error(self):
wifi = WifiShardFactory.build()
self._post([{
'position': {
'latitude': wifi.lat,
'longitude': wifi.lon,
},
'wifiAccessPoints': [{
'macAddress': 10,
}],
}],
status=400)
self._assert_queue_size(0)
def test_error_invalid_float(self, app, celery):
wifi = WifiShardFactory.build()
self._post(app, [{
'latitude': wifi.lat,
'longitude': wifi.lon,
'accuracy': float('+nan'),
'altitude': float('-inf'),
'wifiAccessPoints': [{
'macAddress': wifi.mac,
}],
}])
assert self.queue(celery).size() == 1
item = self.queue(celery).dequeue()[0]
position = item['report']['position']
assert 'accuracy' not in position
assert 'altitude' not in position
def test_error_invalid_float(self):
wifi = WifiShardFactory.build()
self._post([{
'latitude': wifi.lat,
'longitude': wifi.lon,
'accuracy': float('+nan'),
'altitude': float('-inf'),
'wifiAccessPoints': [{
'macAddress': wifi.mac,
}],
}])
self._assert_queue_size(1)
item = self.queue.dequeue(self.queue.queue_key())[0]
position = item['report']['position']
self.assertFalse('accuracy' in position)
self.assertFalse('altitude' in position)
def test_wifi(self):
wifi = WifiShardFactory.build()
self._post(
[
{
"position": {"latitude": wifi.lat, "longitude": wifi.lon},
"wifiAccessPoints": [
{
"macAddress": wifi.mac,
"ssid": "my-wifi",
"age": 3,
"channel": 5,
"frequency": 2437,
"radioType": "802.11n",
"signalStrength": -90,
"signalToNoiseRatio": 5,
"ssid": "my-wifi",
"xtra_field": 3,
}
],
}
]
)
self._assert_queue_size(1)
item = self.queue.dequeue(self.queue.queue_key())[0]
self.assertEqual(item["metadata"]["api_key"], None)
report = item["report"]
self.assertTrue("timestamp" in report)
position = report["position"]
self.assertEqual(position["latitude"], wifi.lat)
self.assertEqual(position["longitude"], wifi.lon)
wifis = item["report"]["wifiAccessPoints"]
self.assertEqual(len(wifis), 1)
self.assertEqual(wifis[0]["macAddress"], wifi.mac)
self.assertEqual(wifis[0]["age"], 3),
self.assertEqual(wifis[0]["channel"], 5),
self.assertEqual(wifis[0]["frequency"], 2437),
self.assertEqual(wifis[0]["radioType"], "802.11n")
self.assertEqual(wifis[0]["signalStrength"], -90),
self.assertEqual(wifis[0]["signalToNoiseRatio"], 5),
self.assertEqual(wifis[0]["ssid"], "my-wifi"),
self.assertFalse("xtra_field" in wifis[0])
