def test_smallest_area(self):
area = CellAreaFactory(radius=25000)
area2 = CellAreaFactory(radius=30000, lat=area.lat + 0.2)
self.session.flush()
query = self.model_query(cells=[area, area2])
result = self.source.search(query)
self.check_model_result(result, area)
def test_smallest_area(self):
now = util.utcnow()
area = CellAreaFactory(radius=25000, num_cells=8)
area2 = CellAreaFactory(radius=30000, lat=area.lat + 0.2, num_cells=6)
self.session.flush()
query = self.model_query(cells=[area, area2])
results = self.source.search(query)
self.check_model_results(results, [area])
self.assertAlmostEqual(results.best().score, area.score(now), 4)
def test_multiple_mcc(self):
now = util.utcnow()
region = GEOCODER.regions_for_mcc(235, metadata=True)[0]
cell = CellAreaFactory(mcc=234, num_cells=6)
cell2 = CellAreaFactory(mcc=235, num_cells=8)
self.session.flush()
query = self.model_query(cells=[cell, cell2])
results = self.source.search(query)
self.assertTrue(len(results) > 2)
best_result = results.best()
self.assertEqual(best_result.region_code, region.code)
self.assertAlmostEqual(best_result.score, 1.25 + cell.score(now), 4)
def test_multiple_mcc(self, geoip_db, http_session, session, source):
now = util.utcnow()
region = GEOCODER.regions_for_mcc(235, metadata=True)[0]
area = CellAreaFactory(mcc=234, num_cells=6)
area2 = CellAreaFactory(mcc=235, num_cells=8)
session.flush()
query = self.model_query(geoip_db, http_session, session, cells=[area, area2])
results = source.search(query)
assert len(results) > 2
best_result = results.best()
assert best_result.region_code == region.code
assert best_result.score == 1.25 + area_score(area, now)
def test_smallest_area(self, geoip_db, http_session, session, source):
now = util.utcnow()
area = CellAreaFactory(radius=25000, num_cells=8)
area2 = CellAreaFactory(radius=30000, lat=area.lat + 0.2, num_cells=6)
session.flush()
query = self.model_query(geoip_db,
http_session,
session,
cells=[area, area2])
results = source.search(query)
self.check_model_results(results, [area])
assert results.best().score == area_score(area, now)
def test_cellarea_without_lacf(self, app, data_queues, session,
metricsmock):
cell = CellAreaFactory()
session.flush()
query = self.model_query(cells=[cell])
query["fallbacks"] = {"lacf": False}
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"],
)
def test_cellarea_with_different_fallback(self, app, session, metricsmock):
cell = CellAreaFactory()
session.flush()
query = self.model_query(cells=[cell])
query["fallbacks"] = {"ipf": True}
res = self._call(app, body=query)
self.check_model_response(res, cell, fallback="lacf")
assert metricsmock.has_record(
"incr",
"request",
value=1,
tags=[self.metric_path, "method:post", "status:200"],
)
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 + ".result",
value=1,
tags=[
"key:test",
"region:none",
"fallback_allowed:false",
"accuracy:low",
"status:hit",
"source:internal",
],
)
def test_cellarea_with_lacf(self, app, session, stats):
cell = CellAreaFactory()
session.flush()
query = self.model_query(cells=[cell])
query['fallbacks'] = {'lacf': True}
res = self._call(app, body=query)
self.check_model_response(res, cell, fallback='lacf')
stats.check(counter=[
('request', [self.metric_path, 'method:post', 'status:200']),
(self.metric_type + '.request', [self.metric_path, 'key:test']),
(self.metric_type + '.query', [
'key:test', 'region:none', 'geoip:false', 'blue:none',
'cell:none', 'wifi:none'
]),
(self.metric_type + '.result', [
'key:test', 'region:none', 'fallback_allowed:false',
'accuracy:low', 'status:hit', 'source:internal'
]),
(self.metric_type + '.source', [
'key:test', 'region:none', 'source:internal', 'accuracy:low',
'status:hit'
]),
])
def test_ambiguous_mcc(self, geoip_db, http_session, session, source, metricsmock):
now = util.utcnow()
regions = GEOCODER.regions_for_mcc(234, metadata=True)
area = CellAreaFactory(mcc=234, num_cells=10)
session.flush()
query = self.model_query(geoip_db, http_session, session, cells=[area])
results = source.search(query)
self.check_model_results(results, regions)
assert results.best().region_code == "GB"
for result in results:
score = 0.25
if result.region_code == "GB":
score += area_score(area, now)
assert result.score == score
assert metricsmock.has_record(
"incr",
self.api_type + ".source",
value=1,
tags=[
"key:test",
"region:none",
"source:internal",
"accuracy:low",
"status:hit",
],
)
def test_ambiguous_mcc(self, geoip_db, http_session, session, source,
stats):
now = util.utcnow()
regions = GEOCODER.regions_for_mcc(234, metadata=True)
area = CellAreaFactory(mcc=234, num_cells=10)
session.flush()
query = self.model_query(geoip_db,
http_session,
session,
stats,
cells=[area])
results = source.search(query)
self.check_model_results(results, regions)
assert results.best().region_code == 'GB'
for result in results:
score = 0.25
if result.region_code == 'GB':
score += area_score(area, now)
assert result.score == score
stats.check(counter=[
(self.api_type + '.source', [
'key:test', 'region:none', 'source:internal', 'accuracy:low',
'status:hit'
]),
])
def test_update(self, celery, session):
area = CellAreaFactory(radio=Radio.gsm, num_cells=1)
area.region = None
BlueShardFactory.create_batch(2, region='CA')
BlueShardFactory.create_batch(3, region='GB')
CellAreaFactory(radio=Radio.gsm, region='DE', num_cells=1)
CellAreaFactory(radio=Radio.gsm, region='DE', num_cells=2)
CellAreaFactory(radio=Radio.gsm, region='CA', num_cells=2)
CellAreaFactory(radio=Radio.wcdma, region='DE', num_cells=3)
CellAreaFactory(radio=Radio.lte, region='CA', num_cells=4)
WifiShardFactory.create_batch(5, region='DE')
WifiShardFactory.create_batch(6, region='US')
wifi = WifiShardFactory()
wifi.region = None
session.add(RegionStat(region='US', blue=1, wifi=2))
session.add(RegionStat(region='TW', wifi=1))
session.flush()
update_statregion.delay().get()
stats = session.query(RegionStat).all()
assert len(stats) == 4
for stat in stats:
values = (stat.gsm, stat.wcdma, stat.lte, stat.blue, stat.wifi)
if stat.region == 'DE':
assert values == (3, 3, 0, 0, 5)
elif stat.region == 'CA':
assert values == (2, 0, 4, 2, 0)
elif stat.region == 'GB':
assert values == (0, 0, 0, 3, 0)
elif stat.region == 'US':
assert values == (0, 0, 0, 0, 6)
def test_update(self):
area = CellAreaFactory(radio=Radio.gsm, num_cells=1)
area.region = None
CellAreaFactory(radio=Radio.gsm, region='DE', num_cells=1)
CellAreaFactory(radio=Radio.gsm, region='DE', num_cells=2)
CellAreaFactory(radio=Radio.gsm, region='CA', num_cells=2)
CellAreaFactory(radio=Radio.wcdma, region='DE', num_cells=3)
CellAreaFactory(radio=Radio.lte, region='CA', num_cells=4)
WifiShardFactory.create_batch(5, region='DE')
WifiShardFactory.create_batch(6, region='US')
wifi = WifiShardFactory()
wifi.region = None
self.session.add(RegionStat(region='US', wifi=2))
self.session.add(RegionStat(region='TW', wifi=1))
self.session.flush()
update_statregion.delay().get()
stats = self.session.query(RegionStat).all()
self.assertEqual(len(stats), 3)
for stat in stats:
values = (stat.gsm, stat.wcdma, stat.lte, stat.wifi)
if stat.region == 'DE':
self.assertEqual(values, (3, 3, 0, 5))
elif stat.region == 'CA':
self.assertEqual(values, (2, 0, 4, 0))
elif stat.region == 'US':
self.assertEqual(values, (0, 0, 0, 6))
def test_from_mcc(self, geoip_db, http_session, session, source,
metricsmock):
region = GEOCODER.regions_for_mcc(235, metadata=True)[0]
area = CellAreaFactory(mcc=235, num_cells=10)
session.flush()
query = self.model_query(geoip_db, http_session, session, cells=[area])
results = source.search(query)
self.check_model_results(results, [region])
assert results[0].score == 1.0
metricsmock.assert_incr_once(
self.api_type + ".source",
tags=["key:test", "source:internal", "accuracy:low", "status:hit"],
)
def test_cellarea_without_lacf(self, app, data_queues, session, stats):
cell = CellAreaFactory()
session.flush()
query = self.model_query(cells=[cell])
query['fallbacks'] = {'lacf': False}
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']),
])
def test_from_mcc(self):
region = GEOCODER.regions_for_mcc(235, metadata=True)[0]
cell = CellAreaFactory(mcc=235, num_cells=10)
self.session.flush()
query = self.model_query(cells=[cell])
results = self.source.search(query)
self.check_model_results(results, [region])
self.assertAlmostEqual(results[0].score, 1.0, 4)
self.check_stats(counter=[
(self.api_type + '.source',
['key:test', 'region:none', 'source:internal',
'accuracy:low', 'status:hit']),
])
def test_scan_areas_remove(self):
session = self.session
redis_client = self.redis_client
# create an orphaned lac entry
area = CellAreaFactory()
session.flush()
enqueue_areas(session, redis_client,
[area.hashkey()], UPDATE_KEY['cell_lac'])
# after scanning the orphaned record gets removed
self.assertEqual(scan_areas.delay().get(), 1)
areas = session.query(CellArea).all()
self.assertEqual(areas, [])
def test_cellarea_with_different_fallback(self):
cell = CellAreaFactory()
self.session.flush()
query = self.model_query(cells=[cell])
query['fallbacks'] = {'ipf': True}
res = self._call(body=query)
self.check_model_response(res, cell, fallback='lacf')
self.check_stats(counter=[
('request', [self.metric_path, 'method:post', 'status:200']),
(self.metric_type + '.request', [self.metric_path, 'key:test']),
(self.metric_type + '.result',
['key:test', 'region:none', 'fallback_allowed:false',
'accuracy:low', 'status:hit', 'source:internal']),
])
def test_cellarea(self, app, session, metricsmock, fallback, logs):
"""
A unknown cell in a known cell area can be a hit, with fallback enabled.
The cell location area fallback (lacf) is on by default, or can be
explicitly enabled.
"""
cell = CellAreaFactory()
session.flush()
query = self.model_query(cells=[cell])
if fallback == "explicit":
query["fallbacks"] = {"lacf": True}
elif fallback == "ipf":
# Enabling IP fallback leaves lac fallback at default
query["fallbacks"] = {"ipf": True}
res = self._call(app, body=query)
self.check_model_response(res, cell, fallback="lacf")
metricsmock.assert_incr_once(
"request", tags=[self.metric_path, "method:post", "status:200"])
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:none", "cell:none",
"wifi:none"
],
)
metricsmock.assert_incr_once(
self.metric_type + ".result",
tags=[
"key:test",
"fallback_allowed:false",
"accuracy:low",
"status:hit",
"source:internal",
],
)
metricsmock.assert_incr_once(
self.metric_type + ".source",
tags=["key:test", "source:internal", "accuracy:low", "status:hit"],
)
assert logs.only_entry["cell"] == 1
assert logs.only_entry["cell_valid"] == 0
def test_cellarea_without_lacf(self, app, data_queues, session,
metricsmock, logs):
"""The cell location area fallback can be disabled."""
cell = CellAreaFactory()
session.flush()
query = self.model_query(cells=[cell])
query["fallbacks"] = {"lacf": False}
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"])
assert logs.only_entry["cell"] == 1
assert logs.only_entry["cell_valid"] == 0
def test_from_mcc(self, geoip_db, http_session, session, source, stats):
region = GEOCODER.regions_for_mcc(235, metadata=True)[0]
area = CellAreaFactory(mcc=235, num_cells=10)
session.flush()
query = self.model_query(geoip_db,
http_session,
session,
stats,
cells=[area])
results = source.search(query)
self.check_model_results(results, [region])
assert results[0].score == 1.0
stats.check(counter=[
(self.api_type + '.source', [
'key:test', 'region:none', 'source:internal', 'accuracy:low',
'status:hit'
]),
])
def test_cellarea(self, app, session, metricsmock):
cell = CellAreaFactory()
session.flush()
query = self.model_query(cells=[cell])
res = self._call(app, body=query)
self.check_model_response(res, cell, fallback="lacf")
assert metricsmock.has_record(
"incr",
"request",
value=1,
tags=[self.metric_path, "method:post", "status:200"],
)
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:none", "cell:none", "wifi:none"],
)
assert metricsmock.has_record(
"incr",
self.metric_type + ".result",
value=1,
tags=[
"key:test",
"fallback_allowed:false",
"accuracy:low",
"status:hit",
"source:internal",
],
)
assert metricsmock.has_record(
"incr",
self.metric_type + ".source",
value=1,
tags=["key:test", "source:internal", "accuracy:low", "status:hit"],
)
def test_ambiguous_mcc(self):
now = util.utcnow()
regions = GEOCODER.regions_for_mcc(234, metadata=True)
cell = CellAreaFactory(mcc=234, num_cells=10)
self.session.flush()
query = self.model_query(cells=[cell])
results = self.source.search(query)
self.check_model_results(results, regions)
self.assertEqual(results.best().region_code, 'GB')
for result in results:
score = 0.25
if result.region_code == 'GB':
score += cell.score(now)
self.assertAlmostEqual(result.score, score, 4)
self.check_stats(counter=[
(self.api_type + '.source',
['key:test', 'region:none', 'source:internal',
'accuracy:low', 'status:hit']),
])
