Give satellite imagery, terrain data, buildings, streetview photos to your LLM
Remove tests
Belluxx58b6c2917b5d
diff --git a/tests/__init__.py b/tests/__init__.pydeleted file mode 100644index e69de29..0000000diff --git a/tests/data/dense.osm.pbf b/tests/data/dense.osm.pbfdeleted file mode 100644index 3a8ac2e..0000000Binary files a/tests/data/dense.osm.pbf and /dev/null differdiff --git a/tests/data/nodes.osm.pbf b/tests/data/nodes.osm.pbfdeleted file mode 100644index 36dbc25..0000000Binary files a/tests/data/nodes.osm.pbf and /dev/null differdiff --git a/tests/fixtures.py b/tests/fixtures.pydeleted file mode 100644index dfe6662..0000000--- a/tests/fixtures.py+++ /dev/null@@ -1,77 +0,0 @@-"""Small offline responses and a TIFF fixture written independently of src.terrain."""--import json-import struct-import zlib-from io import BytesIO--from PIL import Image---def image_bytes(size, color):- with Image.new("RGB", size, color) as image, BytesIO() as stream:- image.save(stream, format="PNG")- return stream.getvalue()---def metadata(pano_id="panorama_0001", lat=0, lon=0):- return json.dumps([None, [[- [1], [2, pano_id], None, None, None,- [[None, [[None, None, lat, lon]]]],- [None] * 7 + [[2024, 6]],- ]]]).encode()---def terrain_bytes(x, y, zoom, heights=(1.25, -10.5, 200.75, -9999), *, order="<", raster_type=1,- block_size=256, predictor=1):- quarters = [struct.pack(order + "f", height) * 256 for height in heights]- raw_blocks = ([row * 256 for row in quarters] if block_size == 256 else- [(quarters[0] + quarters[1]) * 256 + (quarters[2] + quarters[3]) * 256])- blocks = []- for raw in raw_blocks:- if predictor == 3:- # LibTIFF encodes the float predictor independently of our block splitter.- mode = "F;32F" if order == "<" else "F;32BF"- with Image.frombytes("F", (block_size, block_size), raw, "raw", mode) as image, BytesIO() as stream:- image.save(stream, format="TIFF", compression="tiff_adobe_deflate", tiffinfo={317: 3})- encoded = stream.getvalue()- with Image.open(stream) as saved:- raw = b"".join(zlib.decompress(encoded[offset:offset + size])- for offset, size in zip(saved.tag_v2[273], saved.tag_v2[279]))- blocks.append(zlib.compress(raw))- scale = 40075016.68557849 / (2**zoom * 512)- shift = scale / 2 if raster_type == 2 else 0- west = -20037508.342789244 + x * scale * 512 + shift- north = 20037508.342789244 - y * scale * 512 - shift- tags = {- 256: (4, [512]), 257: (4, [512]), 258: (3, [32]), 259: (3, [8]),- 262: (3, [1]), 277: (3, [1]), 284: (3, [1]),- 317: (3, [predictor]),- 322: (4, [block_size]), 323: (4, [block_size]), 324: (4, [0] * len(blocks)),- 325: (4, list(map(len, blocks))), 339: (3, [3]),- 33550: (12, [scale, scale, 0]),- 33922: (12, [0, 0, 0, west, north, 0]),- 34735: (3, [1, 1, 0, 2, 1025, 0, 1, raster_type, 3072, 0, 1, 3857]),- 42113: (2, b"-9999\0"),- }- payload = bytearray()- entries = bytearray()- payload_start = 8 + 2 + 12 * len(tags) + 4- offset_location = None- for code, (kind, values) in sorted(tags.items()):- raw = values if kind == 2 else struct.pack(order + {3: "H", 4: "I", 12: "d"}[kind] * len(values), *values)- if code == 324:- offset_location = payload_start + len(payload) if len(raw) > 4 else 10 + len(entries) + 8- if len(raw) > 4:- location = payload_start + len(payload)- payload.extend(raw)- raw = struct.pack(order + "I", location)- entries.extend(struct.pack(order + "HHI", code, kind, len(values)) + raw.ljust(4, b"\0"))- data = bytearray(b"II" if order == "<" else b"MM")- data.extend(struct.pack(order + "HIH", 42, 8, len(tags)) + entries + b"\0" * 4 + payload)- offsets = []- for block in blocks:- offsets.append(len(data))- data.extend(block)- struct.pack_into(order + "I" * len(offsets), data, offset_location, *offsets)- return bytes(data)diff --git a/tests/test_capture.py b/tests/test_capture.pydeleted file mode 100644index 640631f..0000000--- a/tests/test_capture.py+++ /dev/null@@ -1,282 +0,0 @@-import json-import tempfile-import unittest-from io import BytesIO-from pathlib import Path-from unittest.mock import Mock, patch-from urllib.error import HTTPError-from urllib.parse import parse_qs, urlsplit--from PIL import Image--from src import capture, geo-from src.common import Client, MissingImagery-from tests.fixtures import image_bytes, metadata, terrain_bytes---def street_run():- return dict(- format="aleph-python", version=capture.FORMAT_VERSION,- bounds=[-0.001, -0.001, 0.001, 0.001],- options=capture.settings(dict(include=["streetview"])),- started_at="2024-06-01T00:00:00+00:00", state="planned",- stages=[dict(- mode="streetview", results=[],- paths=[dict(id="way-1-1", osm_id=1, name="Main Road", highway="residential",- layer="0", points=[[0, -0.001], [0, 0.001]])],- samples=[dict(pano_id="panorama_0001", lat=0, lon=0, heading=90,- path_index=0, path_meters=111, stop_in_path=1)],- )],- )---class CaptureRecoveryTests(unittest.TestCase):- def setUp(self):- self.folder = Path(self.enterContext(tempfile.TemporaryDirectory()))- self.progress = Mock()- self.client = Mock(spec=Client)- self.client.get.side_effect = AssertionError("Unexpected image download")- self.client.maps.export.side_effect = AssertionError("Unexpected OSM download")-- def test_spacing_and_delay_require_valid_numbers_without_workload_caps(self):- for step in (0.5, 2000):- options = capture.settings(dict(step=step, delay=60))- self.assertEqual((options["step"], options["delay"]), (step, 60))- self.assertEqual(capture.settings(dict(delay=0))["delay"], 0)- for key, values in (("step", (0, -1, float("inf"), float("nan"))),- ("delay", (-1, float("inf"), float("nan")))):- for value in values:- with self.subTest(key=key, value=value), self.assertRaises(ValueError):- capture.settings({key: value})-- def test_interrupted_second_side_resumes_from_saved_checkpoint(self):- photo = image_bytes((1024, 576), "red")- for error, state in ((KeyboardInterrupt(), "stopped"), (OSError("offline"), "failed")):- with self.subTest(state=state):- folder = self.folder / state- folder.mkdir()- run = street_run()- self.client.get.side_effect = [metadata(), photo, error]- with self.assertRaises(type(error)) as raised:- capture.download(run, folder, self.client, self.progress)- self.assertIs(raised.exception, error)- saved = capture.load(folder)- self.assertEqual(saved["state"], state)- results = saved["stages"][0]["results"]- self.assertEqual([(p["side"], p["heading"]) for p in results], [("left", 0)])- first = folder / results[0]["filename"]- original = first.read_bytes()- self.assertTrue(saved["exports_saved"])-- self.client.get.reset_mock()- self.client.get.side_effect = [metadata(), photo]- capture.download(saved, folder, self.client, self.progress)- completed = capture.load(folder)- self.assertEqual(completed["state"], "complete")- self.assertNotIn("error", completed)- self.assertIn("finished_at", completed)- self.assertEqual(first.read_bytes(), original)- self.assertEqual([(p["side"], p["heading"]) for p in completed["stages"][0]["results"]],- [("left", 0), ("right", 180)])- self.assertEqual(self.client.get.call_count, 2) # Metadata, then only the missing side.- request = self.client.get.call_args_list[-1].args[0]- self.assertEqual(parse_qs(urlsplit(request).query)["yaw"], ["180"])- exported = json.loads((folder / "streetview/photos.geojson").read_bytes())- self.assertEqual(len(exported["features"]), 2)-- def test_missing_imagery_skips_one_side_and_exports_only_saved_photos(self):- run = street_run()- self.client.get.side_effect = [metadata(), MissingImagery("removed"), image_bytes((1024, 576), "blue")]- capture.download(run, self.folder, self.client, self.progress)- saved = capture.load(self.folder)- self.assertEqual(saved["state"], "complete")- self.assertEqual([p["status"] for p in saved["stages"][0]["results"]], ["skipped", "saved"])- exported = json.loads((self.folder / "streetview/photos.geojson").read_bytes())- self.assertEqual([p["properties"]["side"] for p in exported["features"]], ["right"])-- def test_changed_panorama_or_invalid_image_does_not_advance_checkpoint(self):- responses = {- "changed identity": [metadata(pano_id="panorama_0002")],- "moved panorama": [metadata(lat=0.001)],- "wrong dimensions": [metadata(), image_bytes((256, 256), "red")],- "undecodable image": [metadata(), b"not an image"],- }- for name, response in responses.items():- with self.subTest(case=name):- run = street_run()- self.client.get.reset_mock()- self.client.get.side_effect = response- with self.assertRaises((ValueError, OSError)):- capture.download(run, self.folder, self.client, self.progress)- saved = capture.load(self.folder)- self.assertEqual(saved["state"], "failed")- self.assertEqual(saved["stages"][0]["results"], [])- self.assertEqual(self.client.get.call_count, len(response))- self.assertFalse((self.folder / "streetview/photos").exists())-- def test_failed_satellite_export_resumes_offline_and_crops_tiles_correctly(self):- north, west = geo.coordinate(384, 384, 2)- south, east = geo.coordinate(640, 640, 2)- run = capture.plan(self.client, [south, west, north, east],- dict(include=["satellite"], satellite_zoom=2, satellite_format="png"), self.progress)- colors = [(255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 0)]- self.client.get.side_effect = [image_bytes((256, 256), color) for color in colors]- previous = image_bytes((1, 1), "black")- (self.folder / "satellite.tif").write_bytes(previous)- with patch("src.satellite.zlib.compress", side_effect=OSError("export disk full")):- with self.assertRaisesRegex(OSError, "export disk full"):- capture.download(run, self.folder, self.client, self.progress)- self.assertEqual((self.folder / "satellite.tif").read_bytes(), previous)- self.assertFalse(list(self.folder.glob(".satellite.tif-*")))- saved = capture.load(self.folder)- self.assertEqual(saved["state"], "failed")- self.assertFalse(saved["exports_saved"])- self.assertEqual(len(saved["stages"][0]["results"]), 4)-- self.client.get.reset_mock()- self.client.get.side_effect = AssertionError("Saved tiles must not be downloaded again")- (self.folder / "satellite.png").write_bytes(previous)- with patch("src.satellite.zlib.compressobj", side_effect=OSError("PNG disk full")):- with self.assertRaisesRegex(OSError, "PNG disk full"):- capture.download(saved, self.folder, self.client, self.progress)- for extension in ("tif", "png"):- self.assertEqual((self.folder / f"satellite.{extension}").read_bytes(), previous)- self.assertFalse(list(self.folder.glob(f".satellite.{extension}-*")))- self.assertFalse(capture.load(self.folder)["exports_saved"])- capture.download(saved, self.folder, self.client, self.progress)- self.client.get.assert_not_called()- self.assertEqual(capture.load(self.folder)["state"], "complete")- with Image.open(self.folder / "satellite.tif") as mosaic:- self.assertEqual(mosaic.size, (256, 256))- self.assertEqual([mosaic.getpixel(point) for point in ((0, 0), (255, 0), (0, 255), (255, 255))],- [(*color, 255) for color in colors])-- def test_satellite_cog_matches_mosaic_for_empty_partial_and_complete_captures(self):- north, west = geo.coordinate(384, 384, 3)- south, east = geo.coordinate(896, 984, 3)- run = capture.plan(self.client, [south, west, north, east],- dict(include=["satellite"], satellite_zoom=3), self.progress)- stage = run["stages"][0]- patches = []- for i, tile in enumerate(geo.tiles(stage["grid"])):- filename = f"patch-{i}.png"- # Vary both coordinates and alpha to expose cropping and paste errors.- pixels = bytes(v for y in range(256) for x in range(256)- for v in (x, y, i * 20, (x + y) % 256))- with Image.frombytes("RGBA", (256, 256), pixels) as image:- image.save(self.folder / filename)- patches.append(dict(tile, filename=filename))- for count in (0, 4, 9):- with self.subTest(saved_tiles=count), Image.new("RGBA", (512, 600)) as expected:- stage["results"] = patches[:count]- for photo in stage["results"]:- with Image.open(self.folder / photo["filename"]) as image:- expected.paste(image, (photo["x"] * 256 - 384, photo["y"] * 256 - 384))- with patch.object(Image, "new", wraps=Image.new) as allocate:- capture.export(run, self.folder, self.progress)- self.assertTrue(allocate.called)- self.assertTrue(all(max(call.args[1]) <= 513 for call in allocate.call_args_list))- with Image.open(self.folder / "satellite.tif") as actual:- self.assertEqual(actual.format, "TIFF")- self.assertEqual(actual.size, expected.size)- self.assertEqual(actual.mode, "RGBA")- self.assertEqual(actual.tobytes(), expected.tobytes())- with Image.open(self.folder / "satellite.png") as actual:- actual.verify()- with Image.open(self.folder / "satellite.png") as actual:- self.assertEqual(actual.size, expected.size)- self.assertEqual(actual.mode, "RGBA")- self.assertEqual(actual.tobytes(), expected.tobytes())-- def test_satellite_tile_formats_preserve_source_bytes_and_transparent_gaps(self):- north, west = geo.coordinate(256, 256, 2)- south, east = geo.coordinate(512, 512, 2)- for source in ("JPEG", "PNG", "missing"):- for extension in ("jpg", "png"):- with self.subTest(source=source, requested=extension):- folder = self.folder / f"{source}-{extension}"- folder.mkdir()- run = capture.plan(self.client, [south, west, north, east],- dict(include=["satellite"], satellite_zoom=2,- satellite_format=extension), self.progress)- with BytesIO() as buffer, Image.new("RGB", (256, 256), (72, 105, 210)) as image:- image.save(buffer, format="PNG" if source == "missing" else source)- data = buffer.getvalue()- self.client.get.side_effect = [MissingImagery("missing") if source == "missing" else data]- capture.download(run, folder, self.client, self.progress)- filename = run["stages"][0]["results"][0]["filename"]- expected = "png" if source == "missing" else extension- self.assertEqual(Path(filename).suffix, "." + expected)- with Image.open(folder / filename) as tile, tile.convert("RGBA") as rgba:- self.assertEqual(tile.format, "JPEG" if expected == "jpg" else "PNG")- if source == "missing":- self.assertEqual(rgba.getchannel("A").getextrema(), (0, 0))- elif tile.format == source:- self.assertEqual((folder / filename).read_bytes(), data)- for name in ("satellite.png", "satellite.tif"):- with Image.open(folder / name) as merged:- self.assertEqual(merged.tobytes(), rgba.tobytes())-- def test_satellite_404_leaves_transparent_tile_without_retrying_on_resume(self):- north, west = geo.coordinate(384, 384, 2)- south, east = geo.coordinate(640, 640, 2)- run = capture.plan(self.client, [south, west, north, east],- dict(include=["satellite"], satellite_zoom=2, satellite_format="png"), self.progress)- missing = HTTPError("https://mt1.google.com/vt/", 404, "Not Found", {}, BytesIO())- responses = [BytesIO(image_bytes((256, 256), "red")), missing,- BytesIO(image_bytes((256, 256), "blue")),- BytesIO(image_bytes((256, 256), "green"))]- with patch("src.common.urlopen", side_effect=responses) as get:- capture.download(run, self.folder, Client(), self.progress)- self.assertEqual(get.call_count, 4)- self.assertTrue(missing.fp.closed)- saved = capture.load(self.folder)- self.assertEqual(saved["state"], "complete")- original = (self.folder / "satellite.tif").read_bytes()- with Image.open(self.folder / "satellite.tif") as mosaic:- self.assertEqual(mosaic.size, (256, 256))- self.assertEqual(mosaic.getpixel((0, 0)), (255, 0, 0, 255))- self.assertEqual(mosaic.crop((128, 0, 256, 128)).getchannel("A").getextrema(), (0, 0))- self.assertEqual(mosaic.getpixel((0, 255)), (0, 0, 255, 255))- self.assertEqual(mosaic.getpixel((255, 255)), (0, 128, 0, 255))- self.client.get.reset_mock()- capture.download(saved, self.folder, self.client, self.progress)- self.client.get.assert_not_called()- self.assertEqual((self.folder / "satellite.tif").read_bytes(), original)-- def test_osm_failure_still_saves_terrain_and_resume_fetches_only_map(self):- run = capture.plan(self.client, [1, 1, 2, 2],- dict(include=["osm"], terrain_zoom=1), self.progress)- failure = OSError("Geofabrik unavailable")- self.client.maps.export.side_effect = failure-- def download_terrain(address):- self.progress.assert_called_with("Downloading terrain tiles (map failed: Geofabrik unavailable)", 0, 1)- return terrain_bytes(1, 0, 1)-- self.client.get.side_effect = download_terrain- with self.assertRaises(OSError) as raised:- capture.download(run, self.folder, self.client, self.progress)- self.assertIs(raised.exception, failure)- saved = capture.load(self.folder)- self.assertEqual(saved["state"], "failed")- self.assertTrue(saved["exports_saved"])- self.assertEqual(len(saved["stages"][0]["results"]), 1)- mosaic = (self.folder / "terrain.tif").read_bytes()- self.assertFalse((self.folder / "map.osm").exists())-- osm = b'<osm version="0.6"><node id="1" lat="1" lon="1"/><way id="2"><nd ref="1"/></way></osm>'- def export(area, path, progress):- path.write_bytes(osm)- return dict(source_url="https://download.geofabrik.de/test.osm.pbf", osm_data_at="2026-09-20T20:00:00Z")-- self.client.maps.export.side_effect = export- self.client.get.reset_mock()- self.client.get.side_effect = AssertionError("Completed terrain must not be downloaded again")- capture.download(saved, self.folder, self.client, self.progress)- self.client.get.assert_not_called()- self.assertEqual((self.folder / "map.osm").read_bytes(), osm)- self.assertEqual((self.folder / "terrain.tif").read_bytes(), mosaic)- completed = capture.load(self.folder)- self.assertEqual(completed["state"], "complete")- self.assertEqual(len(completed["stages"][0]["results"]), 2)diff --git a/tests/test_cli.py b/tests/test_cli.pydeleted file mode 100644index f2ef8de..0000000--- a/tests/test_cli.py+++ /dev/null@@ -1,60 +0,0 @@-import json-import tempfile-import unittest-from contextlib import redirect_stderr, redirect_stdout-from io import StringIO-from pathlib import Path-from unittest.mock import patch--import aleph-from src.common import Client-from src.osm import Source-from tests.fixtures import image_bytes---class ConfirmationTests(unittest.TestCase):- def test_declining_or_closed_stdin_creates_no_capture_and_downloads_nothing(self):- for answer in ("", EOFError()):- with self.subTest(answer=answer), tempfile.TemporaryDirectory() as directory:- output = Path(directory) / "captures"- with (- patch("builtins.input", side_effect=[answer]),- patch.object(Client, "get", side_effect=AssertionError("Unexpected download")) as get,- patch.object(Source, "region", side_effect=AssertionError("Unexpected OSM request")) as region,- redirect_stdout(StringIO()) as stdout,- redirect_stderr(StringIO()) as stderr,- ):- status = aleph.main(["capture", "create", "--bbox", "1", "1", "2", "2", "--sources", "satellite",- "--satellite-zoom", "1", "-o", str(output)])- self.assertEqual(status, 0)- self.assertIn("Cancelled", stderr.getvalue())- self.assertEqual(stdout.getvalue(), "")- self.assertFalse(output.exists())- get.assert_not_called()- region.assert_not_called()---class CaptureCommandTests(unittest.TestCase):- def test_create_plan_resume_and_export(self):- def invoke(*args):- with redirect_stdout(StringIO()) as stdout, redirect_stderr(StringIO()):- self.assertEqual(aleph.main(["capture", *args, "--json"]), 0)- result = json.loads(stdout.getvalue())- self.assertEqual(result["command"], "capture")- self.assertEqual(result["action"], args[0])- return result-- with tempfile.TemporaryDirectory() as directory:- with patch.object(Client, "get", side_effect=AssertionError("Planning should not download imagery")):- planned = invoke("create", "--bbox", "1", "1", "2", "2", "--sources", "satellite",- "--satellite-zoom", "1", "--plan", "-o", directory)- self.assertEqual(planned["status"], "planned")- folder = planned["folder"]- with patch.object(Client, "get", return_value=image_bytes((256, 256), "red")):- resumed = invoke("resume", folder, "--no-plan")- self.assertEqual(resumed["status"], "complete")- with patch.object(Client, "get", side_effect=AssertionError("Export must stay offline")):- exported = invoke("export", folder)- self.assertEqual(exported["folder"], folder)- self.assertTrue((Path(folder) / "satellite.tif").is_file())- self.assertTrue((Path(folder) / "satellite.png").is_file())diff --git a/tests/test_common.py b/tests/test_common.pydeleted file mode 100644index dcff97a..0000000--- a/tests/test_common.py+++ /dev/null@@ -1,115 +0,0 @@-import json-import tempfile-import unittest-from io import BytesIO-from pathlib import Path-from unittest.mock import patch-from urllib.error import HTTPError--from src import common---class PersistenceTests(unittest.TestCase):- def test_failed_checkpoint_write_keeps_previous_file_and_removes_temporary(self):- with tempfile.TemporaryDirectory() as directory:- path = Path(directory) / "manifest.json"- common.write_json(path, {"saved": 1})- original = path.read_bytes()- with self.assertRaises(ValueError):- common.write_json(path, {"saved": 2, "invalid": float("nan")})- self.assertEqual(path.read_bytes(), original)- with patch.object(Path, "replace", side_effect=OSError("disk full")):- with self.assertRaises(OSError):- common.write_json(path, {"saved": 2})- self.assertEqual(path.read_bytes(), original)- self.assertEqual(list(path.parent.iterdir()), [path])- common.write_json(path, {"saved": 2})- self.assertEqual(json.loads(path.read_bytes()), {"saved": 2})-- def test_output_paths_cannot_escape_through_traversal_or_symlinks(self):- with tempfile.TemporaryDirectory() as directory:- root = Path(directory)- capture = root / "capture"- capture.mkdir()- (capture / "linked").symlink_to(root, target_is_directory=True)- for name in ("../secret", str(root / "secret"), "linked/secret", "..\\secret", "", "."):- with self.subTest(name=name), self.assertRaises(FileNotFoundError):- common.contained(capture, name)- self.assertEqual(common.contained(capture, "photos/one.jpg"), capture.resolve() / "photos/one.jpg")---class NetworkTests(unittest.TestCase):- def setUp(self):- self.elapsed = 0- self.sleeps = []-- def sleep(seconds):- self.sleeps.append(seconds)- self.elapsed += seconds-- self.enterContext(patch.object(common.time, "monotonic", side_effect=lambda: self.elapsed))- self.enterContext(patch.object(common.time, "sleep", side_effect=sleep))- self.urlopen = self.enterContext(patch.object(common, "urlopen"))-- def test_response_read_failure_retries_and_respects_delay_and_backoff(self):- class BrokenResponse(BytesIO):- def read(self):- raise OSError("connection dropped during read")-- broken = BrokenResponse()- self.urlopen.side_effect = [- broken, OSError("offline"), OSError("offline"), BytesIO(b"complete"),- ]- self.assertEqual(common.Client(delay=3).get("https://example.test/tile"), b"complete")- self.assertTrue(broken.closed)- self.assertEqual(self.urlopen.call_count, 4)- self.assertEqual(self.sleeps, [3, 3, 4])-- def test_only_opted_in_404_becomes_missing_imagery_without_retries(self):- for code, missing_ok, expected in ((404, True, common.MissingImagery), (404, False, OSError), (500, True, OSError)):- with self.subTest(code=code, missing_ok=missing_ok):- attempts = 1 if code == 404 and missing_ok else 4- errors = [HTTPError("https://example.test/tile", code, "unavailable", {}, BytesIO()) for _ in range(attempts)]- self.urlopen.reset_mock(side_effect=True)- self.urlopen.side_effect = errors- self.sleeps.clear()- with self.assertRaises(expected) as raised:- common.Client().get("https://example.test/tile", missing_ok=missing_ok)- self.assertIs(raised.exception.__cause__, errors[-1])- self.assertEqual(self.urlopen.call_count, attempts)- self.assertEqual(self.sleeps, [] if attempts == 1 else [1, 2, 4])- self.assertTrue(all(error.fp.closed for error in errors))-- def test_cancellation_during_backoff_stops_before_another_request(self):- def cancel():- if self.elapsed:- raise KeyboardInterrupt()-- self.urlopen.side_effect = OSError("offline")- with self.assertRaises(KeyboardInterrupt):- common.Client(cancel=cancel).get("https://example.test/tile")- self.assertEqual(self.urlopen.call_count, 1)- self.assertLessEqual(self.elapsed, 0.2)-- def test_streamed_download_retries_truncation_and_preserves_old_file_on_cancellation(self):- def response(data):- value = BytesIO(data)- value.headers = {"Content-Length": "8"}- return value-- with tempfile.TemporaryDirectory() as directory:- path = Path(directory) / "region.pbf"- path.write_bytes(b"previous")- self.urlopen.side_effect = [response(b"short"), response(b"complete")]- common.Client().get("https://example.test/region.pbf", destination=path)- self.assertEqual(path.read_bytes(), b"complete")- self.assertEqual(self.urlopen.call_count, 2)- self.urlopen.side_effect = [response(b"replaced")]-- def cancel(*args):- raise KeyboardInterrupt()-- with self.assertRaises(KeyboardInterrupt):- common.Client().get("https://example.test/region.pbf", destination=path, progress=cancel)- self.assertEqual(path.read_bytes(), b"complete")- self.assertEqual(list(path.parent.iterdir()), [path])diff --git a/tests/test_dashboard_osm.py b/tests/test_dashboard_osm.pydeleted file mode 100644index 5c8f0f9..0000000--- a/tests/test_dashboard_osm.py+++ /dev/null@@ -1,136 +0,0 @@-import json-import tempfile-import unittest-from io import BytesIO-from pathlib import Path-from types import SimpleNamespace-from xml.etree import ElementTree as ET--from src.dashboard import Catalog, Handler-from src.dashboard_osm import display_osm-from src.geo import signed_area---class DashboardOSMTests(unittest.TestCase):- def setUp(self):- self.folder = Path(self.enterContext(tempfile.TemporaryDirectory()))- self.path = self.folder / "map.osm"- self.root = ET.Element("osm", version="0.6")-- def nodes(self, points):- for identity, (lon, lat) in points.items():- ET.SubElement(self.root, "node", id=str(identity), lon=str(lon), lat=str(lat))-- def way(self, identity, refs, **tags):- element = ET.SubElement(self.root, "way", id=str(identity), user="unused metadata")- for ref in refs:- ET.SubElement(element, "nd", ref=str(ref))- for key, value in tags.items():- ET.SubElement(element, "tag", k=key, v=value)-- def relation(self, identity, members, **tags):- element = ET.SubElement(self.root, "relation", id=str(identity))- for ref, role in members:- ET.SubElement(element, "member", type="way", ref=str(ref), role=role)- for key, value in tags.items():- ET.SubElement(element, "tag", k=key, v=value)-- def save(self):- ET.ElementTree(self.root).write(self.path)-- def test_only_rendered_geometry_and_properties_with_building_popup_fields(self):- self.nodes({1: (0, 0), 2: (1, 0), 3: (1, 1), 4: (0, 1)})- ring = [1, 2, 3, 4, 1]- self.way(1, ring, building="yes", name="Library", height="30 ft", min_height="50",- amenity="library", source="survey", **{"addr:street": "Unused"})- self.way(2, ring, landuse="forest", name="Unused forest name")- self.way(3, ring, natural="water", water="pond", name="Unused pond name")- self.way(4, ring, highway="residential", junction="roundabout", name="Unused road name")- self.way(5, [1, 2], waterway="stream", name="Unused stream name")- self.way(6, ring, amenity="parking")- self.way(7, ring, building="no")- self.way(8, ring, highway="pedestrian", area="yes")- self.way(9, ring, natural="wood", area="no")- self.way(10, [1, 999], highway="service") # Never bridge missing nodes.- self.way(11, ring, building="house", **{"building:levels": "2"})- self.way(12, ring, building="shed")- self.save()- features = display_osm(self.path)["features"]- self.assertEqual(len(features), 7)- building, forest, pond, road, stream, house, shed = features- self.assertEqual(building["geometry"]["type"], "Polygon")- self.assertEqual(building["properties"], dict(building="yes", name="Library", _height=9.144,- _base=9.144, _estimated=False))- self.assertEqual(forest["properties"], {"land": True})- self.assertEqual(pond["properties"], {"water": True})- self.assertEqual(road["geometry"]["type"], "LineString")- self.assertEqual(road["properties"], {"road": True})- self.assertEqual(stream["properties"], {"waterway": True})- self.assertEqual(house["properties"]["_height"], 6)- self.assertFalse(house["properties"]["_estimated"])- self.assertEqual(shed["properties"]["_height"], 9)- self.assertTrue(shed["properties"]["_estimated"])-- def test_split_reversed_multipolygon_with_hole_and_incomplete_distant_member(self):- self.nodes({1: (0, 0), 2: (8, 0), 3: (8, 8), 4: (0, 8),- 5: (2, 2), 6: (4, 2), 7: (4, 4), 8: (2, 4),- 9: (10, 0), 10: (12, 0), 11: (12, 2), 12: (10, 2)})- self.way(1, [1, 2, 3])- self.way(2, [1, 4, 3])- self.way(3, [5, 6, 7, 8, 5], natural="water")- self.way(4, [9, 10, 11, 12, 9], natural="water")- self.relation(1, [(2, "outer"), (3, "inner"), (1, "outer"), (4, "outer"), (999, "outer")],- type="multipolygon", natural="water", name="Unused")- self.save()- features = display_osm(self.path)["features"]- self.assertEqual(len(features), 1)- self.assertEqual(features[0]["properties"], {"water": True})- geometry = features[0]["geometry"]- self.assertEqual(geometry["type"], "MultiPolygon")- polygons = geometry["coordinates"]- self.assertEqual(sorted(len(p) for p in polygons), [1, 2])- self.assertEqual(sum(signed_area(r) for p in polygons for r in p), 64)- self.assertTrue(all(signed_area(p[0]) > 0 for p in polygons))- self.assertTrue(all(signed_area(r) < 0 for p in polygons for r in p[1:]))-- def test_outer_way_tags_and_independently_tagged_inner_are_preserved(self):- self.nodes({1: (0, 0), 2: (8, 0), 3: (8, 8), 4: (0, 8),- 5: (2, 2), 6: (4, 2), 7: (4, 4), 8: (2, 4)})- self.way(1, [1, 2, 3, 4, 1], landuse="forest")- self.way(2, [5, 6, 7, 8, 5], natural="water")- self.relation(1, [(1, "outer"), (2, "inner")], type="multipolygon")- self.save()- features = display_osm(self.path)["features"]- self.assertEqual([f["properties"] for f in features], [{"land": True}, {"water": True}])- self.assertEqual(len(features[0]["geometry"]["coordinates"][0]), 2)-- def test_endpoint_reconverts_without_cache_and_reports_invalid_xml(self):- server = SimpleNamespace(catalog=Catalog(self.folder.parent), hosts={"localhost"})-- def request():- handler = object.__new__(Handler)- handler.server = server- handler.headers = {"Host": "localhost"}- handler.command, handler.request_version = "GET", "HTTP/1.1"- handler.path = f"/api/captures/{self.folder.name}/osm.geojson"- handler.requestline = f"GET {handler.path} HTTP/1.1"- handler.wfile = BytesIO()- handler.dispatch()- headers, body = handler.wfile.getvalue().split(b"\r\n\r\n", 1)- self.assertIn(b"Cache-Control: no-store", headers)- return headers, json.loads(body)-- self.save()- headers, data = request()- self.assertIn(b"200 OK", headers)- self.assertEqual(data, dict(type="FeatureCollection", features=[]))- self.nodes({1: (0, 0), 2: (1, 1)})- self.way(1, [1, 2], highway="service")- self.save()- self.assertEqual(len(request()[1]["features"]), 1)- self.assertEqual(list(self.folder.iterdir()), [self.path])- self.assertEqual(server.catalog.cache, {})- self.path.write_text("<osm><way>")- headers, data = request()- self.assertIn(b"400 Bad Request", headers)- self.assertIn("invalid XML", data["error"])diff --git a/tests/test_dashboard_tiles.py b/tests/test_dashboard_tiles.pydeleted file mode 100644index 5b6ab02..0000000--- a/tests/test_dashboard_tiles.py+++ /dev/null@@ -1,66 +0,0 @@-import tempfile-import unittest-from concurrent.futures import ThreadPoolExecutor-from pathlib import Path-from unittest.mock import patch--from PIL import Image--from src.dashboard_tiles import Tiles-from tests.fixtures import image_bytes---class DashboardTileTests(unittest.TestCase):- def test_native_and_cached_tiles_do_not_wait_for_generation(self):- with tempfile.TemporaryDirectory() as directory, ThreadPoolExecutor() as workers:- root = Path(directory).resolve()- folder = root / "capture"- folder.mkdir()- with Image.new("RGB", (256, 256), "red") as image:- image.save(folder / "original.jpg")- with Image.new("RGBA", (256, 256)) as image:- image.save(folder / "gap.png")- stage = dict(mode="satellite", grid=dict(zoom=2, x0=0, y0=0, columns=2, rows=2),- results=[dict(filename=name) for name in- ("original.jpg", "gap.png", "original.jpg", "original.jpg")])- run = dict(stages=[stage])- tiles = Tiles(root / "cache")- overview, _ = tiles.get(folder, run, "satellite", 1, 0, 0)- # Only the overview needs encoding; originals remain the native tiles.- self.assertEqual(list((root / "cache").rglob("*.png")), [overview])- with tiles.locks["satellite"], tiles.locks["terrain"], patch.object(- Image, "open", side_effect=AssertionError("Ready tiles must not be decoded")- ):- for z, x, expected in ((2, 0, folder / "original.jpg"), (2, 1, folder / "gap.png"),- (1, 0, overview)):- with self.subTest(zoom=z, x=x):- result = workers.submit(tiles.get, folder, run, "satellite", z, x, 0)- self.assertEqual(result.result(timeout=2), (expected, True))-- def test_cached_overview_refreshes_as_capture_fills_in(self):- with tempfile.TemporaryDirectory() as directory:- root = Path(directory)- folder = root / "capture"- folder.mkdir()- tiles = Tiles(root / "cache")- stage = dict(mode="satellite", grid=dict(zoom=2, x0=0, y0=0, columns=2, rows=2), results=[])- run = dict(stages=[stage])- colors = [(255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 0)]- centers = [(64, 64), (192, 64), (64, 192), (192, 192)]- for count in range(5):- with self.subTest(saved_tiles=count):- if count:- filename = f"{count}.png"- (folder / filename).write_bytes(image_bytes((256, 256), colors[count - 1]))- stage["results"].append(dict(filename=filename))- path, complete = tiles.get(folder, run, "satellite", 1, 0, 0)- self.assertEqual(complete, count == 4)- with Image.open(path) as image:- self.assertEqual([image.getpixel(point) for point in centers],- [(*color, 255) if i < count else (0, 0, 0, 0)- for i, color in enumerate(colors)])- # Repeating a request must return the same usable cached content.- original = path.read_bytes()- cached, cached_complete = tiles.get(folder, run, "satellite", 1, 0, 0)- self.assertEqual(cached.read_bytes(), original)- self.assertEqual(cached_complete, complete)diff --git a/tests/test_osm.py b/tests/test_osm.pydeleted file mode 100644index bf4719a..0000000--- a/tests/test_osm.py+++ /dev/null@@ -1,89 +0,0 @@-import hashlib-import json-from pathlib import Path-import tempfile-import unittest-from unittest.mock import Mock-from xml.etree import ElementTree as ET--from src.common import Client-from src.osm import covers---def polygon(ring, *holes):- return dict(type="Polygon", coordinates=[ring, *holes])---class RegionTests(unittest.TestCase):- def test_region_must_cover_rectangle_interior_and_avoid_holes(self):- outer = [[-2, -2], [2, -2], [2, 2], [-2, 2], [-2, -2]]- hole = [[-.1, -.1], [.1, -.1], [.1, .1], [-.1, .1], [-.1, -.1]]- self.assertTrue(covers(polygon(outer), (-1, -1, 1, 1)))- self.assertFalse(covers(polygon(outer, hole), (-1, -1, 1, 1)))- notch = [[-2, -2], [2, -2], [2, 2], [.1, 2], [.1, 0], [-.1, 0], [-.1, 2], [-2, 2], [-2, -2]]- self.assertFalse(covers(polygon(notch), (-1, -1, 1, 1)))- self.assertFalse(covers(polygon(outer), (-3, -1, 1, 1)))---class ExtractTests(unittest.TestCase):- def setUp(self):- self.folder = Path(self.enterContext(tempfile.TemporaryDirectory()))- self.client = Client(cache_dir=self.folder)- self.client.get = Mock(side_effect=AssertionError("Cached extracts must work offline"))- self.source = self.client.maps- self.source.directory.mkdir()- url = "https://download.geofabrik.de/test-latest.osm.pbf"- self.path = self.source.directory / (hashlib.sha256(url.encode()).hexdigest()[:16] + ".osm.pbf")- index = dict(features=[dict(type="Feature", properties=dict(name="Test region", urls=dict(pbf=url)),- geometry=polygon([[-2, -2], [2, -2], [2, 2], [-2, 2], [-2, -2]]))])- (self.source.directory / "index.json").write_text(json.dumps(index))- self.path.write_bytes((Path(__file__).parent / "data" / "dense.osm.pbf").read_bytes())- self.area = (-.0001, -.0001, .0001, .0005)-- def test_export_completes_ways_and_preserves_partial_relation_members(self):- output = self.folder / "map.osm"- metadata = self.source.export(self.area, output, lambda *args: None)- root = ET.parse(output).getroot()- self.assertEqual({int(n.attrib["id"]) for n in root.findall("node")}, {1, 2, 6})- self.assertEqual({int(w.attrib["id"]) for w in root.findall("way")}, {10, 13})- self.assertEqual({int(r.attrib["id"]) for r in root.findall("relation")}, {19, 20})- self.assertEqual(metadata["osm_data_at"], "2026-09-20T20:00:00Z")- self.client.get.assert_not_called()-- def test_roads_pois_and_connected_street_use_cached_region(self):- ways, metadata = self.source.data(self.area)- self.assertEqual([way["id"] for way in ways], [10])- self.assertEqual(ways[0]["nodes"], [1, 2])- self.assertEqual(ways[0]["points"][-1], (0, .001))- self.assertEqual(metadata["osm_data_at"], "2026-09-20T20:00:00Z")- pois, _ = self.source.data(self.area, poi=True)- relations = {item["id"]: item["center"] for item in pois if item["type"] == "relation"}- self.assertEqual(relations, {19: (0, .001), 20: (0, .001)})- name, street = self.source.street(dict(id="way/10", lat=0, lon=0))- self.assertEqual(name, "Main Street")- self.assertEqual({w["id"] for w in street}, {10, 11})- self.assertEqual(self.source.data((1, 1, 1.1, 1.1), poi=True)[0], [])- self.client.get.assert_not_called()-- def test_refresh_rejects_invalid_download_without_replacing_cached_region(self):- original = self.path.read_bytes()- self.client.refresh = True- self.source.index = json.loads((self.source.directory / "index.json").read_bytes())["features"]-- def download(url, **kwargs):- Path(kwargs["destination"]).write_bytes(b"not a PBF")-- self.client.get.side_effect = download- with self.assertRaises(ValueError):- self.source.region(self.area, lambda *args: None)- self.assertEqual(self.path.read_bytes(), original)-- def test_cancellation_stops_local_processing(self):- output = self.folder / "map.osm"- output.write_bytes(b"previous")- self.source.region(self.area, lambda *args: None)- self.client.cancel = Mock(side_effect=[None, KeyboardInterrupt()])- with self.assertRaises(KeyboardInterrupt):- self.source.export(self.area, output, lambda *args: None)- self.assertEqual(output.read_bytes(), b"previous")- self.assertEqual(list(self.folder.glob(".map.osm-*")), [])diff --git a/tests/test_pbf.py b/tests/test_pbf.pydeleted file mode 100644index c74f01c..0000000--- a/tests/test_pbf.py+++ /dev/null@@ -1,181 +0,0 @@-"""PBF wire-format boundaries and extraction checked without external packages."""--import random-import struct-import subprocess-import sys-import tempfile-import unittest-import zlib-from pathlib import Path-from xml.etree import ElementTree as ET--from src.dashboard_osm import display_osm-from src.pbf import PBF, unpack---def integer(value):- result = bytearray()- while value >= 128:- result.append((value & 127) | 128)- value >>= 7- return bytes(result) + bytes([value])---def field(number, value):- if isinstance(value, bytes):- return integer(number * 8 + 2) + integer(len(value)) + value- return integer(number * 8) + integer(value)---def packed(values, signed=False):- return b"".join(integer((v << 1) ^ (v >> 63) if signed else v) for v in values)---def blob(kind, payload, compressed=False):- data = field(2, len(payload)) + field(3, zlib.compress(payload)) if compressed else field(1, payload)- header = field(1, kind) + field(3, len(data))- return struct.pack(">I", len(header)) + header + data---def snapshot(group, *, options=b"", features=(b"OsmSchema-V0.6", b"DenseNodes"), strings=(b"",)):- header = b"".join(field(4, feature) for feature in features)- data = field(1, b"".join(field(1, value) for value in strings)) + field(2, group) + options- return blob(b"OSMHeader", header) + blob(b"OSMData", data, True)---def multipolygon_snapshot(missing_way=False):- strings = (b"", b"type", b"multipolygon", b"building", b"yes", b"outer", b"inner", b"label", b"route")- coordinates = [(-10000, -10000), (-10000, 10000), (10000, 10000), (10000, -10000),- (-5000, -5000), (-5000, 5000), (5000, 5000), (5000, -5000),- (100000, 100000), (100000, 110000), (20000, 20000)]- nodes = b"".join(field(1, field(1, identity * 2) + field(8, (lat << 1) ^ (lat >> 63))- + field(9, (lon << 1) ^ (lon >> 63)))- for identity, (lat, lon) in enumerate(coordinates, 1))- result = snapshot(nodes, strings=strings)- table = field(1, b"".join(field(1, value) for value in strings))-- def deltas(refs):- return packed([refs[0], *(b - a for a, b in zip(refs, refs[1:]))], True)-- for ways in ([(10, [1, 2]), (15, [5, 6, 7, 8, 5]), (20, [2, 3, 4])],- [(30, [4, 1])], [(40, [9, 10]), (50, [9, 10])]):- group = b"".join(field(3, field(1, identity) + field(8, deltas(refs)))- for identity, refs in ways if not (missing_way and identity == 20))- result += blob(b"OSMData", table + field(2, group), True)- relations = b""- # Only 100 directly intersects the capture and needs polygon completion.- for identity, keys, vals, refs, roles, kinds in (- (100, [1, 3], [2, 4], [10, 20, 30, 15, 11], [5, 5, 5, 6, 7], [1, 1, 1, 1, 0]),- (101, [1], [8], [10, 40], [0, 0], [1, 1]),- (102, [1], [2], [100, 50], [0, 5], [2, 1]),- ):- relations += field(4, field(1, identity) + field(2, packed(keys)) + field(3, packed(vals))- + field(8, packed(roles)) + field(9, deltas(refs)) + field(10, packed(kinds)))- return result + blob(b"OSMData", table + field(2, relations), True)---class PBFTests(unittest.TestCase):- def setUp(self):- self.folder = Path(self.enterContext(tempfile.TemporaryDirectory()))- self.path = self.folder / "region.osm.pbf"- self.output = self.folder / "map.osm"- self.area = (-.0001, -.0001, .0001, .0005)-- def test_dense_and_normal_nodes_preserve_tags_metadata_and_complete_ways(self):- results = []- for name in ("dense.osm.pbf", "nodes.osm.pbf"):- source = PBF(Path(__file__).parent / "data" / name)- source.export(self.area, self.output)- root = ET.parse(self.output).getroot()- self.assertEqual({n.attrib["id"] for n in root.findall("node")}, {"1", "2", "6"})- node = root.find("node")- self.assertEqual(node.attrib["version"], "3")- self.assertEqual(node.attrib["timestamp"], "2026-09-19T12:34:56Z")- self.assertEqual(node.find("tag[@k='name']").attrib["v"], 'Caffè & "Tea" <Terrace>')- results.append(source.read(source.select(self.area), centers=True))- self.assertEqual(*results)-- def test_nondefault_offsets_granularity_and_split_packed_fields(self):- ids = field(1, packed([10], True)) + field(1, packed([1], True))- dense = ids + field(8, packed([-10, 20], True)) + field(9, packed([5, -10], True))- options = field(17, 10_000_000) + field(19, (1 << 64) - 1_000_000_000) + field(20, 2_000_000_000)- self.path.write_bytes(snapshot(field(2, dense), options=options))- source = PBF(self.path)- selected = source.select((-2, 1, 0, 3))- self.assertEqual(selected, ({10, 11}, set(), set()))- self.assertEqual(list(source.nodes(selected[0])), [(10, -1.1, 2.05), (11, -.9, 1.95)])-- def test_integer_boundaries_and_malformed_varints(self):- values = [0, 1, 127, 128, 16384, 1 << 32, (1 << 64) - 1]- self.assertEqual(list(unpack(packed(values))), values)- signed = [0, -1, 63, -64, 64, -65, 1 << 40, -(1 << 63)]- self.assertEqual(list(unpack(packed(signed, True), True)), signed)- for data in (b"\x80", b"\x80" * 10, b"\xff" * 9 + b"\x02"):- with self.subTest(data=data), self.assertRaises(ValueError):- unpack(data)-- def test_bulk_integer_decoding_and_lane_boundaries(self):- rng = random.Random(17)- for signed in (False, True):- limit = 1 << (27 if signed else 28)- values = [rng.randrange(-limit if signed else 0, limit) for _ in range(2000)]- values[0] = -(1 << 63) if signed else (1 << 64) - 1- values[1:9] = [0, 1, 63, 64, 127, 128, 16383, 16384]- if signed:- values[9:14] = [-1, -64, -65, -8192, -8193]- data = packed(values, signed)- self.assertEqual(list(unpack(data, signed)), values)- with self.assertRaises(ValueError):- unpack(data + b"\x80", signed)- values = [1 << 40] + [1] * 1000 + [1 << 30, 0, 3]- self.assertEqual(list(unpack(packed(values, True), True)), values)-- def test_rejects_unknown_features_and_truncated_files(self):- for data in (b"", b"\x00\x00", snapshot(b"", features=(b"HistoricalInformation",)), snapshot(b"")[:-1]):- self.path.write_bytes(data)- with self.subTest(data=data[:20]), self.assertRaises(ValueError):- PBF(self.path)-- def test_missing_way_node_preserves_previous_output(self):- node = field(1, 2) + field(8, 0) + field(9, 0)- way = field(1, 10) + field(8, packed([1, 998], True))- self.path.write_bytes(snapshot(field(1, node) + field(3, way)))- self.output.write_bytes(b"previous")- with self.assertRaisesRegex(ValueError, "incomplete way"):- PBF(self.path).export(self.area, self.output)- self.assertEqual(self.output.read_bytes(), b"previous")- self.assertEqual(list(self.folder.glob(".map.osm-*")), [])-- def test_map_completes_multipolygon_outer_and_hole_without_expanding_other_relations(self):- self.path.write_bytes(multipolygon_snapshot())- area = (-.0011, -.0011, -.0009, -.0009)- source = PBF(self.path)- self.assertEqual(source.select(area)[1], {10, 30})- source.export(area, self.output)- root = ET.parse(self.output).getroot()- self.assertEqual([int(w.attrib["id"]) for w in root.findall("way")], [10, 15, 20, 30])- self.assertEqual({int(n.attrib["id"]) for n in root.findall("node")}, {*range(1, 9), 11})- self.assertEqual([int(r.attrib["id"]) for r in root.findall("relation")], [100, 101, 102])- features = display_osm(self.output)["features"]- self.assertEqual(len(features), 1)- geometry = features[0]["geometry"]- self.assertEqual(geometry["type"], "MultiPolygon")- self.assertEqual(len(geometry["coordinates"][0]), 2) # Closed outer and courtyard.-- def test_missing_multipolygon_way_keeps_available_geometry_and_original_references(self):- self.path.write_bytes(multipolygon_snapshot(missing_way=True))- PBF(self.path).export((-.0011, -.0011, -.0009, -.0009), self.output)- root = ET.parse(self.output).getroot()- self.assertEqual([int(w.attrib["id"]) for w in root.findall("way")], [10, 15, 30])- self.assertIsNotNone(root.find("relation[@id='100']/member[@ref='20']"))- nodes = {n.attrib["id"] for n in root.findall("node")}- self.assertTrue(all(nd.attrib["ref"] in nodes for nd in root.findall("way/nd")))- self.assertEqual(display_osm(self.output)["features"], []) # Do not invent the missing outline.-- def test_standalone_script_runs_without_site_packages(self):- source = Path(__file__).parent / "data" / "dense.osm.pbf"- script = Path(__file__).resolve().parents[1] / "src" / "pbf.py"- subprocess.run([sys.executable, "-S", str(script), str(source), *map(str, self.area),- "-o", str(self.output)], check=True, capture_output=True)- self.assertEqual(len(ET.parse(self.output).getroot().findall("way")), 2)diff --git a/tests/test_queries.py b/tests/test_queries.pydeleted file mode 100644index 90c52be..0000000--- a/tests/test_queries.py+++ /dev/null@@ -1,271 +0,0 @@-"""Agent workflows tested at the CLI boundary with offline provider responses."""--import json-import tempfile-import unittest-from contextlib import redirect_stderr, redirect_stdout-from io import StringIO-from pathlib import Path-from unittest.mock import Mock, patch-from urllib.parse import parse_qs, urlsplit--import aleph-from src import capture, common, routes-from src.osm import Source-from tests.fixtures import image_bytes, metadata---def encoded(value):- return json.dumps(value).encode()---def place(identity=1, name="Test Street", lat=0, lon=0):- return dict(type="Feature", properties=dict(osm_type="W", osm_id=identity, name=name,- osm_key="highway", osm_value="residential", city="Test City"),- geometry=dict(type="Point", coordinates=[lon, lat]))---def way(identity, nodes, points, name="Test Street"):- return dict(type="way", id=identity, nodes=nodes,- tags=dict(highway="residential", name=name),- points=points)---def coverage(views):- return encoded([None, [None, [- [[[2, identity], None, [[None, None, lat, lon]]]] for identity, lat, lon in views- ]]])---class QueryTests(unittest.TestCase):- def setUp(self):- self.directory = Path(self.enterContext(tempfile.TemporaryDirectory()))- self.get = self.enterContext(patch.object(common.Client, "get"))-- def invoke(self, *args):- with redirect_stdout(StringIO()) as output, redirect_stderr(StringIO()):- status = aleph.main([*args, "--json", "--cache-dir", str(self.directory / "cache")])- return status, json.loads(output.getvalue())-- def test_search_reverse_and_nearby_preserve_location_meaning(self):- self.get.return_value = encoded(dict(features=[place(lat=1, lon=2)]))- status, result = self.invoke("resolve", "Test Street")- self.assertEqual(status, 0)- self.assertEqual(result["results"][0]["id"], "way/1")- self.assertEqual((result["results"][0]["lat"], result["results"][0]["lon"]), (1, 2))- status, result = self.invoke("resolve", "--at", "1", "2")- self.assertEqual(result["mode"], "reverse")- self.assertEqual(result["results"][0]["distance_m"], 0)- address = self.get.call_args.args[0]- self.assertEqual(parse_qs(urlsplit(address).query)["limit"], ["1"])- data = [- dict(type="node", id=2, center=(1, 2.0005), tags=dict(name="Cafe", amenity="cafe")),- dict(type="way", id=3, center=(1, 2.0001), tags=dict(name="Museum", tourism="museum")),- dict(type="node", id=4, center=(1, 2.1), tags=dict(name="Far away", shop="books")),- ]- with patch.object(Source, "data", return_value=(data, dict(osm_data_at="2026-09-20T20:00:00Z"))):- status, result = self.invoke("resolve", "--at", "1", "2", "--nearby", "--radius", "100")- self.assertEqual(status, 0)- self.assertEqual([item["id"] for item in result["results"]], ["way/3", "node/2"])- self.assertEqual(result["results"][0]["location_type"], "bbox_center")-- def test_ambiguous_name_returns_candidates_without_downloading(self):- self.get.return_value = encoded(dict(features=[place(), place(2, "Another Street")]))- status, result = self.invoke("streetview", "--place", "Test", "-o", str(self.directory / "output"))- self.assertEqual(status, 1)- self.assertEqual(result["error"]["code"], "ambiguous_place")- self.assertEqual(len(result["error"]["candidates"]), 2)- self.assertEqual(self.get.call_count, 1)- self.assertFalse((self.directory / "output").exists())-- def test_exact_satellite_tile_is_cached_and_can_be_exported_offline(self):- self.get.return_value = image_bytes((256, 256), "red")- for attempt in range(2):- extension = ("png", "jpg")[attempt]- status, result = self.invoke("satellite", "--tile", "19/280337/194891",- "--satellite-format", extension, "-o", str(self.directory))- self.assertEqual(status, 0)- self.assertEqual((result["width"], result["height"]), (256, 256))- self.assertEqual(result["cache"]["hits"], attempt)- folder = Path(result["folder"])- run = capture.load(folder)- self.assertEqual(run["options"]["satellite_format"], extension)- self.assertTrue(run["stages"][0]["results"][0]["filename"].endswith("." + extension))- capture.export(run, folder, lambda *args: None)- self.assertTrue(Path(result["path"]).is_file())- self.assertEqual(self.get.call_count, 1)-- def test_satellite_exceeds_former_size_tile_and_pixel_caps(self):- self.get.return_value = image_bytes((256, 256), "red")- status, result = self.invoke("satellite", "--at", "0", "0", "--size", "200001",- "--zoom", "12", "-o", str(self.directory))- self.assertEqual(status, 0, result)- self.assertGreater(result["width"] * result["height"], 16_000_000)- self.assertGreater(self.get.call_count, 128)- self.assertEqual(Path(result["path"]).name, "satellite.tif")- self.assertTrue(Path(result["path"]).is_file())- self.assertEqual(Path(result["png_path"]).name, "satellite.png")- self.assertTrue(Path(result["png_path"]).is_file())-- def test_single_streetview_uses_actual_camera_and_look_at_without_osm(self):- def response(address, **kwargs):- if "/ac/v1" in address:- return coverage([("panorama_0001", 0, 0.0001), ("panorama_0002", 0, 0.01)])- if "/photometa/v1" in address:- return metadata(lon=0.0001)- if "/thumbnail" in address:- values = parse_qs(urlsplit(address).query)- self.assertAlmostEqual(float(values["yaw"][0]), 90, places=3)- self.assertEqual(values["pitch"], ["-10.0"])- self.assertEqual(values["thumbfov"], ["175"])- return image_bytes((1024, 576), "blue")- self.fail(f"Unexpected request: {address}")-- self.get.side_effect = response- status, result = self.invoke("streetview", "--at", "0", "0", "--look-at", "0", "1",- "--pitch", "10", "--fov", "175", "-o", str(self.directory))- self.assertEqual(status, 0)- photo = result["photos"][0]- self.assertEqual(photo["pano_id"], "panorama_0001")- self.assertEqual(photo["lon"], 0.0001)- self.assertAlmostEqual(photo["distance_m"], 11.12, places=2)- self.assertEqual(photo["imagery_date"], "2024-06")- self.assertTrue(Path(photo["path"]).is_file())-- def test_street_sequence_orders_split_ways_and_saves_both_sides(self):- ways = [way(1, [2, 1], [(0, 0.001), (0, 0)]),- way(2, [2, 3], [(0, 0.001), (0, 0.002)])]- self.enterContext(patch.object(Source, "street", return_value=("Test Street", ways)))- self.enterContext(patch.object(Source, "data", return_value=(ways, {})))- failure, images = None, 0-- def response(address, **kwargs):- nonlocal images- if "/api/?" in address:- return encoded(dict(features=[place()]))- if "/ac/v1" in address:- return coverage([(f"panorama_{i:04d}", 0, lon) for i, lon in enumerate((0, 0.001, 0.002), 1)])- if "/photometa/v1" in address:- identity = next(f"panorama_{i:04d}" for i in range(1, 4) if f"panorama_{i:04d}" in address)- return metadata(identity, lon=(int(identity[-4:]) - 1) * 0.001)- images += 1- if failure and images == 2:- raise failure- return image_bytes((1024, 576), "green")-- self.get.side_effect = response- status, result = self.invoke("streetview", "--street", "Test Street", "--stops", "3", "--view", "both", "-o", str(self.directory))- self.assertEqual(status, 0, result)- self.assertEqual(result["status"], "complete")- self.assertEqual(result["saved_stops"], 3)- self.assertEqual([p["pano_id"] for p in result["photos"]],- [f"panorama_{i:04d}" for i in (1, 1, 2, 2, 3, 3)])- self.assertEqual([round(p["heading"]) for p in result["photos"]], [0, 180] * 3)- self.assertAlmostEqual(result["route"]["length_m"], 222.39, places=2)- status, result = self.invoke("streetview", "--street", "Test Street", "--stops", "101",- "-o", str(self.directory))- self.assertEqual(status, 0, result)- self.assertEqual(result["requested_stops"], 101)- self.assertEqual(result["saved_stops"], 3)- self.assertEqual(len(result["gaps"]), 98)- for failure, expected_status in ((OSError("connection lost"), 1), (KeyboardInterrupt(), 130)):- with self.subTest(failure=type(failure).__name__):- images = 0- status, result = self.invoke("streetview", "--street", "Test Street", "--stops", "3",- "--view", "both", "--refresh", "-o", str(self.directory))- self.assertEqual(status, expected_status, result)- saved = json.loads((Path(result["error"]["folder"]) / "result.json").read_text())- self.assertEqual(saved["status"], "partial")- self.assertEqual(len(saved["photos"]), 1)- self.assertTrue(Path(saved["photos"][0]["path"]).is_file())-- def test_no_coverage_is_a_structured_error_and_does_not_create_output(self):- self.get.return_value = coverage([])- status, result = self.invoke("streetview", "--at", "0", "0", "--radius", "2000",- "-o", str(self.directory / "output"))- self.assertEqual(status, 1)- self.assertEqual(result["error"]["code"], "no_coverage")- self.assertGreater(self.get.call_count, 128)- self.assertFalse((self.directory / "output").exists())-- def test_invalid_or_conflicting_options_fail_before_requests(self):- cases = [- ["resolve", "Rome", "--at", "1", "2"],- ["resolve", "--at", "nan", "0"],- ["resolve", "Rome", "--nearby"],- ["resolve", "--at", "1", "2", "--radius", "20"],- ["resolve", "--at", "1", "2", "--nearby", "--radius", "5001"],- ["resolve", "Test", "--limit", "51"],- ["resolve", "--at", "1", "2", "--nearby", "--limit", "51"],- ["streetview", "--at", "0", "0", "--place", "Rome"],- ["streetview", "--at", "0", "0", "--stops", "10"],- ["streetview", "--street", "Test", "--heading", "90"],- ["streetview", "--street", "Test", "--stops", "0"],- ["streetview", "--at", "0", "0", "--radius", "0"],- ["streetview", "--at", "0", "0", "--radius", "inf"],- ["streetview", "--at", "0", "0", "--pitch", "nan"],- ["streetview", "--at", "0", "0", "--heading", "inf"],- ["streetview", "--at", "0", "0", "--pitch", "1e39"],- ["satellite", "--at", "0", "0", "--size", "0"],- ["satellite", "--at", "0", "0", "--size", "nan"],- ["satellite", "--tile", "19/1"],- ["satellite", "--tile", "1/2/0"],- ["satellite", "--tile", "19/1/1", "--zoom", "20"],- ["satellite", "--bbox", "0", "0", "1", "1", "--size", "20"],- ]- for args in cases:- with self.subTest(args=args):- status, result = self.invoke(*args)- self.assertEqual(status, 2, result)- self.assertEqual(result["error"]["code"], "invalid_arguments")- self.get.assert_not_called()-- def test_streetview_passes_extended_angles_through(self):- def response(address, **kwargs):- if "/photometa/v1" in address:- return metadata()- values = parse_qs(urlsplit(address).query)- self.assertEqual(values["yaw"], ["-720.5"])- self.assertEqual(values["pitch"], ["-100.25"])- return image_bytes((1024, 576), "blue")-- self.get.side_effect = response- status, result = self.invoke("streetview", "--pano-id", "panorama_0001",- "--heading", "-720.5", "--pitch", "100.25",- "-o", str(self.directory))- self.assertEqual(status, 0, result)- self.assertEqual(result["photos"][0]["heading"], -720.5)- self.assertEqual(result["photos"][0]["pitch"], 100.25)---class RouteTests(unittest.TestCase):- def test_branching_streets_return_choices_and_crossings_do_not_connect(self):- ways = [way(1, [1, 2, 3], [(0, 0), (0, 0.001), (0, 0.002)]),- way(2, [2, 4], [(0, 0.001), (0.001, 0.001)])]- self.assertEqual(len(routes.chains(ways)), 3)- client = Mock()- client.maps.street.return_value = ("Test Street", ways)- with self.assertRaises(common.RequestError) as raised:- routes.resolve(client, dict(id="way/1"))- self.assertEqual(raised.exception.code, "ambiguous_route")- choices = raised.exception.details["candidates"]- selected = routes.resolve(client, dict(id="way/1"), route=2, reverse=True)- self.assertEqual(selected["start"], choices[1]["end"])- self.assertEqual(selected["end"], choices[1]["start"])- ways[1] = way(2, [5, 4], [(0, 0.001), (0.001, 0.001)])- self.assertEqual(len(routes.chains(ways)), 2)-- def test_sampling_is_unique_ordered_and_reports_missing_stops(self):- points = [(0, 0), (0, 0.003)]- route = dict(points=points, way_ids=[1])- context = [dict(points=points, osm_id=1, name="Test", highway="residential", layer="0")]- views = [dict(pano_id="a", lat=0, lon=0.0001), dict(pano_id="b", lat=0, lon=0.0029),- dict(pano_id="same-position", lat=0, lon=0.0001),- dict(pano_id="off-road", lat=0.01, lon=0.001)]- samples, gaps = routes.match_views(views, route, context, 3)- self.assertEqual([item["pano_id"] for item in samples], ["a", "b"])- self.assertEqual([item["stop"] for item in gaps], [2])- self.assertLess(samples[0]["path_meters"], samples[1]["path_meters"])- route["points"] = list(reversed(points))- samples, gaps = routes.match_views(views, route, context, 3)- self.assertEqual([item["pano_id"] for item in samples], ["b", "a"])diff --git a/tests/test_satellite.py b/tests/test_satellite.pydeleted file mode 100644index 2037f83..0000000--- a/tests/test_satellite.py+++ /dev/null@@ -1,108 +0,0 @@-"""Check COG layout and pixels with Pillow's independent TIFF reader."""--import math-import struct-import tempfile-import unittest-from pathlib import Path-from unittest.mock import Mock, patch--from PIL import Image--from src import geo, satellite---class SatelliteTests(unittest.TestCase):- def test_cog_layout_georeferencing_and_overviews_in_classic_and_bigtiff(self):- # Odd dimensions and a crop across source tiles expose overview seams,- # padded-edge darkening, and incorrect georeferencing to whole tile edges.- north, west = geo.coordinate(383, 391, 4)- south, east = geo.coordinate(1408, 1160, 4)- grid = geo.grid((south, west, north, east), 4)- for big in (False, True):- with self.subTest(big=big), tempfile.TemporaryDirectory() as directory:- folder = Path(directory)- stage = dict(grid=grid, results=[])- expected = self.enterContext(Image.new("RGBA", (1025, 769)))- for i, tile in enumerate(geo.tiles(grid)):- name = f"{i}.png"- # Transparent red must not bleed into the blue overview.- color = (255, 0, 0, 0) if i % 3 == 0 else (0, 80 + i * 5, 200, 255)- with Image.new("RGBA", (256, 256), color) as image:- image.save(folder / name)- expected.paste(image, (tile["x"] * 256 - grid["left"],- tile["y"] * 256 - grid["top"]))- stage["results"].append(dict(tile, filename=name))- with patch.object(satellite, "TIFF_LIMIT", 0 if big else 2**32):- satellite.merge(stage, folder, Mock())- path = folder / "satellite.tif"- data = path.read_bytes()- self.assertEqual(struct.unpack_from("<H", data, 2)[0], 43 if big else 42)- ifds, offsets, ends, metadata_ends = [], [], [], []- with Image.open(path) as image:- self.assertEqual(image.n_frames, 4)- for frame, size in enumerate(((1025, 769), (513, 385), (257, 193), (129, 97))):- image.seek(frame)- tags = image.tag_v2- self.assertEqual(image.size, size)- self.assertEqual(image.mode, "RGBA")- self.assertEqual(tags[254], int(frame != 0))- self.assertEqual((tags[322], tags[323]), (256, 256))- self.assertEqual(tags[259], 8) # Deflate, lossless.- self.assertEqual(tags[338], (2,)) # Unassociated alpha.- if frame == 0:- scale = 2 * math.pi * geo.MERCATOR_RADIUS / 4096- self.assertEqual(tags[33550], (scale, scale, 0))- self.assertEqual(tags[33922], (0, 0, 0, 383 * scale - math.pi * geo.MERCATOR_RADIUS,- math.pi * geo.MERCATOR_RADIUS - 391 * scale, 0))- self.assertEqual(tags[34735], (1, 1, 0, 3, 1024, 0, 1, 1,- 1025, 0, 1, 1, 3072, 0, 1, 3857))- else:- self.assertNotIn(33550, tags) # Overviews inherit the full image extent.- smaller = expected.resize(size, Image.Resampling.BOX)- expected.close()- expected = self.enterContext(smaller)- self.assertEqual(image.tobytes(), expected.tobytes())- tile_offsets, tile_sizes = tags[324], tags[325]- self.assertEqual(len(tile_offsets), math.ceil(size[0] / 256) * math.ceil(size[1] / 256))- self.assertTrue(all(b == a + count for a, b, count in- zip(tile_offsets, tile_offsets[1:], tile_sizes)))- offsets.append(tile_offsets[0])- ends.append(tile_offsets[-1] + tile_sizes[-1])- # Inspect byte positions independently of the writer. All IFDs- # and out-of-line tag values must precede the first tile.- position = struct.unpack_from("<Q" if big else "<I", data, 8 if big else 4)[0]- while position:- ifds.append(position)- self.assertEqual(position % (8 if big else 2), 0)- count = struct.unpack_from("<Q" if big else "<H", data, position)[0]- cursor = position + (8 if big else 2)- for _ in range(count):- _, kind, length, value = struct.unpack_from("<HHQQ" if big else "<HHII", data, cursor)- size = {3: 2, 4: 4, 12: 8, 16: 8}[kind] * length- if size > (8 if big else 4):- metadata_ends.append(value + size)- cursor += 20 if big else 12- metadata_ends.append(cursor + (8 if big else 4))- position = struct.unpack_from("<Q" if big else "<I", data, cursor)[0]- self.assertEqual(len(ifds), 4)- self.assertEqual(ifds, sorted(ifds))- self.assertLessEqual(max(metadata_ends), min(offsets))- self.assertEqual(offsets, sorted(offsets, reverse=True))- self.assertEqual(ends[1:], offsets[:-1])- self.assertEqual(ends[0], len(data))-- def test_bigtiff_offsets_cross_four_gib_without_allocating_pixel_data(self):- full, overview = satellite.Level(768, 512), satellite.Level(256, 171)- full.sizes.extend([2**30] * 6)- overview.sizes.append(100)- data = satellite.header([full, overview], dict(left=0, top=0, zoom=1))- self.assertEqual(data[:4], b"II+\0")- # IFD 0: read LONG8 tile offsets directly from its directory.- count = struct.unpack_from("<Q", data, 16)[0]- entries = [struct.unpack_from("<HHQQ", data, 24 + i * 20) for i in range(count)]- _, kind, count, pointer = next(entry for entry in entries if entry[0] == 324)- self.assertEqual((kind, count), (16, 6))- offsets = struct.unpack_from("<6Q", data, pointer)- self.assertEqual(offsets[0], len(data) + 100)- self.assertGreater(offsets[-1], 2**32)diff --git a/tests/test_streetview.py b/tests/test_streetview.pydeleted file mode 100644index 3942699..0000000--- a/tests/test_streetview.py+++ /dev/null@@ -1,86 +0,0 @@-import json-import unittest-from urllib.parse import parse_qs, urlsplit--from src import capture, geo, streetview-from src.common import MissingImagery-from tests.fixtures import metadata---class StreetViewTests(unittest.TestCase):- def test_pitch_converts_positive_up_to_provider_positive_down(self):- for pitch in (-20, 0, 20):- with self.subTest(pitch=pitch):- query = parse_qs(urlsplit(streetview.image_url("panorama_0001", 0, 75, pitch)).query)- self.assertEqual(float(query["pitch"][0]), -pitch)-- def test_fov_bounds_and_integer_serialization(self):- for value in (5, 75.0, 175):- with self.subTest(value=value):- options = capture.settings(dict(fov=value))- self.assertIs(type(options["fov"]), int)- query = parse_qs(urlsplit(streetview.image_url("panorama_0001", 0, value)).query)- self.assertEqual(query["thumbfov"], [str(int(value))])- for value in (4, 176, 82.5, float("nan"), float("inf"), True, "75"):- with self.subTest(value=value):- with self.assertRaisesRegex(ValueError, "fov"):- capture.settings(dict(fov=value))- with self.assertRaisesRegex(ValueError, "fov"):- streetview.image_url("panorama_0001", 0, value)-- def test_coverage_distinguishes_empty_tiles_from_unreadable_responses(self):- row = [[[2, "panorama_0001"], None, [[None, None, 12, 34]]]]- data = b")]}'\n" + json.dumps([None, [None, [row, [[1]], [[[3, "user_photo"]]]]]]).encode()- self.assertEqual(streetview.parse_coverage(data), [dict(pano_id="panorama_0001", lat=12, lon=34)])- for empty in (b"[null,null]", b"[null,[]]", b"[null,[null,[]]]"):- with self.subTest(empty=empty):- self.assertEqual(streetview.parse_coverage(empty), [])- for invalid in (b"<html>unavailable</html>", b"[null,{}]", b"[null,[null,[[[]]]]]"):- with self.subTest(invalid=invalid), self.assertRaisesRegex(ValueError, "coverage"):- streetview.parse_coverage(invalid)-- def test_metadata_distinguishes_removed_panorama_from_protocol_errors(self):- expected = dict(pano_id="panorama_0001", lat=0, lon=0, imagery_date="2024-06")- self.assertEqual(streetview.parse_metadata(metadata()), expected)- message = json.loads(metadata())- message[1][0][0][0] = 3- message[1][0][6] = None # Dates are optional, even for usable imagery.- self.assertEqual(streetview.parse_metadata(json.dumps(message).encode()), dict(expected, imagery_date=None))- with self.assertRaises(MissingImagery):- streetview.parse_metadata(b"[null,[[[2]]]]")- for invalid in (b"[null,[[[99]]]]", b"[null,[]]", metadata(lat=91), metadata(pano_id="../bad")):- with self.subTest(invalid=invalid), self.assertRaisesRegex(ValueError, "metadata"):- streetview.parse_metadata(invalid)-- def test_roads_keep_crossings_but_do_not_bridge_outside_excursions(self):- points = [(0.25, -1), (0.25, 2), (0.75, 2), (0.75, -1)]- way = dict(type="way", id=1, tags=dict(highway="residential"),- nodes=[1, 2, 3, 4], points=points)- roads = streetview.roads([way], (0, 0, 1, 1), "roads")- self.assertEqual([road["points"] for road in roads],- [[(0.25, 0), (0.25, 1)], [(0.75, 1), (0.75, 0)]])-- def test_matching_rejects_ambiguous_crossings_but_keeps_connected_roads(self):- horizontal = [(0, -0.001), (0, 0.001)]- crossing = [(-0.001, 0), (0.001, 0)]- connector = [(0, 0), (0.001, 0)]- cases = (- ("intersection", [horizontal, crossing], ["0", "0"], (0, 0), None),- ("junction", [horizontal, connector], ["0", "0"], (0, 0), "through-road-at-connector"),- ("bridge", [horizontal, connector], ["0", "1"], (0, 0), None),- ("reversed joined sections", [[(0, -0.001), (0, 0)], [(0, 0.001), (0, 0)]],- ["0", "0"], (0, 0), "joined-road-sections"),- ("outside matching radius", [horizontal], ["0"], (0.001, 0), None),- )- for name, points, layers, point, method in cases:- with self.subTest(case=name):- parts = [dict(osm_id=i, name="Main Road", highway="residential", layer=layer)- for i, layer in enumerate(layers)]- lines = [geo.Line(line) for line in points]- result = streetview.match_road(parts, lines, geo.RoadIndex(lines), point, 30)- if method is None:- self.assertIsNone(result)- else:- self.assertEqual(result["match_method"], method)- self.assertEqual(result["path_index"], 0)- self.assertAlmostEqual(result["road_distance"], 0, places=5)diff --git a/tests/test_terrain.py b/tests/test_terrain.pydeleted file mode 100644index a1aeb78..0000000--- a/tests/test_terrain.py+++ /dev/null@@ -1,89 +0,0 @@-import struct-import tempfile-import unittest-import zlib-from pathlib import Path-from unittest.mock import Mock--from PIL import Image--from src import terrain-from tests.fixtures import terrain_bytes---class TerrainTests(unittest.TestCase):- def test_merge_preserves_float_blocks_in_spatial_order_and_georeferencing(self):- for order in ("<", ">"):- for raster_type in (1, 2):- with self.subTest(order=order, raster_type=raster_type), tempfile.TemporaryDirectory() as directory:- folder = Path(directory)- results = []- for i in range(4):- x, y = 1 + i % 2, 1 + i // 2- filename = f"{i}.tif"- heights = [i * 4 + j + 0.25 for j in range(4)]- (folder / filename).write_bytes(terrain_bytes(x, y, 2, heights, order=order, raster_type=raster_type))- results.append(dict(x=x, y=y, zoom=2, filename=filename))- path = folder / "terrain.tif"- terrain.merge(path, folder, results, dict(x0=1, y0=1, zoom=2, columns=2, rows=2), Mock())-- # Pillow reads the output directory independently of our TIFF reader.- with Image.open(path) as mosaic:- self.assertEqual(mosaic.size, (1024, 1024))- tags = mosaic.tag_v2- scale = 40075016.68557849 / 2048- shift = scale / 2 if raster_type == 2 else 0- self.assertEqual(tags[33550], (scale, scale, 0))- self.assertEqual(tags[33922], (0, 0, 0, -10018754.171394622 + shift, 10018754.171394622 - shift, 0))- self.assertEqual(tags[34735][7], raster_type)- offsets, sizes = tags[324], tags[325]- data = path.read_bytes()- self.assertEqual(data[:2], b"II" if order == "<" else b"MM")- self.assertEqual(len(offsets), 16)- self.assertEqual(len(sizes), 16)- # Two block rows per source tile, interleaved across tile columns.- expected = [0, 1, 4, 5, 2, 3, 6, 7, 8, 9, 12, 13, 10, 11, 14, 15]- for offset, size, height in zip(offsets, sizes, expected):- block = zlib.compress(struct.pack(order + "f", height + 0.25) * (256 * 256))- self.assertEqual(data[offset:offset + size], block)-- def test_mixed_block_sizes_preserve_every_float_pixel(self):- for order in ("<", ">"):- for predictor in (1, 3):- with self.subTest(order=order, predictor=predictor), tempfile.TemporaryDirectory() as directory:- folder = Path(directory)- results = []- for i, block_size in enumerate((512, 256, 256, 512)):- tile = dict(x=1 + i % 2, y=1 + i // 2, zoom=2, filename=f"{i}.tif")- (folder / tile["filename"]).write_bytes(terrain_bytes(- tile["x"], tile["y"], 2, order=order, block_size=block_size, predictor=predictor))- results.append(tile)- path = folder / "terrain.tif"- terrain.merge(path, folder, results, dict(x0=1, y0=1, zoom=2, columns=2, rows=2), Mock())- with Image.open(path) as mosaic:- self.assertEqual((mosaic.tag_v2[322], mosaic.tag_v2[323]), (256, 256))- for i, tile in enumerate(results):- x, y = i % 2 * 512, i // 2 * 512- with Image.open(folder / tile["filename"]) as source:- self.assertEqual(mosaic.crop((x, y, x + 512, y + 512)).tobytes(), source.tobytes())-- def test_invalid_later_tile_leaves_previous_mosaic_intact(self):- corruptions = {- "wrong georeferencing": terrain_bytes(3, 1, 2),- "truncated block": terrain_bytes(2, 1, 2)[:-1],- "incompatible byte order": terrain_bytes(2, 1, 2, order=">"),- }- for name, data in corruptions.items():- with self.subTest(case=name), tempfile.TemporaryDirectory() as directory:- folder = Path(directory)- (folder / "first.tif").write_bytes(terrain_bytes(1, 1, 2))- (folder / "second.tif").write_bytes(data)- path = folder / "terrain.tif"- original = terrain_bytes(1, 1, 2)- path.write_bytes(original)- results = [dict(x=1, y=1, zoom=2, filename="first.tif"),- dict(x=2, y=1, zoom=2, filename="second.tif")]- with self.assertRaises(ValueError):- terrain.merge(path, folder, results, dict(x0=1, y0=1, zoom=2, columns=2, rows=1), Mock())- self.assertEqual(path.read_bytes(), original)- self.assertEqual({p.name for p in folder.iterdir()}, {"first.tif", "second.tif", "terrain.tif"})