No surface observations found nearby.
+| # | +Lat | +Lon | +Dist (km) | +Elev (m) | +
|---|---|---|---|---|
| {idx} | +{format_number(pt["lat"])} | +{format_number(pt["lon"])} | +{format_number(pt["dist_km"])} | +{format_number(pt["elev"])} | +
No terrain profile available.
<% end %> @@ -262,6 +303,20 @@ defmodule MicrowavepropWeb.QsoLive.Show do +No solar data available for this date.
+ <% end %> + + +No surface observations found nearby.
<% else %> -No solar data available for this date.
+ <.table + id="surface-obs" + rows={@surface_observations} + row_id={fn obs -> "obs-#{obs.id}" end} + sort_by={@obs_sort_by} + sort_order={@obs_sort_order} + sort_target="obs" + > + <:col :let={obs} label="Station" sort_field="station_name"> + {obs.station.name || obs.station.station_code} + + <:col :let={obs} label="Time" sort_field="observed_at"> + {Calendar.strftime(obs.observed_at, "%H:%M")} + + <:col :let={obs} label="Temp (F)" sort_field="temp_f">{obs.temp_f || "—"} + <:col :let={obs} label="Dewpoint (F)" sort_field="dewpoint_f"> + {obs.dewpoint_f || "—"} + + <:col :let={obs} label="RH%" sort_field="relative_humidity"> + {format_number(obs.relative_humidity)} + + <:col :let={obs} label="Wind">{format_wind(obs)} + <:col :let={obs} label="Pressure (mb)" sort_field="sea_level_pressure_mb"> + {obs.sea_level_pressure_mb || "—"} + + <:col :let={obs} label="Sky">{obs.sky_condition || "—"} + <% end %> """ @@ -367,4 +443,10 @@ defmodule MicrowavepropWeb.QsoLive.Show do defp format_kp(nil), do: "—" defp format_kp(values) when is_list(values), do: Enum.map_join(values, ", ", &format_number/1) + + defp terrain_verdict_class("CLEAR"), do: "badge-success" + defp terrain_verdict_class("FRESNEL_MINOR"), do: "badge-warning" + defp terrain_verdict_class("FRESNEL_PARTIAL"), do: "badge-warning" + defp terrain_verdict_class("BLOCKED"), do: "badge-error" + defp terrain_verdict_class(_), do: "badge-ghost" end diff --git a/priv/repo/migrations/20260329210536_create_terrain_profiles_and_add_terrain_queued.exs b/priv/repo/migrations/20260329210536_create_terrain_profiles_and_add_terrain_queued.exs new file mode 100644 index 00000000..185bdedb --- /dev/null +++ b/priv/repo/migrations/20260329210536_create_terrain_profiles_and_add_terrain_queued.exs @@ -0,0 +1,30 @@ +defmodule Microwaveprop.Repo.Migrations.CreateTerrainProfilesAndAddTerrainQueued do + use Ecto.Migration + + def change do + create table(:terrain_profiles, primary_key: false) do + add :id, :binary_id, primary_key: true + add :qso_id, references(:qsos, type: :binary_id, on_delete: :delete_all), null: false + add :sample_count, :integer, null: false + add :path_points, {:array, :map}, default: [], null: false + add :max_elevation_m, :float + add :min_clearance_m, :float + add :diffraction_db, :float + add :fresnel_hit_count, :integer + add :obstructed_count, :integer + add :verdict, :string, null: false + + timestamps(type: :utc_datetime) + end + + create unique_index(:terrain_profiles, [:qso_id]) + + alter table(:qsos) do + add :terrain_queued, :boolean, default: false, null: false + end + + execute "UPDATE qsos SET terrain_queued = false", "SELECT 1" + + create index(:qsos, [:terrain_queued], where: "terrain_queued = false") + end +end diff --git a/test/microwaveprop/radio_test.exs b/test/microwaveprop/radio_test.exs index 99128661..bbfb41d4 100644 --- a/test/microwaveprop/radio_test.exs +++ b/test/microwaveprop/radio_test.exs @@ -281,4 +281,68 @@ defmodule Microwaveprop.RadioTest do assert Radio.mark_hrrr_queued!([]) == {0, nil} end end + + describe "unprocessed_terrain_qsos/1" do + test "returns QSOs where terrain_queued is false and both pos1 and pos2 are not nil" do + q1 = create_qso(%{station1: "W5XD", qso_timestamp: ~U[2026-03-28 12:00:00Z]}) + _q2 = create_qso(%{station1: "NOPOS1", pos1: nil, qso_timestamp: ~U[2026-03-28 13:00:00Z]}) + _q3 = create_qso(%{station1: "NOPOS2", pos2: nil, qso_timestamp: ~U[2026-03-28 14:00:00Z]}) + + results = Radio.unprocessed_terrain_qsos() + ids = Enum.map(results, & &1.id) + assert q1.id in ids + assert length(ids) == 1 + end + + test "excludes QSOs already marked as terrain_queued" do + q = create_qso() + Radio.mark_terrain_queued!([q.id]) + + assert Radio.unprocessed_terrain_qsos() == [] + end + + test "orders by qso_timestamp ascending" do + q_late = create_qso(%{station1: "LATE", qso_timestamp: ~U[2026-03-28 20:00:00Z]}) + q_early = create_qso(%{station1: "EARLY", qso_timestamp: ~U[2026-03-28 10:00:00Z]}) + + results = Radio.unprocessed_terrain_qsos() + ids = Enum.map(results, & &1.id) + assert ids == [q_early.id, q_late.id] + end + + test "respects limit parameter" do + for i <- 1..5 do + ts = DateTime.add(~U[2026-01-01 00:00:00Z], i * 3600, :second) + create_qso(%{qso_timestamp: ts}) + end + + assert length(Radio.unprocessed_terrain_qsos(3)) == 3 + end + end + + describe "mark_terrain_queued!/1" do + test "sets terrain_queued to true for given IDs" do + q1 = create_qso(%{station1: "A1A"}) + q2 = create_qso(%{station1: "B2B"}) + + Radio.mark_terrain_queued!([q1.id, q2.id]) + + assert Repo.get!(Qso, q1.id).terrain_queued == true + assert Repo.get!(Qso, q2.id).terrain_queued == true + end + + test "does not affect other QSOs" do + q1 = create_qso(%{station1: "A1A"}) + q2 = create_qso(%{station1: "B2B"}) + + Radio.mark_terrain_queued!([q1.id]) + + assert Repo.get!(Qso, q1.id).terrain_queued == true + assert Repo.get!(Qso, q2.id).terrain_queued == false + end + + test "handles empty list" do + assert Radio.mark_terrain_queued!([]) == {0, nil} + end + end end diff --git a/test/microwaveprop/terrain/elevation_client_test.exs b/test/microwaveprop/terrain/elevation_client_test.exs new file mode 100644 index 00000000..37f56918 --- /dev/null +++ b/test/microwaveprop/terrain/elevation_client_test.exs @@ -0,0 +1,113 @@ +defmodule Microwaveprop.Terrain.ElevationClientTest do + use ExUnit.Case, async: true + + alias Microwaveprop.Terrain.ElevationClient + + describe "sample_path/5" do + test "generates N+1 evenly spaced points" do + points = ElevationClient.sample_path(32.9, -97.0, 30.3, -97.7, 4) + + assert length(points) == 5 + + first = hd(points) + last = List.last(points) + + assert_in_delta first.lat, 32.9, 0.001 + assert_in_delta first.lon, -97.0, 0.001 + assert_in_delta first.d, 0.0, 0.001 + + assert_in_delta last.lat, 30.3, 0.001 + assert_in_delta last.lon, -97.7, 0.001 + assert_in_delta last.d, 1.0, 0.001 + end + + test "midpoint is correct" do + points = ElevationClient.sample_path(0.0, 0.0, 10.0, 10.0, 2) + + mid = Enum.at(points, 1) + assert_in_delta mid.lat, 5.0, 0.001 + assert_in_delta mid.lon, 5.0, 0.001 + assert_in_delta mid.d, 0.5, 0.001 + end + end + + describe "fetch_elevation_profile/5" do + test "returns profile with elevations from Open-Meteo" do + Req.Test.stub(ElevationClient, fn conn -> + Req.Test.json(conn, %{"elevation" => [200.0, 250.0, 180.0]}) + end) + + assert {:ok, profile} = + ElevationClient.fetch_elevation_profile(32.9, -97.0, 30.3, -97.7, 2) + + assert length(profile) == 3 + + first = hd(profile) + assert Map.has_key?(first, :lat) + assert Map.has_key?(first, :lon) + assert Map.has_key?(first, :elev) + assert Map.has_key?(first, :dist_km) + assert first.elev == 200.0 + assert_in_delta first.dist_km, 0.0, 0.001 + end + + test "batches requests when more than 100 points" do + call_count = :counters.new(1, [:atomics]) + + Req.Test.stub(ElevationClient, fn conn -> + :counters.add(call_count, 1, 1) + # Return 101 elevations for first batch, or however many requested + params = Plug.Conn.fetch_query_params(conn).query_params + lat_count = params["latitude"] |> String.split(",") |> length() + elevations = List.duplicate(100.0, lat_count) + Req.Test.json(conn, %{"elevation" => elevations}) + end) + + assert {:ok, profile} = + ElevationClient.fetch_elevation_profile(32.9, -97.0, 30.3, -97.7, 150) + + # 151 points → 2 batches (100 + 51) + assert length(profile) == 151 + assert :counters.get(call_count, 1) == 2 + end + + test "falls back to Open-Topo-Data on Open-Meteo failure" do + call_count = :counters.new(1, [:atomics]) + + Req.Test.stub(ElevationClient, fn conn -> + :counters.add(call_count, 1, 1) + current = :counters.get(call_count, 1) + + if current == 1 do + # First call (Open-Meteo) fails + Plug.Conn.send_resp(conn, 500, "error") + else + # Second call (Open-Topo-Data) succeeds + Req.Test.json(conn, %{ + "status" => "OK", + "results" => [ + %{"elevation" => 100.0}, + %{"elevation" => 150.0}, + %{"elevation" => 120.0} + ] + }) + end + end) + + assert {:ok, profile} = + ElevationClient.fetch_elevation_profile(32.9, -97.0, 30.3, -97.7, 2) + + assert length(profile) == 3 + assert hd(profile).elev == 100.0 + end + + test "returns error when both APIs fail" do + Req.Test.stub(ElevationClient, fn conn -> + Plug.Conn.send_resp(conn, 500, "error") + end) + + assert {:error, _reason} = + ElevationClient.fetch_elevation_profile(32.9, -97.0, 30.3, -97.7, 2) + end + end +end diff --git a/test/microwaveprop/terrain/terrain_analysis_test.exs b/test/microwaveprop/terrain/terrain_analysis_test.exs new file mode 100644 index 00000000..63e1e478 --- /dev/null +++ b/test/microwaveprop/terrain/terrain_analysis_test.exs @@ -0,0 +1,175 @@ +defmodule Microwaveprop.Terrain.TerrainAnalysisTest do + use ExUnit.Case, async: true + + alias Microwaveprop.Terrain.TerrainAnalysis + + describe "fresnel_radius/3" do + test "returns 0 when d1 or d2 is 0" do + assert TerrainAnalysis.fresnel_radius(0, 1000, 0.023) == 0 + assert TerrainAnalysis.fresnel_radius(1000, 0, 0.023) == 0 + end + + test "computes correct Fresnel radius for known values" do + # 1296 MHz -> lambda = 0.2315 m + lambda = 0.3 / 1.296 + d1 = 50_000.0 + d2 = 50_000.0 + + r = TerrainAnalysis.fresnel_radius(d1, d2, lambda) + assert_in_delta r, 76.1, 1.0 + end + end + + describe "earth_bulge/3" do + test "returns 0 at endpoints" do + assert TerrainAnalysis.earth_bulge(0.0, 100.0) == 0.0 + assert TerrainAnalysis.earth_bulge(1.0, 100.0) == 0.0 + end + + test "maximum bulge at midpoint of 100 km path" do + bulge = TerrainAnalysis.earth_bulge(0.5, 100.0) + assert_in_delta bulge, 147.0, 2.0 + end + + test "bulge increases with path length" do + bulge_50 = TerrainAnalysis.earth_bulge(0.5, 50.0) + bulge_100 = TerrainAnalysis.earth_bulge(0.5, 100.0) + assert bulge_100 > bulge_50 + end + end + + describe "knife_edge_loss/1" do + test "returns 0 for v <= -0.7787 (clear path)" do + assert TerrainAnalysis.knife_edge_loss(-1.0) == 0 + assert TerrainAnalysis.knife_edge_loss(-0.8) == 0 + end + + test "returns ~6 dB for v = 0 (grazing)" do + loss = TerrainAnalysis.knife_edge_loss(0.0) + assert_in_delta loss, 6.0, 0.5 + end + + test "loss increases with v > 0" do + loss_05 = TerrainAnalysis.knife_edge_loss(0.5) + loss_10 = TerrainAnalysis.knife_edge_loss(1.0) + loss_20 = TerrainAnalysis.knife_edge_loss(2.0) + + assert loss_05 > 0 + assert loss_10 > loss_05 + assert loss_20 > loss_10 + end + + test "asymptotic formula for v > 2.4" do + loss = TerrainAnalysis.knife_edge_loss(3.0) + assert_in_delta loss, 22.5, 0.5 + end + end + + describe "analyse/5" do + test "returns CLEAR for flat terrain with antenna heights" do + # 10 km path, flat terrain at 0m, antennas at 30m each + # Earth bulge at midpoint ~ 1.5m, beam at 30m, plenty of clearance + profile = + for i <- 0..10 do + f = i / 10 + %{lat: 32.9 + f * 0.09, lon: -97.0, d: f, elev: 0.0, dist_km: f * 10.0} + end + + result = TerrainAnalysis.analyse(profile, 10.0, 1.296, 30.0, 30.0) + + assert result.verdict == "CLEAR" + assert result.obstructed_count == 0 + assert result.diffraction_db == 0 + end + + test "returns BLOCKED for high obstacle" do + # 50 km path, endpoints at 100m, 500m peak in middle + profile = + for i <- 0..10 do + f = i / 10 + elev = if i == 5, do: 500.0, else: 100.0 + %{lat: 32.9 + f, lon: -97.0, d: f, elev: elev, dist_km: f * 50.0} + end + + result = TerrainAnalysis.analyse(profile, 50.0, 1.296) + + assert result.verdict == "BLOCKED" + assert result.obstructed_count >= 1 + assert result.diffraction_db > 0 + end + + test "max_elevation_m reflects the terrain peak" do + profile = + for i <- 0..4 do + f = i / 4 + elev = if i == 2, do: 500.0, else: 100.0 + %{lat: 32.9 + f, lon: -97.0, d: f, elev: elev, dist_km: f * 50.0} + end + + result = TerrainAnalysis.analyse(profile, 50.0, 1.296) + assert_in_delta result.max_elevation_m, 500.0, 0.1 + end + + test "elevated endpoints clear over flat terrain" do + # 20 km path, terrain at 0m, endpoints at 200m (hilltops) + # Earth bulge midpoint ~ 5.9m, beam at 200m, terrain + bulge = 5.9m + profile = + for i <- 0..10 do + f = i / 10 + %{lat: 32.9 + f * 0.18, lon: -97.0, d: f, elev: 0.0, dist_km: f * 20.0} + end + + # Use antenna heights to represent elevated positions + result = TerrainAnalysis.analyse(profile, 20.0, 1.296, 200.0, 200.0) + assert result.verdict == "CLEAR" + end + + test "returns fresnel verdict for moderate ridge" do + # 20 km path, endpoints at 200m elevation, small ridge at midpoint + # Beam at midpoint = 200m, earth bulge ~ 5.9m + # Ridge at 160m + bulge 5.9m = 165.9m effective -> clearance = 200 - 165.9 = 34.1m + # Fresnel r1 at midpoint 1296 MHz 20km = sqrt(0.2315*10000*10000/20000) ~ 34m + # f1_clear = 34.1 - 34 = 0.1m -> just barely clear + # Need ridge slightly higher: 165m + 5.9 = 170.9 -> clearance 29.1, f1_clear = -4.9 -> penetrated + profile = + for i <- 0..10 do + f = i / 10 + elev = if i == 5, do: 165.0, else: 0.0 + %{lat: 32.9 + f * 0.18, lon: -97.0, d: f, elev: elev, dist_km: f * 20.0} + end + + result = TerrainAnalysis.analyse(profile, 20.0, 1.296, 200.0, 200.0) + assert result.verdict in ["FRESNEL_MINOR", "FRESNEL_PARTIAL"] + assert result.fresnel_hit_count >= 1 + end + + test "antenna heights raise beam above terrain" do + # 10 km path, 30m hill, no antenna height -> blocked (beam at 0m, terrain+bulge > 0) + # With 50m antennas -> clear + profile = + for i <- 0..10 do + f = i / 10 + elev = if i == 5, do: 30.0, else: 0.0 + %{lat: 32.9 + f * 0.09, lon: -97.0, d: f, elev: elev, dist_km: f * 10.0} + end + + result_low = TerrainAnalysis.analyse(profile, 10.0, 1.296, 0.0, 0.0) + result_high = TerrainAnalysis.analyse(profile, 10.0, 1.296, 100.0, 100.0) + + assert result_low.verdict == "BLOCKED" + assert result_high.verdict == "CLEAR" + end + + test "min_clearance_m can be negative for obstructed paths" do + profile = + for i <- 0..4 do + f = i / 4 + elev = if i == 2, do: 500.0, else: 100.0 + %{lat: 32.9 + f, lon: -97.0, d: f, elev: elev, dist_km: f * 50.0} + end + + result = TerrainAnalysis.analyse(profile, 50.0, 1.296) + assert result.min_clearance_m < 0 + end + end +end diff --git a/test/microwaveprop/terrain/terrain_profile_test.exs b/test/microwaveprop/terrain/terrain_profile_test.exs new file mode 100644 index 00000000..e8d4c90f --- /dev/null +++ b/test/microwaveprop/terrain/terrain_profile_test.exs @@ -0,0 +1,94 @@ +defmodule Microwaveprop.Terrain.TerrainProfileTest do + use Microwaveprop.DataCase, async: true + + alias Microwaveprop.Radio.Qso + alias Microwaveprop.Terrain.TerrainProfile + + @qso_attrs %{ + station1: "W5XD", + station2: "K5TR", + qso_timestamp: ~U[2026-03-28 18:00:00Z], + mode: "CW", + band: Decimal.new("1296"), + pos1: %{"lat" => 32.9, "lon" => -97.0}, + pos2: %{"lat" => 30.3, "lon" => -97.7} + } + + defp create_qso do + {:ok, qso} = + %Qso{} + |> Qso.changeset(@qso_attrs) + |> Repo.insert() + + qso + end + + describe "changeset/2" do + test "valid with required fields" do + qso = create_qso() + + attrs = %{ + qso_id: qso.id, + sample_count: 65, + path_points: [%{"lat" => 32.9, "lon" => -97.0, "elev" => 200.0, "dist_km" => 0.0}], + verdict: "CLEAR" + } + + changeset = TerrainProfile.changeset(%TerrainProfile{}, attrs) + assert changeset.valid? + end + + test "invalid without required fields" do + changeset = TerrainProfile.changeset(%TerrainProfile{}, %{}) + refute changeset.valid? + + errors = errors_on(changeset) + assert errors[:qso_id] + assert errors[:sample_count] + assert errors[:path_points] + assert errors[:verdict] + end + + test "valid with all optional fields" do + qso = create_qso() + + attrs = %{ + qso_id: qso.id, + sample_count: 65, + path_points: [%{"lat" => 32.9, "lon" => -97.0, "elev" => 200.0, "dist_km" => 0.0}], + verdict: "BLOCKED", + max_elevation_m: 450.0, + min_clearance_m: -12.5, + diffraction_db: 8.3, + fresnel_hit_count: 3, + obstructed_count: 1 + } + + changeset = TerrainProfile.changeset(%TerrainProfile{}, attrs) + assert changeset.valid? + end + + test "enforces unique qso_id constraint on insert" do + qso = create_qso() + + attrs = %{ + qso_id: qso.id, + sample_count: 65, + path_points: [], + verdict: "CLEAR" + } + + {:ok, _} = + %TerrainProfile{} + |> TerrainProfile.changeset(attrs) + |> Repo.insert() + + {:error, changeset} = + %TerrainProfile{} + |> TerrainProfile.changeset(attrs) + |> Repo.insert() + + assert errors_on(changeset)[:qso_id] + end + end +end diff --git a/test/microwaveprop/terrain_test.exs b/test/microwaveprop/terrain_test.exs new file mode 100644 index 00000000..9da90bc4 --- /dev/null +++ b/test/microwaveprop/terrain_test.exs @@ -0,0 +1,96 @@ +defmodule Microwaveprop.TerrainTest do + use Microwaveprop.DataCase, async: true + + alias Microwaveprop.Radio.Qso + alias Microwaveprop.Terrain + + @qso_attrs %{ + station1: "W5XD", + station2: "K5TR", + qso_timestamp: ~U[2026-03-28 18:00:00Z], + mode: "CW", + band: Decimal.new("1296"), + pos1: %{"lat" => 32.9, "lon" => -97.0}, + pos2: %{"lat" => 30.3, "lon" => -97.7} + } + + defp create_qso do + {:ok, qso} = + %Qso{} + |> Qso.changeset(@qso_attrs) + |> Repo.insert() + + qso + end + + defp terrain_attrs(qso) do + %{ + qso_id: qso.id, + sample_count: 65, + path_points: [ + %{"lat" => 32.9, "lon" => -97.0, "elev" => 200.0, "dist_km" => 0.0}, + %{"lat" => 30.3, "lon" => -97.7, "elev" => 180.0, "dist_km" => 295.0} + ], + verdict: "CLEAR", + max_elevation_m: 450.0, + min_clearance_m: 120.0, + diffraction_db: 0.0, + fresnel_hit_count: 0, + obstructed_count: 0 + } + end + + describe "upsert_terrain_profile/1" do + test "inserts a new terrain profile" do + qso = create_qso() + attrs = terrain_attrs(qso) + + assert {:ok, profile} = Terrain.upsert_terrain_profile(attrs) + assert profile.qso_id == qso.id + assert profile.sample_count == 65 + assert profile.verdict == "CLEAR" + end + + test "upserts on conflict (same qso_id)" do + qso = create_qso() + attrs = terrain_attrs(qso) + + {:ok, _} = Terrain.upsert_terrain_profile(attrs) + + updated_attrs = Map.merge(attrs, %{verdict: "BLOCKED", diffraction_db: 6.5}) + {:ok, profile} = Terrain.upsert_terrain_profile(updated_attrs) + + assert profile.verdict == "BLOCKED" + assert profile.diffraction_db == 6.5 + end + end + + describe "get_terrain_profile/1" do + test "returns profile for a QSO" do + qso = create_qso() + {:ok, _} = Terrain.upsert_terrain_profile(terrain_attrs(qso)) + + profile = Terrain.get_terrain_profile(qso.id) + assert profile.qso_id == qso.id + end + + test "returns nil when no profile exists" do + qso = create_qso() + assert Terrain.get_terrain_profile(qso.id) == nil + end + end + + describe "has_terrain_profile?/1" do + test "returns true when profile exists" do + qso = create_qso() + {:ok, _} = Terrain.upsert_terrain_profile(terrain_attrs(qso)) + + assert Terrain.has_terrain_profile?(qso.id) + end + + test "returns false when no profile exists" do + qso = create_qso() + refute Terrain.has_terrain_profile?(qso.id) + end + end +end diff --git a/test/microwaveprop/workers/qso_weather_enqueue_worker_test.exs b/test/microwaveprop/workers/qso_weather_enqueue_worker_test.exs index cb2bcdd6..ccd11805 100644 --- a/test/microwaveprop/workers/qso_weather_enqueue_worker_test.exs +++ b/test/microwaveprop/workers/qso_weather_enqueue_worker_test.exs @@ -2,6 +2,7 @@ defmodule Microwaveprop.Workers.QsoWeatherEnqueueWorkerTest do use Microwaveprop.DataCase, async: true alias Microwaveprop.Radio.Qso + alias Microwaveprop.Terrain.ElevationClient alias Microwaveprop.Weather alias Microwaveprop.Weather.IemClient alias Microwaveprop.Workers.QsoWeatherEnqueueWorker @@ -128,6 +129,13 @@ defmodule Microwaveprop.Workers.QsoWeatherEnqueueWorkerTest do end end) + # Stub elevation API for terrain profile workers + Req.Test.stub(ElevationClient, fn conn -> + params = Plug.Conn.fetch_query_params(conn).query_params + lat_count = params["latitude"] |> String.split(",") |> length() + Req.Test.json(conn, %{"elevation" => List.duplicate(200.0, lat_count)}) + end) + :ok end @@ -228,4 +236,61 @@ defmodule Microwaveprop.Workers.QsoWeatherEnqueueWorkerTest do assert QsoWeatherEnqueueWorker.build_hrrr_jobs([qso]) == [] end end + + describe "build_terrain_jobs/1" do + test "builds one terrain job per QSO" do + qso = create_qso() + + jobs = QsoWeatherEnqueueWorker.build_terrain_jobs([qso]) + + assert length(jobs) == 1 + job = hd(jobs) + assert job.changes.args["qso_id"] == qso.id + end + + test "deduplicates by qso_id" do + qso = create_qso() + + jobs = QsoWeatherEnqueueWorker.build_terrain_jobs([qso, qso]) + assert length(jobs) == 1 + end + end + + describe "perform/1 terrain enqueue" do + setup do + Req.Test.stub(IemClient, fn conn -> + case conn.request_path do + "/cgi-bin/request/asos.py" -> Req.Test.text(conn, "#DEBUG,\nstation,valid,tmpf\n") + _ -> Req.Test.json(conn, %{"profiles" => []}) + end + end) + + Req.Test.stub(ElevationClient, fn conn -> + params = Plug.Conn.fetch_query_params(conn).query_params + lat_count = params["latitude"] |> String.split(",") |> length() + Req.Test.json(conn, %{"elevation" => List.duplicate(200.0, lat_count)}) + end) + + :ok + end + + test "enqueues terrain jobs and marks QSOs as terrain_queued" do + qso = create_qso() + assert qso.terrain_queued == false + + assert :ok = QsoWeatherEnqueueWorker.perform(%Oban.Job{args: %{}}) + + updated = Repo.get!(Qso, qso.id) + assert updated.terrain_queued == true + end + + test "skips terrain for QSOs missing pos2" do + _qso = create_qso(%{pos2: nil}) + + assert :ok = QsoWeatherEnqueueWorker.perform(%Oban.Job{args: %{}}) + + all_qsos = Repo.all(Qso) + refute Enum.any?(all_qsos, & &1.terrain_queued) + end + end end diff --git a/test/microwaveprop/workers/terrain_profile_worker_test.exs b/test/microwaveprop/workers/terrain_profile_worker_test.exs new file mode 100644 index 00000000..77f7844b --- /dev/null +++ b/test/microwaveprop/workers/terrain_profile_worker_test.exs @@ -0,0 +1,95 @@ +defmodule Microwaveprop.Workers.TerrainProfileWorkerTest do + use Microwaveprop.DataCase, async: true + + alias Microwaveprop.Radio.Qso + alias Microwaveprop.Terrain + alias Microwaveprop.Terrain.ElevationClient + alias Microwaveprop.Workers.TerrainProfileWorker + + @qso_attrs %{ + station1: "W5XD", + station2: "K5TR", + qso_timestamp: ~U[2026-03-28 18:00:00Z], + mode: "CW", + band: Decimal.new("1296"), + pos1: %{"lat" => 32.9, "lon" => -97.0}, + pos2: %{"lat" => 30.3, "lon" => -97.7}, + distance_km: Decimal.new("295") + } + + defp create_qso(attrs \\ %{}) do + {:ok, qso} = + %Qso{} + |> Qso.changeset(Map.merge(@qso_attrs, attrs)) + |> Repo.insert() + + qso + end + + defp stub_elevation_api do + Req.Test.stub(ElevationClient, fn conn -> + params = Plug.Conn.fetch_query_params(conn).query_params + lat_count = params["latitude"] |> String.split(",") |> length() + elevations = List.duplicate(200.0, lat_count) + Req.Test.json(conn, %{"elevation" => elevations}) + end) + end + + describe "perform/1" do + test "fetches elevation and stores terrain profile" do + stub_elevation_api() + qso = create_qso() + + refute Terrain.has_terrain_profile?(qso.id) + + job = TerrainProfileWorker.new(%{"qso_id" => qso.id}) + assert :ok = TerrainProfileWorker.perform(%Oban.Job{args: job.changes.args}) + + assert Terrain.has_terrain_profile?(qso.id) + profile = Terrain.get_terrain_profile(qso.id) + assert profile.sample_count == 65 + assert profile.verdict in ["CLEAR", "FRESNEL_MINOR", "FRESNEL_PARTIAL", "BLOCKED"] + assert is_list(profile.path_points) + end + + test "skips if terrain profile already exists" do + stub_elevation_api() + qso = create_qso() + + {:ok, _} = + Terrain.upsert_terrain_profile(%{ + qso_id: qso.id, + sample_count: 65, + path_points: [], + verdict: "CLEAR" + }) + + job = TerrainProfileWorker.new(%{"qso_id" => qso.id}) + assert :ok = TerrainProfileWorker.perform(%Oban.Job{args: job.changes.args}) + end + + test "returns error when elevation API fails" do + Req.Test.stub(ElevationClient, fn conn -> + Plug.Conn.send_resp(conn, 500, "error") + end) + + qso = create_qso() + + job = TerrainProfileWorker.new(%{"qso_id" => qso.id}) + assert {:error, _} = TerrainProfileWorker.perform(%Oban.Job{args: job.changes.args}) + + refute Terrain.has_terrain_profile?(qso.id) + end + + test "uses correct frequency from band" do + stub_elevation_api() + qso = create_qso(%{band: Decimal.new("10368")}) + + job = TerrainProfileWorker.new(%{"qso_id" => qso.id}) + assert :ok = TerrainProfileWorker.perform(%Oban.Job{args: job.changes.args}) + + profile = Terrain.get_terrain_profile(qso.id) + assert profile.verdict + end + end +end