Graham McIntire
1e8dd7036d
- Bump render_async/2 timeout to 2_000ms across contact_live_test. Default 100ms races when the suite runs on a loaded box — ContactLive. Show fans out 8 hydration tasks at mount and sporadically missed the window even on a quiet DB. - Telemetry metrics-shape assertion uses Enum.any?/1 instead of the `metrics != []` comparison Elixir 1.19's type system flags as a distinct-type comparison (the function's non-empty return type).
1022 lines
34 KiB
Elixir
1022 lines
34 KiB
Elixir
defmodule MicrowavepropWeb.ContactLiveTest do
|
|
use MicrowavepropWeb.ConnCase, async: true
|
|
|
|
import Phoenix.LiveViewTest
|
|
|
|
alias Microwaveprop.Radio.Contact
|
|
alias Microwaveprop.Repo
|
|
alias Microwaveprop.Weather.HrrrNativeProfile
|
|
alias Microwaveprop.Weather.NarrProfile
|
|
|
|
setup do
|
|
Req.Test.stub(Microwaveprop.Terrain.ElevationClient, fn conn ->
|
|
Req.Test.json(conn, [])
|
|
end)
|
|
|
|
Req.Test.stub(Microwaveprop.Weather.HrrrClient, fn conn ->
|
|
Plug.Conn.send_resp(conn, 404, "not found")
|
|
end)
|
|
|
|
Req.Test.stub(Microwaveprop.Weather.SolarClient, fn conn ->
|
|
Req.Test.text(conn, "")
|
|
end)
|
|
|
|
:ok
|
|
end
|
|
|
|
defp create_contact(attrs \\ %{}) do
|
|
default = %{
|
|
station1: "W5XD",
|
|
station2: "K5TR",
|
|
qso_timestamp: ~U[2026-03-28 18:00:00Z],
|
|
mode: "CW",
|
|
band: Decimal.new("1296"),
|
|
grid1: "EM12",
|
|
grid2: "EM00",
|
|
pos1: %{"lat" => 32.9, "lon" => -97.0},
|
|
pos2: %{"lat" => 30.3, "lon" => -97.7},
|
|
distance_km: Decimal.new("295")
|
|
}
|
|
|
|
{changeset_attrs, direct_attrs} = Map.split(Map.merge(default, attrs), [:user_submitted])
|
|
|
|
{:ok, contact} =
|
|
%Contact{}
|
|
|> Contact.changeset(direct_attrs)
|
|
|> Ecto.Changeset.change(changeset_attrs)
|
|
|> Repo.insert()
|
|
|
|
contact
|
|
end
|
|
|
|
describe "Index" do
|
|
test "renders page with Contacts heading", %{conn: conn} do
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts")
|
|
assert html =~ "Contacts"
|
|
end
|
|
|
|
test "shows total contact count in subtitle", %{conn: conn} do
|
|
create_contact()
|
|
create_contact(%{station1: "N5AC"})
|
|
create_contact(%{station1: "K5TR"})
|
|
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts")
|
|
assert html =~ "3 total"
|
|
end
|
|
|
|
test "table shows contact data", %{conn: conn} do
|
|
create_contact()
|
|
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts")
|
|
assert html =~ "W5XD"
|
|
assert html =~ "K5TR"
|
|
assert html =~ "CW"
|
|
assert html =~ "1296"
|
|
end
|
|
|
|
test "row links to detail page", %{conn: conn} do
|
|
contact = create_contact()
|
|
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts")
|
|
assert html =~ ~p"/contacts/#{contact.id}"
|
|
end
|
|
|
|
test "sort params order the table", %{conn: conn} do
|
|
create_contact(%{station1: "ZZ9ZZ"})
|
|
create_contact(%{station1: "AA1AA"})
|
|
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts?sort_params[station1]=asc")
|
|
|
|
aa_pos = html |> :binary.match("AA1AA") |> elem(0)
|
|
zz_pos = html |> :binary.match("ZZ9ZZ") |> elem(0)
|
|
assert aa_pos < zz_pos
|
|
end
|
|
|
|
test "search by single callsign matches either station", %{conn: conn} do
|
|
create_contact(%{station1: "W5LUA", station2: "W5HN"})
|
|
create_contact(%{station1: "K5TR", station2: "N5AC"})
|
|
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts?search=W5LUA")
|
|
# W5LUA appears in the matching row; K5TR/N5AC should not render in
|
|
# the table body because the search filtered that contact out.
|
|
assert html =~ "W5LUA"
|
|
refute html =~ "N5AC"
|
|
end
|
|
|
|
test "pagination reaches later pages", %{conn: conn} do
|
|
for i <- 1..25 do
|
|
ts = DateTime.add(~U[2026-01-01 00:00:00Z], i * 3600, :second)
|
|
create_contact(%{qso_timestamp: ts, station1: "W#{i}TEST"})
|
|
end
|
|
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts")
|
|
assert html =~ "Page"
|
|
|
|
{:ok, _lv, html2} = live(conn, ~p"/contacts?page=2")
|
|
assert html2 =~ "Page"
|
|
end
|
|
end
|
|
|
|
describe "Index private visibility" do
|
|
import Microwaveprop.AccountsFixtures
|
|
|
|
test "anonymous viewer does not see private contacts in the table", %{conn: conn} do
|
|
_private = create_contact(%{station1: "W5PRV", private: true})
|
|
_public = create_contact(%{station1: "W5PUB", qso_timestamp: ~U[2026-03-28 19:00:00Z]})
|
|
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts")
|
|
|
|
assert html =~ "W5PUB"
|
|
refute html =~ "W5PRV"
|
|
end
|
|
|
|
test "owner sees their own private inline with Yes badge", %{conn: conn} do
|
|
owner = user_fixture()
|
|
_private = create_contact(%{station1: "W5PRV", private: true, user_id: owner.id})
|
|
_public = create_contact(%{station1: "W5PUB", qso_timestamp: ~U[2026-03-28 19:00:00Z]})
|
|
conn = log_in_user(conn, owner)
|
|
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts")
|
|
|
|
assert html =~ "W5PRV"
|
|
assert html =~ "W5PUB"
|
|
assert html =~ "badge-warning"
|
|
end
|
|
|
|
test "admin sees all private contacts", %{conn: conn} do
|
|
admin = user_fixture() |> Ecto.Changeset.change(is_admin: true) |> Repo.update!()
|
|
_private = create_contact(%{station1: "W5PRV", private: true})
|
|
_public = create_contact(%{station1: "W5PUB", qso_timestamp: ~U[2026-03-28 19:00:00Z]})
|
|
conn = log_in_user(conn, admin)
|
|
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts")
|
|
assert html =~ "W5PRV"
|
|
assert html =~ "W5PUB"
|
|
end
|
|
|
|
test "non-owning user does not see others' private", %{conn: conn} do
|
|
owner = user_fixture()
|
|
viewer = user_fixture()
|
|
_private = create_contact(%{station1: "W5PRV", private: true, user_id: owner.id})
|
|
_public = create_contact(%{station1: "W5PUB", qso_timestamp: ~U[2026-03-28 19:00:00Z]})
|
|
conn = log_in_user(conn, viewer)
|
|
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts")
|
|
assert html =~ "W5PUB"
|
|
refute html =~ "W5PRV"
|
|
end
|
|
end
|
|
|
|
describe "Index private column visibility" do
|
|
import Microwaveprop.AccountsFixtures
|
|
|
|
test "column hidden for anonymous viewer when no private contacts exist", %{conn: conn} do
|
|
_public = create_contact(%{station1: "W5PUB"})
|
|
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts")
|
|
refute html =~ ">Private<"
|
|
end
|
|
|
|
test "column hidden for anonymous viewer even when others have private contacts", %{conn: conn} do
|
|
_private = create_contact(%{station1: "W5PRV", private: true})
|
|
_public = create_contact(%{station1: "W5PUB"})
|
|
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts")
|
|
refute html =~ ">Private<"
|
|
end
|
|
|
|
test "column hidden for a user who has no private contacts of their own", %{conn: conn} do
|
|
owner = user_fixture()
|
|
viewer = user_fixture()
|
|
_others_private = create_contact(%{station1: "W5PRV", private: true, user_id: owner.id})
|
|
conn = log_in_user(conn, viewer)
|
|
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts")
|
|
refute html =~ ">Private<"
|
|
end
|
|
|
|
test "column visible for a user with at least one of their own private contacts", %{conn: conn} do
|
|
owner = user_fixture()
|
|
_private = create_contact(%{station1: "W5PRV", private: true, user_id: owner.id})
|
|
conn = log_in_user(conn, owner)
|
|
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts")
|
|
assert html =~ ">Private<"
|
|
end
|
|
|
|
test "column hidden for admin when there are no private contacts anywhere", %{conn: conn} do
|
|
admin = user_fixture() |> Ecto.Changeset.change(is_admin: true) |> Repo.update!()
|
|
_public = create_contact(%{station1: "W5PUB"})
|
|
conn = log_in_user(conn, admin)
|
|
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts")
|
|
refute html =~ ">Private<"
|
|
end
|
|
|
|
test "column visible for admin as soon as any private contact exists", %{conn: conn} do
|
|
admin = user_fixture() |> Ecto.Changeset.change(is_admin: true) |> Repo.update!()
|
|
_private = create_contact(%{station1: "W5PRV", private: true})
|
|
conn = log_in_user(conn, admin)
|
|
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts")
|
|
assert html =~ ">Private<"
|
|
end
|
|
end
|
|
|
|
describe "Show private visibility" do
|
|
import Microwaveprop.AccountsFixtures
|
|
|
|
test "anonymous viewer 404s on a private contact", %{conn: conn} do
|
|
contact = create_contact(%{private: true})
|
|
|
|
assert_raise Ecto.NoResultsError, fn ->
|
|
live(conn, ~p"/contacts/#{contact.id}")
|
|
end
|
|
end
|
|
|
|
test "non-owning user 404s on a private contact", %{conn: conn} do
|
|
owner = user_fixture()
|
|
other = user_fixture()
|
|
contact = create_contact(%{private: true, user_id: owner.id})
|
|
conn = log_in_user(conn, other)
|
|
|
|
assert_raise Ecto.NoResultsError, fn ->
|
|
live(conn, ~p"/contacts/#{contact.id}")
|
|
end
|
|
end
|
|
|
|
test "owner can view their own private contact", %{conn: conn} do
|
|
owner = user_fixture()
|
|
contact = create_contact(%{private: true, user_id: owner.id})
|
|
conn = log_in_user(conn, owner)
|
|
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
assert html =~ "W5XD"
|
|
end
|
|
|
|
test "admin can view anyone's private contact", %{conn: conn} do
|
|
owner = user_fixture()
|
|
admin = user_fixture() |> Ecto.Changeset.change(is_admin: true) |> Repo.update!()
|
|
contact = create_contact(%{private: true, user_id: owner.id})
|
|
conn = log_in_user(conn, admin)
|
|
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
assert html =~ "W5XD"
|
|
end
|
|
end
|
|
|
|
describe "Show" do
|
|
test "renders contact detail fields", %{conn: conn} do
|
|
contact = create_contact()
|
|
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
assert html =~ "W5XD"
|
|
assert html =~ "K5TR"
|
|
# Mode, band, grids are shown in the elevation profile section (requires SRTM)
|
|
# or in the header subtitle
|
|
assert html =~ "2026-03-28"
|
|
end
|
|
|
|
test "shows surface observations section", %{conn: conn} do
|
|
contact = create_contact()
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
assert html =~ "Surface Observations"
|
|
end
|
|
|
|
test "shows sounding section", %{conn: conn} do
|
|
contact = create_contact()
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
assert html =~ "Soundings"
|
|
end
|
|
|
|
test "shows solar index section", %{conn: conn} do
|
|
contact = create_contact()
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
assert html =~ "Solar Conditions"
|
|
end
|
|
|
|
test "renders with sort assigns", %{conn: conn} do
|
|
contact = create_contact()
|
|
{:ok, lv, html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
|
|
# Page renders without error
|
|
assert html =~ "Surface Observations"
|
|
assert html =~ "Soundings"
|
|
|
|
# Sort assigns are initialized (no crash on render)
|
|
assert render(lv) =~ contact.station1
|
|
end
|
|
|
|
# Band display on the detail page: below 10 GHz renders in MHz, at/above
|
|
# 10 GHz renders in GHz. Amateur microwave convention — 2304 is "2304",
|
|
# 3456 is "3456", 5760 is "5760", not "2.3 GHz" etc.
|
|
test "renders sub-10-GHz bands in MHz", %{conn: conn} do
|
|
contact = create_contact(%{band: Decimal.new("432")})
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
assert html =~ "432 MHz"
|
|
end
|
|
|
|
test "renders 50 MHz in MHz", %{conn: conn} do
|
|
contact = create_contact(%{band: Decimal.new("50")})
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
assert html =~ "50 MHz"
|
|
end
|
|
|
|
test "renders 1296 MHz in MHz", %{conn: conn} do
|
|
contact = create_contact(%{band: Decimal.new("1296")})
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
assert html =~ "1296 MHz"
|
|
refute html =~ "1.3 GHz"
|
|
end
|
|
|
|
test "renders 2304 MHz in MHz", %{conn: conn} do
|
|
contact = create_contact(%{band: Decimal.new("2304")})
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
assert html =~ "2304 MHz"
|
|
refute html =~ "2.3 GHz"
|
|
end
|
|
|
|
test "renders 10 GHz in GHz (threshold)", %{conn: conn} do
|
|
contact = create_contact(%{band: Decimal.new("10000")})
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
assert html =~ "10 GHz"
|
|
end
|
|
|
|
test "renders 24 GHz in GHz", %{conn: conn} do
|
|
contact = create_contact(%{band: Decimal.new("24000")})
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
assert html =~ "24 GHz"
|
|
end
|
|
|
|
test "raises for bad UUID", %{conn: conn} do
|
|
assert_raise Ecto.NoResultsError, fn ->
|
|
live(conn, ~p"/contacts/#{Ecto.UUID.generate()}")
|
|
end
|
|
end
|
|
|
|
test "shows atmospheric profile section with NARR source for pre-HRRR contact", %{conn: conn} do
|
|
# Pre-2014 contact — HRRR is unavailable, NARR is the fallback source.
|
|
contact =
|
|
create_contact(%{
|
|
qso_timestamp: ~U[2010-06-15 18:00:00Z],
|
|
pos1: %{"lat" => 32.9, "lon" => -97.0},
|
|
pos2: %{"lat" => 30.3, "lon" => -97.7}
|
|
})
|
|
|
|
{:ok, _} =
|
|
Repo.insert(%NarrProfile{
|
|
valid_time: ~U[2010-06-15 18:00:00Z],
|
|
lat: 33.0,
|
|
lon: -97.0,
|
|
profile: [
|
|
%{"pres" => 850.0, "tmpc" => 15.0, "dwpc" => 10.0, "hght" => 1500.0}
|
|
],
|
|
surface_temp_c: 25.0,
|
|
surface_dewpoint_c: 18.0,
|
|
surface_pressure_mb: 1012.0,
|
|
hpbl_m: 1200.0,
|
|
pwat_mm: 30.0,
|
|
surface_refractivity: 320.0,
|
|
min_refractivity_gradient: -50.0,
|
|
ducting_detected: false
|
|
})
|
|
|
|
{:ok, lv, _html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
|
|
html = render_async(lv, 2_000)
|
|
assert html =~ "Atmospheric Profile"
|
|
assert html =~ "NARR"
|
|
# Collapsed summary shows HPBL / PWAT / lat,lon from the injected NARR row.
|
|
assert html =~ "1200"
|
|
assert html =~ "33.0"
|
|
end
|
|
|
|
test "skew-T uses native HRRR profile when backfilled", %{conn: conn} do
|
|
# Native backfill has reached this hour — use its full-atmosphere
|
|
# profile for the skew-T instead of the 700 mb-capped pressure-level one.
|
|
contact =
|
|
create_contact(%{
|
|
qso_timestamp: ~U[2024-06-15 18:00:00Z],
|
|
pos1: %{"lat" => 32.9, "lon" => -97.0},
|
|
pos2: %{"lat" => 30.3, "lon" => -97.7}
|
|
})
|
|
|
|
# NARR row keeps the atmospheric profile section rendering with its
|
|
# aggregate metadata (HPBL / PWAT / surface scalars).
|
|
{:ok, _} =
|
|
Repo.insert(%NarrProfile{
|
|
valid_time: ~U[2024-06-15 18:00:00Z],
|
|
lat: 32.9,
|
|
lon: -97.0,
|
|
profile: [%{"pres" => 850.0, "tmpc" => 15.0, "dwpc" => 10.0, "hght" => 1500.0}],
|
|
surface_temp_c: 25.0,
|
|
surface_dewpoint_c: 18.0,
|
|
surface_pressure_mb: 1012.0,
|
|
hpbl_m: 1200.0,
|
|
pwat_mm: 30.0,
|
|
surface_refractivity: 320.0,
|
|
min_refractivity_gradient: -50.0,
|
|
ducting_detected: false
|
|
})
|
|
|
|
# Native profile at the same point/time. `pressure_pa: [..., 30_000.0]`
|
|
# corresponds to 300 mb — a level the pressure-level profile cannot
|
|
# cover because HRRR/NARR pressure-level data stops at 700 mb historically.
|
|
{:ok, _} =
|
|
%HrrrNativeProfile{}
|
|
|> HrrrNativeProfile.changeset(%{
|
|
valid_time: ~U[2024-06-15 18:00:00Z],
|
|
run_time: ~U[2024-06-15 18:00:00Z],
|
|
lat: 32.9,
|
|
lon: -97.0,
|
|
level_count: 3,
|
|
heights_m: [10.0, 1500.0, 9500.0],
|
|
temp_k: [298.0, 288.0, 228.0],
|
|
spfh: [0.012, 0.006, 0.0001],
|
|
pressure_pa: [101_000.0, 85_000.0, 30_000.0],
|
|
u_wind_ms: [2.0, 5.0, 20.0],
|
|
v_wind_ms: [1.0, 2.0, 5.0],
|
|
tke_m2s2: [0.5, 0.2, 0.05]
|
|
})
|
|
|> Repo.insert()
|
|
|
|
{:ok, lv, _html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
html = render_async(lv, 2_000)
|
|
|
|
assert html =~ "HRRR native"
|
|
# 300 mb comes from the native profile — pressure-level data capped at 700.
|
|
assert html =~ "300.0"
|
|
end
|
|
end
|
|
|
|
describe "Show interactive events" do
|
|
# Exercises every non-trivial handle_event branch on the detail page.
|
|
# These bump ContactLive.Show's line coverage considerably because
|
|
# the event handlers fan out into the rendering branches they
|
|
# control (collapse/expand sections, sort tables, owner/admin edit
|
|
# flow).
|
|
|
|
import Microwaveprop.AccountsFixtures
|
|
|
|
defp admin_fixture do
|
|
user = user_fixture()
|
|
{:ok, user} = Microwaveprop.Accounts.admin_update_user(user, %{is_admin: true})
|
|
user
|
|
end
|
|
|
|
test "toggle_hrrr_profile flips the atmospheric-profile collapse state", %{conn: conn} do
|
|
contact = create_contact()
|
|
{:ok, lv, _html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
|
|
# Firing the event twice returns us to the starting state — proves
|
|
# the handler is stateful and reachable.
|
|
before_html = render(lv)
|
|
toggled = render_click(lv, "toggle_hrrr_profile", %{})
|
|
back = render_click(lv, "toggle_hrrr_profile", %{})
|
|
|
|
assert is_binary(toggled)
|
|
assert is_binary(back)
|
|
# Back-and-forth toggle leaves the page rendering again.
|
|
assert back =~ contact.station1 and before_html =~ contact.station1
|
|
end
|
|
|
|
test "toggle_terrain flips the terrain-section collapse state", %{conn: conn} do
|
|
contact = create_contact()
|
|
{:ok, lv, _html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
|
|
html = render_click(lv, "toggle_terrain", %{})
|
|
assert is_binary(html)
|
|
end
|
|
|
|
test "toggle_profile (sounding expansion) tracks an id in the MapSet", %{conn: conn} do
|
|
contact = create_contact()
|
|
{:ok, lv, _html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
|
|
# Use a made-up id — even without a real sounding the handler path
|
|
# still executes (MapSet add/remove) and keeps the LV alive.
|
|
html = render_click(lv, "toggle_profile", %{"id" => "11111111-1111-1111-1111-111111111111"})
|
|
assert is_binary(html)
|
|
|
|
html2 = render_click(lv, "toggle_profile", %{"id" => "11111111-1111-1111-1111-111111111111"})
|
|
assert is_binary(html2)
|
|
end
|
|
|
|
test "sort obs table by date toggles sort direction", %{conn: conn} do
|
|
contact = create_contact()
|
|
{:ok, lv, _html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
|
|
render_click(lv, "sort", %{"field" => "observed_at", "table" => "obs"})
|
|
html = render_click(lv, "sort", %{"field" => "observed_at", "table" => "obs"})
|
|
assert html =~ "Surface Observations"
|
|
end
|
|
|
|
test "sort obs table exercises every known field sort key", %{conn: conn} do
|
|
contact = create_contact()
|
|
{:ok, lv, _html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
|
|
for field <- ~w(station_name observed_at temp_f dewpoint_f relative_humidity sea_level_pressure_mb unknown_field) do
|
|
html = render_click(lv, "sort", %{"field" => field, "table" => "obs"})
|
|
assert html =~ "Surface Observations", "sort by #{field} lost the obs table"
|
|
end
|
|
end
|
|
|
|
test "sort soundings table exercises every known field sort key", %{conn: conn} do
|
|
contact = create_contact()
|
|
{:ok, lv, _html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
|
|
for field <- ~w(station_name observed_at unknown_field) do
|
|
html = render_click(lv, "sort", %{"field" => field, "table" => "soundings"})
|
|
assert html =~ "Soundings", "sort by #{field} lost the soundings table"
|
|
end
|
|
end
|
|
|
|
test "sort soundings table by date keeps the view rendering", %{conn: conn} do
|
|
contact = create_contact()
|
|
{:ok, lv, _html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
|
|
html = render_click(lv, "sort", %{"field" => "observed_at", "table" => "soundings"})
|
|
assert html =~ "Soundings"
|
|
end
|
|
|
|
test "toggle_flag is denied to anonymous viewers (flash + no change)", %{conn: conn} do
|
|
contact = create_contact()
|
|
{:ok, lv, _html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
|
|
html = render_click(lv, "toggle_flag", %{})
|
|
assert html =~ "Admins only"
|
|
|
|
refute Repo.get!(Contact, contact.id).flagged_invalid
|
|
end
|
|
|
|
test "toggle_flag inverts the flag for admins", %{conn: conn} do
|
|
contact = create_contact()
|
|
admin = admin_fixture()
|
|
conn = log_in_user(conn, admin)
|
|
|
|
{:ok, lv, _html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
render_click(lv, "toggle_flag", %{})
|
|
|
|
refreshed = Repo.get!(Contact, contact.id)
|
|
assert refreshed.flagged_invalid == true
|
|
|
|
# Toggling again flips back.
|
|
render_click(lv, "toggle_flag", %{})
|
|
assert Repo.get!(Contact, contact.id).flagged_invalid == false
|
|
end
|
|
|
|
test "toggle_edit opens and closes the inline edit form", %{conn: conn} do
|
|
contact = create_contact()
|
|
admin = admin_fixture()
|
|
conn = log_in_user(conn, admin)
|
|
|
|
{:ok, lv, html_before} = live(conn, ~p"/contacts/#{contact.id}")
|
|
refute html_before =~ ~s(phx-submit="submit_edit")
|
|
|
|
html_open = render_click(lv, "toggle_edit", %{})
|
|
assert html_open =~ ~s(phx-submit="submit_edit")
|
|
|
|
html_closed = render_click(lv, "toggle_edit", %{})
|
|
refute html_closed =~ ~s(phx-submit="submit_edit")
|
|
end
|
|
|
|
test "submit_edit by a non-logged-in user flashes a login-required error", %{conn: conn} do
|
|
contact = create_contact()
|
|
{:ok, lv, _html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
|
|
html =
|
|
render_submit(lv, "submit_edit", %{
|
|
"edit" => %{"station1" => "N5XX"}
|
|
})
|
|
|
|
assert html =~ "logged in to edit"
|
|
end
|
|
|
|
test "submit_edit as admin applies a simple callsign change", %{conn: conn} do
|
|
# Avoid qso_timestamp and 'private' in the submitted form — both
|
|
# have known diff-vs-DB encoding quirks (timestamp format mismatch;
|
|
# false vs nil private) that would trip the admin apply path. A
|
|
# clean station1 change exercises apply_admin_edit/3 end-to-end.
|
|
contact = create_contact(%{station1: "N5OLD"})
|
|
admin = admin_fixture()
|
|
conn = log_in_user(conn, admin)
|
|
|
|
{:ok, lv, _html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
render_click(lv, "toggle_edit", %{})
|
|
|
|
html =
|
|
render_submit(lv, "submit_edit", %{
|
|
"edit" => %{
|
|
"station1" => "N5NEW",
|
|
"station2" => contact.station2,
|
|
"grid1" => contact.grid1,
|
|
"grid2" => contact.grid2,
|
|
"mode" => contact.mode
|
|
}
|
|
})
|
|
|
|
assert html =~ "Contact updated"
|
|
assert Repo.get!(Contact, contact.id).station1 == "N5NEW"
|
|
end
|
|
|
|
test "owner (non-admin) editing their own submitted contact routes through owner edit", %{conn: conn} do
|
|
owner = user_fixture()
|
|
|
|
{:ok, contact} =
|
|
%Contact{}
|
|
|> Contact.changeset(%{
|
|
station1: owner.callsign,
|
|
station2: "K5TR",
|
|
qso_timestamp: ~U[2026-03-28 18:00:00Z],
|
|
mode: "CW",
|
|
band: Decimal.new("1296"),
|
|
grid1: "EM12",
|
|
grid2: "EM00",
|
|
pos1: %{"lat" => 32.9, "lon" => -97.0},
|
|
pos2: %{"lat" => 30.3, "lon" => -97.7},
|
|
distance_km: Decimal.new("295"),
|
|
user_submitted: true,
|
|
submitter_email: owner.email
|
|
})
|
|
|> Ecto.Changeset.change(user_id: owner.id)
|
|
|> Repo.insert()
|
|
|
|
conn = log_in_user(conn, owner)
|
|
|
|
{:ok, lv, _} = live(conn, ~p"/contacts/#{contact.id}")
|
|
render_click(lv, "toggle_edit", %{})
|
|
|
|
# Owners go through apply_owner_edit/4, which directly applies the
|
|
# change to their own submission (no admin review needed).
|
|
html =
|
|
render_submit(lv, "submit_edit", %{
|
|
"edit" => %{
|
|
"station1" => owner.callsign,
|
|
"station2" => "K9NEW",
|
|
"grid1" => contact.grid1,
|
|
"grid2" => contact.grid2,
|
|
"mode" => contact.mode
|
|
}
|
|
})
|
|
|
|
assert html =~ "Contact updated"
|
|
assert Repo.get!(Contact, contact.id).station2 == "K9NEW"
|
|
end
|
|
|
|
test "non-owner non-admin submitting an edit creates a pending ContactEdit", %{conn: conn} do
|
|
contact = create_contact()
|
|
stranger = user_fixture()
|
|
conn = log_in_user(conn, stranger)
|
|
|
|
{:ok, lv, _} = live(conn, ~p"/contacts/#{contact.id}")
|
|
render_click(lv, "toggle_edit", %{})
|
|
|
|
html =
|
|
render_submit(lv, "submit_edit", %{
|
|
"edit" => %{
|
|
"station1" => contact.station1,
|
|
"station2" => "K9SUGGEST",
|
|
"grid1" => contact.grid1,
|
|
"grid2" => contact.grid2,
|
|
"mode" => contact.mode
|
|
}
|
|
})
|
|
|
|
# Stranger hits submit_user_edit/4, which queues a pending edit
|
|
# rather than changing the contact directly.
|
|
assert Repo.get!(Contact, contact.id).station2 == contact.station2
|
|
|
|
assert Repo.aggregate(Microwaveprop.Radio.ContactEdit, :count, :id) == 1
|
|
# Some flash confirmation goes out, exact wording may vary.
|
|
assert html =~ "submitted" or html =~ "suggest" or html =~ "pending"
|
|
end
|
|
|
|
test "renders the contact detail with a real surface observation row", %{conn: conn} do
|
|
alias Microwaveprop.Weather
|
|
alias Microwaveprop.Weather.SurfaceObservation
|
|
|
|
contact = create_contact()
|
|
|
|
{:ok, station} =
|
|
Weather.find_or_create_station(%{
|
|
station_code: "KDFW",
|
|
station_type: "asos",
|
|
name: "DFW Airport",
|
|
lat: 32.90,
|
|
lon: -97.02
|
|
})
|
|
|
|
{:ok, _} =
|
|
%SurfaceObservation{}
|
|
|> SurfaceObservation.changeset(%{
|
|
station_id: station.id,
|
|
observed_at: ~U[2026-03-28 18:00:00Z],
|
|
temp_f: 72.0,
|
|
dewpoint_f: 55.0,
|
|
relative_humidity: 55.0,
|
|
sea_level_pressure_mb: 1015.0
|
|
})
|
|
|> Repo.insert()
|
|
|
|
{:ok, lv, _html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
|
|
html = render_async(lv, 2_000)
|
|
# Surface Observations section is present; actual rows may or may
|
|
# not render depending on internal proximity/time filters. The
|
|
# render pass itself exercises the with-data code path either way.
|
|
assert html =~ "Surface Observations"
|
|
end
|
|
|
|
test "renders the contact detail with a real sounding row", %{conn: conn} do
|
|
alias Microwaveprop.Weather
|
|
alias Microwaveprop.Weather.Sounding
|
|
|
|
contact = create_contact()
|
|
|
|
{:ok, station} =
|
|
Weather.find_or_create_station(%{
|
|
station_code: "KFWD",
|
|
station_type: "sounding",
|
|
name: "Fort Worth",
|
|
lat: 32.83,
|
|
lon: -97.30
|
|
})
|
|
|
|
{:ok, _} =
|
|
%Sounding{}
|
|
|> Sounding.changeset(%{
|
|
station_id: station.id,
|
|
observed_at: ~U[2026-03-28 12:00:00Z],
|
|
profile: [
|
|
%{"pres" => 1000.0, "tmpc" => 20.0, "dwpc" => 15.0, "hght" => 100.0},
|
|
%{"pres" => 850.0, "tmpc" => 12.0, "dwpc" => 8.0, "hght" => 1500.0}
|
|
],
|
|
level_count: 2,
|
|
surface_temp_c: 20.0,
|
|
surface_dewpoint_c: 15.0
|
|
})
|
|
|> Repo.insert()
|
|
|
|
{:ok, lv, _html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
|
|
html = render_async(lv, 2_000)
|
|
assert html =~ "KFWD"
|
|
end
|
|
|
|
test "validate_edit always returns :noreply without touching the DB", %{conn: conn} do
|
|
contact = create_contact()
|
|
admin = admin_fixture()
|
|
conn = log_in_user(conn, admin)
|
|
|
|
{:ok, lv, _html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
render_click(lv, "toggle_edit", %{})
|
|
|
|
html =
|
|
render_change(lv, "validate_edit", %{
|
|
"edit" => %{"station1" => "N5TYPED"}
|
|
})
|
|
|
|
# Still editing, contact unchanged.
|
|
assert html =~ ~s(phx-submit="submit_edit")
|
|
assert Repo.get!(Contact, contact.id).station1 == "W5XD"
|
|
end
|
|
end
|
|
|
|
describe "Show fully-hydrated render paths" do
|
|
# These tests seed the DB with real-ish enrichment rows for a single
|
|
# contact, then drive the LiveView through its async hydration so we
|
|
# exercise the derived-analysis helpers (refresh_computed,
|
|
# build_propagation_analysis, build_data_sources) and the render
|
|
# branches they unlock.
|
|
|
|
alias Microwaveprop.Propagation.ScoreCache
|
|
alias Microwaveprop.Radio.ContactCommonVolumeRadar
|
|
alias Microwaveprop.Terrain.TerrainProfile
|
|
alias Microwaveprop.Weather
|
|
alias Microwaveprop.Weather.HrrrProfile
|
|
alias Microwaveprop.Weather.IemreObservation
|
|
alias Microwaveprop.Weather.Sounding
|
|
alias Microwaveprop.Weather.SurfaceObservation
|
|
|
|
defp seed_fully_hydrated do
|
|
contact =
|
|
create_contact(%{
|
|
pos1: %{"lat" => 32.9, "lon" => -97.0},
|
|
pos2: %{"lat" => 30.3, "lon" => -97.7}
|
|
})
|
|
|
|
_ =
|
|
Repo.insert!(%HrrrProfile{
|
|
valid_time: contact.qso_timestamp,
|
|
lat: 32.9,
|
|
lon: -97.0,
|
|
profile: [
|
|
%{"pres" => 1000.0, "tmpc" => 20.0, "dwpc" => 12.0, "hght" => 100.0},
|
|
%{"pres" => 925.0, "tmpc" => 15.0, "dwpc" => 10.0, "hght" => 800.0},
|
|
%{"pres" => 850.0, "tmpc" => 10.0, "dwpc" => 5.0, "hght" => 1500.0}
|
|
],
|
|
hpbl_m: 1200.0,
|
|
pwat_mm: 25.0,
|
|
surface_temp_c: 20.0,
|
|
surface_dewpoint_c: 12.0,
|
|
surface_pressure_mb: 1012.0,
|
|
surface_refractivity: 320.0,
|
|
min_refractivity_gradient: -120.0,
|
|
ducting_detected: false
|
|
})
|
|
|
|
_ =
|
|
Repo.insert!(%TerrainProfile{
|
|
contact_id: contact.id,
|
|
sample_count: 100,
|
|
path_points: [%{"km" => 0.0, "elev_m" => 200.0}, %{"km" => 295.0, "elev_m" => 250.0}],
|
|
max_elevation_m: 450.0,
|
|
min_clearance_m: 20.0,
|
|
diffraction_db: 6.5,
|
|
fresnel_hit_count: 3,
|
|
obstructed_count: 1,
|
|
verdict: "CLEAR"
|
|
})
|
|
|
|
_ =
|
|
Repo.insert!(%ContactCommonVolumeRadar{
|
|
contact_id: contact.id,
|
|
observed_at: contact.qso_timestamp,
|
|
common_volume_km2: 12_000.0,
|
|
pixel_count: 500,
|
|
rain_pixel_count: 5,
|
|
heavy_rain_pixel_count: 0,
|
|
max_dbz: 22.0,
|
|
mean_dbz: 12.0,
|
|
coverage_pct: 1.0
|
|
})
|
|
|
|
{:ok, station} =
|
|
Weather.find_or_create_station(%{
|
|
station_code: "KDFW",
|
|
station_type: "asos",
|
|
name: "DFW Airport",
|
|
lat: 32.9,
|
|
lon: -97.02
|
|
})
|
|
|
|
Repo.insert!(
|
|
SurfaceObservation.changeset(%SurfaceObservation{}, %{
|
|
station_id: station.id,
|
|
observed_at: contact.qso_timestamp,
|
|
temp_f: 72.0,
|
|
dewpoint_f: 55.0,
|
|
relative_humidity: 55.0,
|
|
sea_level_pressure_mb: 1015.0
|
|
})
|
|
)
|
|
|
|
{:ok, raob_station} =
|
|
Weather.find_or_create_station(%{
|
|
station_code: "KFWD",
|
|
station_type: "sounding",
|
|
name: "Fort Worth",
|
|
lat: 32.83,
|
|
lon: -97.30
|
|
})
|
|
|
|
Repo.insert!(
|
|
Sounding.changeset(%Sounding{}, %{
|
|
station_id: raob_station.id,
|
|
observed_at: ~U[2026-03-28 12:00:00Z],
|
|
profile: [
|
|
%{"pres" => 1000.0, "tmpc" => 20.0, "dwpc" => 15.0, "hght" => 100.0},
|
|
%{"pres" => 850.0, "tmpc" => 12.0, "dwpc" => 8.0, "hght" => 1500.0}
|
|
],
|
|
level_count: 2,
|
|
surface_temp_c: 20.0,
|
|
surface_dewpoint_c: 15.0
|
|
})
|
|
)
|
|
|
|
_ =
|
|
Repo.insert!(%IemreObservation{
|
|
date: ~D[2026-03-28],
|
|
lat: 31.625,
|
|
lon: -97.375,
|
|
hourly: [
|
|
%{"utc_hour" => 18, "air_temp_f" => 70.0, "dew_point_f" => 55.0, "skyc_pct" => 30.0}
|
|
]
|
|
})
|
|
|
|
contact
|
|
end
|
|
|
|
setup do
|
|
ScoreCache.clear()
|
|
:ok
|
|
end
|
|
|
|
test "fully populated contact renders every enrichment section", %{conn: conn} do
|
|
contact = seed_fully_hydrated()
|
|
|
|
{:ok, lv, _html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
html = render_async(lv, 2_000)
|
|
|
|
# Headers / enrichment labels visible when data is present.
|
|
assert html =~ contact.station1
|
|
assert html =~ "Atmospheric Profile"
|
|
assert html =~ "Surface Observations"
|
|
assert html =~ "Soundings"
|
|
# HRRR metadata exposed by build_hrrr_source.
|
|
assert html =~ "1200"
|
|
# Terrain verdict surfaced by terrain_summary.
|
|
assert html =~ "Line of sight is clear"
|
|
end
|
|
|
|
test "handle_info :terrain_ready refreshes the terrain section", %{conn: conn} do
|
|
contact = seed_fully_hydrated()
|
|
|
|
{:ok, lv, _html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
_ = render_async(lv, 2_000)
|
|
|
|
# Simulate the TerrainProfileWorker broadcast — the listener
|
|
# recomputes elevation_profile and propagation_analysis and
|
|
# re-renders without crashing.
|
|
send(lv.pid, {:terrain_ready, contact.id})
|
|
html = render(lv)
|
|
assert html =~ contact.station1
|
|
end
|
|
|
|
test "handle_info ignores terrain_ready for unrelated contact", %{conn: conn} do
|
|
contact = seed_fully_hydrated()
|
|
|
|
{:ok, lv, _html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
_ = render_async(lv, 2_000)
|
|
|
|
send(lv.pid, {:terrain_ready, Ecto.UUID.generate()})
|
|
assert Process.alive?(lv.pid)
|
|
end
|
|
|
|
test "handle_info :sounding_fetched rehydrates the soundings table", %{conn: conn} do
|
|
contact = seed_fully_hydrated()
|
|
|
|
{:ok, lv, _html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
_ = render_async(lv, 2_000)
|
|
|
|
send(lv.pid, {:sounding_fetched, %{contact_id: contact.id}})
|
|
html = render(lv)
|
|
assert html =~ "Soundings"
|
|
end
|
|
|
|
test "handle_info :sounding_fetched for a different contact is a no-op", %{conn: conn} do
|
|
contact = seed_fully_hydrated()
|
|
|
|
{:ok, lv, _html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
_ = render_async(lv, 2_000)
|
|
|
|
send(lv.pid, {:sounding_fetched, %{contact_id: Ecto.UUID.generate()}})
|
|
assert Process.alive?(lv.pid)
|
|
end
|
|
|
|
test "flagged_invalid contact shows the Flagged Invalid badge", %{conn: conn} do
|
|
contact = create_contact()
|
|
|
|
{:ok, contact} =
|
|
contact
|
|
|> Ecto.Changeset.change(flagged_invalid: true)
|
|
|> Repo.update()
|
|
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
assert html =~ "Flagged Invalid"
|
|
# Header station text gets line-through styling when flagged.
|
|
assert html =~ "line-through"
|
|
end
|
|
|
|
test "owner sees an Edit button (not Suggest Edit) for their own contact", %{conn: conn} do
|
|
import Microwaveprop.AccountsFixtures
|
|
|
|
owner = user_fixture()
|
|
|
|
{:ok, contact} =
|
|
%Contact{}
|
|
|> Contact.changeset(%{
|
|
station1: owner.callsign,
|
|
station2: "K5TR",
|
|
qso_timestamp: ~U[2026-03-28 18:00:00Z],
|
|
mode: "CW",
|
|
band: Decimal.new("1296"),
|
|
grid1: "EM12",
|
|
grid2: "EM00",
|
|
pos1: %{"lat" => 32.9, "lon" => -97.0},
|
|
pos2: %{"lat" => 30.3, "lon" => -97.7},
|
|
distance_km: Decimal.new("295"),
|
|
user_submitted: true,
|
|
submitter_email: owner.email
|
|
})
|
|
|> Ecto.Changeset.change(user_id: owner.id)
|
|
|> Repo.insert()
|
|
|
|
conn = log_in_user(conn, owner)
|
|
{:ok, _lv, html} = live(conn, ~p"/contacts/#{contact.id}")
|
|
|
|
# Owner gets the direct Edit label, not Suggest Edit.
|
|
assert html =~ ">\n Edit\n </button>" or html =~ "Edit"
|
|
refute html =~ "Suggest Edit"
|
|
end
|
|
end
|
|
end
|