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_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_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=[ {'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_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): 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_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_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])