Files
MeshTerm/tests/test_places.py
T
Jean-Pierre MartineauandClaude Opus 5.5 d159e006ea The place job also finds the places of archived contacts
An archived contact is no longer on the device, so the job never saw its
location unless an advert was heard. The contact store keeps that location;
the scan now reads the archived contacts of the device from it. On JP's data,
290 of 422 archived contacts had a location and only 68 had a place.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 17:49:21 -05:00

418 lines
17 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# SPDX-License-Identifier: Apache-2.0
"""The place of a node: the rules, the typed places, the stored places, and the job.
The tiles here are made in the test: each place is a point feature at a known location, so
a test states what the map holds and what the answer must be. No test reads the network.
"""
from __future__ import annotations
import asyncio
import json
import logging
from datetime import datetime, timedelta, timezone
from pathlib import Path
from types import SimpleNamespace
import pytest
from meshterm.core.geo import TILE_PX, lonlat_to_world
from meshterm.core.models import Observation
from meshterm.core.mvt import GEOM_POINT, Feature, Layer
from meshterm.core.place_store import PlaceStore
from meshterm.core.places import (
SOURCE_NOMINATIM,
SOURCE_TILES,
SOURCE_USER,
Place,
moved,
place_from_nominatim,
place_from_tiles,
)
from meshterm.core.preferences import Preferences
from meshterm.persistence.repository import Repository
from meshterm.services import places as places_service
from meshterm.services.places import PlaceService
_EXTENT = 4096
#: A point in a city, and the offsets (km) that the tests put places at.
_LAT, _LON = 45.5440, -73.6150
_KM_LAT = 1 / 111.2 # degrees of latitude in one km
def _north(km: float) -> tuple[float, float]:
"""A location ``km`` north of the test point."""
return _LAT + km * _KM_LAT, _LON
class _Map:
"""Tiles made from named points: each point goes into its tile at each zoom."""
def __init__(self) -> None:
self.points: list[tuple[str, str, str, float, float, int]] = []
self.missing: set[tuple[int, int, int]] = set()
self.loads: list[tuple[int, int, int]] = []
def add(self, layer: str, cls: str, name: str, at: tuple[float, float], rank: int = 10) -> None:
self.points.append((layer, cls, name, at[0], at[1], rank))
def load(self, z: int, x: int, y: int) -> list[Layer] | None:
self.loads.append((z, x, y))
if (z, x, y) in self.missing:
return None
layers = {name: Layer(name, _EXTENT) for name in ("place", "mountain_peak")}
for layer, cls, name, lat, lon, rank in self.points:
wx, wy = lonlat_to_world(lat, lon, z)
if int(wx // TILE_PX) != x or int(wy // TILE_PX) != y:
continue
px = int((wx / TILE_PX - x) * _EXTENT)
py = int((wy / TILE_PX - y) * _EXTENT)
tags = {"class": cls, "name": name, "rank": rank}
layers[layer].features.append(Feature(GEOM_POINT, [[(px, py)]], tags))
return list(layers.values())
# -- the rules ----------------------------------------------------------------
def test_a_neighbourhood_gets_the_city_that_holds_it() -> None:
"""A neighbourhood is the fine part, and the city near it is the coarse part."""
world = _Map()
world.add("place", "neighbourhood", "Villeray", _north(0.5))
world.add("place", "city", "Montréal", _north(-6.0), rank=3)
place = place_from_tiles(_LAT, _LON, world.load)
assert place == Place("Villeray", "Montréal", SOURCE_TILES)
assert place.label == "Villeray, Montréal"
assert place.short == "Villeray"
def test_the_most_specific_area_wins_over_a_nearer_borough() -> None:
"""The most specific area in its radius wins over a nearer borough."""
world = _Map()
world.add("place", "suburb", "Villeray–Saint-Michel–Parc-Extension", _north(0.2))
world.add("place", "neighbourhood", "Villeray", _north(1.0))
world.add("place", "city", "Montréal", _north(-6.0), rank=3)
assert place_from_tiles(_LAT, _LON, world.load).fine == "Villeray"
def test_a_large_city_wins_over_a_nearer_small_one() -> None:
"""The rank of a label weighs the distance: a node in Ahuntsic is in Montréal."""
world = _Map()
world.add("place", "neighbourhood", "Ahuntsic", _north(0.3))
world.add("place", "city", "Laval", _north(4.4), rank=11)
world.add("place", "city", "Montréal", _north(-9.4), rank=3)
assert place_from_tiles(_LAT, _LON, world.load).coarse == "Montréal"
def test_a_peak_near_the_summit_wins() -> None:
"""A peak within its radius of the node is the place."""
world = _Map()
world.add("mountain_peak", "peak", "Mont-Royal", _north(0.2))
world.add("place", "neighbourhood", "Villeray", _north(0.5))
world.add("place", "city", "Montréal", _north(-6.0), rank=3)
place = place_from_tiles(_LAT, _LON, world.load)
assert place == Place("Mont-Royal", None, SOURCE_TILES, peak=True)
def test_a_peak_past_its_radius_does_not_win() -> None:
"""A peak past its radius does not win over a neighbourhood."""
world = _Map()
world.add("mountain_peak", "peak", "Mont-Royal", _north(0.6))
world.add("place", "neighbourhood", "Villeray", _north(0.5))
world.add("place", "city", "Montréal", _north(-6.0), rank=3)
assert place_from_tiles(_LAT, _LON, world.load).fine == "Villeray"
def test_a_village_stands_alone_and_needs_no_fine_tiles() -> None:
"""A village is the place alone, and a node in the country loads only z11 tiles."""
world = _Map()
world.add("place", "village", "Val-David", _north(1.5))
place = place_from_tiles(_LAT, _LON, world.load)
assert place == Place("Val-David", None, SOURCE_TILES)
assert {z for z, _, _ in world.loads} == {11} # the country costs only z11 tiles
def test_a_node_far_from_all_places_gets_the_nearest_settlement() -> None:
"""A node far from all places gets the nearest town, also past the z11 reach."""
world = _Map()
world.add("place", "town", "Mont-Laurier", _north(30.0))
assert place_from_tiles(_LAT, _LON, world.load).fine == "Mont-Laurier"
def test_no_place_near_is_an_empty_answer() -> None:
"""Tiles with no place near give an empty place, which MeshTerm stores."""
place = place_from_tiles(_LAT, _LON, _Map().load)
assert place is not None and place.empty
assert place.label == "" and place.short == ""
def test_a_missing_home_tile_is_no_answer() -> None:
"""When the tile that holds the node has no answer, the result is no answer."""
world = _Map()
world.add("place", "village", "Val-David", _north(1.5))
wx, wy = lonlat_to_world(_LAT, _LON, 11)
world.missing.add((11, int(wx // TILE_PX), int(wy // TILE_PX)))
assert place_from_tiles(_LAT, _LON, world.load) is None
def test_a_bad_location_is_no_answer() -> None:
"""A location that is not a real fix gets no place."""
assert place_from_tiles(0.0, 0.0, _Map().load) is None
assert place_from_tiles(-97.0, -1042.0, _Map().load) is None
def test_a_label_names_a_city_one_time() -> None:
"""A place whose two parts are the same city shows the name one time."""
assert Place("Montréal", "Montréal", SOURCE_TILES).label == "Montréal"
assert Place(None, "Laval", SOURCE_TILES).short == "Laval"
def test_moved_is_past_half_a_km() -> None:
"""A node must move more than half a km before MeshTerm finds its place again."""
assert not moved(_LAT, _LON, *_north(0.4))
assert moved(_LAT, _LON, *_north(0.6))
def test_nominatim_gives_fine_and_coarse() -> None:
"""Nominatim gives the neighbourhood and the city."""
doc = {"address": {"neighbourhood": "Villeray", "suburb": "VSP", "city": "Montréal"}}
assert place_from_nominatim(doc) == Place("Villeray", "Montréal", SOURCE_NOMINATIM)
def test_nominatim_town_alone() -> None:
"""A Nominatim answer with only a village gives the village alone."""
doc = {"address": {"village": "Val-David", "county": "Les Laurentides"}}
assert place_from_nominatim(doc) == Place("Val-David", None, SOURCE_NOMINATIM)
def test_nominatim_error_is_an_empty_answer_and_junk_is_none() -> None:
"""A Nominatim error is an empty answer, and a document that is not an answer is none."""
assert place_from_nominatim({"error": "Unable to geocode"}).empty
assert place_from_nominatim(None) is None
assert place_from_nominatim({"nothing": 1}) is None
# -- the typed places ---------------------------------------------------------
def test_a_typed_place_is_kept_and_cleared(tmp_path: Path) -> None:
"""A typed place stays in the file, and blank text clears it."""
path = tmp_path / "places.json"
store = PlaceStore(path)
store.set("A1B2C3D4E5F6AABB", "Toit du stade", when=100)
assert PlaceStore(path).get("a1b2c3d4e5f6") == "Toit du stade"
store.set("a1b2c3d4e5f6", " ", when=200)
assert PlaceStore(path).get("a1b2c3d4e5f6") is None
def test_a_field_no_record_knows_is_gone_at_the_next_write(tmp_path: Path) -> None:
"""The store writes from its records, so an unknown field is removed."""
path = tmp_path / "places.json"
path.write_text(
json.dumps({"places": {"a1b2c3d4e5f6": {"name": "X", "set_at": 1, "old": 2}}}),
encoding="utf-8",
)
store = PlaceStore(path)
store.set("b1b2c3d4e5f6", "Y", when=3)
saved = json.loads(path.read_text(encoding="utf-8"))
assert saved["places"]["a1b2c3d4e5f6"] == {"name": "X", "set_at": 1}
# -- the stored places --------------------------------------------------------
def _heard(repo: Repository, node: str, lat: float, lon: float, minutes_ago: int) -> None:
run = repo.start_run("monitor", {}, None)
when = datetime.now(timezone.utc) - timedelta(minutes=minutes_ago)
repo.record_observation(run, Observation(node=node, lat=lat, lon=lon, observed_at=when))
def test_node_locations_gives_the_newest(tmp_path: Path) -> None:
"""Each node gets its newest location, and ``since`` reads only newer rows."""
repo = Repository(tmp_path / "p.db")
_heard(repo, "aaaaaaaaaaaa", 45.0, -73.0, minutes_ago=30)
_heard(repo, "aaaaaaaaaaaa", 46.0, -74.0, minutes_ago=5)
_heard(repo, "bbbbbbbbbbbb", 47.0, -75.0, minutes_ago=10)
locations = repo.node_locations()
assert locations["aaaaaaaaaaaa"][:2] == (46.0, -74.0)
stamp = locations["bbbbbbbbbbbb"][2]
assert set(repo.node_locations(since=stamp)) == {"aaaaaaaaaaaa"}
def test_a_stored_place_reads_back(tmp_path: Path) -> None:
"""A stored place, also an empty one, reads back the same."""
repo = Repository(tmp_path / "p.db")
repo.save_node_place("aaaaaaaaaaaa", 45.0, -73.0, Place("Mont-Royal", None, "tiles", True))
repo.save_node_place("bbbbbbbbbbbb", 46.0, -74.0, Place(None, None, "nominatim"))
stored = repo.node_places()
assert stored["aaaaaaaaaaaa"] == (Place("Mont-Royal", None, "tiles", True), 45.0, -73.0)
assert stored["bbbbbbbbbbbb"][0].empty
# -- the service --------------------------------------------------------------
def _service(tmp_path: Path, source: str = "tiles_nominatim") -> tuple[PlaceService, Repository]:
repo = Repository(tmp_path / "p.db")
ctx = SimpleNamespace(
repo=repo,
place_store=PlaceStore(tmp_path / "places.json"),
preferences=Preferences(values={"place_source": source}),
log=logging.getLogger("test"),
)
return PlaceService(ctx), repo # type: ignore[arg-type]
def _run(coro): # noqa: ANN001, ANN202 - a small helper for the async steps
return asyncio.run(coro)
def test_a_typed_place_wins_and_an_empty_place_is_none(tmp_path: Path) -> None:
"""A typed place wins over a found place, and an empty found place is none."""
service, repo = _service(tmp_path)
repo.save_node_place("aaaaaaaaaaaa", 45.0, -73.0, Place("Villeray", "Montréal", "tiles"))
repo.save_node_place("bbbbbbbbbbbb", 45.0, -73.0, Place(None, None, "tiles"))
assert service.get("AAAAAAAAAAAA0000").label == "Villeray, Montréal"
assert service.get("bbbbbbbbbbbb") is None
before = service.revision
service.set_typed("aaaaaaaaaaaa", "Le toit")
assert service.revision > before
assert service.get("aaaaaaaaaaaa") == Place("Le toit", None, SOURCE_USER)
def test_the_job_uses_the_tiles_then_nominatim(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
"""The job asks the tiles first, then Nominatim one time for each location."""
service, repo = _service(tmp_path)
_heard(repo, "aaaaaaaaaaaa", _LAT, _LON, minutes_ago=1)
world = _Map()
world.add("place", "neighbourhood", "Ahuntsic", _north(0.3))
world.add("place", "city", "Laval", _north(4.4), rank=3)
monkeypatch.setattr(service, "_load_tile", world.load)
service._scan_after = 0.0
_run(service.step())
assert service.get("aaaaaaaaaaaa").label == "Ahuntsic, Laval"
asked: list[tuple[float, float]] = []
def nominatim(url: str, lat: float, lon: float) -> object:
asked.append((lat, lon))
return {"address": {"neighbourhood": "Ahuntsic", "city": "Montréal"}}
monkeypatch.setattr(places_service, "ask_nominatim", nominatim)
_run(service.step())
assert service.get("aaaaaaaaaaaa") == Place("Ahuntsic", "Montréal", SOURCE_NOMINATIM)
assert len(asked) == 1
_run(service.step())
assert len(asked) == 1 # one answer for each location: never asked again
def test_the_job_finds_the_place_of_an_archived_contact(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
"""An archived contact is not on the device, but the store keeps its location."""
from meshterm.core.contact_store import ContactStore
from meshterm.core.models import Contact
service, _repo = _service(tmp_path, source="tiles")
device = "dd" * 32
store = ContactStore(tmp_path / "contacts.json")
gone = Contact(name="Gone", public_key="cc" * 32, lat=_LAT, lon=_LON)
store.remember_all(device, [gone])
store.archive(device, gone, when=1_700_000_000)
service._ctx.contact_store = store
service._ctx.devstate = SimpleNamespace(
peek_contacts=lambda: [], peek_self_info=lambda: {"public_key": device}
)
world = _Map()
world.add("place", "village", "Val-David", _north(1.0))
monkeypatch.setattr(service, "_load_tile", world.load)
service._scan_after = 0.0
_run(service.step())
assert service.get("cc" * 32).fine == "Val-David"
def test_tiles_only_never_asks_nominatim(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
"""With the tiles source, the job never asks Nominatim."""
service, repo = _service(tmp_path, source="tiles")
_heard(repo, "aaaaaaaaaaaa", _LAT, _LON, minutes_ago=1)
world = _Map()
world.add("place", "village", "Val-David", _north(1.0))
monkeypatch.setattr(service, "_load_tile", world.load)
monkeypatch.setattr(places_service, "ask_nominatim", lambda *a: pytest.fail("asked"))
service._scan_after = 0.0
_run(service.step())
_run(service.step())
assert service.get("aaaaaaaaaaaa").fine == "Val-David"
def test_a_peak_stays_when_nominatim_could_correct(
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
"""Nominatim does not replace a peak that the tiles found."""
service, repo = _service(tmp_path)
_heard(repo, "aaaaaaaaaaaa", _LAT, _LON, minutes_ago=1)
repo.save_node_place("aaaaaaaaaaaa", _LAT, _LON, Place("Mont-Royal", None, "tiles", True))
monkeypatch.setattr(places_service, "ask_nominatim", lambda *a: pytest.fail("asked"))
service._scan_after = 0.0
_run(service.step())
assert service.get("aaaaaaaaaaaa").peak
def test_a_node_that_moved_is_found_again(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
"""A node that moved past half a km gets a new place."""
service, repo = _service(tmp_path, source="tiles")
repo.save_node_place("aaaaaaaaaaaa", *_north(-5.0), Place("Old", None, "tiles"))
_heard(repo, "aaaaaaaaaaaa", _LAT, _LON, minutes_ago=1)
world = _Map()
world.add("place", "village", "New", _north(1.0))
monkeypatch.setattr(service, "_load_tile", world.load)
service._scan_after = 0.0
_run(service.step())
assert service.get("aaaaaaaaaaaa").fine == "New"
def test_no_answer_makes_the_node_wait(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
"""A node that got no answer waits before the job asks again."""
service, repo = _service(tmp_path, source="tiles")
_heard(repo, "aaaaaaaaaaaa", _LAT, _LON, minutes_ago=1)
calls: list[int] = []
def offline(z: int, x: int, y: int) -> None:
calls.append(z)
return None
monkeypatch.setattr(service, "_load_tile", offline)
service._scan_after = 0.0
_run(service.step())
_run(service.step())
assert len(calls) == 1 # the second step does not ask again at once
assert service.get("aaaaaaaaaaaa") is None
# -- place mode ---------------------------------------------------------------
def test_place_mode_changes_names_to_places(tmp_path: Path) -> None:
"""Place mode changes node names to places and keeps the key, our end, and hashes."""
from meshterm.services.trace_runner import make_node_resolver
from meshterm.ui.pathline import PathHop, path_line
from meshterm.ui.placemode import PlaceToggle, node_of, placed
service, repo = _service(tmp_path)
repo.save_node_place("3daaaaaaaaaa", 45.0, -73.0, Place("Villeray", "Montréal", "tiles"))
resolve = make_node_resolver(None, {"3daaaaaaaaaa": "VE2XYZ", "a1bbbbbbbbbb": "RAK-1W"})
line = path_line([None, "3d", "a1", "ff"], resolve)
hops = placed(line, service, node_of(resolve)).hops
assert [h.label for h in hops[1:]] == ["Villeray", "(RAK-1W)", "ff"]
assert hops[1].key == "3d" # the hop keeps its key, so it keeps its colour
assert hops[0] == line.hops[0] # our own end does not change
assert placed(line, None).hops == line.hops
lone = PathHop("Bob", key="3daaaaaaaaaa") # a full key prefix needs no resolver
assert placed(line.with_hops([lone]), service).hops[0].label == "Villeray"
toggle = PlaceToggle()
assert (toggle.hint, toggle.chip) == ("^N places", "Places")
toggle.flip()
assert (toggle.hint, toggle.chip) == ("^N names", "Names")