Expand test coverage: WindowFovCone, WorstCaseProvider, matrix config

Frontend (249 tests, +17):
- Add WindowFovCone.test.ts: 14 tests for destinationPoint geometry,
  sectorPoints array structure, createFovCone interface and cleanup
- Export sectorPoints/destinationPoint as testable pure functions
- Add MatrixConfig test for derived terrain model exclusion
- Extend Leaflet mock with polygon, circleMarker, off, dragging

Backend (391 tests, +8):
- Add WorstCaseProvider.get_tile tests: uniform max, per-pixel max,
  caching behavior with mock sub-providers
- Add _tile_name_for_point tests: positive/negative lat/lon, edge cases
- Add KNOWN_TERRAIN includes worst_case assertion
- Fix Black formatting in test_window_mode.py

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: JamesonRGrieve

src/__tests__/components/MatrixConfig.test.ts

@@ -122,6 +122,14 @@ describe("MatrixConfig.vue", () => {
     expect(wrapper.find(".badge.bg-success").text()).toBe("Saved");
   });
 
+  it("excludes derived terrain models (weighted_aggregate, worst_case)", async () => {
+    const wrapper = await mountMatrixConfig();
+    expect(wrapper.find("#ter-weighted_aggregate").exists()).toBe(false);
+    expect(wrapper.find("#ter-worst_case").exists()).toBe(false);
+    expect(wrapper.text()).not.toContain("Weighted Aggregate");
+    expect(wrapper.text()).not.toContain("Worst Case");
+  });
+
   it("renders correct labels from shared label maps", async () => {
     const wrapper = await mountMatrixConfig();
     expect(wrapper.text()).toContain("Heltec V3");

src/__tests__/setup.ts

@@ -16,6 +16,8 @@ const mockMap = {
   addTo: vi.fn().mockReturnThis(),
   once: vi.fn(),
   on: vi.fn(),
+  off: vi.fn(),
+  dragging: { enable: vi.fn(), disable: vi.fn() },
   eachLayer: vi.fn(),
   getSize: vi.fn(() => ({ x: 800, y: 600 })),
   getPane: vi.fn(() => document.createElement("div")),
@@ -51,6 +53,15 @@ vi.mock("leaflet", () => ({
       extend: vi.fn(() => class {}),
     },
     Util: { setOptions: vi.fn() },
+    polygon: vi.fn(() => ({
+      addTo: vi.fn().mockReturnThis(),
+      setLatLngs: vi.fn(),
+    })),
+    circleMarker: vi.fn(() => ({
+      addTo: vi.fn().mockReturnThis(),
+      setLatLng: vi.fn(),
+      on: vi.fn(),
+    })),
     polyline: vi.fn(() => ({ addTo: vi.fn(), bindPopup: vi.fn() })),
     easyPrint: vi.fn(() => ({ addTo: vi.fn() })),
   },

src/layers/WindowFovCone.ts

@@ -11,7 +11,7 @@ const CONE_COLOR = "#3388ff";
  * Build a lat/lon polygon representing a sector (pie wedge) centered
  * on `center`, spanning `fovDeg` degrees around `azimuthDeg` (CW from north).
  */
-function sectorPoints(
+export function sectorPoints(
   center: L.LatLng,
   radiusM: number,
   azimuthDeg: number,
@@ -34,7 +34,7 @@ function sectorPoints(
  * Calculate a destination point given a start, distance (m), and bearing (degrees CW from north).
  * Uses spherical earth approximation.
  */
-function destinationPoint(start: L.LatLng, distanceM: number, bearingDeg: number): L.LatLng {
+export function destinationPoint(start: L.LatLng, distanceM: number, bearingDeg: number): L.LatLng {
   const R = 6371000; // Earth radius in meters
   const d = distanceM / R;
   const brng = (bearingDeg * Math.PI) / 180;

src/layers/__tests__/WindowFovCone.test.ts

@@ -0,0 +1,114 @@
+// @vitest-environment jsdom
+import "../../__tests__/setup";
+import { describe, it, expect, vi } from "vitest";
+import { destinationPoint, sectorPoints, createFovCone } from "../WindowFovCone";
+import L from "leaflet";
+
+describe("destinationPoint", () => {
+  it("bearing 0 (north) increases latitude", () => {
+    const start = L.latLng(45, -75);
+    const result = destinationPoint(start, 1000, 0);
+    expect(result.lat).toBeGreaterThan(45);
+    expect(result.lng).toBeCloseTo(-75, 4);
+  });
+
+  it("bearing 180 (south) decreases latitude", () => {
+    const start = L.latLng(45, -75);
+    const result = destinationPoint(start, 1000, 180);
+    expect(result.lat).toBeLessThan(45);
+    expect(result.lng).toBeCloseTo(-75, 4);
+  });
+
+  it("bearing 90 (east) increases longitude", () => {
+    const start = L.latLng(45, -75);
+    const result = destinationPoint(start, 1000, 90);
+    expect(result.lat).toBeCloseTo(45, 4);
+    expect(result.lng).toBeGreaterThan(-75);
+  });
+
+  it("bearing 270 (west) decreases longitude", () => {
+    const start = L.latLng(45, -75);
+    const result = destinationPoint(start, 1000, 270);
+    expect(result.lat).toBeCloseTo(45, 4);
+    expect(result.lng).toBeLessThan(-75);
+  });
+
+  it("distance 0 returns the same point", () => {
+    const start = L.latLng(45, -75);
+    const result = destinationPoint(start, 0, 42);
+    expect(result.lat).toBeCloseTo(45, 10);
+    expect(result.lng).toBeCloseTo(-75, 10);
+  });
+
+  it("1000m displacement is approximately correct", () => {
+    const start = L.latLng(0, 0);
+    const result = destinationPoint(start, 1000, 0);
+    // 1000m north at the equator is ~0.009 degrees latitude
+    const expectedDeg = (1000 / 6371000) * (180 / Math.PI);
+    expect(result.lat).toBeCloseTo(expectedDeg, 4);
+  });
+});
+
+describe("sectorPoints", () => {
+  it("returns array starting and ending with center", () => {
+    const center = L.latLng(45, -75);
+    const points = sectorPoints(center, 500, 0, 90, 10);
+    expect(points[0]).toBe(center);
+    expect(points[points.length - 1]).toBe(center);
+  });
+
+  it("returns segments + 3 points (center + segments+1 arc + center)", () => {
+    const center = L.latLng(45, -75);
+    const segments = 10;
+    const points = sectorPoints(center, 500, 0, 90, segments);
+    // center + (segments + 1) arc points + center = segments + 3
+    expect(points).toHaveLength(segments + 3);
+  });
+
+  it("arc points are all different from center", () => {
+    const center = L.latLng(45, -75);
+    const points = sectorPoints(center, 500, 0, 90, 4);
+    // Points 1 through length-2 are arc points (not center)
+    for (let i = 1; i < points.length - 1; i++) {
+      expect(points[i]).not.toBe(center);
+    }
+  });
+
+  it("single segment produces 4 points", () => {
+    const center = L.latLng(45, -75);
+    const points = sectorPoints(center, 500, 0, 90, 1);
+    // center + 2 arc endpoints + center
+    expect(points).toHaveLength(4);
+  });
+});
+
+describe("createFovCone", () => {
+  it("returns an object with update and remove methods", () => {
+    const map = L.map(document.createElement("div"));
+    const handle = createFovCone(map, [45, -75], 0, 90, vi.fn());
+    expect(typeof handle.update).toBe("function");
+    expect(typeof handle.remove).toBe("function");
+  });
+
+  it("remove() calls map.removeLayer twice (polygon + handle)", () => {
+    const map = L.map(document.createElement("div"));
+    const handle = createFovCone(map, [45, -75], 0, 90, vi.fn());
+    handle.remove();
+    expect(map.removeLayer).toHaveBeenCalledTimes(2);
+  });
+
+  it("remove() calls map.off to clean up event listeners", () => {
+    const map = L.map(document.createElement("div"));
+    const handle = createFovCone(map, [45, -75], 0, 90, vi.fn());
+    handle.remove();
+    expect(map.off).toHaveBeenCalledWith("mousemove", expect.any(Function));
+    expect(map.off).toHaveBeenCalledWith("mouseup", expect.any(Function));
+  });
+
+  it("creates polygon and circleMarker via Leaflet", () => {
+    const map = L.map(document.createElement("div"));
+    createFovCone(map, [45, -75], 0, 90, vi.fn());
+    expect(L.polygon).toHaveBeenCalled();
+    expect(L.circleMarker).toHaveBeenCalled();
+  });
+});

tests/test_matrix.py

@@ -3,13 +3,19 @@
 from app.db import db_session
 from app.matrix import (
     DEFAULT_MATRIX_CONFIG,
+    KNOWN_TERRAIN,
     get_matrix_combinations,
     get_matrix_config,
     set_matrix_config,
 )
 from app.models.MatrixConfigRequest import MatrixConfigRequest
 
 
+class TestKnownTerrain:
+    def test_known_terrain_includes_worst_case(self):
+        assert "worst_case" in KNOWN_TERRAIN
+
+
 class TestDefaultMatrixConfig:
     def test_has_expected_fields(self):
         assert DEFAULT_MATRIX_CONFIG.hardware == ["v3", "v4"]

tests/test_window_mode.py

@@ -1,6 +1,5 @@
 """Tests for window mode — directional attenuation through glass/structure."""
 
-
 import numpy as np
 import pytest
 from pydantic import ValidationError

tests/test_worst_case.py

@@ -2,12 +2,14 @@
 
 import gzip
 import io
+from unittest.mock import MagicMock
 
 import numpy as np
 import pytest
 
 from app.models.CoveragePredictionRequest import CoveragePredictionRequest
-from app.services.terrain import _HGT_SIZE, TerrainProvider
+from app.services.splat import Splat
+from app.services.terrain import _HGT_SIZE, TerrainProvider, WorstCaseProvider
 
 
 def _make_hgt_gz(value: int, side: int = _HGT_SIZE) -> bytes:
@@ -130,3 +132,91 @@ def test_floor_at_one_meter(self):
         adjusted = max(1.0, 5.0 - delta)
         assert delta == 100.0
         assert adjusted == 1.0
+
+
+SMALL_SIDE = 5
+
+
+class TestWorstCaseProviderGetTile:
+    """Test WorstCaseProvider.get_tile() returns per-pixel max of three sub-providers."""
+
+    def _build_provider(self, srtm_data: bytes, dsm_data: bytes, lulc_data: bytes) -> WorstCaseProvider:
+        srtm_mock = MagicMock()
+        srtm_mock.get_tile.return_value = srtm_data
+        dsm_mock = MagicMock()
+        dsm_mock.get_tile.return_value = dsm_data
+        lulc_mock = MagicMock()
+        lulc_mock.get_tile.return_value = lulc_data
+        cache: dict = {}
+        s3_mock = MagicMock()
+        provider = WorstCaseProvider.__new__(WorstCaseProvider)
+        provider.s3 = s3_mock
+        provider.tile_cache = cache
+        provider._srtm = srtm_mock
+        provider._dsm = dsm_mock
+        provider._lulc = lulc_mock
+        return provider
+
+    def test_uniform_tiles_returns_max(self):
+        """When all tiles are uniform, result equals the highest value."""
+        srtm = _make_hgt_gz(100, side=SMALL_SIDE)
+        dsm = _make_hgt_gz(150, side=SMALL_SIDE)
+        lulc = _make_hgt_gz(120, side=SMALL_SIDE)
+        provider = self._build_provider(srtm, dsm, lulc)
+
+        result_gz = provider.get_tile("N45W075.hgt.gz")
+        result_arr = TerrainProvider._decompress_hgt(result_gz)
+
+        np.testing.assert_array_equal(result_arr, 150)
+
+    def test_varying_sources_per_pixel_max(self):
+        """When different sources dominate at different pixels, result is per-pixel max."""
+        srtm_arr = np.array([[200, 50, 10], [10, 10, 10], [10, 10, 10]], dtype=np.int16)
+        dsm_arr = np.array([[10, 300, 10], [10, 10, 10], [10, 10, 10]], dtype=np.int16)
+        lulc_arr = np.array([[10, 10, 400], [10, 10, 10], [10, 10, 10]], dtype=np.int16)
+        provider = self._build_provider(
+            _make_hgt_gz_from_array(srtm_arr),
+            _make_hgt_gz_from_array(dsm_arr),
+            _make_hgt_gz_from_array(lulc_arr),
+        )
+
+        result_gz = provider.get_tile("N45W075.hgt.gz")
+        result_arr = TerrainProvider._decompress_hgt(result_gz)
+
+        assert result_arr[0, 0] == 200
+        assert result_arr[0, 1] == 300
+        assert result_arr[0, 2] == 400
+        # All remaining pixels should be 10 (all sources equal)
+        np.testing.assert_array_equal(result_arr[1:, :], 10)
+
+    def test_result_is_cached(self):
+        """After the first call, subsequent calls return from cache without re-fetching."""
+        srtm = _make_hgt_gz(100, side=SMALL_SIDE)
+        dsm = _make_hgt_gz(200, side=SMALL_SIDE)
+        lulc = _make_hgt_gz(150, side=SMALL_SIDE)
+        provider = self._build_provider(srtm, dsm, lulc)
+
+        first = provider.get_tile("test_tile.hgt.gz")
+        second = provider.get_tile("test_tile.hgt.gz")
+
+        assert first == second
+        # Sub-providers should only have been called once each
+        provider._srtm.get_tile.assert_called_once()
+        provider._dsm.get_tile.assert_called_once()
+        provider._lulc.get_tile.assert_called_once()
+
+
+class TestTileNameForPoint:
+    """Test Splat._tile_name_for_point() static method."""
+
+    def test_positive_lat_negative_lon(self):
+        assert Splat._tile_name_for_point(45.5, -74.3) == "N45W075.hgt.gz"
+
+    def test_negative_lat_positive_lon(self):
+        assert Splat._tile_name_for_point(-12.3, 34.7) == "S13E034.hgt.gz"
+
+    def test_near_zero_positive(self):
+        assert Splat._tile_name_for_point(0.5, 0.5) == "N00E000.hgt.gz"
+
+    def test_exact_negative_lon(self):
+        assert Splat._tile_name_for_point(40.0, -105.0) == "N40W106.hgt.gz"