Add comprehensive LiveView tests and fix two FailuresLive pagination bugs

- Fix reset_all_failures leaving page at stale position: add page reset to 1
- Fix change_page accepting out-of-range values: clamp to current total_pages
- Add total_pages_from_html helper for cleaner pagination assertions

New test coverage:
- rules_live_test: expand 8 → 19 tests; section content, exclusivity, nav buttons,
  atom-injection rejection, multi-step switching
- list_pagination_test: new file, 20 tests for max_page/2 and pagination_label/3
- broadway_live_test: expand 5 → 12 tests; stardate format, timezone changes,
  update_stardate info message handling
- failures_live_test: expand pagination describe to 6 tests; page 1 of 2 display,
  page 2 content, filter page-reset, clamp beyond total, reset_all page-reset

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: mjc

lib/reencodarr_web/live/failures_live.ex

@@ -102,9 +102,10 @@ defmodule ReencodarrWeb.FailuresLive do
     # Reset all failed videos
     Media.reset_failed_videos()
 
-    # Reload the failures data
+    # Reload the failures data, returning to page 1 (avoid stale page state)
     {:noreply,
      socket
+     |> assign(:page, 1)
      |> put_flash(:info, "All failed videos have been reset")
      |> async_load_failures()}
   end
@@ -227,7 +228,8 @@ defmodule ReencodarrWeb.FailuresLive do
 
   @impl true
   def handle_event("change_page", %{"page" => page}, socket) do
-    page = page |> Parsers.parse_int(1) |> max(1)
+    total_pages = max(1, socket.assigns.total_pages)
+    page = page |> Parsers.parse_int(1) |> max(1) |> min(total_pages)
 
     socket =
       socket

test/reencodarr_web/live/broadway_live_test.exs

@@ -20,6 +20,33 @@ defmodule ReencodarrWeb.BroadwayLiveTest do
       assert html =~ "OVERVIEW"
       assert html =~ "FAILURES"
     end
+
+    test "PIPELINE MONITOR is marked as active in navigation", %{conn: conn} do
+      {:ok, _view, html} = live(conn, ~p"/broadway")
+
+      # The page title and active navigation item both contain PIPELINE MONITOR
+      assert html =~ "PIPELINE MONITOR"
+    end
+
+    test "stardate is rendered as a number", %{conn: conn} do
+      {:ok, _view, html} = live(conn, ~p"/broadway")
+
+      # The stardate should appear as a decimal number (e.g. 75234.5)
+      assert html =~ ~r/STARDATE\s+\d+\.\d/
+    end
+
+    test "renders the coming soon message for Broadway content", %{conn: conn} do
+      {:ok, _view, html} = live(conn, ~p"/broadway")
+
+      assert html =~ "Broadway pipeline monitoring interface"
+    end
+
+    test "assigns default UTC timezone on mount", %{conn: conn} do
+      {:ok, view, _html} = live(conn, ~p"/broadway")
+
+      # Default timezone is UTC — verify the page renders without issue
+      assert render(view) =~ "PIPELINE MONITOR"
+    end
   end
 
   describe "set_timezone event" do
@@ -38,5 +65,43 @@ defmodule ReencodarrWeb.BroadwayLiveTest do
 
       assert html =~ "PIPELINE MONITOR"
     end
+
+    test "handles multiple timezone changes in sequence", %{conn: conn} do
+      {:ok, view, _} = live(conn, ~p"/broadway")
+
+      view |> render_click("set_timezone", %{"timezone" => "America/Chicago"})
+      view |> render_click("set_timezone", %{"timezone" => "Europe/London"})
+      html = view |> render_click("set_timezone", %{"timezone" => "Asia/Tokyo"})
+
+      assert html =~ "PIPELINE MONITOR"
+    end
+
+    test "handles empty timezone string without crashing", %{conn: conn} do
+      {:ok, view, _} = live(conn, ~p"/broadway")
+
+      html = view |> render_click("set_timezone", %{"timezone" => ""})
+
+      assert html =~ "PIPELINE MONITOR"
+    end
+  end
+
+  describe "update_stardate message" do
+    test "handles :update_stardate info message without crashing", %{conn: conn} do
+      {:ok, view, _html} = live(conn, ~p"/broadway")
+
+      send(view.pid, :update_stardate)
+
+      html = render(view)
+      assert html =~ "STARDATE"
+    end
+
+    test "stardate is still a number after :update_stardate message", %{conn: conn} do
+      {:ok, view, _html} = live(conn, ~p"/broadway")
+
+      send(view.pid, :update_stardate)
+
+      html = render(view)
+      assert html =~ ~r/STARDATE\s+\d+\.\d/
+    end
   end
 end

test/reencodarr_web/live/failures_live_test.exs

@@ -26,6 +26,16 @@ defmodule ReencodarrWeb.FailuresLiveTest do
     end
   end
 
+  defp total_pages_from_html(html) do
+    case Regex.run(
+           ~r/of\s*<span class="font-medium text-white">(\d+)<\/span>/,
+           html
+         ) do
+      [_, total] -> String.to_integer(total)
+      _ -> nil
+    end
+  end
+
   # ---------------------------------------------------------------------------
   # Mount / basic render
   # ---------------------------------------------------------------------------
@@ -407,5 +417,116 @@ defmodule ReencodarrWeb.FailuresLiveTest do
 
       assert current_page_from_html(html) == 1
     end
+
+    test "shows Page 1 of 2 with 21 failures at per_page 20", %{conn: conn} do
+      Enum.each(1..21, fn n ->
+        {:ok, video} = Fixtures.video_fixture(%{path: "/media/paginate_#{n}.mkv"})
+        Media.record_video_failure(video, :encoding, :timeout, message: "p #{n}")
+      end)
+
+      {:ok, view, _} = live(conn, ~p"/failures")
+      html = loaded_html(view)
+
+      assert current_page_from_html(html) == 1
+      assert total_pages_from_html(html) == 2
+    end
+
+    test "navigating to page 2 shows the 21st failure", %{conn: conn} do
+      {:ok, first_video} = Fixtures.video_fixture(%{path: "/media/first_on_page_one.mkv"})
+      Media.record_video_failure(first_video, :encoding, :timeout, message: "first")
+
+      Enum.each(2..20, fn n ->
+        {:ok, v} = Fixtures.video_fixture(%{path: "/media/filler_#{n}.mkv"})
+        Media.record_video_failure(v, :encoding, :timeout, message: "filler #{n}")
+      end)
+
+      {:ok, last_video} = Fixtures.video_fixture(%{path: "/media/last_on_page_two.mkv"})
+      Media.record_video_failure(last_video, :encoding, :timeout, message: "last")
+
+      {:ok, view, _} = live(conn, ~p"/failures")
+      loaded_html(view)
+
+      view
+      |> element("button[phx-click='change_page'][title='Next page']")
+      |> render_click()
+
+      html = render_async(view)
+
+      assert current_page_from_html(html) == 2
+      assert html =~ "last_on_page_two"
+      refute html =~ "first_on_page_one"
+    end
+
+    test "filter resets page to 1 when on page 2", %{conn: conn} do
+      Enum.each(1..21, fn n ->
+        {:ok, video} = Fixtures.video_fixture(%{path: "/media/filter_reset_#{n}.mkv"})
+        Media.record_video_failure(video, :encoding, :timeout, message: "filter #{n}")
+      end)
+
+      {:ok, view, _} = live(conn, ~p"/failures")
+      loaded_html(view)
+
+      view
+      |> element("button[phx-click='change_page'][title='Next page']")
+      |> render_click()
+
+      render_async(view)
+
+      view
+      |> element("button[phx-click='filter_failures'][phx-value-filter='encoding']")
+      |> render_click()
+
+      html = render_async(view)
+
+      assert current_page_from_html(html) == 1
+    end
+
+    test "change_page clamps to total_pages when page exceeds total", %{conn: conn} do
+      Enum.each(1..21, fn n ->
+        {:ok, video} = Fixtures.video_fixture(%{path: "/media/clamp_#{n}.mkv"})
+        Media.record_video_failure(video, :encoding, :timeout, message: "clamp #{n}")
+      end)
+
+      {:ok, view, _} = live(conn, ~p"/failures")
+      loaded_html(view)
+
+      render_click(view, "change_page", %{"page" => "999"})
+      html = render_async(view)
+
+      # page should be clamped to total_pages (2), not left at 999
+      assert current_page_from_html(html) == 2
+    end
+
+    test "reset_all_failures resets page to 1", %{conn: conn} do
+      Enum.each(1..21, fn n ->
+        {:ok, video} = Fixtures.video_fixture(%{path: "/media/reset_page_#{n}.mkv"})
+        Media.record_video_failure(video, :encoding, :timeout, message: "reset #{n}")
+      end)
+
+      {:ok, view, _} = live(conn, ~p"/failures")
+      loaded_html(view)
+
+      view
+      |> element("button[phx-click='change_page'][title='Next page']")
+      |> render_click()
+
+      render_async(view)
+
+      view
+      |> element("button[phx-click='reset_all_failures']")
+      |> render_click()
+
+      render_async(view)
+
+      # Add a new failure after the reset — it will land on page 1
+      {:ok, new_video} = Fixtures.video_fixture(%{path: "/media/new_after_reset.mkv"})
+      Media.record_video_failure(new_video, :encoding, :timeout, message: "after reset")
+
+      send(view.pid, :update_failures_data)
+      html = render_async(view)
+
+      # If page was not reset to 1, we'd be on page 2 and the new failure would be invisible
+      assert html =~ "new_after_reset"
+    end
   end
 end

test/reencodarr_web/live/list_pagination_test.exs

@@ -0,0 +1,111 @@
+defmodule ReencodarrWeb.Live.ListPaginationTest do
+  @moduledoc """
+  Tests for the ListPagination helper module.
+  """
+  use ExUnit.Case, async: true
+
+  alias ReencodarrWeb.Live.ListPagination
+
+  describe "max_page/2" do
+    test "returns 1 for zero total items" do
+      assert ListPagination.max_page(0, 10) == 1
+    end
+
+    test "returns 1 when items fit in one page" do
+      assert ListPagination.max_page(10, 10) == 1
+    end
+
+    test "returns 1 for fewer items than per_page" do
+      assert ListPagination.max_page(5, 10) == 1
+    end
+
+    test "returns 2 when one item overflows to second page" do
+      assert ListPagination.max_page(11, 10) == 2
+    end
+
+    test "returns 2 when items fill exactly two pages" do
+      assert ListPagination.max_page(20, 10) == 2
+    end
+
+    test "returns 3 when one item overflows to third page" do
+      assert ListPagination.max_page(21, 10) == 3
+    end
+
+    test "returns correct page count for large datasets" do
+      assert ListPagination.max_page(100, 10) == 10
+      assert ListPagination.max_page(250, 50) == 5
+      assert ListPagination.max_page(1000, 25) == 40
+    end
+
+    test "always returns at least 1 even with 0 items" do
+      assert ListPagination.max_page(0, 1) >= 1
+      assert ListPagination.max_page(0, 100) >= 1
+    end
+
+    test "handles single item per page" do
+      assert ListPagination.max_page(1, 1) == 1
+      assert ListPagination.max_page(5, 1) == 5
+      assert ListPagination.max_page(10, 1) == 10
+    end
+
+    test "result is always a positive integer" do
+      for total <- [0, 1, 5, 10, 100, 999],
+          per_page <- [1, 10, 25, 50, 100] do
+        result = ListPagination.max_page(total, per_page)
+        assert is_integer(result), "Expected integer for max_page(#{total}, #{per_page})"
+        assert result >= 1, "Expected >= 1 for max_page(#{total}, #{per_page})"
+      end
+    end
+  end
+
+  describe "pagination_label/3" do
+    test "returns '0 results' when total is 0" do
+      assert ListPagination.pagination_label(1, 10, 0) == "0 results"
+    end
+
+    test "returns range for first page with full page of items" do
+      assert ListPagination.pagination_label(1, 10, 10) == "1-10 of 10"
+    end
+
+    test "returns range for first page with partial items" do
+      assert ListPagination.pagination_label(1, 10, 5) == "1-5 of 5"
+    end
+
+    test "returns correct range for second page" do
+      assert ListPagination.pagination_label(2, 10, 15) == "11-15 of 15"
+    end
+
+    test "returns correct range for second full page" do
+      assert ListPagination.pagination_label(2, 10, 20) == "11-20 of 20"
+    end
+
+    test "last page with partial items shows correct range" do
+      assert ListPagination.pagination_label(3, 10, 25) == "21-25 of 25"
+    end
+
+    test "first item on a page is always (page-1)*per_page + 1" do
+      # Page 1: first = 1
+      assert ListPagination.pagination_label(1, 25, 30) =~ "1-"
+      # Page 2: first = 26
+      assert ListPagination.pagination_label(2, 25, 30) =~ "26-"
+    end
+
+    test "total is always shown correctly after 'of'" do
+      assert ListPagination.pagination_label(1, 10, 42) =~ "of 42"
+      assert ListPagination.pagination_label(2, 10, 42) =~ "of 42"
+    end
+
+    test "last item does not exceed total" do
+      # Page 5, per_page 10, total 42 → should show 41-42 not 41-50
+      assert ListPagination.pagination_label(5, 10, 42) == "41-42 of 42"
+    end
+
+    test "with per_page=20 defaults as in failures_live" do
+      # Matches FailuresLive @per_page default
+      assert ListPagination.pagination_label(1, 20, 0) == "0 results"
+      assert ListPagination.pagination_label(1, 20, 15) == "1-15 of 15"
+      assert ListPagination.pagination_label(1, 20, 20) == "1-20 of 20"
+      assert ListPagination.pagination_label(2, 20, 25) == "21-25 of 25"
+    end
+  end
+end