def test_iterable(self):
result = self._make_result()
results = ResultList()
results.add(result)
results.add(result)
for res in results:
assert res == result
def _search(self, query):
results = ResultList(result=self.result_type())
for name, source in self.sources:
if source.should_search(query, results):
results.add(source.search(query))
return self._best_result(results)
def test_iterable(self):
result = self._make_result()
results = ResultList()
results.add(result)
results.add(result)
for res in results:
self.assertEqual(res, result)
def test_iterable(self):
result = self._make_result()
results = ResultList()
results.add(result)
results.add(result)
for res in results:
self.assertEqual(res, result)
def test_iterable(self):
result = self._make_result()
results = ResultList()
results.add(result)
results.add(result)
for res in results:
assert res == result
def search(self, query):
results = ResultList(self.result_type())
for should, search in (
(self.should_search_wifi, self.search_wifi),
(self.should_search_cell, self.search_cell)):
if should(query, results):
results.add(search(query))
if results.satisfies(query):
# If we have a good enough result, stop.
break
query.emit_source_stats(self.source, results.best())
return results
def test_repr(self):
results = ResultList([Position(lat=1.0), Position(lat=2.0)])
rep = repr(results)
self.assertTrue(rep.startswith('ResultList'), rep)
self.assertTrue('Position<' in rep, rep)
self.assertTrue('lat:1.0' in rep, rep)
self.assertTrue('lat:2.0' in rep, rep)
def search_mcc(self, query):
results = ResultList()
codes = set()
for cell in list(query.cell) + list(query.cell_area):
codes.add(cell.mcc)
regions = []
for code in codes:
regions.extend(GEOCODER.regions_for_mcc(code, metadata=True))
for region in regions:
region_code = region.code
results.add(self.result_type(
region_code=region_code,
region_name=region.name,
accuracy=region.radius))
return results
def search_mcc(self, query):
results = ResultList()
codes = set()
for cell in list(query.cell) + list(query.cell_area):
codes.add(cell.mcc)
regions = []
for code in codes:
regions.extend(GEOCODER.regions_for_mcc(code, metadata=True))
for region in regions:
region_code = region.code
results.add(self.result_type(
region_code=region_code,
region_name=region.name,
accuracy=region.radius))
return results
def test_repr(self):
results = ResultList([self._make_result(), self._make_result()])
rep = repr(results)
self.assertTrue(rep.startswith('ResultList:'), rep)
self.assertTrue('Position<' in rep, rep)
self.assertTrue('lat:1.0' in rep, rep)
self.assertTrue('lon:1.0' in rep, rep)
self.assertTrue('accuracy:10.0' in rep, rep)
self.assertTrue('score:0.5' in rep, rep)
def test_repr(self):
results = ResultList([self._make_result(), self._make_result()])
rep = repr(results)
assert rep.startswith('ResultList:')
assert 'Position<' in rep
assert 'lat:1.0' in rep
assert 'lon:1.0' in rep
assert 'accuracy:10.0' in rep
assert 'score:0.5' in rep
def test_repr(self):
results = ResultList([self._make_result(), self._make_result()])
rep = repr(results)
assert rep.startswith("ResultList:")
assert "Position<" in rep
assert "lat:1.0" in rep
assert "lon:1.0" in rep
assert "accuracy:10.0" in rep
assert "score:0.5" in rep
def test_incomplete_keys(self):
cells = CellAreaFactory.build_batch(4)
cells[0].radio = None
cells[1].mcc = None
cells[2].mnc = None
cells[3].lac = None
with self.db_call_checker() as check_db_calls:
query = self.model_query(cells=cells)
result = self.source.result_type()
self.assertFalse(
self.source.should_search(query, ResultList(result)))
check_db_calls(rw=0, ro=0)
def search(self, query):
results = ResultList()
for should, search in ((self.should_search_cell, self.search_mcc), ):
if should(query, results):
results.add(search(query))
if results.satisfies(query):
# If we have a good enough result, stop.
break
if len(results):
query.emit_source_stats(self.source, results.best())
else:
results.add(self.result_type())
return results
def search(self, query):
results = ResultList()
codes = set()
for cell in list(query.cell) + list(query.cell_area):
codes.add(cell.mcc)
countries = []
for code in codes:
countries.extend(mobile_codes.mcc(str(code)))
for country in countries:
country_code = country.alpha2
results.add(self.result_type(
country_code=country_code,
country_name=country.name,
accuracy=geoip_accuracy(country_code)))
if len(results):
query.emit_source_stats(self.source, results[0])
else:
results.add(self.result_type())
return results
def check_model_result(self, results, models, **kw):
type_ = self.TestSource.result_type
if not isinstance(results, ResultList):
results = ResultList(results)
if not models:
for result in results:
self.assertTrue(result.empty())
self.assertEqual(type(result), type_)
return
if not isinstance(models, list):
models = [models]
expected = []
if type_ is Position:
check_func = self.assertAlmostEqual
for model in models:
accuracy = kw.get('accuracy', model.radius)
if isinstance(model, (CellOCID, CellShard)):
accuracy = min(max(accuracy, CELL_MIN_ACCURACY),
CELL_MAX_ACCURACY)
elif isinstance(model, (CellArea, CellAreaOCID)):
accuracy = min(max(accuracy, CELLAREA_MIN_ACCURACY),
CELLAREA_MAX_ACCURACY)
elif isinstance(model, WifiShard):
accuracy = min(max(accuracy, WIFI_MIN_ACCURACY),
WIFI_MAX_ACCURACY)
expected.append({
'lat': kw.get('lat', model.lat),
'lon': kw.get('lon', model.lon),
'accuracy': accuracy,
})
elif type_ is Region:
check_func = self.assertEqual
for model in models:
expected.append({
'region_code': model.code,
'region_name': model.name,
})
for expect, result in zip(expected, results):
self.assertFalse(result.empty())
self.assertEqual(type(result), type_)
for key, value in expect.items():
check_func(getattr(result, key), value)
def test_add_many(self):
results = ResultList(self._make_result())
results.add((self._make_result(), self._make_result()))
assert len(results) == 3
def test_len(self):
results = ResultList()
results.add(self._make_result())
results.add(self._make_result())
assert len(results) == 2
def test_init(self):
results = ResultList(self._make_result())
assert len(results) == 1
def test_getitem(self):
result = self._make_result()
results = ResultList()
results.add(result)
self.assertEqual(results[0], result)
def check_should_search(self, query, should, results=None):
if results is None:
results = ResultList(self.source.result_type())
elif isinstance(results, list):
results = ResultList(results)
self.assertIs(self.source.should_search(query, results), should)
def test_add(self):
results = ResultList()
results.add(self._make_result())
self.assertEqual(len(results), 1)
def test_add_many(self):
results = ResultList(self._make_result())
results.add((self._make_result(), self._make_result()))
self.assertEqual(len(results), 3)
def test_add_many(self):
results = ResultList(self._make_result())
results.add((self._make_result(), self._make_result()))
self.assertEqual(len(results), 3)
def test_getitem(self):
result = self._make_result()
results = ResultList()
results.add(result)
assert results[0] == result
def test_add(self):
results = ResultList()
results.add(Result())
self.assertEqual(len(results), 1)
def test_len(self):
results = ResultList()
results.add(self._make_result())
results.add(self._make_result())
assert len(results) == 2
def test_add_many(self):
results = ResultList(self._make_result())
results.add((self._make_result(), self._make_result()))
assert len(results) == 3
def test_len(self):
results = ResultList()
results.add(Result())
results.add(Result())
self.assertEqual(len(results), 2)
def test_getitem(self):
result = self._make_result()
results = ResultList()
results.add(result)
assert results[0] == result
def test_getitem(self):
result = self._make_result()
results = ResultList()
results.add(result)
self.assertEqual(results[0], result)
def test_len(self):
results = ResultList()
results.add(self._make_result())
results.add(self._make_result())
self.assertEqual(len(results), 2)
def test_check_empty(self):
query = self.model_query()
result = self.source.result_type()
self.assertFalse(self.source.should_search(query, ResultList(result)))
def test_should_search(self):
query = self._make_query()
empty = self.source.result_type()
self.assertTrue(self.source.should_search(query, ResultList(empty)))
def test_init(self):
results = ResultList(self._make_result())
self.assertEqual(len(results), 1)
