def test_blue_not_found(self, app, data_queues, metricsmock, logs):
"""A failed Bluetooth-based lookup emits several metrics."""
blues = BlueShardFactory.build_batch(2)
query = self.model_query(blues=blues)
res = self._call(app, body=query, status=404)
self.check_response(data_queues, res, "not_found")
metricsmock.assert_incr_once(
"request", tags=[self.metric_path, "method:post", "status:404"]
)
metricsmock.assert_incr_once(
self.metric_type + ".request", tags=[self.metric_path, "key:test"]
)
metricsmock.assert_incr_once(
self.metric_type + ".query",
tags=["key:test", "geoip:false", "blue:many", "cell:none", "wifi:none"],
)
metricsmock.assert_incr_once(
self.metric_type + ".result",
tags=["key:test", "accuracy:high", "fallback_allowed:false", "status:miss"],
)
metricsmock.assert_incr_once(
self.metric_type + ".source",
tags=["key:test", "source:internal", "accuracy:high", "status:miss"],
)
assert logs.only_entry["blue_valid"] == 2
def test_blue_miss(self, geoip_db, http_session, session, source):
blues = BlueShardFactory.build_batch(2, samples=10)
session.flush()
query = self.model_query(geoip_db, http_session, session, blues=blues)
results = source.search(query)
self.check_model_results(results, None)
def test_blue(self):
blues = BlueShardFactory.build_batch(2)
query = Query(
blue=[
{
"macAddress": blue.mac,
"age": 1500,
"name": "beacon",
"signalStrength": -90,
}
for blue in blues
]
)
data = self._call(query.json())
assert data == {
"bluetoothBeacons": [
{
"macAddress": blues[0].mac,
"age": 1500,
"name": "beacon",
"signalStrength": -90,
},
{
"macAddress": blues[1].mac,
"age": 1500,
"name": "beacon",
"signalStrength": -90,
},
],
"fallbacks": {"lacf": True},
}
def test_get_blue(self, cache, stats):
blues = BlueShardFactory.build_batch(2)
query = self._query(blue=self.blue_model_query(blues))
assert cache.get(query) is None
stats.check(counter=[
('locate.fallback.cache', 1, 1, ['status:miss']),
])
def test_blue_not_found(self, app, data_queues, stats):
blues = BlueShardFactory.build_batch(2)
query = self.model_query(blues=blues)
res = self._call(app, body=query, status=self.not_found.code)
self.check_response(data_queues, res, 'not_found')
stats.check(counter=[
('request', [
self.metric_path, 'method:post',
'status:%s' % self.not_found.code
]),
(self.metric_type + '.request', [self.metric_path, 'key:test']),
(self.metric_type + '.query', [
'key:test', 'region:none', 'geoip:false', 'blue:many',
'cell:none', 'wifi:none'
]),
(self.metric_type + '.result', 'fallback_allowed:false',
['key:test', 'region:none', 'accuracy:high', 'status:miss']),
(self.metric_type + '.source', [
'key:test', 'region:none', 'source:internal', 'accuracy:high',
'status:miss'
]),
],
timer=[
('request', [self.metric_path, 'method:post']),
])
def test_blue(self):
blues = BlueShardFactory.build_batch(2)
query = Query(blue=[{
'mac': blue.mac,
'age': 1500,
'name': 'beacon',
'signal': -90
} for blue in blues])
data = self.schema.deserialize(query.internal_query())
self.assertEqual(
data, {
'bluetoothBeacons': [{
'macAddress': blues[0].mac,
'age': 1500,
'name': 'beacon',
'signalStrength': -90,
}, {
'macAddress': blues[1].mac,
'age': 1500,
'name': 'beacon',
'signalStrength': -90,
}],
'fallbacks': {
'lacf': True
},
})
def add_reports(self, num=1, blue_factor=0, cell_factor=1, wifi_factor=2,
api_key='test', nickname=None,
blue_key=None, cell_mcc=None, wifi_key=None,
lat=None, lon=None):
reports = []
for i in range(num):
pos = CellShardFactory.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 = BlueShardFactory.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 = CellShardFactory.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)
items = [{'api_key': api_key,
'nickname': nickname,
'report': rep} for rep in reports]
self.incoming_queue.enqueue(items)
update_incoming.delay().get()
return reports
def test_blue(self):
blues = BlueShardFactory.build_batch(2)
query = Query(blue=[{
'macAddress': blue.mac,
'age': 1500,
'name': 'beacon',
'signalStrength': -90
} for blue in blues])
data = OUTBOUND_SCHEMA.deserialize(query.json())
assert (data == {
'bluetoothBeacons': [{
'macAddress': blues[0].mac,
'age': 1500,
'name': 'beacon',
'signalStrength': -90,
}, {
'macAddress': blues[1].mac,
'age': 1500,
'name': 'beacon',
'signalStrength': -90,
}],
'fallbacks': {
'lacf': True
},
})
def test_blue_miss(self):
blues = BlueShardFactory.build_batch(2, samples=10)
self.session.flush()
query = self.model_query(blues=blues)
results = self.source.search(query)
self.check_model_results(results, None)
def test_get_blue(self):
blues = BlueShardFactory.build_batch(2)
query = Query(blue=self.blue_model_query(blues))
self.assertEqual(self.cache.get(query), None)
self.check_stats(counter=[
('locate.fallback.cache', 1, 1, ['status:miss']),
])
def test_get_blue(self):
blues = BlueShardFactory.build_batch(2)
query = self._query(blue=self.blue_model_query(blues))
self.assertEqual(self.cache.get(query), None)
self.check_stats(counter=[
('locate.fallback.cache', 1, 1, ['status:miss']),
])
def test_blue_miss(self, geoip_db, http_session, session, source):
"""Unknown Bluetooth stations fail to determine the region."""
blues = BlueShardFactory.build_batch(2, samples=10)
session.flush()
query = self.model_query(geoip_db, http_session, session, blues=blues)
results = source.search(query)
self.check_model_results(results, None)
def test_get_blue(self, cache, stats):
blues = BlueShardFactory.build_batch(2)
query = self._query(blue=self.blue_model_query(blues))
assert cache.get(query) is None
stats.check(counter=[
('locate.fallback.cache', 1, 1,
[self.fallback_tag, 'status:miss']),
])
def test_set_blue(self, cache, metricsmock):
blues = BlueShardFactory.build_batch(2)
blue = blues[0]
query = self._query(blue=self.blue_model_query(blues))
result = ExternalResult(blue.lat, blue.lon, blue.radius, None)
cache.set(query, result)
assert cache.get(query) == result
metricsmock.assert_incr_once("locate.fallback.cache",
tags=[self.fallback_tag, "status:hit"])
def add_reports(self, num=1, blue_factor=0, cell_factor=1, wifi_factor=2,
blue_key=None, cell_mcc=None, wifi_key=None,
api_key='test', lat=None, lon=None):
reports = []
for i in range(num):
pos = CellShardFactory.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 = BlueShardFactory.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 = CellShardFactory.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)
items = [{'api_key': api_key, 'report': rep} for rep in reports]
self.queue.enqueue(items)
return reports
def test_set_blue(self, cache, stats):
blues = BlueShardFactory.build_batch(2)
blue = blues[0]
query = self._query(blue=self.blue_model_query(blues))
result = ExternalResult(blue.lat, blue.lon, blue.radius, None)
cache.set(query, result)
assert cache.get(query) == result
stats.check(counter=[
('locate.fallback.cache', 1, 1, ['status:hit']),
])
def test_blue_miss(self, geoip_db, http_session,
session, source, stats):
blues = BlueShardFactory.build_batch(2, samples=10)
session.flush()
query = self.model_query(
geoip_db, http_session, session, stats,
blues=blues)
results = source.search(query)
self.check_model_results(results, None)
def test_set_blue(self):
blues = BlueShardFactory.build_batch(2)
blue = blues[0]
query = Query(blue=self.blue_model_query(blues))
result = ExternalResult(blue.lat, blue.lon, blue.radius, None)
self.cache.set(query, result)
self.assertEqual(self.cache.get(query), result)
self.check_stats(counter=[
('locate.fallback.cache', 1, 1, ['status:hit']),
])
def test_many(self, geoip_db, metricsmock):
blues = BlueShardFactory.build_batch(2)
cells = CellShardFactory.build_batch(2)
wifis = WifiShardFactory.build_batch(3)
self._make_query(
geoip_db, blue=blues, cell=cells, wifi=wifis, ip=self.london_ip
)
metricsmock.assert_incr_once(
"locate.query", tags=["key:test", "blue:many", "cell:many", "wifi:many"]
)
def test_many(self):
blues = BlueShardFactory.build_batch(2)
cells = CellShardFactory.build_batch(2)
wifis = WifiShardFactory.build_batch(3)
self._make_query(blue=blues, cell=cells, wifi=wifis, ip=self.london_ip)
self.check_stats(total=1, counter=[
('locate.query',
['key:key', 'region:GB',
'blue:many', 'cell:many', 'wifi:many']),
])
def test_set_blue(self, cache, stats):
blues = BlueShardFactory.build_batch(2)
blue = blues[0]
query = self._query(blue=self.blue_model_query(blues))
result = ExternalResult(blue.lat, blue.lon, blue.radius, None)
cache.set(query, result)
assert cache.get(query) == result
stats.check(counter=[
('locate.fallback.cache', 1, 1,
[self.fallback_tag, 'status:hit']),
])
def test_blue_better(self):
blues = BlueShardFactory.build_batch(2)
query = Query(blue=[
{'mac': blues[0].mac, 'signal': -90, 'name': 'my-beacon'},
{'mac': blues[0].mac, 'signal': -82},
{'mac': blues[0].mac, 'signal': -85},
{'mac': blues[1].mac, 'signal': -70},
])
self.assertEqual(len(query.blue), 2)
self.assertEqual(
set([blue.signal for blue in query.blue]), set([-70, -82]))
def test_blue_better(self):
blues = BlueShardFactory.build_batch(2)
query = Query(blue=[
{'macAddress': blues[0].mac, 'signalStrength': -90,
'name': 'my-beacon'},
{'macAddress': blues[0].mac, 'signalStrength': -82},
{'macAddress': blues[0].mac, 'signalStrength': -85},
{'macAddress': blues[1].mac, 'signalStrength': -70},
])
assert len(query.blue) == 2
assert (set([blue.signalStrength for blue in query.blue]) ==
set([-70, -82]))
def test_blue(self):
blues = BlueShardFactory.build_batch(2)
macs = [blue.mac for blue in blues]
query = Query(blue=self.blue_model_query(blues))
self.assertEqual(len(query.blue), 2)
self.assertEqual(query.expected_accuracy, DataAccuracy.high)
for blue in query.blue:
self.assertEqual(blue.age, 10)
self.assertEqual(blue.signal, -85)
self.assertTrue(blue.mac in macs)
def test_blue(self):
blues = BlueShardFactory.build_batch(2)
macs = [blue.mac for blue in blues]
query = Query(blue=self.blue_model_query(blues))
self.assertEqual(len(query.blue), 2)
self.assertEqual(query.expected_accuracy, DataAccuracy.high)
for blue in query.blue:
self.assertEqual(blue.age, 10)
self.assertEqual(blue.signal, -85)
self.assertTrue(blue.mac in macs)
def test_blue(self):
blues = BlueShardFactory.build_batch(2)
macs = [blue.mac for blue in blues]
query = Query(blue=self.blue_model_query(blues))
assert len(query.blue) == 2
assert query.expected_accuracy is DataAccuracy.high
for blue in query.blue:
assert blue.age == 10
assert blue.signalStrength == -85
assert blue.macAddress in macs
def test_one(self):
blues = BlueShardFactory.build_batch(1)
cells = CellShardFactory.build_batch(1)
wifis = WifiShardFactory.build_batch(1)
self._make_query(blue=blues, cell=cells, wifi=wifis, ip=self.london_ip)
self.check_stats(total=1,
counter=[
('locate.query', [
'key:key', 'region:GB', 'blue:one',
'cell:one', 'wifi:one'
]),
])
def test_many(self, geoip_db, stats):
blues = BlueShardFactory.build_batch(2)
cells = CellShardFactory.build_batch(2)
wifis = WifiShardFactory.build_batch(3)
self._make_query(
geoip_db, stats,
blue=blues, cell=cells, wifi=wifis, ip=self.london_ip)
stats.check(total=1, counter=[
('locate.query',
['key:test', 'region:GB',
'blue:many', 'cell:many', 'wifi:many']),
])
def test_blue(self):
blues = BlueShardFactory.build_batch(2)
macs = [blue.mac for blue in blues]
query = Query(blue=self.blue_model_query(blues))
assert len(query.blue) == 2
assert query.expected_accuracy is DataAccuracy.high
assert query.geoip_only is False
for blue in query.blue:
assert blue.age == 10
assert blue.signalStrength == -85
assert blue.macAddress in macs
def test_one(self, geoip_db, stats):
blues = BlueShardFactory.build_batch(1)
cells = CellShardFactory.build_batch(1)
wifis = WifiShardFactory.build_batch(1)
self._make_query(
geoip_db, stats,
blue=blues, cell=cells, wifi=wifis, ip=self.london_ip)
stats.check(total=1, counter=[
('locate.query',
['key:test', 'region:GB',
'blue:one', 'cell:one', 'wifi:one']),
])
def test_get_blue(self, cache, metricsmock):
blues = BlueShardFactory.build_batch(2)
query = self._query(blue=self.blue_model_query(blues))
assert cache.get(query) is None
assert (
len(
metricsmock.filter_records(
"incr",
"locate.fallback.cache",
value=1,
tags=[self.fallback_tag, "status:miss"],
)
)
== 1
)
def test_many(self, geoip_db, metricsmock):
blues = BlueShardFactory.build_batch(2)
cells = CellShardFactory.build_batch(2)
wifis = WifiShardFactory.build_batch(3)
self._make_query(geoip_db,
blue=blues,
cell=cells,
wifi=wifis,
ip=self.london_ip)
assert metricsmock.get_records() == [(
"incr",
"locate.query",
1,
["key:test", "region:GB", "blue:many", "cell:many", "wifi:many"],
)]
def test_blue_better(self):
blues = BlueShardFactory.build_batch(2)
query = Query(
blue=[
{
"macAddress": blues[0].mac,
"signalStrength": -90,
"name": "my-beacon",
},
{"macAddress": blues[0].mac, "signalStrength": -82},
{"macAddress": blues[0].mac, "signalStrength": -85},
{"macAddress": blues[1].mac, "signalStrength": -70},
]
)
assert len(query.blue) == 2
assert set([blue.signalStrength for blue in query.blue]) == set([-70, -82])
def test_blue(self):
blues = BlueShardFactory.build_batch(2)
query = Query(blue=[
{'mac': blue.mac, 'signal': -90, 'name': 'my'} for blue in blues])
data = self.schema.deserialize(query.internal_query())
self.assertEqual(data, {
'bluetoothBeacons': [{
'macAddress': blues[0].mac,
'signalStrength': -90,
'name': 'my',
}, {
'macAddress': blues[1].mac,
'signalStrength': -90,
'name': 'my',
}],
'fallbacks': {'lacf': True},
})
def test_blue_not_found(self, app, data_queues, metricsmock):
blues = BlueShardFactory.build_batch(2)
query = self.model_query(blues=blues)
res = self._call(app, body=query, status=self.not_found.code)
self.check_response(data_queues, res, "not_found")
assert metricsmock.has_record(
"incr",
"request",
value=1,
tags=[self.metric_path, "method:post", "status:%s" % self.not_found.code],
)
assert metricsmock.has_record(
"incr",
self.metric_type + ".request",
value=1,
tags=[self.metric_path, "key:test"],
)
assert metricsmock.has_record(
"incr",
self.metric_type + ".query",
value=1,
tags=["key:test", "geoip:false", "blue:many", "cell:none", "wifi:none"],
)
assert metricsmock.has_record(
"incr",
self.metric_type + ".result",
value=1,
tags=[
"key:test",
"accuracy:high",
"fallback_allowed:false",
"status:miss",
],
)
assert metricsmock.has_record(
"incr",
self.metric_type + ".source",
value=1,
tags=["key:test", "source:internal", "accuracy:high", "status:miss"],
)
assert metricsmock.has_record(
"timing", "request.timing", tags=[self.metric_path, "method:post"]
)
def test_set_blue(self, cache, metricsmock):
blues = BlueShardFactory.build_batch(2)
blue = blues[0]
query = self._query(blue=self.blue_model_query(blues))
result = ExternalResult(blue.lat, blue.lon, blue.radius, None)
cache.set(query, result)
assert cache.get(query) == result
assert (
len(
metricsmock.filter_records(
"incr",
"locate.fallback.cache",
value=1,
tags=[self.fallback_tag, "status:hit"],
)
)
== 1
)
def test_get_mixed(self, cache, stats):
blues = BlueShardFactory.build_batch(2)
cells = CellShardFactory.build_batch(1)
wifis = WifiShardFactory.build_batch(2)
query = self._query(cell=self.cell_model_query(cells),
wifi=self.wifi_model_query(wifis))
assert cache.get(query) is None
query = self._query(blue=self.blue_model_query(blues),
cell=self.cell_model_query(cells))
assert cache.get(query) is None
query = self._query(blue=self.blue_model_query(blues),
wifi=self.wifi_model_query(wifis))
assert cache.get(query) is None
stats.check(counter=[
('locate.fallback.cache', 3, 1, ['status:bypassed']),
])
def test_get_mixed(self):
blues = BlueShardFactory.build_batch(2)
cells = CellShardFactory.build_batch(1)
wifis = WifiShardFactory.build_batch(2)
query = Query(cell=self.cell_model_query(cells),
wifi=self.wifi_model_query(wifis))
self.assertEqual(self.cache.get(query), None)
query = Query(blue=self.blue_model_query(blues),
cell=self.cell_model_query(cells))
self.assertEqual(self.cache.get(query), None)
query = Query(blue=self.blue_model_query(blues),
wifi=self.wifi_model_query(wifis))
self.assertEqual(self.cache.get(query), None)
self.check_stats(counter=[
('locate.fallback.cache', 3, 1, ['status:bypassed']),
])
def test_get_mixed(self, cache, metricsmock, mix1, mix2):
"""A fallback query with mixed station types is not cached."""
kwargs = {}
mix = set((mix1, mix2))
assert len(mix) == 2
if "cell" in mix:
kwargs["cell"] = self.cell_model_query(
CellShardFactory.build_batch(1))
if "blue" in mix:
kwargs["blue"] = self.blue_model_query(
BlueShardFactory.build_batch(2))
if "wifi" in mix:
kwargs["wifi"] = self.wifi_model_query(
WifiShardFactory.build_batch(2))
query = self._query(**kwargs)
assert cache.get(query) is None
metricsmock.assert_incr_once(
"locate.fallback.cache",
tags=[self.fallback_tag, "status:bypassed"])
def test_get_mixed(self, cache, stats):
blues = BlueShardFactory.build_batch(2)
cells = CellShardFactory.build_batch(1)
wifis = WifiShardFactory.build_batch(2)
query = self._query(cell=self.cell_model_query(cells),
wifi=self.wifi_model_query(wifis))
assert cache.get(query) is None
query = self._query(blue=self.blue_model_query(blues),
cell=self.cell_model_query(cells))
assert cache.get(query) is None
query = self._query(blue=self.blue_model_query(blues),
wifi=self.wifi_model_query(wifis))
assert cache.get(query) is None
stats.check(counter=[
('locate.fallback.cache', 3, 1,
[self.fallback_tag, 'status:bypassed']),
])
def test_blue(self):
blues = BlueShardFactory.build_batch(2)
query = Query(blue=[
{'macAddress': blue.mac, 'age': 1500, 'name': 'beacon',
'signalStrength': -90}
for blue in blues])
data = self._call(query.json())
assert (data == {
'bluetoothBeacons': [{
'macAddress': blues[0].mac,
'age': 1500,
'name': 'beacon',
'signalStrength': -90,
}, {
'macAddress': blues[1].mac,
'age': 1500,
'name': 'beacon',
'signalStrength': -90,
}],
'fallbacks': {'lacf': True},
})
def test_get_mixed(self, cache, metricsmock):
blues = BlueShardFactory.build_batch(2)
cells = CellShardFactory.build_batch(1)
wifis = WifiShardFactory.build_batch(2)
query = self._query(
cell=self.cell_model_query(cells), wifi=self.wifi_model_query(wifis)
)
assert cache.get(query) is None
query = self._query(
blue=self.blue_model_query(blues), cell=self.cell_model_query(cells)
)
assert cache.get(query) is None
query = self._query(
blue=self.blue_model_query(blues), wifi=self.wifi_model_query(wifis)
)
assert cache.get(query) is None
assert metricsmock.get_records() == [
(
"incr",
"locate.fallback.cache",
1,
[self.fallback_tag, "status:bypassed"],
),
(
"incr",
"locate.fallback.cache",
1,
[self.fallback_tag, "status:bypassed"],
),
(
"incr",
"locate.fallback.cache",
1,
[self.fallback_tag, "status:bypassed"],
),
]
def test_blue_not_found(self):
blues = BlueShardFactory.build_batch(2)
query = self.model_query(blues=blues)
res = self._call(body=query, status=self.not_found.code)
self.check_response(res, 'not_found')
self.check_stats(counter=[
('request', [self.metric_path, 'method:post',
'status:%s' % self.not_found.code]),
(self.metric_type + '.request', [self.metric_path, 'key:test']),
(self.metric_type + '.query',
['key:test', 'region:none',
'geoip:false', 'blue:many', 'cell:none', 'wifi:none']),
(self.metric_type + '.result', 'fallback_allowed:false',
['key:test', 'region:none', 'accuracy:high', 'status:miss']),
(self.metric_type + '.source',
['key:test', 'region:none', 'source:internal',
'accuracy:high', 'status:miss']),
], timer=[
('request', [self.metric_path, 'method:post']),
])
def test_blue_better(self):
blues = BlueShardFactory.build_batch(2)
query = Query(blue=[
{
'mac': blues[0].mac,
'signal': -90,
'name': 'my-beacon'
},
{
'mac': blues[0].mac,
'signal': -82
},
{
'mac': blues[0].mac,
'signal': -85
},
{
'mac': blues[1].mac,
'signal': -70
},
])
self.assertEqual(len(query.blue), 2)
self.assertEqual(set([blue.signal for blue in query.blue]),
set([-70, -82]))
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_blue_region(self):
blues = BlueShardFactory.build_batch(2)
query = Query(
blue=self.blue_model_query(blues), api_type='region')
self.assertEqual(query.expected_accuracy, DataAccuracy.low)
def test_get_blue(self, cache, metricsmock):
blues = BlueShardFactory.build_batch(2)
query = self._query(blue=self.blue_model_query(blues))
assert cache.get(query) is None
metricsmock.assert_incr_once("locate.fallback.cache",
tags=[self.fallback_tag, "status:miss"])
def add_reports(
self,
celery,
num=1,
blue_factor=0,
cell_factor=1,
wifi_factor=2,
blue_key=None,
cell_mcc=None,
wifi_key=None,
api_key="test",
lat=None,
lon=None,
source=None,
):
reports = []
timestamp = int(time.time() * 1000)
for i in range(num):
pos = CellShardFactory.build()
report = {
"timestamp": timestamp,
"position": {},
"bluetoothBeacons": [],
"cellTowers": [],
"wifiAccessPoints": [],
}
report["position"]["latitude"] = lat or pos.lat
report["position"]["longitude"] = lon or pos.lon
report["position"]["accuracy"] = 17.0 + i
if source is not None:
report["position"]["source"] = source
blues = BlueShardFactory.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 = CellShardFactory.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)
items = [{
"api_key": api_key,
"source": rep["position"].get("source", "gnss"),
"report": rep,
} for rep in reports]
self.queue(celery).enqueue(items)
return reports
