def add_line_of_cells_and_scan_lac(self):
from ichnaea.tasks import cell_location_update, scan_lacs
session = self.db_master_session
big = 10000000
small = big / 10
keys = dict(radio=1, mcc=1, mnc=1, lac=1)
measures = [
CellMeasure(lat=ctr + xd, lon=ctr + yd, cid=cell, **keys)
for cell in range(0, 10) for ctr in [cell * big]
for (xd, yd) in [(small, small), (small,
-small), (-small,
small), (-small,
-small)]
]
session.add_all(measures)
cells = [
Cell(lat=ctr,
lon=ctr,
cid=cell,
new_measures=4,
total_measures=1,
**keys) for cell in range(0, 10) for ctr in [cell * big]
]
session.add_all(cells)
session.commit()
result = cell_location_update.delay(min_new=0,
max_new=9999,
batch=len(measures))
self.assertEqual(result.get(), (len(cells), 0))
scan_lacs.delay()
def add_line_of_cells_and_scan_lac(self):
from ichnaea.tasks import cell_location_update, scan_lacs
session = self.db_master_session
big = 1.0
small = big / 10
keys = dict(radio=1, mcc=1, mnc=1, lac=1)
measures = [
CellMeasure(lat=ctr + xd, lon=ctr + yd, cid=cell, **keys)
for cell in range(10)
for ctr in [cell * big]
for (xd, yd) in [(small, small),
(small, -small),
(-small, small),
(-small, -small)]
]
session.add_all(measures)
cells = [
Cell(lat=ctr, lon=ctr, cid=cell,
new_measures=4, total_measures=1, **keys)
for cell in range(10)
for ctr in [cell * big]
]
session.add_all(cells)
session.commit()
result = cell_location_update.delay(min_new=0,
max_new=9999,
batch=len(measures))
self.assertEqual(result.get(), (len(cells), 0))
scan_lacs.delay()
def test_cell_max_min_range_update(self):
from ichnaea.tasks import cell_location_update
session = self.db_master_session
k1 = dict(radio=1, mcc=1, mnc=2, lac=3, cid=4)
data = [
Cell(lat=1.001, lon=-1.001,
max_lat=1.002, min_lat=1.0,
max_lon=-1.0, min_lon=-1.002,
new_measures=2, total_measures=4, **k1),
CellMeasure(lat=1.001, lon=-1.003, **k1),
CellMeasure(lat=1.005, lon=-1.007, **k1),
]
session.add_all(data)
session.commit()
result = cell_location_update.delay(min_new=1)
self.assertEqual(result.get(), (1, 0))
cells = session.query(Cell).filter(Cell.cid != CELLID_LAC).all()
self.assertEqual(len(cells), 1)
cell = cells[0]
self.assertEqual(cell.lat, 1.002)
self.assertEqual(cell.max_lat, 1.005)
self.assertEqual(cell.min_lat, 1.0)
self.assertEqual(cell.lon, -1.003)
self.assertEqual(cell.max_lon, -1.0)
self.assertEqual(cell.min_lon, -1.007)
# independent calculation: the cell bounding box is
# (1.000, -1.007) to (1.005, -1.000), with centroid
# at (1.002, -1.003); worst distance from centroid
# to any corner is 556m
self.assertEqual(cell.range, 556)
def test_cell_max_min_range_update(self):
from ichnaea.tasks import cell_location_update
session = self.db_master_session
k1 = dict(radio=1, mcc=1, mnc=2, lac=3, cid=4)
data = [
Cell(lat=10010000, lon=-10010000,
max_lat=10020000, min_lat=10000000,
max_lon=-10000000, min_lon=-10020000,
new_measures=2, total_measures=4, **k1),
CellMeasure(lat=10010000, lon=-10030000, **k1),
CellMeasure(lat=10050000, lon=-10070000, **k1),
]
session.add_all(data)
session.commit()
result = cell_location_update.delay(min_new=1)
self.assertEqual(result.get(), (1, 0))
cells = session.query(Cell).all()
self.assertEqual(len(cells), 1)
cell = cells[0]
self.assertEqual(cell.lat, 10020000)
self.assertEqual(cell.max_lat, 10050000)
self.assertEqual(cell.min_lat, 10000000)
self.assertEqual(cell.lon, -10030000)
self.assertEqual(cell.max_lon, -10000000)
self.assertEqual(cell.min_lon, -10070000)
# independent calculation: the cell bounding box is
# (1.000, -1.007) to (1.005, -1.000), and distance
# between those is 956.43m, int(round(dist/2.0)) is 478m
self.assertEqual(cell.range, 478)
def test_cell_location_update(self):
from ichnaea.tasks import cell_location_update
now = util.utcnow()
before = now - timedelta(days=1)
session = self.db_master_session
k1 = dict(radio=1, mcc=1, mnc=2, lac=3, cid=4)
k2 = dict(radio=1, mcc=1, mnc=2, lac=6, cid=8)
k3 = dict(radio=1, mcc=1, mnc=2, lac=-1, cid=-1)
data = [
Cell(new_measures=3, total_measures=5, **k1),
CellMeasure(lat=1.0, lon=1.0, **k1),
CellMeasure(lat=1.002, lon=1.003, **k1),
CellMeasure(lat=1.004, lon=1.006, **k1),
# The lac, cid are invalid and should be skipped
CellMeasure(lat=1.5, lon=1.5, **k3),
CellMeasure(lat=1.502, lon=1.503, **k3),
Cell(lat=2.0, lon=2.0,
new_measures=2, total_measures=4, **k2),
# the lat/lon is bogus and mismatches the line above on purpose
# to make sure old measures are skipped
CellMeasure(lat=-1.0, lon=-1.0, created=before, **k2),
CellMeasure(lat=-1.0, lon=-1.0, created=before, **k2),
CellMeasure(lat=2.002, lon=2.004, **k2),
CellMeasure(lat=2.002, lon=2.004, **k2),
]
session.add_all(data)
session.commit()
result = cell_location_update.delay(min_new=1)
self.assertEqual(result.get(), (2, 0))
self.check_stats(
total=2,
timer=['task.cell_location_update'],
gauge=['task.cell_location_update.new_measures_1_100'],
)
cells = session.query(Cell).filter(Cell.cid != CELLID_LAC).all()
self.assertEqual(len(cells), 2)
self.assertEqual([c.new_measures for c in cells], [0, 0])
for cell in cells:
if cell.cid == 4:
self.assertEqual(cell.lat, 1.002)
self.assertEqual(cell.lon, 1.003)
elif cell.cid == 8:
self.assertEqual(cell.lat, 2.001)
self.assertEqual(cell.lon, 2.002)
def test_cell_lac_asymmetric(self):
from ichnaea.tasks import cell_location_update, scan_lacs
session = self.db_master_session
big = 1000000
small = big / 10
keys = dict(radio=1, mcc=1, mnc=1, lac=1)
measures = [
CellMeasure(lat=ctr + xd, lon=ctr + yd, cid=cell, **keys)
for cell in range(0, 6) for ctr in [(2**cell) * big]
for (xd, yd) in [(small, small), (small,
-small), (-small,
small), (-small,
-small)]
]
session.add_all(measures)
cells = [
Cell(lat=ctr,
lon=ctr,
cid=cell,
new_measures=4,
total_measures=1,
**keys) for cell in range(0, 6) for ctr in [(2**cell) * big]
]
session.add_all(cells)
session.commit()
result = cell_location_update.delay(min_new=0,
max_new=9999,
batch=len(measures))
self.assertEqual(result.get(), (len(cells), 0))
scan_lacs.delay()
lac = session.query(Cell).filter(Cell.lac == 1,
Cell.cid == CELLID_LAC).first()
# We produced a sequence of 0.02-degree-on-a-side
# cell bounding boxes centered at
# [0, 0.2, 0.4, 0.8, 1.6, 3.2] degrees.
# So the lower-left corner is at (-0.01, -0.01)
# and the upper-right corner is at (3.21, 3.21)
# we should therefore see a LAC centroid at (1.05, 1.05)
# with a range of 339.540m
self.assertEqual(lac.lat, 10500000)
self.assertEqual(lac.lon, 10500000)
self.assertEqual(lac.range, 339540)
def test_cell_lac_asymmetric(self):
from ichnaea.tasks import cell_location_update, scan_lacs
session = self.db_master_session
big = 0.1
small = big / 10
keys = dict(radio=1, mcc=1, mnc=1, lac=1)
measures = [
CellMeasure(lat=ctr + xd, lon=ctr + yd, cid=cell, **keys)
for cell in range(6)
for ctr in [(2 ** cell) * big]
for (xd, yd) in [(small, small),
(small, -small),
(-small, small),
(-small, -small)]
]
session.add_all(measures)
cells = [
Cell(lat=ctr, lon=ctr, cid=cell,
new_measures=4, total_measures=1, **keys)
for cell in range(6)
for ctr in [(2 ** cell) * big]
]
session.add_all(cells)
session.commit()
result = cell_location_update.delay(min_new=0,
max_new=9999,
batch=len(measures))
self.assertEqual(result.get(), (len(cells), 0))
scan_lacs.delay()
lac = session.query(Cell).filter(
Cell.lac == 1,
Cell.cid == CELLID_LAC).first()
# We produced a sequence of 0.02-degree-on-a-side
# cell bounding boxes centered at
# [0, 0.2, 0.4, 0.8, 1.6, 3.2] degrees.
# So the lower-left corner is at (-0.01, -0.01)
# and the upper-right corner is at (3.21, 3.21)
# we should therefore see a LAC centroid at (1.05, 1.05)
# with a range of 339.540m
self.assertEqual(lac.lat, 1.05)
self.assertEqual(lac.lon, 1.05)
self.assertEqual(lac.range, 339540)
def test_cell_location_update(self):
from ichnaea.tasks import cell_location_update
now = datetime.utcnow()
before = now - timedelta(days=1)
session = self.db_master_session
k1 = dict(radio=1, mcc=1, mnc=2, lac=3, cid=4)
k2 = dict(radio=1, mcc=1, mnc=2, lac=6, cid=8)
k3 = dict(radio=1, mcc=1, mnc=2, lac=-1, cid=-1)
data = [
Cell(new_measures=3, total_measures=5, **k1),
CellMeasure(lat=10000000, lon=10000000, **k1),
CellMeasure(lat=10020000, lon=10030000, **k1),
CellMeasure(lat=10040000, lon=10060000, **k1),
# The lac, cid are invalid and should be skipped
CellMeasure(lat=15000000, lon=15000000, **k3),
CellMeasure(lat=15020000, lon=15030000, **k3),
Cell(lat=20000000,
lon=20000000,
new_measures=2,
total_measures=4,
**k2),
# the lat/lon is bogus and mismatches the line above on purpose
# to make sure old measures are skipped
CellMeasure(lat=-10000000, lon=-10000000, created=before, **k2),
CellMeasure(lat=-10000000, lon=-10000000, created=before, **k2),
CellMeasure(lat=20020000, lon=20040000, **k2),
CellMeasure(lat=20020000, lon=20040000, **k2),
]
session.add_all(data)
session.commit()
result = cell_location_update.delay(min_new=1)
self.assertEqual(result.get(), (2, 0))
cells = session.query(Cell).filter(Cell.cid != CELLID_LAC).all()
self.assertEqual(len(cells), 2)
self.assertEqual([c.new_measures for c in cells], [0, 0])
for cell in cells:
if cell.cid == 4:
self.assertEqual(cell.lat, 10020000)
self.assertEqual(cell.lon, 10030000)
elif cell.cid == 8:
self.assertEqual(cell.lat, 20010000)
self.assertEqual(cell.lon, 20020000)
def test_cell_max_min_range_update(self):
from ichnaea.tasks import cell_location_update
session = self.db_master_session
k1 = dict(radio=1, mcc=1, mnc=2, lac=3, cid=4)
data = [
Cell(
lat=10010000,
lon=-10010000,
max_lat=10020000,
min_lat=10000000,
max_lon=-10000000,
min_lon=-10020000,
new_measures=2,
total_measures=4,
**k1
),
CellMeasure(lat=10010000, lon=-10030000, **k1),
CellMeasure(lat=10050000, lon=-10070000, **k1),
]
session.add_all(data)
session.commit()
result = cell_location_update.delay(min_new=1)
self.assertEqual(result.get(), (1, 0))
cells = session.query(Cell).all()
self.assertEqual(len(cells), 1)
cell = cells[0]
self.assertEqual(cell.lat, 10020000)
self.assertEqual(cell.max_lat, 10050000)
self.assertEqual(cell.min_lat, 10000000)
self.assertEqual(cell.lon, -10030000)
self.assertEqual(cell.max_lon, -10000000)
self.assertEqual(cell.min_lon, -10070000)
# independent calculation: the cell bounding box is
# (1.000, -1.007) to (1.005, -1.000), and distance
# between those is 956.43m, int(round(dist/2.0)) is 478m
self.assertEqual(cell.range, 478)
def test_scan_lacs_race_with_cell_location_update(self):
from ichnaea.tasks import cell_location_update, scan_lacs
session = self.db_master_session
# First batch of cell measurements for CID 1
keys = dict(radio=1, mcc=1, mnc=1, lac=1, cid=1)
cell = Cell(new_measures=4, total_measures=1, **keys)
measures = [
CellMeasure(lat=1.0, lon=1.0, **keys),
CellMeasure(lat=1.0, lon=1.0, **keys),
CellMeasure(lat=1.0, lon=1.0, **keys),
CellMeasure(lat=1.0, lon=1.0, **keys),
]
session.add(cell)
session.add_all(measures)
session.commit()
# Periodic cell_location_update runs and updates CID 1
# to have a location, inserts LAC 1 with new_measures=1
# which will be picked up by the next scan_lac.
result = cell_location_update.delay(min_new=1)
self.assertEqual(result.get(), (1, 0))
# Second batch of cell measurements for CID 2
keys['cid'] = 2
cell = Cell(new_measures=4, total_measures=1, **keys)
measures = [
CellMeasure(lat=1.0, lon=1.0, **keys),
CellMeasure(lat=1.0, lon=1.0, **keys),
CellMeasure(lat=1.0, lon=1.0, **keys),
CellMeasure(lat=1.0, lon=1.0, **keys),
]
session.add(cell)
session.add_all(measures)
session.commit()
# Periodic LAC scan runs, picking up LAC 1; this could
# accidentally pick up CID 2, but it should not since it
# has not had its location updated yet. If there's no
# exception here, CID 2 is properly ignored.
scan_lacs.delay()
def test_cell_max_min_range_update(self):
from ichnaea.tasks import cell_location_update
session = self.db_master_session
k1 = dict(radio=1, mcc=1, mnc=2, lac=3, cid=4)
data = [
Cell(lat=10010000,
lon=-10010000,
max_lat=10020000,
min_lat=10000000,
max_lon=-10000000,
min_lon=-10020000,
new_measures=2,
total_measures=4,
**k1),
CellMeasure(lat=10010000, lon=-10030000, **k1),
CellMeasure(lat=10050000, lon=-10070000, **k1),
]
session.add_all(data)
session.commit()
result = cell_location_update.delay(min_new=1)
self.assertEqual(result.get(), (1, 0))
cells = session.query(Cell).filter(Cell.cid != CELLID_LAC).all()
self.assertEqual(len(cells), 1)
cell = cells[0]
self.assertEqual(cell.lat, 10020000)
self.assertEqual(cell.max_lat, 10050000)
self.assertEqual(cell.min_lat, 10000000)
self.assertEqual(cell.lon, -10030000)
self.assertEqual(cell.max_lon, -10000000)
self.assertEqual(cell.min_lon, -10070000)
# independent calculation: the cell bounding box is
# (1.000, -1.007) to (1.005, -1.000), with centroid
# at (1.002, -1.003); worst distance from centroid
# to any corner is 556m
self.assertEqual(cell.range, 556)
def test_cell_location_update(self):
from ichnaea.tasks import cell_location_update
now = datetime.utcnow()
before = now - timedelta(days=1)
session = self.db_master_session
k1 = dict(radio=1, mcc=1, mnc=2, lac=3, cid=4)
k2 = dict(radio=1, mcc=1, mnc=2, lac=6, cid=8)
data = [
Cell(new_measures=3, total_measures=3, **k1),
CellMeasure(lat=10000000, lon=10000000, **k1),
CellMeasure(lat=10020000, lon=10030000, **k1),
CellMeasure(lat=10040000, lon=10060000, **k1),
Cell(lat=20000000, lon=20000000,
new_measures=2, total_measures=4, **k2),
# the lat/lon is bogus and mismatches the line above on purpose
# to make sure old measures are skipped
CellMeasure(lat=-10000000, lon=-10000000, created=before, **k2),
CellMeasure(lat=-10000000, lon=-10000000, created=before, **k2),
CellMeasure(lat=20020000, lon=20040000, **k2),
CellMeasure(lat=20020000, lon=20040000, **k2),
]
session.add_all(data)
session.commit()
result = cell_location_update.delay(min_new=1)
self.assertEqual(result.get(), 2)
cells = session.query(Cell).all()
self.assertEqual(len(cells), 2)
self.assertEqual([c.new_measures for c in cells], [0, 0])
for cell in cells:
if cell.cid == 4:
self.assertEqual(cell.lat, 10020000)
self.assertEqual(cell.lon, 10030000)
elif cell.cid == 8:
self.assertEqual(cell.lat, 20010000)
self.assertEqual(cell.lon, 20020000)
def test_blacklist_moving_cells(self):
from ichnaea.tasks import cell_location_update
now = datetime.utcnow()
long_ago = now - timedelta(days=40)
session = self.db_master_session
k1 = dict(radio=1, mcc=1, mnc=2, lac=3, cid=4)
k2 = dict(radio=1, mcc=1, mnc=2, lac=6, cid=8)
k3 = dict(radio=1, mcc=1, mnc=2, lac=9, cid=12)
k4 = dict(radio=1, mcc=1, mnc=2, lac=12, cid=16)
k5 = dict(radio=1, mcc=1, mnc=2, lac=15, cid=20)
k6 = dict(radio=1, mcc=1, mnc=2, lac=18, cid=24)
keys = set([CellKey(**k) for k in [k1, k2, k3, k4, k5, k6]])
# keys k2, k3 and k4 are expected to be detected as moving
data = [
# a cell with an entry but no prior position
Cell(new_measures=3, total_measures=0, **k1),
CellMeasure(lat=10010000, lon=10010000, **k1),
CellMeasure(lat=10020000, lon=10050000, **k1),
CellMeasure(lat=10030000, lon=10090000, **k1),
# a cell with a prior known position
Cell(lat=20000000, lon=20000000, new_measures=2, total_measures=1, **k2),
CellMeasure(lat=20000000, lon=20000000, **k2),
CellMeasure(lat=40000000, lon=20000000, **k2),
# a cell with a very different prior position
Cell(lat=10000000, lon=10000000, new_measures=2, total_measures=1, **k3),
CellMeasure(lat=30000000, lon=30000000, **k3),
CellMeasure(lat=-30000000, lon=30000000, **k3),
# another cell with a prior known position (and negative lat)
Cell(lat=-40000000, lon=40000000, new_measures=2, total_measures=1, **k4),
CellMeasure(lat=-40000000, lon=40000000, **k4),
CellMeasure(lat=-60000000, lon=40000000, **k4),
# an already blacklisted cell
CellBlacklist(**k5),
CellMeasure(lat=50000000, lon=50000000, **k5),
CellMeasure(lat=80000000, lon=50000000, **k5),
# a cell with an old different record we ignore, position
# estimate has been updated since
Cell(lat=60000000, lon=60000000, new_measures=2, total_measures=1, **k6),
CellMeasure(lat=69000000, lon=69000000, created=long_ago, **k6),
CellMeasure(lat=60000000, lon=60000000, **k6),
CellMeasure(lat=60010000, lon=60000000, **k6),
]
session.add_all(data)
session.commit()
result = cell_location_update.delay(min_new=1)
self.assertEqual(result.get(), (5, 3))
black = session.query(CellBlacklist).all()
self.assertEqual(set([to_cellkey(b) for b in black]), set([CellKey(**k) for k in [k2, k3, k4, k5]]))
measures = session.query(CellMeasure).all()
self.assertEqual(len(measures), 14)
self.assertEqual(set([to_cellkey(m) for m in measures]), keys)
# test duplicate call
result = cell_location_update.delay(min_new=1)
self.assertEqual(result.get(), 0)
msgs = self.heka_client.stream.msgs
self.assertEqual(4, len(msgs))
# We made duplicate calls
find_msg = self.find_heka_messages
taskname = "task.cell_location_update"
self.assertEqual(2, len(find_msg("timer", taskname)))
# One of those would've scheduled a remove_cell task
taskname = "task.remove_cell"
self.assertEqual(1, len(find_msg("timer", taskname)))
def test_blacklist_moving_cells(self):
from ichnaea.tasks import cell_location_update
now = datetime.utcnow()
long_ago = now - timedelta(days=40)
session = self.db_master_session
k1 = dict(radio=1, mcc=1, mnc=2, lac=3, cid=4)
k2 = dict(radio=1, mcc=1, mnc=2, lac=6, cid=8)
k3 = dict(radio=1, mcc=1, mnc=2, lac=9, cid=12)
k4 = dict(radio=1, mcc=1, mnc=2, lac=12, cid=16)
k5 = dict(radio=1, mcc=1, mnc=2, lac=15, cid=20)
k6 = dict(radio=1, mcc=1, mnc=2, lac=18, cid=24)
keys = set([CellKey(**k) for k in [k1, k2, k3, k4, k5, k6]])
# keys k2, k3 and k4 are expected to be detected as moving
data = [
# a cell with an entry but no prior position
Cell(new_measures=3, total_measures=0, **k1),
CellMeasure(lat=10010000, lon=10010000, **k1),
CellMeasure(lat=10020000, lon=10050000, **k1),
CellMeasure(lat=10030000, lon=10090000, **k1),
# a cell with a prior known position
Cell(lat=20000000,
lon=20000000,
new_measures=2,
total_measures=1,
**k2),
CellMeasure(lat=20000000, lon=20000000, **k2),
CellMeasure(lat=40000000, lon=20000000, **k2),
# a cell with a very different prior position
Cell(lat=10000000,
lon=10000000,
new_measures=2,
total_measures=1,
**k3),
CellMeasure(lat=30000000, lon=30000000, **k3),
CellMeasure(lat=-30000000, lon=30000000, **k3),
# another cell with a prior known position (and negative lat)
Cell(lat=-40000000,
lon=40000000,
new_measures=2,
total_measures=1,
**k4),
CellMeasure(lat=-40000000, lon=40000000, **k4),
CellMeasure(lat=-60000000, lon=40000000, **k4),
# an already blacklisted cell
CellBlacklist(**k5),
CellMeasure(lat=50000000, lon=50000000, **k5),
CellMeasure(lat=80000000, lon=50000000, **k5),
# a cell with an old different record we ignore, position
# estimate has been updated since
Cell(lat=60000000,
lon=60000000,
new_measures=2,
total_measures=1,
**k6),
CellMeasure(lat=69000000, lon=69000000, created=long_ago, **k6),
CellMeasure(lat=60000000, lon=60000000, **k6),
CellMeasure(lat=60010000, lon=60000000, **k6),
]
session.add_all(data)
session.commit()
result = cell_location_update.delay(min_new=1)
self.assertEqual(result.get(), (5, 3))
black = session.query(CellBlacklist).all()
self.assertEqual(set([to_cellkey(b) for b in black]),
set([CellKey(**k) for k in [k2, k3, k4, k5]]))
measures = session.query(CellMeasure).all()
self.assertEqual(len(measures), 14)
self.assertEqual(set([to_cellkey(m) for m in measures]), keys)
# test duplicate call
result = cell_location_update.delay(min_new=1)
self.assertEqual(result.get(), 0)
self.check_expected_heka_messages(
total=4,
timer=[
# We made duplicate calls
('task.cell_location_update', 2),
# One of those would've scheduled a remove_cell task
('task.remove_cell', 1)
])
def test_blacklist_moving_cells(self):
from ichnaea.tasks import cell_location_update
now = util.utcnow()
long_ago = now - timedelta(days=40)
session = self.db_master_session
k1 = dict(radio=1, mcc=1, mnc=2, lac=3, cid=4)
k2 = dict(radio=1, mcc=1, mnc=2, lac=6, cid=8)
k3 = dict(radio=1, mcc=1, mnc=2, lac=9, cid=12)
k4 = dict(radio=1, mcc=1, mnc=2, lac=12, cid=16)
k5 = dict(radio=1, mcc=1, mnc=2, lac=15, cid=20)
k6 = dict(radio=1, mcc=1, mnc=2, lac=18, cid=24)
keys = set([CellKey(**k) for k in [k1, k2, k3, k4, k5, k6]])
# keys k2, k3 and k4 are expected to be detected as moving
data = [
# a cell with an entry but no prior position
Cell(new_measures=3, total_measures=0, **k1),
CellMeasure(lat=1.001, lon=1.001, **k1),
CellMeasure(lat=1.002, lon=1.005, **k1),
CellMeasure(lat=1.003, lon=1.009, **k1),
# a cell with a prior known position
Cell(lat=2.0, lon=2.0,
new_measures=2, total_measures=1, **k2),
CellMeasure(lat=2.0, lon=2.0, **k2),
CellMeasure(lat=4.0, lon=2.0, **k2),
# a cell with a very different prior position
Cell(lat=1.0, lon=1.0,
new_measures=2, total_measures=1, **k3),
CellMeasure(lat=3.0, lon=3.0, **k3),
CellMeasure(lat=-3.0, lon=3.0, **k3),
# another cell with a prior known position (and negative lat)
Cell(lat=-4.0, lon=4.0,
new_measures=2, total_measures=1, **k4),
CellMeasure(lat=-4.0, lon=4.0, **k4),
CellMeasure(lat=-6.0, lon=4.0, **k4),
# an already blacklisted cell
CellBlacklist(**k5),
CellMeasure(lat=5.0, lon=5.0, **k5),
CellMeasure(lat=8.0, lon=5.0, **k5),
# a cell with an old different record we ignore, position
# estimate has been updated since
Cell(lat=6.0, lon=6.0,
new_measures=2, total_measures=1, **k6),
CellMeasure(lat=6.9, lon=6.9, time=long_ago, **k6),
CellMeasure(lat=6.0, lon=6.0, **k6),
CellMeasure(lat=6.001, lon=6, **k6),
]
session.add_all(data)
session.commit()
result = cell_location_update.delay(min_new=1)
self.assertEqual(result.get(), (5, 3))
black = session.query(CellBlacklist).all()
self.assertEqual(set([to_cellkey(b) for b in black]),
set([CellKey(**k) for k in [k2, k3, k4, k5]]))
measures = session.query(CellMeasure).all()
self.assertEqual(len(measures), 14)
self.assertEqual(set([to_cellkey(m) for m in measures]), keys)
# test duplicate call
result = cell_location_update.delay(min_new=1)
self.assertEqual(result.get(), 0)
self.check_stats(
total=6,
timer=[
# We made duplicate calls
('task.cell_location_update', 2),
# One of those would've scheduled a remove_cell task
('task.remove_cell', 1)
],
gauge=[
('task.cell_location_update.new_measures_1_100', 2),
])
