Cache validation failed: {e}. Try again
"` - [ ] 5.9 Call `config.write({"lat": confirmed_lat, "lon": confirmed_lon, "radius_nm": radius, "wifi_ssid": wifi_ssid, "wifi_password": wifi_password, "provisioned": True})` - [ ] 5.10 Call `wifi.kill_wifi()`; on `ProvisioningError`, re-raise so the provisioning loop resets - [ ] 5.11 On full success, return: `"Setup complete. The device will now start displaying radar.
"` - [ ] 5.12 Wrap steps 5.5–5.11 in `try/except ProvisioningError` where appropriate (validation fails → retry HTML; rfkill failure → re-raise) - [ ] Task 6: Wire `provision.py` `main()` to run the full provisioning sequence (AC: #1, #2, #3, #4) - [ ] 6.1 Remove the placeholder `provisioned = True` line from `provision.py` - [ ] 6.2 Ensure the provisioning loop calls `portal.run()` (the Flask blocking call) which now includes the `POST /submit` route - [ ] 6.3 Confirm the `ProvisioningError` from `wifi.kill_wifi()` propagates up to the `except ProvisioningError` in the main loop, which calls `reset_to_portal_state()` - [ ] 6.4 Confirm the loop sets `provisioned = True` only after `portal.run()` returns without raising - [ ] Task 7: Write tests (AC: #1, #2, #3, #4) - [ ] 7.1 `tests/provisioning/test_wifi.py` — `test_join_home_wifi_success`: mock `subprocess.run` to return `CompletedProcess(returncode=0)`; assert no exception raised - [ ] 7.2 `tests/provisioning/test_wifi.py` — `test_join_home_wifi_failure`: mock `subprocess.run` to return `CompletedProcess(returncode=1, stderr=b"error")`; assert `ProvisioningError` raised - [ ] 7.3 `tests/provisioning/test_tiles.py` — `test_download_and_composite`: mock `requests.get` to return a fake 256×256 PNG bytes response; use `tmp_path` to patch `BACKGROUND_PATH`; assert `background.png` is created and is a valid PNG - [ ] 7.4 `tests/provisioning/test_tiles.py` — `test_lat_lon_to_tile_known_values`: assert known tile coordinates for a documented lat/lon/zoom triple (e.g. lat=51.5, lon=-0.1, zoom=10 → well-known London tile) - [ ] 7.5 `tests/provisioning/test_tiles.py` — `test_validate_cache_passes`: write a real 1×1 PNG to `tmp_path/background.png`; patch `BACKGROUND_PATH`; assert no exception - [ ] 7.6 `tests/provisioning/test_tiles.py` — `test_validate_cache_missing`: patch `BACKGROUND_PATH` to a non-existent path; assert `ProvisioningError` - [ ] 7.7 `tests/provisioning/test_tiles.py` — `test_validate_cache_empty`: write a zero-byte file; assert `ProvisioningError` - [ ] 7.8 `tests/provisioning/test_tiles.py` — `test_validate_cache_corrupt`: write non-PNG bytes; assert `ProvisioningError` - [ ] 7.9 `tests/provisioning/test_airspace.py` — `test_download_no_api_key`: unset `OPENAIP_API_KEY`; patch `AIRSPACE_PATH` to `tmp_path`; call `download(51.5, -0.1, 100)`; assert empty GeoJSON written - [ ] 7.10 `tests/provisioning/test_airspace.py` — `test_download_with_api_key`: set `OPENAIP_API_KEY="test"`; mock `requests.get` to return a minimal GeoJSON response; patch `AIRSPACE_PATH` to `tmp_path`; assert file written with response content - [ ] 7.11 `tests/provisioning/test_portal.py` — `test_submit_success`: mock `wifi.join_home_wifi`, `tiles.download_and_composite`, `airspace.download`, `tiles.validate_cache`, `config.write`, `wifi.kill_wifi`; POST to `/submit` with valid form data; assert 200 and response contains "Setup complete" - [ ] 7.12 `tests/provisioning/test_portal.py` — `test_submit_validation_failure`: mock `tiles.validate_cache` to raise `ProvisioningError("bad png")`; POST to `/submit`; assert 200 and response contains "Try again" - [ ] 7.13 All mocks use `unittest.mock.patch`; no real network or filesystem access beyond `tmp_path` - [ ] Task 8: Run quality gates - [ ] 8.1 `pytest tests/` — all tests pass, 0 failures - [ ] 8.2 `ruff check .` — zero violations - [ ] 8.3 `ruff format --check .` — no formatting issues ## Dev Notes ### OSM tile URL pattern and User-Agent Tile URL: `https://tile.openstreetmap.org/{z}/{x}/{y}.png` OSM requires a `User-Agent` header (same policy as Nominatim). Use the same agent string established in Story 1.4: ```python TILE_USER_AGENT = "planemapper/0.1 (https://github.com/football2801/planeMapper)" ``` ### Tile coordinate math (Web Mercator) Standard OSM formula for converting lat/lon to tile (x, y) at a given zoom level: ```python import math def lat_lon_to_tile(lat: float, lon: float, zoom: int) -> tuple[int, int]: x = int((lon + 180.0) / 360.0 * (1 << zoom)) lat_r = math.radians(lat) y = int((1.0 - math.log(math.tan(lat_r) + 1.0 / math.cos(lat_r)) / math.pi) / 2.0 * (1 << zoom)) return x, y ``` Reference: https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames ### Zoom level selection ```python def _zoom_for_radius(radius_nm: float) -> int: if radius_nm > 200: return 8 if radius_nm > 100: return 9 if radius_nm > 50: return 10 return 11 ``` Zoom 10 ≈ 100nm coverage; zoom 8 gives wider coverage for large radii. ### background.png compositing The compositing logic must: 1. Determine the tile bounding box: convert the four corners of the geographic bounding box to tile coordinates, then derive `x_min, x_max, y_min, y_max` 2. Calculate a pixel offset for each tile: `pixel_x = (tx - x_min) * 256`, `pixel_y = (ty - y_min) * 256` 3. Create a canvas sized to fit all tiles: `canvas_w = (x_max - x_min + 1) * 256`, `canvas_h = (y_max - y_min + 1) * 256` 4. Paste each 256×256 tile at its pixel offset 5. Crop or resize the result to `(DISPLAY_WIDTH, DISPLAY_HEIGHT)` = `(800, 480)` — centre the crop on the home location pixel The home location pixel is: `home_x = (home_tile_x - x_min) * 256 + home_pixel_offset_x` (and similarly for y), where `home_pixel_offset_x` is the sub-tile offset computed from the fractional tile coordinate. Crop symmetrically around this point; clamp to canvas bounds. ### `BACKGROUND_PATH` and `AIRSPACE_PATH` from constants Both paths must be imported from `planemapper.constants`, never hardcoded: ```python from planemapper.constants import BACKGROUND_PATH, AIRSPACE_PATH ``` ### `POST /submit` synchronous approach For MVP, the browser connection stays open while provisioning runs (no background thread). The handler executes: join WiFi → download tiles → download airspace → validate → write config → kill WiFi. This means the browser may wait 2–5 minutes. The "Downloading…" page is returned as the HTTP response body in a single blocking `return` — but given Flask's synchronous mode, this means we must render the "Downloading…" response first and then run provisioning. The simplest approach is to use Flask's `Response` with a generator or to use `after_this_request`. A pragmatic MVP alternative: return the status page as a streamed response (use `flask.stream_with_context` or a plain generator response) so the browser renders "Downloading…" immediately, then provisioning runs synchronously before the stream closes. If streaming is overly complex, an acceptable fallback is to use `threading.Thread` to run provisioning in the background and return the status page immediately. The test should mock all provisioning calls regardless. ### OpenAIP API key fallback If `OPENAIP_API_KEY` is not set in the environment, write an empty GeoJSON and degrade gracefully — airspace outlines are a cosmetic overlay and the device is fully functional without them. This avoids a hard dependency on a third-party API key for provisioning to succeed. ```python EMPTY_GEOJSON = '{"type": "FeatureCollection", "features": []}' ``` ### Patching paths in tests Tests must patch `BACKGROUND_PATH` and `AIRSPACE_PATH` to `tmp_path` entries to avoid any writes to `/etc/planemapper/`. Use `unittest.mock.patch` targeting the module-level name: ```python from unittest.mock import patch from pathlib import Path def test_download_and_composite(tmp_path, mock_tile_response): bg_path = tmp_path / "background.png" with patch("planemapper.provisioning.tiles.BACKGROUND_PATH", bg_path): download_and_composite(51.5, -0.1, 100) assert bg_path.exists() ``` Similarly for `AIRSPACE_PATH` in airspace tests. ### subprocess mock for `nmcli` and `rfkill` ```python from unittest.mock import patch, MagicMock import subprocess @patch("planemapper.provisioning.wifi.subprocess.run") def test_join_home_wifi_success(mock_run): mock_run.return_value = subprocess.CompletedProcess(args=[], returncode=0) join_home_wifi("MySSID", "MyPass") # should not raise mock_run.assert_called_once() ``` Mock `subprocess.run` at the module where it is used (`planemapper.provisioning.wifi.subprocess.run`), not at the `subprocess` package level. ### Coordinate convention All internal functions use `(lat, lon)` order — never `(lon, lat)`. The bounding box computation (`lat ± radius_deg`, `lon ± radius_deg`) follows this convention. The radius in degrees is approximated as `radius_nm / 60.0` (1 arcminute ≈ 1 nautical mile).