def test_cell_area_region_no_fallback(self):
cell = CellAreaFactory.build()
cell_query = self.cell_model_query([cell])
query = Query(cell=cell_query, api_type='region',
fallback={'lacf': False})
self.assertEqual(query.expected_accuracy, DataAccuracy.none)
def test_blue_region(self):
blues = BlueShardFactory.build_batch(2)
query = Query(blue=self.blue_model_query(blues), api_type="region")
assert query.expected_accuracy is DataAccuracy.low
def test_cell_area_region(self):
cell = CellAreaFactory.build()
cell_query = self.cell_model_query([cell])
query = Query(cell=cell_query, api_type="region")
assert query.expected_accuracy is DataAccuracy.low
def _query(self, **kwargs):
return Query(api_key=ApiKeyFactory(fallback_cache_expire=60), **kwargs)
def test_blue_single(self):
blue = BlueShardFactory.build()
blue_query = {"macAddress": blue.mac}
query = Query(blue=[blue_query])
assert len(query.blue) == 0
def test_satisfies_empty(self):
wifis = WifiShardFactory.build_batch(2)
wifi_query = [{'mac': wifi.mac} for wifi in wifis]
positions = PositionResultList()
query = Query(api_type='locate', wifi=wifi_query)
self.assertFalse(positions.satisfies(query))
def test_satisfies_fail(self):
regions = RegionResultList()
self.assertFalse(regions.satisfies(Query()))
def test_api_type_failure(self):
with self.assertRaises(ValueError):
Query(api_type='something')
def test_session(self):
query = Query(session=self.session)
self.assertEqual(query.session, self.session)
def test_api_key(self):
api_key = ApiKeyFactory.build()
query = Query(api_key=api_key)
self.assertEqual(query.api_key.valid_key, api_key.valid_key)
self.assertEqual(query.api_key, api_key)
def test_api_type(self):
query = Query(api_type='locate')
self.assertEqual(query.api_type, 'locate')
def test_wifi_region(self):
wifis = WifiShardFactory.build_batch(2)
query = Query(
wifi=self.wifi_model_query(wifis), api_type='region')
self.assertEqual(query.expected_accuracy, DataAccuracy.none)
def test_wifi_malformed(self):
wifi = WifiShardFactory.build()
wifi_query = {'mac': wifi.mac}
query = Query(wifi=[wifi_query, {'mac': 'foo'}])
self.assertEqual(len(query.wifi), 0)
def test_wifi_single(self):
wifi = WifiShardFactory.build()
wifi_query = {'mac': wifi.mac}
query = Query(wifi=[wifi_query])
self.assertEqual(len(query.wifi), 0)
def test_satisfies_fail(self):
wifis = WifiShardFactory.build_batch(2)
wifi_query = [{'mac': wifi.mac} for wifi in wifis]
position = Position(lat=1.0, lon=1.0, accuracy=2500.0)
query = Query(api_type='locate', wifi=wifi_query)
self.assertFalse(position.satisfies(query))
def test_stats_client(self):
query = Query(stats_client=self.stats_client)
self.assertEqual(query.stats_client, self.stats_client)
def test_satisfies(self):
self.assertFalse(Result().satisfies(Query()))
def test_geoip_malformed(self):
query = Query(ip='127.0.0.0.0.1', geoip_db=self.geoip_db)
self.assertEqual(query.region, None)
self.assertEqual(query.geoip, None)
self.assertEqual(query.ip, None)
def test_satisfies(self):
regions = RegionResultList(
Region(region_code='DE', region_name='Germany', accuracy=100000.0))
self.assertTrue(regions.satisfies(Query()))
def _make_query(self, geoip_db, stats, **kw):
return Query(
api_key=ApiKeyFactory.build(valid_key='test'),
geoip_db=geoip_db,
stats_client=stats,
**kw)
def test_query(self):
query = Query()
data = OUTBOUND_SCHEMA.deserialize(query.json())
assert data == {'fallbacks': {'lacf': True}}
def test_query(self):
query = Query()
data = self._call(query.json())
assert data == {"fallbacks": {"lacf": True}, "token": None}
def test_geoip_malformed(self, geoip_db):
query = Query(ip="127.0.0.0.0.1", geoip_db=geoip_db)
assert query.region is None
assert query.geoip is None
assert query.ip is None
assert query.geoip_only is None
def _query(self, **kwargs):
if "api_key" not in kwargs:
kwargs["api_key"] = KeyFactory(fallback_cache_expire=60)
return Query(**kwargs)
def test_blue_malformed(self):
blue = BlueShardFactory.build()
blue_query = {"macAddress": blue.mac}
query = Query(blue=[blue_query, {"macAddress": "foo"}])
assert len(query.blue) == 0
def test_query(self):
query = Query()
data = self._call(query.json())
assert data == {"considerIp": False}
def test_cell_malformed(self):
query = Query(cell=[{"radioType": "foo", "mobileCountryCode": "ab"}])
assert len(query.cell) == 0
def test_satisfies_fail(self):
region = Region()
self.assertFalse(region.satisfies(Query()))
def test_wifi_single(self):
wifi = WifiShardFactory.build()
wifi_query = {"macAddress": wifi.mac}
query = Query(wifi=[wifi_query])
assert len(query.wifi) == 0
def test_cell_area_region(self):
cell = CellAreaFactory.build()
cell_query = self.cell_model_query([cell])
query = Query(cell=cell_query, api_type='region')
self.assertEqual(query.expected_accuracy, DataAccuracy.low)
