Skip to content

armgit / Aleph

Public Imported from GitHub
0

Give satellite imagery, terrain data, buildings, streetview photos to your LLM

Remove tests

Belluxx58b6c2917b5d
diff --git a/tests/__init__.py b/tests/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/data/dense.osm.pbf b/tests/data/dense.osm.pbf
deleted file mode 100644
index 3a8ac2e..0000000
Binary files a/tests/data/dense.osm.pbf and /dev/null differ
diff --git a/tests/data/nodes.osm.pbf b/tests/data/nodes.osm.pbf
deleted file mode 100644
index 36dbc25..0000000
Binary files a/tests/data/nodes.osm.pbf and /dev/null differ
diff --git a/tests/fixtures.py b/tests/fixtures.py
deleted file mode 100644
index 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.py
deleted file mode 100644
index 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.py
deleted file mode 100644
index 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.py
deleted file mode 100644
index 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.py
deleted file mode 100644
index 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.py
deleted file mode 100644
index 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.py
deleted file mode 100644
index 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.py
deleted file mode 100644
index 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.py
deleted file mode 100644
index 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.py
deleted file mode 100644
index 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.py
deleted file mode 100644
index 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.py
deleted file mode 100644
index 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"})