def test_should_not_provide_location_if_malformed_wifi(self):
wifi = WifiFactory.build()
malformed_wifi = WifiFactory.build()
malformed_wifi.key = 'abcd'
query = self.model_query(wifis=[wifi, malformed_wifi])
self.check_should_locate(query, False)
def test_blacklist(self):
utcnow = util.utcnow()
bad_wifi = WifiFactory.build()
good_wifi = WifiFactory.build()
black = WifiBlacklist(time=utcnow, count=1, key=bad_wifi.key)
self.session.add(black)
self.session.flush()
obs = dict(lat=good_wifi.lat, lon=good_wifi.lon)
entries = [
{'key': good_wifi.key},
{'key': good_wifi.key},
{'key': bad_wifi.key},
]
for entry in entries:
entry.update(obs)
result = insert_measures_wifi.delay(entries)
self.assertEqual(result.get(), 2)
self.assertEqual(self.data_queue.size(), 2)
update_wifi.delay().get()
wifis = self.session.query(Wifi).all()
self.assertEqual(len(wifis), 1)
self._compare_sets([w.key for w in wifis], [good_wifi.key])
self.check_statcounter(StatKey.wifi, 2)
self.check_statcounter(StatKey.unique_wifi, 1)
def test_max_min_range_update(self):
wifi = WifiFactory(range=100, total_measures=4)
wifi_lat = wifi.lat
wifi_lon = wifi.lon
wifi.max_lat = wifi.lat + 0.001
wifi.min_lat = wifi.lat - 0.001
wifi.max_lon = wifi.lon + 0.001
wifi.min_lon = wifi.lon - 0.001
observations = [
WifiObservation(lat=wifi.lat + 0.002, lon=wifi.lon - 0.004,
key=wifi.key),
WifiObservation(lat=wifi.lat - 0.002, lon=wifi.lon + 0.01,
key=wifi.key),
]
self.data_queue.enqueue(observations)
self.session.commit()
self.assertEqual(update_wifi.delay().get(), (1, 0))
wifis = self.session.query(Wifi).all()
self.assertEqual(len(wifis), 1)
wifi = wifis[0]
self.assertAlmostEqual(wifi.lat, wifi_lat)
self.assertAlmostEqual(wifi.max_lat, wifi_lat + 0.002)
self.assertAlmostEqual(wifi.min_lat, wifi_lat - 0.002)
self.assertAlmostEqual(wifi.lon, wifi_lon + 0.001)
self.assertAlmostEqual(wifi.max_lon, wifi_lon + 0.01)
self.assertAlmostEqual(wifi.min_lon, wifi_lon - 0.004)
self.assertEqual(wifi.range, 662)
self.assertEqual(wifi.total_measures, 6)
def add_reports(self, num=1, blue_factor=0, cell_factor=1, wifi_factor=2,
api_key='test', email=None, ip=None, nickname=None,
blue_key=None, cell_mcc=None, wifi_key=None, lat=None):
reports = []
for i in range(num):
pos = CellFactory.build()
report = {
'timestamp': time.time() * 1000.0,
'position': {},
'bluetoothBeacons': [],
'cellTowers': [],
'wifiAccessPoints': [],
}
report['position']['latitude'] = lat or pos.lat
report['position']['longitude'] = pos.lon
report['position']['accuracy'] = 17 + i
blues = WifiFactory.build_batch(blue_factor,
lat=pos.lat, lon=pos.lon)
for blue in blues:
blue_data = {
'macAddress': blue_key or blue.key,
'signalStrength': -100 + i,
}
report['bluetoothBeacons'].append(blue_data)
cells = CellFactory.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 = WifiFactory.build_batch(wifi_factor,
lat=pos.lat, lon=pos.lon)
for wifi in wifis:
wifi_data = {
'macAddress': wifi_key or wifi.key,
'signalStrength': -90 + i,
}
report['wifiAccessPoints'].append(wifi_data)
reports.append(report)
queue_reports.delay(reports=reports, api_key=api_key,
email=email, ip=ip, nickname=nickname).get()
return reports
def test_ok_wifi(self):
session = self.session
wifis = WifiFactory.create_batch(4)
new_wifi = WifiFactory()
session.flush()
res = self.app.post_json('/v1/geosubmit?key=test', {
"items": [
{
"latitude":
wifis[0].lat,
"longitude":
wifis[0].lon,
"wifiAccessPoints": [
{
"macAddress": wifis[0].key
},
{
"macAddress": wifis[1].key
},
{
"macAddress": wifis[2].key
},
{
"macAddress": wifis[3].key
},
{
"macAddress": new_wifi.key
},
]
},
]
},
status=200)
self.assertEqual(res.content_type, 'application/json')
self.assertEqual(res.json, {})
# Check that new wifi exists
query = session.query(Wifi)
count = query.filter(Wifi.key == new_wifi.key).count()
self.assertEquals(count, 1)
# check that WifiObservation records are created
self.assertEquals(session.query(WifiObservation).count(), 5)
self.check_stats(counter=[
'items.api_log.test.uploaded.batches',
'items.api_log.test.uploaded.reports',
'items.api_log.test.uploaded.wifi_observations',
'items.uploaded.wifi_observations',
],
timer=['items.api_log.test.uploaded.batch_size'])
def test_wifi_prefer_larger_cluster_over_high_signal(self):
wifi = WifiFactory()
wifis = WifiFactory.create_batch(3, lat=wifi.lat, lon=wifi.lon)
wifis2 = WifiFactory.create_batch(3, lat=wifi.lat + 1.0, lon=wifi.lon)
self.session.flush()
query = self.model_query(wifis=[wifi] + wifis + wifis2)
for entry in query.wifi[:-3]:
entry['signal'] = -80
for entry in query.wifi[-3:]:
entry['signal'] = -70
location = self.provider.locate(query)
self.check_model_location(location, wifi)
def test_wifi(self):
wifi = WifiFactory.build()
self._post([{
'latitude': wifi.lat,
'longitude': wifi.lon,
'wifiAccessPoints': [{
'macAddress': wifi.key,
'age': 3,
'channel': 5,
'frequency': 2437,
'radioType': '802.11n',
'signalStrength': -90,
'signalToNoiseRatio': 5,
'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.key)
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.assertFalse('xtra_field' in wifis[0])
def test_geoip_fallback(self):
london = self.geoip_data['London']
wifis = WifiFactory.build_batch(4)
res = self.app.post_json(
'%s?key=test' % self.url, {
"wifiAccessPoints": [
{
"macAddress": wifis[0].key
},
{
"macAddress": wifis[1].key
},
{
"macAddress": wifis[2].key
},
{
"macAddress": wifis[3].key
},
]
},
extra_environ={'HTTP_X_FORWARDED_FOR': london['ip']},
status=200)
self.assertEqual(res.content_type, 'application/json')
self.assertEqual(
res.json, {
"location": {
"lat": london['latitude'],
"lng": london['longitude']
},
"accuracy": london['accuracy']
})
def test_log_unknown_api_key(self):
wifis = WifiFactory.create_batch(2)
self.app.post_json('/v1/geosubmit?key=invalidkey', {
"items": [
{
"latitude":
wifis[0].lat,
"longitude":
wifis[0].lon,
"wifiAccessPoints": [
{
"macAddress": wifis[0].key
},
{
"macAddress": wifis[1].key
},
]
},
]
},
status=200)
self.check_stats(counter=[
'geosubmit.unknown_api_key', ('geosubmit.api_key.invalidkey', 0)
])
def test_wifi(self):
wifi = WifiFactory.build()
self._post([{
'lat': wifi.lat,
'lon': wifi.lon,
'accuracy': 17,
'wifi': [{'key': wifi.key.upper(),
'frequency': 2437,
'signal': -70,
'signalToNoiseRatio': 5,
}]
}])
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)
self.assertFalse('altitude' in position)
self.assertFalse('altitudeAccuracy' in position)
wifis = report['wifiAccessPoints']
self.assertEqual(wifis[0]['macAddress'], wifi.key.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)
def test_minimal(self):
schema = SubmitV1Schema()
wifi = WifiFactory.build()
data = schema.deserialize(
{'items': [{'lat': wifi.lat, 'lon': wifi.lon, 'wifi': [{}]}]})
self.assertTrue('items' in data)
self.assertEqual(len(data['items']), 1)
def test_wifi_not_found(self):
wifis = WifiFactory.build_batch(2)
res = self.app.post_json(
'%s?key=test' % self.url, {
'wifiAccessPoints': [
{'macAddress': wifis[0].key},
{'macAddress': wifis[1].key},
]},
status=404)
self.assertEqual(res.content_type, 'application/json')
self.assertEqual(
res.json, {'error': {
'errors': [{
'domain': 'geolocation',
'reason': 'notFound',
'message': 'Not found',
}],
'code': 404,
'message': 'Not found'
}}
)
# Make sure to get two counters, a timer, and no traceback
self.check_stats(
counter=[self.metric + '.api_key.test',
self.metric + '.api_log.test.wifi_miss',
self.metric_url + '.404'],
timer=[self.metric_url])
def test_email_header(self):
nickname = 'World Tr\xc3\xa4veler'
email = 'world_tr\xc3\[email protected]'
session = self.session
wifis = WifiFactory.create_batch(2)
self.app.post_json('/v1/geosubmit?key=test', {
"items": [
{
"latitude":
wifis[0].lat,
"longitude":
wifis[0].lon,
"wifiAccessPoints": [
{
"macAddress": wifis[0].key
},
{
"macAddress": wifis[1].key
},
]
},
]
},
headers={
'X-Nickname': nickname,
'X-Email': email,
},
status=200)
session = self.session
result = session.query(User).all()
self.assertEqual(len(result), 1)
self.assertEqual(result[0].email, email.decode('utf-8'))
def test_no_call_made_when_not_allowed_for_apikey(self):
cells = CellFactory.build_batch(2)
wifis = WifiFactory.build_batch(2)
self.provider.api_key.allow_fallback = False
query = self.model_query(cells=cells, wifis=wifis)
self.check_should_locate(query, False)
def test_wifi_not_found(self):
wifis = WifiFactory.build_batch(2)
res = self.app.post_json(
'%s?key=test' % self.url, {
"wifiAccessPoints": [
{"macAddress": wifis[0].key},
{"macAddress": wifis[1].key},
]},
status=404)
self.assertEqual(res.content_type, 'application/json')
self.assertEqual(
res.json, {"error": {
"errors": [{
"domain": "geolocation",
"reason": "notFound",
"message": "Not found",
}],
"code": 404,
"message": "Not found"
}}
)
# Make sure to get two counters, a timer, and no traceback
self.check_stats(
counter=[self.metric + '.api_key.test',
self.metric + '.api_log.test.wifi_miss',
self.metric_url + '.404'],
timer=[self.metric_url])
self.check_raven(total=0)
def test_duplicated_wifi_observations(self):
session = self.session
wifi = WifiFactory.build()
self.app.post_json('/v1/geosubmit?key=test', {
"items": [
{
"latitude":
wifi.lat,
"longitude":
wifi.lon,
"wifiAccessPoints": [
{
"macAddress": wifi.key,
"signalStrength": -92
},
{
"macAddress": wifi.key,
"signalStrength": -77
},
]
},
]
},
status=200)
self.assertEquals(session.query(WifiObservation).count(), 1)
def setUp(self):
super(TestFallbackProvider, self).setUp()
self.provider.api_key.allow_fallback = True
self.response_location = {
'location': {
'lat': 51.5366,
'lng': 0.03989,
},
'accuracy': 1500,
'fallback': 'lacf',
}
self.cells = []
for cell in CellFactory.build_batch(2):
self.cells.append({
'radio': cell.radio,
'mcc': cell.mcc,
'mnc': cell.mnc,
'lac': cell.lac,
'cid': cell.cid,
'signal': -70,
})
self.cells[0]['ta'] = 1
self.wifis = []
for wifi in WifiFactory.build_batch(2):
self.wifis.append({
'key': wifi.key,
'signal': -77,
})
self.wifis[0]['channel'] = 6
self.wifis[0]['frequency'] = 2437
self.wifis[0]['snr'] = 13
def add_reports(self, number=3, api_key='test', email=None):
reports = []
for i in range(number):
report = {
'timestamp': time.time() * 1000.0,
'position': {},
'cellTowers': [],
'wifiAccessPoints': [],
}
cell = CellFactory.build()
report['position']['latitude'] = cell.lat
report['position']['longitude'] = cell.lon
report['position']['accuracy'] = 17 + i
cell_data = {
'radioType': cell.radio.name,
'mobileCountryCode': cell.mcc,
'mobileNetworkCode': cell.mnc,
'locationAreaCode': cell.lac,
'cellId': cell.cid,
'primaryScramblingCode': cell.psc,
'signalStrength': -110 + i,
}
report['cellTowers'].append(cell_data)
wifis = WifiFactory.build_batch(2, lat=cell.lat, lon=cell.lon)
for wifi in wifis:
wifi_data = {
'macAddress': wifi.key,
'signalStrength': -90 + i,
}
report['wifiAccessPoints'].append(wifi_data)
reports.append(report)
queue_reports.delay(
reports=reports, api_key=api_key, email=email).get()
return reports
def test_database_error(self):
london = self.geoip_data['London']
self.session.execute(text('drop table wifi;'))
self.session.execute(text('drop table cell;'))
cell = CellFactory.build()
wifis = WifiFactory.build_batch(2)
res = self.app.post_json(
'/v1/geolocate?key=test', {
'cellTowers': [{
'radioType': cell.radio.name,
'mobileCountryCode': cell.mcc,
'mobileNetworkCode': cell.mnc,
'locationAreaCode': cell.lac,
'cellId': cell.cid},
],
'wifiAccessPoints': [
{'macAddress': wifis[0].key},
{'macAddress': wifis[1].key},
]},
extra_environ={'HTTP_X_FORWARDED_FOR': london['ip']},
status=200)
self.assertEqual(res.content_type, 'application/json')
self.assertEqual(res.json, {'location': {'lat': london['latitude'],
'lng': london['longitude']},
'accuracy': london['accuracy']})
self.check_stats(
timer=['request.v1.geolocate'],
counter=[
'request.v1.geolocate.200',
'geolocate.geoip_hit',
])
self.check_raven([('ProgrammingError', 2)])
def add_reports(self, number=3, api_key='test', email=None):
reports = []
for i in range(number):
report = {
'timestamp': time.time() * 1000.0,
'position': {},
'cellTowers': [],
'wifiAccessPoints': [],
}
cell = CellFactory.build()
report['position']['latitude'] = cell.lat
report['position']['longitude'] = cell.lon
report['position']['accuracy'] = 17 + i
cell_data = {
'radioType': cell.radio.name,
'mobileCountryCode': cell.mcc,
'mobileNetworkCode': cell.mnc,
'locationAreaCode': cell.lac,
'cellId': cell.cid,
'primaryScramblingCode': cell.psc,
'signalStrength': -110 + i,
}
report['cellTowers'].append(cell_data)
wifis = WifiFactory.build_batch(2, lat=cell.lat, lon=cell.lon)
for wifi in wifis:
wifi_data = {
'macAddress': wifi.key,
'signalStrength': -90 + i,
}
report['wifiAccessPoints'].append(wifi_data)
reports.append(report)
queue_reports.delay(reports=reports, api_key=api_key,
email=email).get()
return reports
def test_bluetooth(self):
wifi = WifiFactory.build()
self._post([{
'position': {
'latitude': wifi.lat,
'longitude': wifi.lon,
},
'bluetoothBeacons': [{
'macAddress': wifi.key,
'name': 'my-beacon',
'age': 3,
'signalStrength': -90,
'xtra_field': 4,
}],
'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.key)
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), 1)
def test_empty_wifi_entry(self):
schema = ReportV1Schema()
wifi = WifiFactory.build()
request = self._make_request(
'{"lat": %s, "lon": %s, "wifi": [{}]}' % (wifi.lat, wifi.lon))
data, errors = preprocess_request(request, schema, None)
self.assertFalse(errors)
def test_email_header(self):
nickname = 'World Tr\xc3\xa4veler'
email = 'world_tr\xc3\[email protected]'
session = self.session
wifis = WifiFactory.create_batch(2)
self.app.post_json(
'/v1/geosubmit?key=test',
{"items": [{
"latitude": wifis[0].lat,
"longitude": wifis[0].lon,
"wifiAccessPoints": [
{"macAddress": wifis[0].key},
{"macAddress": wifis[1].key},
]},
]},
headers={
'X-Nickname': nickname,
'X-Email': email,
},
status=200)
session = self.session
result = session.query(User).all()
self.assertEqual(len(result), 1)
self.assertEqual(result[0].email, email.decode('utf-8'))
def test_wifi_too_few_candidates(self):
wifis = WifiFactory.create_batch(2)
self.session.flush()
query = self.model_query(wifis=[wifis[0]])
location = self.provider.locate(query)
self.check_model_location(location, None)
def test_should_not_provide_location_if_non_geoip_location_found(self):
wifis = WifiFactory.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_locate(query, False, location=internal_pos)
def test_fallback_used_when_geoip_also_present(self):
cells = CellFactory.build_batch(2, radio=Radio.wcdma)
wifis = WifiFactory.build_batch(3)
api_key = ApiKey.getkey(self.session, 'test')
api_key.allow_fallback = True
self.session.flush()
with requests_mock.Mocker() as mock:
response_location = {
'location': {
'lat': 1.0,
'lng': 1.0,
},
'accuracy': 100,
}
mock.register_uri(
'POST', requests_mock.ANY, json=response_location)
query = self.model_query(cells=cells, wifis=wifis)
res = self._call(body=query, ip=self.test_ip)
send_json = mock.request_history[0].json()
self.assertEqual(len(send_json['cellTowers']), 2)
self.assertEqual(len(send_json['wifiAccessPoints']), 3)
self.check_model_response(res, None, lat=1.0, lon=1.0, accuracy=100)
self.check_stats(
timer=[self.metric_url],
counter=[self.metric + '.api_key.test',
self.metric + '.fallback_hit',
self.metric_url + '.200',
self.metric + '.api_log.test.fallback_hit'],
)
def test_wifi_too_few_matches(self):
wifis = WifiFactory.create_batch(3)
wifis[0].lat = None
self.session.flush()
query = self.model_query(wifis=wifis[:2])
location = self.provider.locate(query)
self.check_model_location(location, None, used=True)
def test_wifi_similar_bssids_but_enough_found_clusters(self):
wifi = WifiFactory(key='00000000001f')
wifi2 = WifiFactory(key='000000000024',
lat=wifi.lat + 0.00004, lon=wifi.lon + 0.00004)
other_wifi = [
WifiFactory.build(key='000000000020'),
WifiFactory.build(key='000000000021'),
WifiFactory.build(key='000000000022'),
WifiFactory.build(key='000000000023'),
]
self.session.flush()
query = self.model_query(wifis=[wifi, wifi2] + other_wifi)
location = self.provider.locate(query)
self.check_model_location(
location, wifi,
lat=wifi.lat + 0.00002, lon=wifi.lon + 0.00002)
def test_error(self):
wifi = WifiFactory.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_minimal(self):
schema = SubmitV1Schema()
wifi = WifiFactory.build()
request = self._make_request(
'{"items": [{"lat": %s, "lon": %s}]}' % (wifi.lat, wifi.lon))
data, errors = preprocess_request(request, schema, None)
self.assertFalse(errors)
self.assertTrue('items' in data)
self.assertEqual(len(data['items']), 1)
def test_error(self):
wifi = WifiFactory.build()
self._post([{
'latitude': wifi.lat,
'longitude': wifi.lon,
'wifiAccessPoints': [{
'macAddress': 10,
}],
}], status=400)
self._assert_queue_size(0)
def test_error(self):
wifi = WifiFactory.build()
res = self.app.post_json(
'/v1/submit',
[{'lat': wifi.lat, 'lon': wifi.lon, 'cell': []}],
status=400)
self.assertEqual(res.content_type, 'application/json')
self.assertTrue('errors' in res.json)
self.assertFalse('status' in res.json)
self.check_raven(['JSONError'])
def test_should_provide_location_if_only_geoip_location_found(self):
london = self.london_model
wifis = WifiFactory.build_batch(2)
geoip_pos = Position(
source=DataSource.GeoIP,
lat=london.lat,
lon=london.lon,
accuracy=london.range)
query = self.model_query(wifis=wifis, geoip=london.ip)
self.check_should_locate(query, True, location=geoip_pos)
def test_wifi(self):
wifis = WifiFactory.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)
self.check_stats(
counter=[self.metric + '.miss'])
def test_many_errors(self):
wifi = WifiFactory.build()
wifis = [{'wrong_key': 'ab'} for i in range(100)]
res = self.app.post_json(
'/v1/submit',
{'items': [{'lat': wifi.lat, 'lon': wifi.lon, 'wifi': wifis}]},
status=400)
self.assertEqual(res.content_type, 'application/json')
self.assertTrue('errors' in res.json)
self.assertTrue(len(res.json['errors']) < 10)
self.check_raven(['JSONError'])
def test_error_missing_latlon(self):
wifi = WifiFactory.build()
self._post([
{'lat': wifi.lat,
'lon': wifi.lon,
'accuracy': 17,
'wifi': [{'key': wifi.key}],
},
{'wifi': [{'key': wifi.key}],
'accuracy': 16},
])
self._assert_queue_size(2)
def test_ok_wifi(self):
wifi = WifiFactory()
offset = 0.0001
wifis = [
wifi,
WifiFactory(lat=wifi.lat + offset),
WifiFactory(lat=wifi.lat + offset * 2),
WifiFactory(lat=None, lon=None),
]
self.session.flush()
res = self.app.post_json('%s?key=test' % self.url, {
"wifiAccessPoints": [
{
"macAddress": wifis[0].key
},
{
"macAddress": wifis[1].key
},
{
"macAddress": wifis[2].key
},
{
"macAddress": wifis[3].key
},
]
},
status=200)
self.check_stats(counter=[
self.metric + '.api_key.test', self.metric +
'.api_log.test.wifi_hit'
])
self.assertEqual(res.content_type, 'application/json')
self.assertEqual(
res.json, {
"location": {
"lat": wifi.lat + offset,
"lng": wifi.lon
},
"accuracy": wifi.range
})
def test_unique_wifi_histogram(self):
session = self.session
today = util.utcnow()
yesterday = (today - timedelta(1))
two_days = (today - timedelta(2))
long_ago = (today - timedelta(3))
WifiFactory(key="ab1234567890", created=long_ago)
WifiFactory(key="bc1234567890", created=two_days)
WifiFactory(key="cd1234567890", created=yesterday)
WifiFactory(key="de1234567890", created=yesterday)
WifiFactory(key="ef1234567890", created=today)
session.flush()
result = unique_wifi_histogram.delay(ago=3)
added = result.get()
self.assertEqual(added, 1)
stats = session.query(Stat).order_by(Stat.time).all()
self.assertEqual(len(stats), 1)
self.assertEqual(stats[0].key, StatKey.unique_wifi)
self.assertEqual(stats[0].time, long_ago.date())
self.assertEqual(stats[0].value, 1)
# fill up newer dates
unique_wifi_histogram.delay(ago=2).get()
unique_wifi_histogram.delay(ago=1).get()
unique_wifi_histogram.delay(ago=0).get()
# test duplicate execution
unique_wifi_histogram.delay(ago=1).get()
stats = session.query(Stat.time, Stat.value).order_by(Stat.time).all()
self.assertEqual(len(stats), 4)
self.assertEqual(dict(stats), {
long_ago.date(): 1,
two_days.date(): 2,
yesterday.date(): 4,
today.date(): 5})
def test_database_error(self):
london = self.geoip_data['London']
session = self.session
stmt = text("drop table wifi;")
session.execute(stmt)
stmt = text("drop table cell;")
session.execute(stmt)
cell = CellFactory.build()
wifis = WifiFactory.build_batch(2)
res = self.app.post_json(
'/v1/geolocate?key=test', {
"cellTowers": [
{
"radioType": cell.radio.name,
"mobileCountryCode": cell.mcc,
"mobileNetworkCode": cell.mnc,
"locationAreaCode": cell.lac,
"cellId": cell.cid
},
],
"wifiAccessPoints": [
{
"macAddress": wifis[0].key
},
{
"macAddress": wifis[1].key
},
]
},
extra_environ={'HTTP_X_FORWARDED_FOR': london['ip']},
status=200)
self.assertEqual(res.content_type, 'application/json')
self.assertEqual(
res.json, {
"location": {
"lat": london['latitude'],
"lng": london['longitude']
},
"accuracy": london['accuracy']
})
self.check_stats(timer=['request.v1.geolocate'],
counter=[
'request.v1.geolocate.200',
'geolocate.geoip_hit',
])
self.check_raven([('ProgrammingError', 2)])
def test_many_errors(self):
wifi = WifiFactory.build()
wifis = [{'wrong_key': 'ab'} for i in range(100)]
res = self.app.post_json(
'/v1/submit',
{'items': [{
'lat': wifi.lat,
'lon': wifi.lon,
'wifi': wifis
}]},
status=400)
self.assertEqual(res.content_type, 'application/json')
self.assertTrue('errors' in res.json)
self.assertTrue(len(res.json['errors']) < 10)
self.check_raven(['JSONError'])
def test_invalid_latitude(self):
session = self.session
wifi = WifiFactory.build()
self.app.post_json('/v1/geosubmit?key=test', {
"items": [
{
"latitude": 12345.0,
"longitude": wifi.lon,
"wifiAccessPoints": [{
"macAddress": wifi.key,
}]
},
]
},
status=200)
self.assertEquals(session.query(WifiObservation).count(), 0)
def test_batches(self):
session = self.session
batch_size = 110
wifis = WifiFactory.create_batch(batch_size)
items = [{
"latitude": wifis[i].lat,
"longitude": wifis[i].lon + (i / 10000.0),
"wifiAccessPoints": [{
"macAddress": wifis[i].key
}]
} for i in range(batch_size)]
# let's add a bad one, this will just be skipped
items.append({'lat': 10, 'lon': 10, 'whatever': 'xx'})
self.app.post_json('/v1/geosubmit?key=test', {"items": items},
status=200)
result = session.query(WifiObservation).all()
self.assertEqual(len(result), batch_size)
def test_ok_no_existing_wifi(self):
session = self.session
wifi = WifiFactory.build()
res = self.app.post_json('/v1/geosubmit?key=test', {
"items": [
{
"latitude":
wifi.lat,
"longitude":
wifi.lon,
"wifiAccessPoints": [{
"macAddress": wifi.key,
"age": 3,
"channel": 6,
"frequency": 2437,
"signalToNoiseRatio": 13,
"signalStrength": -77,
}]
},
]
},
status=200)
self.assertEqual(res.content_type, 'application/json')
self.assertEqual(res.json, {})
# Check that wifi exists
query = session.query(Wifi)
count = query.filter(Wifi.key == wifi.key).count()
self.assertEquals(count, 1)
# check that WifiObservation records are created
result = session.query(WifiObservation).all()
self.assertEquals(len(result), 1)
obs = result[0]
self.assertEqual(obs.lat, wifi.lat)
self.assertEqual(obs.lon, wifi.lon)
self.assertEqual(obs.key, wifi.key)
self.assertEqual(obs.channel, 6)
self.assertEqual(obs.signal, -77)
self.assertEqual(obs.snr, 13)
def test_invalid_float(self):
wifi = WifiFactory.build()
self.app.post_json('/v1/geosubmit?key=test', {
"items": [
{
"latitude": wifi.lat,
"longitude": wifi.lon,
"accuracy": float('+nan'),
"altitude": float('-inf'),
"wifiAccessPoints": [{
"macAddress": wifi.key,
}]
},
]
},
status=200)
obs = self.session.query(WifiObservation).all()
self.assertEqual(len(obs), 1)
self.assertFalse(obs[0].accuracy)
self.assertFalse(obs[0].altitude)
def test_wifi_not_found(self):
wifis = WifiFactory.build_batch(2)
res = self.app.post_json('%s?key=test' % self.url, {
"wifiAccessPoints": [
{
"macAddress": wifis[0].key
},
{
"macAddress": wifis[1].key
},
]
},
status=404)
self.assertEqual(res.content_type, 'application/json')
self.assertEqual(
res.json, {
"error": {
"errors": [{
"domain": "geolocation",
"reason": "notFound",
"message": "Not found",
}],
"code":
404,
"message":
"Not found"
}
})
# Make sure to get two counters, a timer, and no traceback
self.check_stats(counter=[
self.metric + '.api_key.test',
self.metric + '.api_log.test.wifi_miss', self.metric_url + '.404'
],
timer=[self.metric_url])
self.check_raven(total=0)
