def test_invalid_radiotype(self): cell = CellFactory.build() cell2 = CellFactory.build(radio=Radio.wcdma) self.app.post_json('/v1/geosubmit?key=test', { 'items': [ { 'latitude': cell.lat, 'longitude': cell.lon, 'cellTowers': [{ 'radioType': '18', 'mobileCountryCode': cell.mcc, 'mobileNetworkCode': cell.mnc, 'locationAreaCode': cell.lac, 'cellId': cell.cid, }, { 'radioType': 'umts', 'mobileCountryCode': cell2.mcc, 'mobileNetworkCode': cell2.mnc, 'locationAreaCode': cell2.lac, 'cellId': cell2.cid, }] }, ] }, status=200) obs = self.session.query(CellObservation).all() self.assertEqual(len(obs), 1) self.assertEqual(obs[0].cid, cell2.cid)
def test_invalid_radiotype(self): cell = CellFactory.build() cell2 = CellFactory.build(radio=Radio.wcdma) self.app.post_json( '/v1/geosubmit?key=test', {'items': [ {'latitude': cell.lat, 'longitude': cell.lon, 'cellTowers': [{ 'radioType': '18', 'mobileCountryCode': cell.mcc, 'mobileNetworkCode': cell.mnc, 'locationAreaCode': cell.lac, 'cellId': cell.cid, }, { 'radioType': 'umts', 'mobileCountryCode': cell2.mcc, 'mobileNetworkCode': cell2.mnc, 'locationAreaCode': cell2.lac, 'cellId': cell2.cid, }]}, ]}, status=200) obs = self.session.query(CellObservation).all() self.assertEqual(len(obs), 1) self.assertEqual(obs[0].cid, cell2.cid)
def test_duplicated_cell_observations(self): session = self.session cell = CellFactory.build() self.app.post_json( '/v1/geosubmit?key=test', {"items": [ {"latitude": cell.lat, "longitude": cell.lon, "cellTowers": [ {"radioType": cell.radio.name, "mobileCountryCode": cell.mcc, "mobileNetworkCode": cell.mnc, "locationAreaCode": cell.lac, "cellId": cell.cid, "asu": 10}, {"radioType": cell.radio.name, "mobileCountryCode": cell.mcc, "mobileNetworkCode": cell.mnc, "locationAreaCode": cell.lac, "cellId": cell.cid, "asu": 16}, ]}, ]}, status=200) self.assertEquals(session.query(CellObservation).count(), 1)
def test_duplicated_cell_observations(self): session = self.session cell = CellFactory.build() self.app.post_json('/v1/geosubmit?key=test', { "items": [ { "latitude": cell.lat, "longitude": cell.lon, "cellTowers": [ { "radioType": cell.radio.name, "mobileCountryCode": cell.mcc, "mobileNetworkCode": cell.mnc, "locationAreaCode": cell.lac, "cellId": cell.cid, "asu": 10 }, { "radioType": cell.radio.name, "mobileCountryCode": cell.mcc, "mobileNetworkCode": cell.mnc, "locationAreaCode": cell.lac, "cellId": cell.cid, "asu": 16 }, ] }, ] }, status=200) self.assertEquals(session.query(CellObservation).count(), 1)
def test_empty_result_from_fallback_cached(self): cell = CellFactory.build() with requests_mock.Mocker() as mock_request: mock_request.register_uri( 'POST', requests_mock.ANY, json=LocationNotFound.json_body(), status_code=404 ) query = self.model_query(cells=[cell]) location = self.provider.locate(query) self.check_model_location(location, None) self.assertEqual(mock_request.call_count, 1) self.check_stats( counter=[ 'm.fallback.lookup_status.404', 'm.fallback.cache.miss', ], timer=['m.fallback.lookup']) query = self.model_query(cells=[cell]) location = self.provider.locate(query) self.check_model_location(location, None) self.assertEqual(mock_request.call_count, 1) self.check_stats( counter=[ 'm.fallback.lookup_status.404', 'm.fallback.cache.hit', ], timer=['m.fallback.lookup'])
def test_single_cell_results_cached_preventing_external_call(self): cell = CellFactory.build() with requests_mock.Mocker() as mock_request: mock_request.register_uri( 'POST', requests_mock.ANY, json=self.fallback_location) query = self.model_query(cells=[cell]) query.cell[0]['signal'] = -77 location = self.provider.locate(query) self.check_model_location(location, self.fallback_model) self.assertEqual(mock_request.call_count, 1) self.check_stats( counter=[ 'm.fallback.lookup_status.200', 'm.fallback.cache.miss', ], timer=['m.fallback.lookup']) # vary the signal strength, not part of cache key query.cell[0]['signal'] = -82 location = self.provider.locate(query) self.check_model_location(location, self.fallback_model) self.assertEqual(mock_request.call_count, 1) self.check_stats( counter=[ 'm.fallback.lookup_status.200', 'm.fallback.cache.hit', ], timer=['m.fallback.lookup'])
def test_cache_single_cell(self): cell = CellFactory.build() with requests_mock.Mocker() as mock_request: mock_request.register_uri( 'POST', requests_mock.ANY, json=self.fallback_result) query = self.model_query(cells=[cell]) query.cell[0].signal = -77 result = self.source.search(query) self.check_model_result(result, self.fallback_model) self.assertEqual(mock_request.call_count, 1) self.check_stats(counter=[ ('locate.fallback.cache', ['status:miss']), ('locate.fallback.lookup', ['status:200']), ], timer=[ 'locate.fallback.lookup', ]) # vary the signal strength, not part of cache key query.cell[0].signal = -82 result = self.source.search(query) self.check_model_result(result, self.fallback_model) self.assertEqual(mock_request.call_count, 1) self.check_stats(counter=[ ('locate.fallback.cache', ['status:hit']), ('locate.fallback.lookup', ['status:200']), ], timer=[ 'locate.fallback.lookup', ])
def test_success(self): cell = CellFactory.build() with requests_mock.Mocker() as mock_request: mock_request.register_uri( 'POST', requests_mock.ANY, json=self.fallback_result) query = self.model_query( cells=[cell], fallback={ 'lacf': True, 'ipf': False, }, ) result = self.source.search(query) self.check_model_result(result, self.fallback_model) request_json = mock_request.request_history[0].json() self.assertEqual(request_json['fallbacks'], {'lacf': True}) self.check_stats(counter=[ ('locate.fallback.lookup', ['status:200']), ], timer=[ 'locate.fallback.lookup', ])
def test_locate_finds_country_from_mcc(self): country = mobile_codes.mcc("235")[0] cell = CellFactory.build(mcc=235) query = self.model_query(cells=[cell]) location = self.provider.locate(query) self.check_model_location(location, country)
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_cell(self): cell = CellFactory.build() cell_query = { 'radio': cell.radio.name, 'mcc': cell.mcc, 'mnc': cell.mnc, 'lac': cell.lac, 'cid': cell.cid, 'psc': cell.psc, 'signal': -90, 'ta': 1, } query = Query(cell=[cell_query]) self.assertEqual(len(query.cell), 1) query_cell = query.cell[0] for key, value in cell_query.items(): if key == 'radio': self.assertEqual(query_cell[key], cell.radio) else: self.assertEqual(query_cell[key], value) self.assertEqual(len(query.cell_area), 1) query_area = query.cell_area[0] for key, value in cell_query.items(): if key == 'radio': self.assertEqual(query_area[key], cell.radio) elif key in ('cid', 'psc'): pass else: self.assertEqual(query_area[key], value)
def test_blacklist(self): now = util.utcnow() cell = CellFactory.build() observations = [dict(radio=int(cell.radio), mcc=cell.mcc, mnc=cell.mnc, lac=cell.lac, cid=cell.cid + i, psc=cell.psc, lat=cell.lat + i * 0.0000001, lon=cell.lon + i * 0.0000001) for i in range(1, 4)] black = CellBlacklist( radio=cell.radio, mcc=cell.mcc, mnc=cell.mnc, lac=cell.lac, cid=cell.cid + 1, time=now, count=1, ) self.session.add(black) self.session.flush() result = insert_measures_cell.delay(observations) self.assertEqual(result.get(), 2) self.assertEqual(self.data_queue.size(), 2) update_cell.delay().get() cells = self.session.query(Cell).all() self.assertEqual(len(cells), 2) self.check_statcounter(StatKey.cell, 2) self.check_statcounter(StatKey.unique_cell, 2)
def test_cache_empty_result(self): cell = CellFactory.build() with requests_mock.Mocker() as mock_request: mock_request.register_uri( 'POST', requests_mock.ANY, json=LocationNotFound.json_body(), status_code=404 ) query = self.model_query(cells=[cell]) result = self.source.search(query) self.check_model_result(result, None) self.assertEqual(mock_request.call_count, 1) self.check_stats(counter=[ ('locate.fallback.cache', ['status:miss']), ('locate.fallback.lookup', ['status:404']), ]) query = self.model_query(cells=[cell]) result = self.source.search(query) self.check_model_result(result, None) self.assertEqual(mock_request.call_count, 1) self.check_stats(counter=[ ('locate.fallback.cache', ['status:hit']), ('locate.fallback.lookup', ['status:404']), ])
def test_ok_no_existing_cell(self): session = self.session now_ms = int(time.time() * 1000) first_of_month = utcnow().replace(day=1, hour=0, minute=0, second=0) cell = CellFactory.build() res = self.app.post_json('/v1/geosubmit?key=test', { "items": [ { "latitude": cell.lat, "longitude": cell.lon, "accuracy": 12.4, "altitude": 100.1, "altitudeAccuracy": 23.7, "heading": 45.0, "speed": 3.6, "timestamp": now_ms, "cellTowers": [{ "radioType": cell.radio.name, "mobileCountryCode": cell.mcc, "mobileNetworkCode": cell.mnc, "locationAreaCode": cell.lac, "cellId": cell.cid, "age": 3, "asu": 31, "psc": cell.psc, "signalStrength": -51, "timingAdvance": 1, }] }, ] }, status=200) self.assertEqual(res.content_type, 'application/json') self.assertEqual(res.json, {}) self.assertEquals(session.query(Cell).count(), 1) result = session.query(CellObservation).all() self.assertEquals(len(result), 1) obs = result[0] for name in ('lat', 'lon', 'radio', 'mcc', 'mnc', 'lac', 'cid', 'psc'): self.assertEqual(getattr(obs, name), getattr(cell, name)) self.assertEqual(obs.accuracy, 12) self.assertEqual(obs.altitude, 100) self.assertEqual(obs.altitude_accuracy, 24) self.assertEqual(obs.heading, 45.0) self.assertEqual(obs.speed, 3.6) self.assertEqual(obs.time, first_of_month) self.assertEqual(obs.asu, 31) self.assertEqual(obs.signal, -51) self.assertEqual(obs.ta, 1)
def test_set_cache_redis_failure(self): cell = CellFactory.build() mock_redis_client = self._mock_redis_client() mock_redis_client.mget.return_value = [] mock_redis_client.mset.side_effect = RedisError() mock_redis_client.expire.side_effect = RedisError() mock_redis_client.execute.side_effect = RedisError() with requests_mock.Mocker() as mock_request: mock_request.register_uri( 'POST', requests_mock.ANY, json=self.fallback_result) with mock.patch.object(self.source.cache, 'redis_client', mock_redis_client): query = self.model_query(cells=[cell]) result = self.source.search(query) self.check_model_result(result, self.fallback_model) self.assertTrue(mock_redis_client.mget.called) self.assertTrue(mock_redis_client.mset.called) self.assertTrue(mock_request.called) self.check_stats(counter=[ ('locate.fallback.cache', ['status:miss']), ])
def test_blacklist_time_used_as_creation_time(self): now = util.utcnow() last_week = now - TEMPORARY_BLACKLIST_DURATION - timedelta(days=1) cell = CellFactory.build() self.session.add( CellBlacklist(time=last_week, count=1, radio=cell.radio, mcc=cell.mcc, mnc=cell.mnc, lac=cell.lac, cid=cell.cid)) self.session.flush() # add a new entry for the previously blacklisted cell obs = dict(lat=cell.lat, lon=cell.lon, radio=int(cell.radio), mcc=cell.mcc, mnc=cell.mnc, lac=cell.lac, cid=cell.cid) insert_measures_cell.delay([obs]).get() self.assertEqual(self.data_queue.size(), 1) update_cell.delay().get() # the cell was inserted again cells = self.session.query(Cell).all() self.assertEqual(len(cells), 1) # and the creation date was set to the date of the blacklist entry self.assertEqual(cells[0].created, last_week) self.check_statcounter(StatKey.cell, 1) self.check_statcounter(StatKey.unique_cell, 0)
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 test_cell(self): cell = CellFactory.build() cell_query = self.cell_model_query([cell]) query = Query(cell=cell_query) self.assertEqual(len(query.cell), 1) self.assertEqual(query.expected_accuracy, DataAccuracy.medium) query_cell = query.cell[0] for key, value in cell_query[0].items(): query_value = getattr(query_cell, key, None) if key == 'radio': self.assertEqual(query_value, cell.radio) else: self.assertEqual(query_value, value) self.assertEqual(len(query.cell_area), 1) query_area = query.cell_area[0] for key, value in cell_query[0].items(): query_value = getattr(query_area, key, None) if key == 'radio': self.assertEqual(query_value, cell.radio) elif key in ('cid', 'psc'): pass else: self.assertEqual(query_value, value)
def test_cell_area_duplicated(self): cell = CellFactory.build() cell_query = self.cell_model_query([cell, cell, cell]) cell_query[1]['cid'] += 2 cell_query[2]['cid'] += 1 query = Query(cell=cell_query) self.assertEqual(len(query.cell), 3) self.assertEqual(len(query.cell_area), 1)
def _one_cell_query(self, radio=True): cell = CellFactory.build() query = {'lat': cell.lat, 'lon': cell.lon, 'cell': [{'mcc': cell.mcc, 'mnc': cell.mnc, 'lac': cell.lac, 'cid': cell.cid}]} if radio: query['cell'][0]['radio'] = cell.radio.name return (cell, query)
def test_no_api_key_shortname(self): api_key = ApiKeyFactory.build(shortname=None, log_locate=True) cell = CellFactory.build() self._make_query(api_key=api_key, cell=[cell]) self.check_stats(counter=[ ('locate.query', ['key:%s' % api_key.valid_key, 'region:none', 'geoip:false', 'cell:one', 'wifi:none']), ])
def test_cell_duplicated(self): cell = CellFactory.build() cell_query = self.cell_model_query([cell, cell, cell]) cell_query[0]['signal'] = -95 cell_query[1]['signal'] = -90 cell_query[2]['signal'] = -92 query = Query(cell=cell_query) self.assertEqual(len(query.cell), 1) self.assertEqual(query.cell[0].signal, -90)
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, lon=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'] = lon or pos.lon report['position']['accuracy'] = 17.0 + i blues = WifiShardFactory.build_batch(blue_factor, lat=pos.lat, lon=pos.lon) for blue in blues: blue_data = { 'macAddress': blue_key or blue.mac, '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 = WifiShardFactory.build_batch(wifi_factor, lat=pos.lat, lon=pos.lon) for wifi in wifis: wifi_data = { 'macAddress': wifi_key or wifi.mac, 'signalStrength': -90 + i, 'ssid': 'my-wifi', } 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_invalid_json_returns_empty_location(self): cell = CellFactory.build() with requests_mock.Mocker() as mock_request: mock_request.register_uri( 'POST', requests_mock.ANY, json=['invalid json']) query = self.model_query(cells=[cell]) location = self.provider.locate(query) self.check_model_location(location, None)
def test_malformed_json(self): cell = CellFactory.build() with requests_mock.Mocker() as mock_request: mock_request.register_uri( 'POST', requests_mock.ANY, content=b'[invalid json') query = self.model_query(cells=[cell]) result = self.source.search(query) self.check_model_result(result, None)
def test_ambiguous_mcc(self): regions = GEOCODER.regions_for_mcc(234, metadata=True) cell = CellFactory.build(mcc=234) query = self.model_query(cells=[cell]) results = self.source.search(query) self.check_model_result(results, regions) self.check_stats(counter=[ (self.api_type + '.source', ['key:test', 'region:none', 'source:internal', 'accuracy:low', 'status:hit']), ])
def test_ambiguous_mcc(self): countries = mobile_codes.mcc('234') cell = CellFactory.build(mcc=234) query = self.model_query(cells=[cell]) results = self.source.search(query) self.check_model_result(results, countries) self.check_stats(counter=[ (self.api_type + '.source', ['key:test', 'country:none', 'source:internal', 'accuracy:low', 'status:hit']), ])
def test_gzip(self): cell = CellFactory.build() query = self.model_query(cells=[cell]) body = util.encode_gzip(json.dumps(query)) headers = { 'Content-Encoding': 'gzip', } res = self._call(body=body, headers=headers, method='post', status=self.not_found.code) self.check_response(res, 'not_found')
def test_set_cell_not_found(self): cell = CellFactory.build() query = Query(cell=self.cell_model_query([cell])) result = ExternalResult(None, None, None, None) self.cache.set(query, result) keys = self.redis_client.keys('cache:fallback:cell:*') self.assertEqual(len(keys), 1) self.assertEqual(self.redis_client.get(keys[0]), b'"404"') self.assertEqual(self.cache.get(query), result) self.check_stats(counter=[ ('locate.fallback.cache', 1, 1, ['status:hit']), ])
def test_set_cell(self): cell = CellFactory.build() query = Query(cell=self.cell_model_query([cell])) result = ExternalResult(cell.lat, cell.lon, cell.radius, None) self.cache.set(query, result) keys = self.redis_client.keys('cache:fallback:cell:*') self.assertEqual(len(keys), 1) self.assertTrue(500 < self.redis_client.ttl(keys[0]) <= 600) self.assertEqual(self.cache.get(query), result) self.check_stats(counter=[ ('locate.fallback.cache', 1, 1, ['status:hit']), ])
def test_ok_cell(self): session = self.session cell = CellFactory() new_cell = CellFactory.build() session.flush() res = self.app.post_json( '/v1/geosubmit?key=test', {"items": [ {"latitude": cell.lat, "longitude": cell.lon, "radioType": cell.radio.name, "cellTowers": [{ "mobileCountryCode": cell.mcc, "mobileNetworkCode": cell.mnc, "locationAreaCode": cell.lac, "cellId": cell.cid, }]}, {"latitude": new_cell.lat, "longitude": new_cell.lon, "cellTowers": [{ "radioType": new_cell.radio.name, "mobileCountryCode": new_cell.mcc, "mobileNetworkCode": new_cell.mnc, "locationAreaCode": new_cell.lac, "cellId": new_cell.cid, }]}, ]}, status=200) # check that we get an empty response self.assertEqual(res.content_type, 'application/json') self.assertEqual(res.json, {}) self.assertEqual(session.query(Cell).count(), 2) observations = session.query(CellObservation).all() self.assertEqual(len(observations), 2) radios = set([obs.radio for obs in observations]) self.assertEqual(radios, set([cell.radio, new_cell.radio])) self.check_stats( counter=['geosubmit.api_key.test', 'items.api_log.test.uploaded.batches', 'items.api_log.test.uploaded.reports', 'items.api_log.test.uploaded.cell_observations', 'items.uploaded.cell_observations', 'items.uploaded.batches', 'items.uploaded.reports', 'request.v1.geosubmit.200', ], timer=['items.api_log.test.uploaded.batch_size', 'items.uploaded.batch_size', 'request.v1.geosubmit'])
def test_cell_not_found(self): cell = CellFactory.build() query = self.model_query(cells=[cell]) res = self._call(body=query, status=self.not_found.code) self.check_response(res, 'not_found') self.check_stats( counter=[self.metric + '.api_key.test', self.metric + '.api_log.test.cell_miss', self.metric_url + '.' + str(self.not_found.code)], timer=[self.metric_url])
def test_failed_call_returns_empty_location(self): cell = CellFactory.build() with requests_mock.Mocker() as mock_request: def raise_request_exception(request, context): raise RequestException() mock_request.register_uri( 'POST', requests_mock.ANY, json=raise_request_exception) query = self.model_query(cells=[cell]) location = self.provider.locate(query) self.check_model_location(location, None)
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_missing_radio(self): cell = CellFactory.build() self.app.post_json('/v1/submit', { 'items': [{ 'lat': cell.lat, 'lon': cell.lon, 'cell': [{ 'mcc': cell.mcc, 'mnc': cell.mnc, 'lac': cell.lac, 'cid': cell.cid, }] }] }, status=204) self.assertEqual(self.session.query(CellObservation).count(), 0)
def test_invalid_cell(self): cell = CellFactory.build() self.app.post_json('/v1/geosubmit?key=test', { "items": [ { "latitude": cell.lat, "longitude": cell.lon, "cellTowers": [{ "radioType": cell.radio.name, "mobileCountryCode": cell.mcc, "mobileNetworkCode": 2000, "locationAreaCode": cell.lac, "cellId": cell.cid, }] }, ] }, status=200) self.assertEquals(self.session.query(CellObservation).count(), 0)
def test_ok_radioless_cell(self): cell = CellFactory.build() self.app.post_json('/v1/geosubmit?key=test', { "items": [ { "latitude": cell.lat, "longitude": cell.lon, "cellTowers": [{ "mobileCountryCode": cell.mcc, "mobileNetworkCode": cell.mnc, "locationAreaCode": cell.lac, "cellId": cell.cid, "psc": cell.psc, }] }, ] }, status=200) observations = self.session.query(CellObservation).all() self.assertEqual(len(observations), 0)
def test_ok_cell(self): session = self.session cell = CellFactory() new_cell = CellFactory.build() session.flush() res = self.app.post_json('/v1/geosubmit?key=test', { "items": [ { "latitude": cell.lat, "longitude": cell.lon, "radioType": cell.radio.name, "cellTowers": [{ "mobileCountryCode": cell.mcc, "mobileNetworkCode": cell.mnc, "locationAreaCode": cell.lac, "cellId": cell.cid, }] }, { "latitude": new_cell.lat, "longitude": new_cell.lon, "cellTowers": [{ "radioType": new_cell.radio.name, "mobileCountryCode": new_cell.mcc, "mobileNetworkCode": new_cell.mnc, "locationAreaCode": new_cell.lac, "cellId": new_cell.cid, }] }, ] }, status=200) # check that we get an empty response self.assertEqual(res.content_type, 'application/json') self.assertEqual(res.json, {}) self.assertEqual(session.query(Cell).count(), 2) observations = session.query(CellObservation).all() self.assertEqual(len(observations), 2) radios = set([obs.radio for obs in observations]) self.assertEqual(radios, set([cell.radio, new_cell.radio])) self.check_stats(counter=[ 'geosubmit.api_key.test', 'items.api_log.test.uploaded.batches', 'items.api_log.test.uploaded.reports', 'items.api_log.test.uploaded.cell_observations', 'items.uploaded.cell_observations', 'items.uploaded.batches', 'items.uploaded.reports', 'request.v1.geosubmit.200', ], timer=[ 'items.api_log.test.uploaded.batch_size', 'items.uploaded.batch_size', 'request.v1.geosubmit' ])