+ attr :videos, :list, required: true
+ attr :selected, MapSet, required: true
+ attr :select_count, :integer, required: true
+ attr :sort_by, :atom, required: true
+ attr :sort_dir, :atom, required: true
+ attr :expanded_bad_forms, :list, required: true
+
+ defp videos_table(assigns) do
+ ~H"""
+
+ """
+ end
+
+ attr :video, :map, required: true
+ attr :selected, MapSet, required: true
+ attr :expanded_bad_forms, :list, required: true
-
-
-
{pagination_label(@page, @per_page, @total)}
-
-
- Previous
-
- {@page} / {@max_page}
- = @max_page}
- class="px-3 py-1 bg-gray-700 rounded text-gray-300 hover:bg-gray-600 disabled:opacity-40 disabled:cursor-not-allowed"
- >
- Next
-
-
+ defp video_row(assigns) do
+ ~H"""
+
+
+
+
+ {Path.basename(@video.path)}
+ <%= if @video.title do %>
+
+ {@video.title}
+ <%= if @video.content_year do %>
+ ({@video.content_year})
+ <% end %>
<% end %>
-
+
+ {Path.basename(Path.dirname(@video.path))}
+ {format_resolution(@video.width, @video.height)}
+ {format_bitrate(@video.bitrate)}
+ {service_display(@video.service_type)}
+ <%= if @video.hdr do %>
+ <.hdr_badge hdr={@video.hdr} />
+ <% end %>
+ <%= if @video.original_size && @video.size do %>
+ <.space_saved_badge original_size={@video.original_size} current_size={@video.size} />
+ <% end %>
+
+
+
+
+ {@video.state}
+
+
+ {format_size(@video.size)}
+
+ {format_datetime(@video.updated_at)}
+
+
+ <.video_actions video={@video} />
+ <.mark_bad_form :if={@video.id in @expanded_bad_forms} video={@video} />
+
+
+ """
+ end
+
+ attr :video, :map, required: true
+
+ defp video_actions(assigns) do
+ ~H"""
+
+ <%= if queueable_video?(@video) do %>
+
+ prioritize
+
+ <% end %>
+ <%= if queueable_video?(@video) and season_directory(@video.path) do %>
+
+ prioritize season
+
+ <% end %>
+ <%= if fail_action_video?(@video) do %>
+
+ x
+
+ <% end %>
+
+ scan
+
+ <%= if @video.state in [:failed, :encoded, :crf_searched, :analyzed] do %>
+
+ reset
+
+ <% end %>
+
+ mark bad
+
+
+ del
+
"""
end
- # ---------------------------------------------------------------------------
- # Components
- # ---------------------------------------------------------------------------
+ attr :video, :map, required: true
+
+ defp mark_bad_form(assigns) do
+ ~H"""
+
+ """
+ end
attr :col, :atom, required: true
attr :label, :string, required: true
diff --git a/mix.lock b/mix.lock
index 2402b686..d2b7e2a0 100644
--- a/mix.lock
+++ b/mix.lock
@@ -56,10 +56,10 @@
"phoenix_html": {:hex, :phoenix_html, "4.3.0", "d3577a5df4b6954cd7890c84d955c470b5310bb49647f0a114a6eeecc850f7ad", [:mix], [], "hexpm", "3eaa290a78bab0f075f791a46a981bbe769d94bc776869f4f3063a14f30497ad"},
"phoenix_live_dashboard": {:hex, :phoenix_live_dashboard, "0.8.7", "405880012cb4b706f26dd1c6349125bfc903fb9e44d1ea668adaf4e04d4884b7", [:mix], [{:ecto, "~> 3.6.2 or ~> 3.7", [hex: :ecto, repo: "hexpm", optional: true]}, {:ecto_mysql_extras, "~> 0.5", [hex: :ecto_mysql_extras, repo: "hexpm", optional: true]}, {:ecto_psql_extras, "~> 0.7", [hex: :ecto_psql_extras, repo: "hexpm", optional: true]}, {:ecto_sqlite3_extras, "~> 1.1.7 or ~> 1.2.0", [hex: :ecto_sqlite3_extras, repo: "hexpm", optional: true]}, {:mime, "~> 1.6 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:phoenix_live_view, "~> 0.19 or ~> 1.0", [hex: :phoenix_live_view, repo: "hexpm", optional: false]}, {:telemetry_metrics, "~> 0.6 or ~> 1.0", [hex: :telemetry_metrics, repo: "hexpm", optional: false]}], "hexpm", "3a8625cab39ec261d48a13b7468dc619c0ede099601b084e343968309bd4d7d7"},
"phoenix_live_reload": {:hex, :phoenix_live_reload, "1.6.2", "b18b0773a1ba77f28c52decbb0f10fd1ac4d3ae5b8632399bbf6986e3b665f62", [:mix], [{:file_system, "~> 0.2.10 or ~> 1.0", [hex: :file_system, repo: "hexpm", optional: false]}, {:phoenix, "~> 1.4", [hex: :phoenix, repo: "hexpm", optional: false]}], "hexpm", "d1f89c18114c50d394721365ffb428cce24f1c13de0467ffa773e2ff4a30d5b9"},
- "phoenix_live_view": {:hex, :phoenix_live_view, "1.2.1", "39db357b4293e168a62c43128354df4be0ad8bcb5aadacf403c0d9526b076f5a", [:mix], [{:igniter, ">= 0.6.16 and < 1.0.0-0", [hex: :igniter, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:lazy_html, "~> 0.1.0", [hex: :lazy_html, repo: "hexpm", optional: true]}, {:phoenix, "~> 1.6.15 or ~> 1.7.0 or ~> 1.8.0", [hex: :phoenix, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 3.3 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:plug, "~> 1.15", [hex: :plug, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "7ddd6e85a828f08666aea23bdc3a81b1773cd16a94eee459a41bafb18c5a069f"},
+ "phoenix_live_view": {:hex, :phoenix_live_view, "1.2.4", "804d80c4672f35bafc2bc461676179e1c37327512471267e1ed970344066956e", [:mix], [{:igniter, ">= 0.6.16 and < 1.0.0-0", [hex: :igniter, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:lazy_html, "~> 0.1.0", [hex: :lazy_html, repo: "hexpm", optional: true]}, {:phoenix, "~> 1.6.15 or ~> 1.7.0 or ~> 1.8.0", [hex: :phoenix, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 3.3 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:plug, "~> 1.15", [hex: :plug, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "d6a93564e4680edd78bf1a0dba27b08e32f4fe2ccbaf82b66eadeba0be956e39"},
"phoenix_pubsub": {:hex, :phoenix_pubsub, "2.2.0", "ff3a5616e1bed6804de7773b92cbccfc0b0f473faf1f63d7daf1206c7aeaaa6f", [:mix], [], "hexpm", "adc313a5bf7136039f63cfd9668fde73bba0765e0614cba80c06ac9460ff3e96"},
"phoenix_template": {:hex, :phoenix_template, "1.0.4", "e2092c132f3b5e5b2d49c96695342eb36d0ed514c5b252a77048d5969330d639", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}], "hexpm", "2c0c81f0e5c6753faf5cca2f229c9709919aba34fab866d3bc05060c9c444206"},
- "plug": {:hex, :plug, "1.19.2", "e4950525b22c6789dfb38a3f95d47171ba159da3fc5a33be9643b43d5e8adb98", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "b6fce20a56af5e60fa5dfecf3f907bb98ec981be43c79a3809a499bc3d133de0"},
+ "plug": {:hex, :plug, "1.20.1", "82cdee1d7535d4f4db5c5602a7fd49512d64690be54fd62374856ee70e62eb29", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "892d2a1a7a3f5368c5a3b9067bba1050c031495f48c430ec00b09691dbf211b7"},
"plug_crypto": {:hex, :plug_crypto, "2.1.1", "19bda8184399cb24afa10be734f84a16ea0a2bc65054e23a62bb10f06bc89491", [:mix], [], "hexpm", "6470bce6ffe41c8bd497612ffde1a7e4af67f36a15eea5f921af71cf3e11247c"},
"req": {:hex, :req, "0.6.1", "7b904c8b42d0e08136a5c6aba024fd12fc79a1ed8856e7a3522b0917f7e75113", [:mix], [{:brotli, "~> 0.3.1", [hex: :brotli, repo: "hexpm", optional: true]}, {:ezstd, "~> 1.0", [hex: :ezstd, repo: "hexpm", optional: true]}, {:finch, "~> 0.21.0 or ~> 0.22.0", [hex: :finch, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mime, "~> 2.0.6 or ~> 2.1", [hex: :mime, repo: "hexpm", optional: false]}, {:nimble_csv, "~> 1.0", [hex: :nimble_csv, repo: "hexpm", optional: true]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "aaf11c9c80f2df2364630b3594e1857fe610d8ea7cb994e1ce3dcb55f204ff1c"},
"req_fuse": {:hex, :req_fuse, "0.3.2", "8f96b26527deefe3d128496c058a23014754a569d12d281905d4c9e56bc3bae2", [:mix], [{:fuse, ">= 2.4.0", [hex: :fuse, repo: "hexpm", optional: false]}, {:req, ">= 0.4.14", [hex: :req, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "55cf642c03f10aed0dc4f97adc10f0985b355b377d2bc32bb0c569d82f3aa07e"},
diff --git a/priv/repo/migrations/20260630131500_add_list_page_filter_indexes.exs b/priv/repo/migrations/20260630131500_add_list_page_filter_indexes.exs
new file mode 100644
index 00000000..e0f4f866
--- /dev/null
+++ b/priv/repo/migrations/20260630131500_add_list_page_filter_indexes.exs
@@ -0,0 +1,273 @@
+defmodule Reencodarr.Repo.Migrations.AddListPageFilterIndexes do
+ use Ecto.Migration
+
+ def up do
+ execute """
+ CREATE VIRTUAL TABLE IF NOT EXISTS bad_file_issues_search USING fts5(
+ issue_kind,
+ classification,
+ manual_reason,
+ manual_note,
+ tokenize = 'unicode61 remove_diacritics 2'
+ )
+ """
+
+ execute """
+ INSERT INTO bad_file_issues_search(rowid, issue_kind, classification, manual_reason, manual_note)
+ SELECT id,
+ COALESCE(issue_kind, ''),
+ COALESCE(classification, ''),
+ COALESCE(manual_reason, ''),
+ COALESCE(manual_note, '')
+ FROM bad_file_issues
+ WHERE id NOT IN (SELECT rowid FROM bad_file_issues_search)
+ """
+
+ execute """
+ CREATE TRIGGER IF NOT EXISTS bad_file_issues_search_insert
+ AFTER INSERT ON bad_file_issues
+ BEGIN
+ INSERT INTO bad_file_issues_search(rowid, issue_kind, classification, manual_reason, manual_note)
+ VALUES (
+ NEW.id,
+ COALESCE(NEW.issue_kind, ''),
+ COALESCE(NEW.classification, ''),
+ COALESCE(NEW.manual_reason, ''),
+ COALESCE(NEW.manual_note, '')
+ );
+ END;
+ """
+
+ execute """
+ CREATE TRIGGER IF NOT EXISTS bad_file_issues_search_delete
+ AFTER DELETE ON bad_file_issues
+ BEGIN
+ DELETE FROM bad_file_issues_search WHERE rowid = OLD.id;
+ END;
+ """
+
+ execute """
+ CREATE TRIGGER IF NOT EXISTS bad_file_issues_search_update
+ AFTER UPDATE ON bad_file_issues
+ BEGIN
+ DELETE FROM bad_file_issues_search WHERE rowid = OLD.id;
+ INSERT INTO bad_file_issues_search(rowid, issue_kind, classification, manual_reason, manual_note)
+ VALUES (
+ NEW.id,
+ COALESCE(NEW.issue_kind, ''),
+ COALESCE(NEW.classification, ''),
+ COALESCE(NEW.manual_reason, ''),
+ COALESCE(NEW.manual_note, '')
+ );
+ END;
+ """
+
+ execute """
+ CREATE VIRTUAL TABLE IF NOT EXISTS video_failures_search USING fts5(
+ video_id UNINDEXED,
+ failure_code,
+ failure_message,
+ tokenize = 'unicode61 remove_diacritics 2'
+ )
+ """
+
+ execute """
+ INSERT INTO video_failures_search(rowid, video_id, failure_code, failure_message)
+ SELECT id,
+ video_id,
+ COALESCE(failure_code, ''),
+ COALESCE(failure_message, '')
+ FROM video_failures
+ WHERE id NOT IN (SELECT rowid FROM video_failures_search)
+ """
+
+ execute """
+ CREATE TRIGGER IF NOT EXISTS video_failures_search_insert
+ AFTER INSERT ON video_failures
+ BEGIN
+ INSERT INTO video_failures_search(rowid, video_id, failure_code, failure_message)
+ VALUES (
+ NEW.id,
+ NEW.video_id,
+ COALESCE(NEW.failure_code, ''),
+ COALESCE(NEW.failure_message, '')
+ );
+ END;
+ """
+
+ execute """
+ CREATE TRIGGER IF NOT EXISTS video_failures_search_delete
+ AFTER DELETE ON video_failures
+ BEGIN
+ DELETE FROM video_failures_search WHERE rowid = OLD.id;
+ END;
+ """
+
+ execute """
+ CREATE TRIGGER IF NOT EXISTS video_failures_search_update
+ AFTER UPDATE ON video_failures
+ BEGIN
+ DELETE FROM video_failures_search WHERE rowid = OLD.id;
+ INSERT INTO video_failures_search(rowid, video_id, failure_code, failure_message)
+ VALUES (
+ NEW.id,
+ NEW.video_id,
+ COALESCE(NEW.failure_code, ''),
+ COALESCE(NEW.failure_message, '')
+ );
+ END;
+ """
+
+ execute """
+ CREATE INDEX IF NOT EXISTS videos_service_updated_at_desc_index
+ ON videos(service_type, updated_at DESC, id DESC)
+ WHERE service_type IS NOT NULL
+ """
+
+ execute """
+ CREATE INDEX IF NOT EXISTS videos_state_service_updated_at_desc_index
+ ON videos(state, service_type, updated_at DESC, id DESC)
+ WHERE service_type IS NOT NULL
+ """
+
+ execute """
+ CREATE INDEX IF NOT EXISTS videos_sdr_updated_at_desc_index
+ ON videos(updated_at DESC, id DESC)
+ WHERE hdr IS NULL
+ """
+
+ execute """
+ CREATE INDEX IF NOT EXISTS videos_hdr_updated_at_desc_index
+ ON videos(updated_at DESC, id DESC)
+ WHERE hdr IS NOT NULL
+ """
+
+ execute """
+ CREATE INDEX IF NOT EXISTS videos_state_sdr_updated_at_desc_index
+ ON videos(state, updated_at DESC, id DESC)
+ WHERE hdr IS NULL
+ """
+
+ execute """
+ CREATE INDEX IF NOT EXISTS videos_state_hdr_updated_at_desc_index
+ ON videos(state, updated_at DESC, id DESC)
+ WHERE hdr IS NOT NULL
+ """
+
+ execute """
+ CREATE INDEX IF NOT EXISTS videos_service_sdr_updated_at_desc_index
+ ON videos(service_type, updated_at DESC, id DESC)
+ WHERE hdr IS NULL
+ """
+
+ execute """
+ CREATE INDEX IF NOT EXISTS videos_service_hdr_updated_at_desc_index
+ ON videos(service_type, updated_at DESC, id DESC)
+ WHERE hdr IS NOT NULL
+ """
+
+ execute """
+ CREATE INDEX IF NOT EXISTS videos_state_service_sdr_updated_at_desc_index
+ ON videos(state, service_type, updated_at DESC, id DESC)
+ WHERE hdr IS NULL
+ """
+
+ execute """
+ CREATE INDEX IF NOT EXISTS videos_state_service_hdr_updated_at_desc_index
+ ON videos(state, service_type, updated_at DESC, id DESC)
+ WHERE hdr IS NOT NULL
+ """
+
+ execute """
+ CREATE INDEX IF NOT EXISTS videos_path_sort_index
+ ON videos(path, id)
+ """
+
+ execute """
+ CREATE INDEX IF NOT EXISTS videos_size_sort_index
+ ON videos(size, id)
+ """
+
+ execute """
+ CREATE INDEX IF NOT EXISTS videos_width_sort_index
+ ON videos(width, id)
+ WHERE width IS NOT NULL
+ """
+
+ execute """
+ CREATE INDEX IF NOT EXISTS videos_bitrate_sort_index
+ ON videos(bitrate, id)
+ WHERE bitrate IS NOT NULL
+ """
+
+ execute """
+ CREATE INDEX IF NOT EXISTS bad_file_issues_status_kind_updated_at_desc_index
+ ON bad_file_issues(status, issue_kind, updated_at DESC, id DESC)
+ """
+
+ execute """
+ CREATE INDEX IF NOT EXISTS bad_file_issues_resolved_status_kind_updated_at_index
+ ON bad_file_issues(status, issue_kind, updated_at DESC, id ASC)
+ """
+
+ execute """
+ CREATE INDEX IF NOT EXISTS bad_file_issues_status_inserted_at_index
+ ON bad_file_issues(status, inserted_at ASC, id ASC, video_id)
+ """
+
+ execute """
+ CREATE INDEX IF NOT EXISTS bad_file_issues_video_status_updated_at_desc_index
+ ON bad_file_issues(video_id, status, updated_at DESC, id DESC)
+ """
+
+ execute """
+ CREATE INDEX IF NOT EXISTS video_failures_unresolved_filter_video_index
+ ON video_failures(resolved, failure_stage, failure_category, video_id)
+ WHERE resolved = 0
+ """
+
+ execute """
+ CREATE INDEX IF NOT EXISTS video_failures_video_unresolved_filter_recent_index
+ ON video_failures(video_id, resolved, failure_stage, failure_category, inserted_at DESC)
+ WHERE resolved = 0
+ """
+
+ execute """
+ CREATE INDEX IF NOT EXISTS videos_failed_updated_at_desc_index
+ ON videos(updated_at DESC, id DESC)
+ WHERE state = 'failed'
+ """
+ end
+
+ def down do
+ execute "DROP TRIGGER IF EXISTS video_failures_search_update"
+ execute "DROP TRIGGER IF EXISTS video_failures_search_delete"
+ execute "DROP TRIGGER IF EXISTS video_failures_search_insert"
+ execute "DROP TABLE IF EXISTS video_failures_search"
+ execute "DROP TRIGGER IF EXISTS bad_file_issues_search_update"
+ execute "DROP TRIGGER IF EXISTS bad_file_issues_search_delete"
+ execute "DROP TRIGGER IF EXISTS bad_file_issues_search_insert"
+ execute "DROP TABLE IF EXISTS bad_file_issues_search"
+ execute "DROP INDEX IF EXISTS videos_failed_updated_at_desc_index"
+ execute "DROP INDEX IF EXISTS video_failures_video_unresolved_filter_recent_index"
+ execute "DROP INDEX IF EXISTS video_failures_unresolved_filter_video_index"
+ execute "DROP INDEX IF EXISTS bad_file_issues_video_status_updated_at_desc_index"
+ execute "DROP INDEX IF EXISTS bad_file_issues_status_inserted_at_index"
+ execute "DROP INDEX IF EXISTS bad_file_issues_resolved_status_kind_updated_at_index"
+ execute "DROP INDEX IF EXISTS bad_file_issues_status_kind_updated_at_desc_index"
+ execute "DROP INDEX IF EXISTS videos_bitrate_sort_index"
+ execute "DROP INDEX IF EXISTS videos_width_sort_index"
+ execute "DROP INDEX IF EXISTS videos_size_sort_index"
+ execute "DROP INDEX IF EXISTS videos_path_sort_index"
+ execute "DROP INDEX IF EXISTS videos_state_service_hdr_updated_at_desc_index"
+ execute "DROP INDEX IF EXISTS videos_state_service_sdr_updated_at_desc_index"
+ execute "DROP INDEX IF EXISTS videos_service_hdr_updated_at_desc_index"
+ execute "DROP INDEX IF EXISTS videos_service_sdr_updated_at_desc_index"
+ execute "DROP INDEX IF EXISTS videos_state_hdr_updated_at_desc_index"
+ execute "DROP INDEX IF EXISTS videos_state_sdr_updated_at_desc_index"
+ execute "DROP INDEX IF EXISTS videos_hdr_updated_at_desc_index"
+ execute "DROP INDEX IF EXISTS videos_sdr_updated_at_desc_index"
+ execute "DROP INDEX IF EXISTS videos_state_service_updated_at_desc_index"
+ execute "DROP INDEX IF EXISTS videos_service_updated_at_desc_index"
+ end
+end
diff --git a/test/reencodarr/bad_file_issue_test.exs b/test/reencodarr/bad_file_issue_test.exs
index 07aa3bde..174bb71f 100644
--- a/test/reencodarr/bad_file_issue_test.exs
+++ b/test/reencodarr/bad_file_issue_test.exs
@@ -86,7 +86,8 @@ defmodule Reencodarr.BadFileIssueTest do
assert first_issue.id == second_issue.id
assert second_issue.manual_reason == "updated"
assert second_issue.manual_note == "reproduces consistently"
- assert Enum.count(Media.list_bad_file_issues()) == 1
+ {issues, _} = Media.list_bad_file_issues(%{"page_size" => "250"})
+ assert Enum.count(issues) == 1
end
end
diff --git a/test/reencodarr/bad_files_state_test.exs b/test/reencodarr/bad_files_state_test.exs
index 2f197db2..dcff36d4 100644
--- a/test/reencodarr/bad_files_state_test.exs
+++ b/test/reencodarr/bad_files_state_test.exs
@@ -32,4 +32,134 @@ defmodule Reencodarr.BadFiles.StateTest do
assert is_map(payload.issue_summary)
assert payload.tracked_count >= 1
end
+
+ test "resolved filter loads resolved issues even when show_resolved is false" do
+ {:ok, video} = Fixtures.video_fixture(%{path: "/media/resolved_filter_payload.mkv"})
+
+ {:ok, issue} =
+ Media.create_bad_file_issue(video, %{
+ origin: :manual,
+ issue_kind: :manual,
+ classification: :manual_bad,
+ manual_reason: "resolved filter"
+ })
+
+ {:ok, _issue} = Media.dismiss_bad_file_issue(issue)
+
+ payload =
+ State.load(%{
+ page: 1,
+ per_page: 50,
+ status_filter: "resolved",
+ service_filter: "all",
+ kind_filter: "all",
+ search_query: "resolved_filter_payload",
+ show_resolved: false
+ })
+
+ assert Enum.any?(payload.active_issues, &(&1.video_id == video.id))
+ assert Enum.any?(payload.issues, &(&1.video_id == video.id))
+ assert payload.resolved_issues == []
+ assert payload.meta.total_count == 1
+ end
+
+ test "resolved filter is a paginated primary list" do
+ Enum.each(1..26, fn n ->
+ {:ok, video} = Fixtures.video_fixture(%{path: "/media/resolved_page_#{n}.mkv"})
+
+ {:ok, issue} =
+ Media.create_bad_file_issue(video, %{
+ origin: :manual,
+ issue_kind: :manual,
+ classification: :manual_bad,
+ manual_reason: "resolved page"
+ })
+
+ {:ok, _issue} = Media.dismiss_bad_file_issue(issue)
+ end)
+
+ payload =
+ State.load(%{
+ page: 2,
+ per_page: 25,
+ status_filter: "resolved",
+ service_filter: "all",
+ kind_filter: "all",
+ search_query: "resolved_page",
+ show_resolved: false
+ })
+
+ assert payload.meta.total_count == 26
+ assert payload.meta.current_page == 2
+ assert Enum.map(payload.active_issues, & &1.video.path) == ["/media/resolved_page_26.mkv"]
+ assert payload.resolved_issues == []
+ end
+
+ test "list_active_issues returns all matching pages for bulk actions" do
+ Enum.each(1..251, fn n ->
+ {:ok, video} = Fixtures.video_fixture(%{path: "/media/bulk_filtered_#{n}.mkv"})
+
+ {:ok, _issue} =
+ Media.create_bad_file_issue(video, %{
+ origin: :manual,
+ issue_kind: :manual,
+ classification: :manual_bad,
+ manual_reason: "bulk filtered"
+ })
+ end)
+
+ issues =
+ State.list_active_issues(%{
+ page: 1,
+ per_page: 50,
+ status_filter: "all",
+ service_filter: "all",
+ kind_filter: "all",
+ search_query: "bulk_filtered",
+ show_resolved: false
+ })
+
+ assert Enum.count(issues) == 251
+ end
+
+ test "replacement_issues includes matching replacement issues outside current page" do
+ Enum.each(1..25, fn n ->
+ {:ok, video} = Fixtures.video_fixture(%{path: "/media/replacement_page_open_#{n}.mkv"})
+
+ {:ok, _issue} =
+ Media.create_bad_file_issue(video, %{
+ origin: :manual,
+ issue_kind: :manual,
+ classification: :manual_bad,
+ manual_reason: "replacement page"
+ })
+ end)
+
+ {:ok, replacement_video} =
+ Fixtures.video_fixture(%{path: "/media/replacement_page_waiting.mkv"})
+
+ {:ok, issue} =
+ Media.create_bad_file_issue(replacement_video, %{
+ origin: :manual,
+ issue_kind: :manual,
+ classification: :manual_bad,
+ manual_reason: "replacement page"
+ })
+
+ {:ok, issue} = Media.update_bad_file_issue_status(issue, :waiting_for_replacement)
+
+ payload =
+ State.load(%{
+ page: 1,
+ per_page: 25,
+ status_filter: "open",
+ service_filter: "all",
+ kind_filter: "all",
+ search_query: "replacement_page",
+ show_resolved: false
+ })
+
+ refute Enum.any?(payload.issues, &(&1.id == issue.id))
+ assert Enum.any?(payload.replacement_issues, &(&1.id == issue.id))
+ end
end
diff --git a/test/reencodarr/flop_fixtures_test.exs b/test/reencodarr/flop_fixtures_test.exs
new file mode 100644
index 00000000..d521919a
--- /dev/null
+++ b/test/reencodarr/flop_fixtures_test.exs
@@ -0,0 +1,37 @@
+defmodule Reencodarr.FlopFixturesTest do
+ use ExUnit.Case, async: true
+
+ alias Reencodarr.FlopFixtures
+ alias Reencodarr.Media.Video
+
+ test "meta_fixture/1 defaults to empty first page" do
+ meta = FlopFixtures.meta_fixture()
+
+ assert meta.schema == Video
+ assert meta.current_page == 1
+ assert meta.page_size == 20
+ assert meta.total_count == 0
+ assert meta.total_pages == 0
+ refute meta.has_next_page?
+ refute meta.has_previous_page?
+ end
+
+ test "meta_fixture/1 builds multi-page meta" do
+ meta = FlopFixtures.meta_fixture(page: 2, page_size: 10, total_count: 25)
+
+ assert meta.current_page == 2
+ assert meta.total_pages == 3
+ assert meta.has_previous_page?
+ assert meta.has_next_page?
+ assert meta.previous_page == 1
+ assert meta.next_page == 3
+ end
+
+ test "meta_fixture/1 clamps page beyond total" do
+ meta = FlopFixtures.meta_fixture(page: 99, page_size: 10, total_count: 15)
+
+ assert meta.current_page == 2
+ assert meta.total_pages == 2
+ refute meta.has_next_page?
+ end
+end
diff --git a/test/reencodarr/media/list_bad_file_issues_test.exs b/test/reencodarr/media/list_bad_file_issues_test.exs
new file mode 100644
index 00000000..383b710f
--- /dev/null
+++ b/test/reencodarr/media/list_bad_file_issues_test.exs
@@ -0,0 +1,106 @@
+defmodule Reencodarr.Media.ListBadFileIssuesTest do
+ use Reencodarr.DataCase, async: true
+
+ alias Reencodarr.Fixtures
+ alias Reencodarr.Media
+
+ test "list_bad_file_issues/2 filters by kind and paginates" do
+ {:ok, audio_video} = Fixtures.video_fixture(%{path: "/media/audio_issue.mkv"})
+ {:ok, manual_video} = Fixtures.video_fixture(%{path: "/media/manual_issue.mkv"})
+
+ {:ok, _} =
+ Media.create_bad_file_issue(audio_video, %{
+ origin: :manual,
+ issue_kind: :audio,
+ classification: :confirmed_bad_audio_layout
+ })
+
+ {:ok, _} =
+ Media.create_bad_file_issue(manual_video, %{
+ origin: :manual,
+ issue_kind: :manual,
+ classification: :manual_bad,
+ manual_reason: "manual"
+ })
+
+ assert {issues, meta} =
+ Media.list_bad_file_issues(%{"kind" => "audio", "page" => "1", "page_size" => "10"})
+
+ assert meta.total_count == 1
+ assert [%{issue_kind: :audio}] = issues
+ end
+
+ test "search matches video path" do
+ {:ok, video} = Fixtures.video_fixture(%{path: "/media/searchable_bad.mkv"})
+
+ {:ok, _} =
+ Media.create_bad_file_issue(video, %{
+ origin: :manual,
+ issue_kind: :manual,
+ classification: :manual_bad,
+ manual_reason: "searchable"
+ })
+
+ assert {issues, meta} = Media.list_bad_file_issues(%{"search" => "searchable_bad"})
+ assert meta.total_count == 1
+ assert hd(issues).video.path =~ "searchable_bad"
+ end
+
+ test "search treats percent and underscore literally" do
+ {:ok, percent_video} = Fixtures.video_fixture(%{path: "/media/literal_percent_%_bad.mkv"})
+ {:ok, plain_video} = Fixtures.video_fixture(%{path: "/media/literal_percent_x_bad.mkv"})
+
+ for video <- [percent_video, plain_video] do
+ {:ok, _} =
+ Media.create_bad_file_issue(video, %{
+ origin: :manual,
+ issue_kind: :manual,
+ classification: :manual_bad,
+ manual_reason: "literal wildcard"
+ })
+ end
+
+ assert {issues, meta} = Media.list_bad_file_issues(%{"search" => "%_"})
+ assert meta.total_count == 1
+ assert hd(issues).video.path == "/media/literal_percent_%_bad.mkv"
+ end
+
+ test "queue_bad_file_issue_series does not stop at the first bad-file page" do
+ {:ok, series_video} =
+ Fixtures.video_fixture(%{
+ path: "/media/Series Queue/Season 01/series_queue_target.mkv",
+ service_type: :sonarr
+ })
+
+ {:ok, issue} =
+ Media.create_bad_file_issue(series_video, %{
+ origin: :manual,
+ issue_kind: :manual,
+ classification: :manual_bad,
+ manual_reason: "series queue target"
+ })
+
+ Enum.each(1..251, fn n ->
+ {:ok, video} =
+ Fixtures.video_fixture(%{
+ path: "/media/Other Series #{n}/Season 01/decoy_#{n}.mkv",
+ service_type: :sonarr
+ })
+
+ {:ok, _issue} =
+ Media.create_bad_file_issue(video, %{
+ origin: :manual,
+ issue_kind: :manual,
+ classification: :manual_bad,
+ manual_reason: "series queue decoy"
+ })
+ end)
+
+ assert {:ok, 1} = Media.queue_bad_file_issue_series(issue)
+
+ assert %{status: :queued} =
+ issue.id
+ |> Media.get_bad_file_issue!()
+ |> Reencodarr.Repo.reload!()
+ end
+end
diff --git a/test/reencodarr/media/list_failures_test.exs b/test/reencodarr/media/list_failures_test.exs
new file mode 100644
index 00000000..c0eb67cf
--- /dev/null
+++ b/test/reencodarr/media/list_failures_test.exs
@@ -0,0 +1,108 @@
+defmodule Reencodarr.Media.ListFailuresTest do
+ use Reencodarr.DataCase, async: false
+
+ alias Reencodarr.Fixtures
+ alias Reencodarr.Media
+ alias Reencodarr.Media.VideoFailure
+ alias Reencodarr.Repo
+
+ defp failed_video!(attrs) do
+ {:ok, video} = Fixtures.video_fixture(attrs)
+ Media.record_video_failure(video, :encoding, :timeout, message: "test failure")
+ video
+ end
+
+ defp failure!(video, stage, category, message) do
+ %VideoFailure{}
+ |> VideoFailure.changeset(%{
+ video_id: video.id,
+ failure_stage: stage,
+ failure_category: category,
+ failure_message: message
+ })
+ |> Repo.insert!()
+ end
+
+ describe "list_failures/1" do
+ test "returns failed videos with no filters on page 1" do
+ video = failed_video!(%{path: "/media/no_filter.mkv"})
+
+ assert {videos, meta} = Media.list_failures(%{})
+ assert meta.total_count == 1
+ assert Enum.map(videos, & &1.id) == [video.id]
+ end
+
+ test "stage filter limits results" do
+ {:ok, analysis_video} = Fixtures.video_fixture(%{path: "/media/analysis_only.mkv"})
+ Media.record_video_failure(analysis_video, :analysis, :timeout, message: "analysis")
+
+ {:ok, encoding_video} = Fixtures.video_fixture(%{path: "/media/encoding_only.mkv"})
+ Media.record_video_failure(encoding_video, :encoding, :timeout, message: "encoding")
+
+ assert {videos, _meta} = Media.list_failures(%{"stage" => "analysis"})
+ assert [%{path: "/media/analysis_only.mkv"}] = videos
+ end
+
+ test "category filter limits results" do
+ {:ok, process_video} = Fixtures.video_fixture(%{path: "/media/process_fail.mkv"})
+ Media.record_video_failure(process_video, :encoding, :process_failure, message: "process")
+
+ {:ok, timeout_video} = Fixtures.video_fixture(%{path: "/media/timeout_fail.mkv"})
+ Media.record_video_failure(timeout_video, :encoding, :timeout, message: "timeout")
+
+ assert {videos, _meta} = Media.list_failures(%{"category" => "timeout"})
+ assert [%{path: "/media/timeout_fail.mkv"}] = videos
+ end
+
+ test "search matches path" do
+ failed_video!(%{path: "/media/FindMe_Special.mkv"})
+ failed_video!(%{path: "/media/other_file.mkv"})
+
+ assert {videos, meta} = Media.list_failures(%{"search" => "findme"})
+ assert meta.total_count == 1
+ assert hd(videos).path =~ "FindMe"
+ end
+
+ test "search treats percent and underscore literally" do
+ failed_video!(%{path: "/media/failure_%_literal.mkv"})
+ failed_video!(%{path: "/media/failure_x_literal.mkv"})
+
+ assert {videos, meta} = Media.list_failures(%{"search" => "%_"})
+ assert meta.total_count == 1
+ assert hd(videos).path == "/media/failure_%_literal.mkv"
+ end
+
+ test "load_failures_page displays failures matching active filters" do
+ {:ok, video} = Fixtures.video_fixture(%{path: "/media/mixed_failures.mkv", state: :failed})
+ failure!(video, :analysis, :file_access, "analysis failure")
+ failure!(video, :encoding, :timeout, "encoding failure")
+
+ payload = Media.load_failures_page(%{"stage" => "analysis"})
+
+ assert [%{failure_stage: :analysis, failure_message: "analysis failure"}] =
+ payload.video_failures[video.id]
+ end
+
+ test "pagination returns page 2 slice" do
+ Enum.each(1..21, fn n ->
+ failed_video!(%{path: "/media/page_#{n}.mkv"})
+ end)
+
+ assert {page1, meta1} = Media.list_failures(%{"page" => "1", "page_size" => "20"})
+ assert {page2, meta2} = Media.list_failures(%{"page" => "2", "page_size" => "20"})
+
+ assert meta1.total_count == 21
+ assert meta2.total_count == 21
+ assert 20 == Enum.count(page1)
+ assert [_only] = page2
+ end
+
+ test "invalid stage coerces to all" do
+ video = failed_video!(%{path: "/media/invalid_stage.mkv"})
+
+ assert {videos, meta} = Media.list_failures(%{"stage" => "not_a_stage"})
+ assert meta.total_count == 1
+ assert hd(videos).id == video.id
+ end
+ end
+end
diff --git a/test/reencodarr_web/flop_list_test_helpers_test.exs b/test/reencodarr_web/flop_list_test_helpers_test.exs
new file mode 100644
index 00000000..d7d9df2a
--- /dev/null
+++ b/test/reencodarr_web/flop_list_test_helpers_test.exs
@@ -0,0 +1,25 @@
+defmodule ReencodarrWeb.FlopListTestHelpersTest do
+ use ExUnit.Case, async: true
+
+ alias Reencodarr.FlopFixtures
+ alias ReencodarrWeb.FlopListTestHelpers
+
+ test "current_page_from_meta/1 reads flop meta page" do
+ meta = FlopFixtures.meta_fixture(page: 3, page_size: 20, total_count: 60)
+ assert FlopListTestHelpers.current_page_from_meta(meta) == 3
+ end
+
+ test "assert_filter_in_url/3 matches query params" do
+ assert :ok =
+ FlopListTestHelpers.assert_filter_in_url(
+ "/failures?stage=analysis&search=foo",
+ "stage",
+ "analysis"
+ )
+ end
+
+ test "pagination_label_from_html/1 parses flop label" do
+ html = ~s(
1-20 of 42 )
+ assert FlopListTestHelpers.pagination_label_from_html(html) == "1-20 of 42"
+ end
+end
diff --git a/test/reencodarr_web/live/bad_files_live_test.exs b/test/reencodarr_web/live/bad_files_live_test.exs
index 9823b6f4..f8a2a288 100644
--- a/test/reencodarr_web/live/bad_files_live_test.exs
+++ b/test/reencodarr_web/live/bad_files_live_test.exs
@@ -3,6 +3,8 @@ defmodule ReencodarrWeb.BadFilesLiveTest do
import Phoenix.LiveViewTest
+ import ReencodarrWeb.FlopListTestHelpers
+
alias Reencodarr.BadFileRemediation
alias Reencodarr.Dashboard.Events
alias Reencodarr.Fixtures
@@ -562,7 +564,7 @@ defmodule ReencodarrWeb.BadFilesLiveTest do
|> form("#bad-files-status-filter", %{"status" => "queued"})
|> render_change()
- assert_patch(view, ~p"/bad-files?page=1&per_page=50&status=queued")
+ assert_patch(view, ~p"/bad-files?status=queued")
html = render_async(view)
assert html =~ "filter_queued.mkv"
refute html =~ "filter_open.mkv"
@@ -598,7 +600,7 @@ defmodule ReencodarrWeb.BadFilesLiveTest do
|> form("#bad-files-service-filter", %{"service" => "radarr"})
|> render_change()
- assert_patch(view, ~p"/bad-files?page=1&per_page=50&service=radarr")
+ assert_patch(view, ~p"/bad-files?service=radarr")
html = render_async(view)
assert html =~ "filter_radarr.mkv"
refute html =~ "filter_sonarr.mkv"
@@ -630,7 +632,7 @@ defmodule ReencodarrWeb.BadFilesLiveTest do
|> form("#bad-files-kind-filter", %{"kind" => "audio"})
|> render_change()
- assert_patch(view, ~p"/bad-files?kind=audio&page=1&per_page=50")
+ assert_patch(view, ~p"/bad-files?kind=audio")
html = render_async(view)
assert html =~ "filter_audio_kind.mkv"
refute html =~ "filter_manual_kind.mkv"
@@ -663,7 +665,7 @@ defmodule ReencodarrWeb.BadFilesLiveTest do
|> form("#bad-files-search-filter", %{"query" => "search_this"})
|> render_change()
- assert_patch(view, ~p"/bad-files?page=1&per_page=50&search=search_this")
+ assert_patch(view, ~p"/bad-files?search=search_this")
by_path_html = render_async(view)
assert by_path_html =~ "search_this_title.mkv"
refute by_path_html =~ "other_title.mkv"
@@ -672,10 +674,143 @@ defmodule ReencodarrWeb.BadFilesLiveTest do
|> form("#bad-files-search-filter", %{"query" => "blocky"})
|> render_change()
- assert_patch(view, ~p"/bad-files?page=1&per_page=50&search=blocky")
+ assert_patch(view, ~p"/bad-files?search=blocky")
by_reason_html = render_async(view)
assert by_reason_html =~ "other_title.mkv"
refute by_reason_html =~ "search_this_title.mkv"
end
end
+
+ describe "URL state" do
+ test "direct navigation hydrates filters from query string", %{conn: conn} do
+ {:ok, open_video} = Fixtures.video_fixture(%{path: "/media/url_open.mkv"})
+ {:ok, queued_video} = Fixtures.video_fixture(%{path: "/media/url_queued.mkv"})
+
+ {:ok, _open_issue} =
+ Media.create_bad_file_issue(open_video, %{
+ origin: :manual,
+ issue_kind: :manual,
+ classification: :manual_bad,
+ manual_reason: "open"
+ })
+
+ {:ok, queued_issue} =
+ Media.create_bad_file_issue(queued_video, %{
+ origin: :manual,
+ issue_kind: :manual,
+ classification: :manual_bad,
+ manual_reason: "queued"
+ })
+
+ {:ok, _queued_issue} = Media.enqueue_bad_file_issue(queued_issue)
+
+ {:ok, view, _html} =
+ live(conn, ~p"/bad-files?status=queued&page=1&per_page=25")
+
+ html = render_async(view)
+ assert html =~ "url_queued.mkv"
+ refute html =~ "url_open.mkv"
+ end
+
+ test "invalid filter params coerce to safe defaults", %{conn: conn} do
+ {:ok, view, _html} =
+ live(conn, ~p"/bad-files?status=not-a-status&service=bogus&page=0")
+
+ html = render_async(view)
+
+ assert has_element?(view, "#bad-files-status-filter select option[value='all'][selected]")
+ assert has_element?(view, "#bad-files-service-filter select option[value='all'][selected]")
+ assert current_page_from_html(html) == 1
+ end
+
+ test "page beyond total clamps to last page", %{conn: conn} do
+ Enum.each(1..26, fn n ->
+ {:ok, video} = Fixtures.video_fixture(%{path: "/media/bad_clamp_#{n}.mkv"})
+
+ {:ok, _issue} =
+ Media.create_bad_file_issue(video, %{
+ origin: :manual,
+ issue_kind: :manual,
+ classification: :manual_bad,
+ manual_reason: "clamp #{n}"
+ })
+ end)
+
+ {:ok, view, _html} = live(conn, ~p"/bad-files?page=999&per_page=25")
+ html = render_async(view)
+
+ assert pagination_label_from_html(html) == "26-26 of 26"
+ assert html =~ "bad_clamp_1.mkv"
+ refute html =~ "bad_clamp_26.mkv"
+ end
+
+ test "resolved status is paginated as the primary list", %{conn: conn} do
+ Enum.each(1..26, fn n ->
+ {:ok, video} = Fixtures.video_fixture(%{path: "/media/resolved_url_#{n}.mkv"})
+
+ {:ok, issue} =
+ Media.create_bad_file_issue(video, %{
+ origin: :manual,
+ issue_kind: :manual,
+ classification: :manual_bad,
+ manual_reason: "resolved url"
+ })
+
+ {:ok, _issue} = Media.dismiss_bad_file_issue(issue)
+ end)
+
+ {:ok, view, _html} = live(conn, ~p"/bad-files?status=resolved&page=2&per_page=25")
+ html = render_async(view)
+
+ assert pagination_label_from_html(html) == "26-26 of 26"
+ assert html =~ "Resolved Issues"
+ assert html =~ "resolved_url_"
+ refute html =~ "Recent resolved issues are loaded on demand."
+ end
+
+ test "combined filters in query string", %{conn: conn} do
+ {:ok, sonarr_video} =
+ Fixtures.video_fixture(%{path: "/media/url_combo.mkv", service_type: :sonarr})
+
+ {:ok, radarr_video} =
+ Fixtures.video_fixture(%{path: "/media/wrong_service_combo.mkv", service_type: :radarr})
+
+ {:ok, audio_video} =
+ Fixtures.video_fixture(%{path: "/media/wrong_kind_combo.mkv", service_type: :sonarr})
+
+ {:ok, _issue} =
+ Media.create_bad_file_issue(sonarr_video, %{
+ origin: :manual,
+ issue_kind: :manual,
+ classification: :manual_bad,
+ manual_reason: "combo search target"
+ })
+
+ {:ok, _wrong_service} =
+ Media.create_bad_file_issue(radarr_video, %{
+ origin: :manual,
+ issue_kind: :manual,
+ classification: :manual_bad,
+ manual_reason: "combo wrong service"
+ })
+
+ {:ok, _wrong_kind} =
+ Media.create_bad_file_issue(audio_video, %{
+ origin: :manual,
+ issue_kind: :audio,
+ classification: :confirmed_bad_audio_layout
+ })
+
+ {:ok, view, _html} =
+ live(
+ conn,
+ ~p"/bad-files?service=sonarr&kind=manual&search=combo&page=1&per_page=50"
+ )
+
+ html = render_async(view)
+ assert html =~ "url_combo.mkv"
+ refute html =~ "wrong_service_combo.mkv"
+ refute html =~ "wrong_kind_combo.mkv"
+ end
+ end
end
diff --git a/test/reencodarr_web/live/failures_live_test.exs b/test/reencodarr_web/live/failures_live_test.exs
index 8470149b..856533d5 100644
--- a/test/reencodarr_web/live/failures_live_test.exs
+++ b/test/reencodarr_web/live/failures_live_test.exs
@@ -11,31 +11,15 @@ defmodule ReencodarrWeb.FailuresLiveTest do
use ReencodarrWeb.ConnCase, async: false
import Phoenix.LiveViewTest
+ import ReencodarrWeb.FlopListTestHelpers
alias Reencodarr.Fixtures
alias Reencodarr.Media
+ alias Reencodarr.Media.VideoFailure
+ alias Reencodarr.Repo
- # Flush the LiveView process mailbox (processes :load_initial_data) and return
- # the fully-loaded HTML.
defp loaded_html(view), do: render(view)
- defp current_page_from_html(html) do
- case Regex.run(~r/Page\s*
(-?\d+)<\/span>/, html) do
- [_, page] -> String.to_integer(page)
- _ -> nil
- end
- end
-
- defp total_pages_from_html(html) do
- case Regex.run(
- ~r/of\s*(\d+)<\/span>/,
- html
- ) do
- [_, total] -> String.to_integer(total)
- _ -> nil
- end
- end
-
# ---------------------------------------------------------------------------
# Mount / basic render
# ---------------------------------------------------------------------------
@@ -277,6 +261,23 @@ defmodule ReencodarrWeb.FailuresLiveTest do
html = view |> element("button[phx-click='reset_all_failures']") |> render_click()
assert html =~ "Failures"
end
+
+ test "reset_all_failures deletes unresolved failures and requeues failed videos", %{
+ conn: conn
+ } do
+ {:ok, video} = Fixtures.video_fixture(%{path: "/media/reset_all_semantics.mkv"})
+ Media.record_video_failure(video, :encoding, :timeout, message: "reset me")
+
+ {:ok, view, _} = live(conn, ~p"/failures")
+ loaded_html(view)
+
+ view
+ |> element("button[phx-click='reset_all_failures']")
+ |> render_click()
+
+ assert Media.get_video!(video.id).state == :needs_analysis
+ assert Repo.get_by(VideoFailure, video_id: video.id) == nil
+ end
end
describe "retry_failure_code event" do
@@ -393,32 +394,36 @@ defmodule ReencodarrWeb.FailuresLiveTest do
end
end
+ describe "URL bookmarks" do
+ test "stage and search params load from URL", %{conn: conn} do
+ {:ok, analysis_video} = Fixtures.video_fixture(%{path: "/media/url_analysis.mkv"})
+ {:ok, encoding_video} = Fixtures.video_fixture(%{path: "/media/url_analysis_encoding.mkv"})
+
+ Media.record_video_failure(analysis_video, :analysis, :timeout, message: "analysis")
+ Media.record_video_failure(encoding_video, :encoding, :timeout, message: "encoding")
+
+ {:ok, _view, html} = live(conn, ~p"/failures?stage=analysis&search=url_analysis")
+
+ assert html =~ "url_analysis.mkv"
+ refute html =~ "url_analysis_encoding.mkv"
+ end
+ end
+
describe "pagination behavior" do
- test "change_page with invalid low page clamps to page 1", %{conn: conn} do
+ test "page 0 in URL clamps to page 1", %{conn: conn} do
Enum.each(1..21, fn n ->
{:ok, video} = Fixtures.video_fixture(%{path: "/media/page_item_#{n}.mkv"})
Media.record_video_failure(video, :encoding, :timeout, message: "failure #{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='change_page'][title='First page']")
- |> render_click(%{"page" => "0"})
-
- html = render_async(view)
+ {:ok, view, _} = live(conn, ~p"/failures?page=0")
+ html = loaded_html(view)
assert current_page_from_html(html) == 1
+ assert pagination_label_from_html(html) == "1-20 of 21"
end
- test "shows Page 1 of 2 with 21 failures at per_page 20", %{conn: conn} do
+ test "shows flop pagination label for page 1 of 2 with 21 failures", %{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}")
@@ -429,6 +434,7 @@ defmodule ReencodarrWeb.FailuresLiveTest do
assert current_page_from_html(html) == 1
assert total_pages_from_html(html) == 2
+ assert pagination_label_from_html(html) == "1-20 of 21"
end
test "navigating to page 2 shows the 21st failure", %{conn: conn} do
@@ -443,18 +449,12 @@ defmodule ReencodarrWeb.FailuresLiveTest do
{: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)
+ {:ok, view, _} = live(conn, ~p"/failures?page=2")
+ html = loaded_html(view)
- assert current_page_from_html(html) == 2
- assert html =~ "last_on_page_two"
- refute html =~ "first_on_page_one"
+ assert pagination_label_from_html(html) == "21-21 of 21"
+ assert html =~ "first_on_page_one"
+ refute html =~ "last_on_page_two"
end
test "filter resets page to 1 when on page 2", %{conn: conn} do
@@ -466,10 +466,7 @@ defmodule ReencodarrWeb.FailuresLiveTest do
{:ok, view, _} = live(conn, ~p"/failures")
loaded_html(view)
- view
- |> element("button[phx-click='change_page'][title='Next page']")
- |> render_click()
-
+ click_flop_next(view)
render_async(view)
view
@@ -481,20 +478,17 @@ defmodule ReencodarrWeb.FailuresLiveTest do
assert current_page_from_html(html) == 1
end
- test "change_page clamps to total_pages when page exceeds total", %{conn: conn} do
+ test "page beyond total clamps to last page", %{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)
+ {:ok, view, _} = live(conn, ~p"/failures?page=999")
+ html = loaded_html(view)
- # page should be clamped to total_pages (2), not left at 999
assert current_page_from_html(html) == 2
+ assert pagination_label_from_html(html) == "21-21 of 21"
end
test "reset_all_failures resets page to 1", %{conn: conn} do
@@ -506,10 +500,7 @@ defmodule ReencodarrWeb.FailuresLiveTest do
{:ok, view, _} = live(conn, ~p"/failures")
loaded_html(view)
- view
- |> element("button[phx-click='change_page'][title='Next page']")
- |> render_click()
-
+ click_flop_next(view)
render_async(view)
view
diff --git a/test/reencodarr_web/live/flop_list_test.exs b/test/reencodarr_web/live/flop_list_test.exs
new file mode 100644
index 00000000..12b2d289
--- /dev/null
+++ b/test/reencodarr_web/live/flop_list_test.exs
@@ -0,0 +1,146 @@
+defmodule ReencodarrWeb.Live.FlopListTest do
+ use ExUnit.Case, async: true
+
+ import Phoenix.LiveViewTest
+
+ alias Reencodarr.FlopFixtures
+ alias ReencodarrWeb.Live.FlopList
+
+ describe "flop_pagination/1" do
+ test "simple mode renders label and prev/next without page numbers" do
+ meta = FlopFixtures.meta_fixture(page: 2, page_size: 50, total_count: 120)
+
+ html =
+ render_component(&FlopList.flop_pagination/1, %{
+ id: "videos-flop-pagination",
+ meta: meta,
+ path: "/videos",
+ mode: :simple
+ })
+
+ assert html =~ "id=\"videos-flop-pagination\""
+ assert html =~ ~s(data-role="flop-pagination-label")
+ assert html =~ "51-100 of 120"
+ assert html =~ ~s(data-role="flop-pagination-prev")
+ assert html =~ ~s(data-role="flop-pagination-next")
+ assert html =~ "bg-gray-700"
+ refute html =~ ~s(aria-current="page")
+ end
+
+ test "base_path builds patch links preserving custom query params" do
+ meta = FlopFixtures.meta_fixture(page: 1, page_size: 50, total_count: 120)
+
+ html =
+ render_component(&FlopList.flop_pagination/1, %{
+ meta: meta,
+ base_path: "/videos",
+ query: %{
+ "sort_by" => "updated_at",
+ "sort_dir" => "desc",
+ "per_page" => 50
+ },
+ mode: :simple
+ })
+
+ assert html =~ "sort_by=updated_at"
+ assert html =~ "sort_dir=desc"
+ assert html =~ "per_page=50"
+ end
+
+ test "full mode renders numbered page links" do
+ meta = FlopFixtures.meta_fixture(page: 5, page_size: 20, total_count: 200)
+
+ html =
+ render_component(&FlopList.flop_pagination/1, %{
+ id: "failures-flop-pagination",
+ meta: meta,
+ path: "/failures",
+ mode: :full,
+ page_links: 5
+ })
+
+ assert html =~ "id=\"failures-flop-pagination\""
+ assert html =~ ~s(data-role="flop-pagination-page")
+ assert html =~ "bg-blue-600"
+ end
+
+ test "simple mode disables previous on first page" do
+ meta = FlopFixtures.meta_fixture(page: 1, page_size: 10, total_count: 25)
+
+ html =
+ render_component(&FlopList.flop_pagination/1, %{
+ meta: meta,
+ path: "/videos",
+ mode: :simple
+ })
+
+ assert html =~ "disabled"
+ assert html =~ "opacity-40"
+ end
+ end
+
+ describe "pagination_label/1" do
+ test "delegates to range label from meta" do
+ meta = FlopFixtures.meta_fixture(page: 1, page_size: 10, total_count: 5)
+
+ assert FlopList.pagination_label(meta) == "1-5 of 5"
+ end
+
+ test "clamps oversized current_page before building the label" do
+ meta = %Flop.Meta{current_page: 999_999, page_size: 10, total_count: 25}
+
+ assert FlopList.pagination_label(meta) == "21-25 of 25"
+ end
+ end
+
+ describe "patch_with_page/3" do
+ test "omits page param on first page" do
+ url = FlopList.patch_with_page("/videos", %{"per_page" => 50}, 1)
+
+ assert %URI{path: "/videos", query: query} = URI.parse(url)
+ assert URI.decode_query(query) == %{"per_page" => "50"}
+ end
+
+ test "includes page param when not on first page" do
+ url = FlopList.patch_with_page("/videos", %{"per_page" => 50}, 2)
+
+ assert %URI{path: "/videos", query: query} = URI.parse(url)
+ assert URI.decode_query(query) == %{"page" => "2", "per_page" => "50"}
+ end
+
+ test "returns bare path when merged query is empty" do
+ assert FlopList.patch_with_page("/bad-files", %{}, 1) == "/bad-files"
+ end
+ end
+
+ describe "parse_page/3" do
+ test "clamps page to total pages when total and per_page given" do
+ assert FlopList.parse_page(%{"page" => "99"}, 1, total: 25, per_page: 10) == 3
+ end
+ end
+
+ describe "parse_per_page/3" do
+ test "falls back to default for invalid per_page" do
+ assert FlopList.parse_per_page(%{"per_page" => "13"}, 25, [25, 50, 100]) == 25
+ end
+ end
+
+ describe "pagination_assigns/4" do
+ test "returns assign-ready page and per_page values" do
+ assert FlopList.pagination_assigns(%{"page" => "4", "per_page" => "50"}, 25, [25, 50]) ==
+ %{page: 4, per_page: 50}
+ end
+
+ test "coerces invalid values to safe defaults" do
+ assert FlopList.pagination_assigns(%{"page" => "0", "per_page" => "13"}, 25, [25, 50]) ==
+ %{page: 1, per_page: 25}
+ end
+ end
+
+ describe "total_pages/2" do
+ test "returns at least one page" do
+ assert FlopList.total_pages(0, 10) == 1
+ assert FlopList.total_pages(21, 10) == 3
+ end
+ end
+end
diff --git a/test/reencodarr_web/live/list_pagination_test.exs b/test/reencodarr_web/live/list_pagination_test.exs
deleted file mode 100644
index d9ef8486..00000000
--- a/test/reencodarr_web/live/list_pagination_test.exs
+++ /dev/null
@@ -1,111 +0,0 @@
-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
diff --git a/test/reencodarr_web/live/videos_live_test.exs b/test/reencodarr_web/live/videos_live_test.exs
index 4e179ade..c5e383bc 100644
--- a/test/reencodarr_web/live/videos_live_test.exs
+++ b/test/reencodarr_web/live/videos_live_test.exs
@@ -117,7 +117,7 @@ defmodule ReencodarrWeb.VideosLiveTest do
assert_patch(
view,
- "/videos?page=1&per_page=50&sort_by=updated_at&sort_dir=desc&state=encoded"
+ "/videos?state=encoded"
)
end
@@ -190,12 +190,13 @@ defmodule ReencodarrWeb.VideosLiveTest do
# ---------------------------------------------------------------------------
describe "pagination" do
- test "prev_page button is disabled on page 1", %{conn: conn} do
+ test "renders flop pagination on page 1", %{conn: conn} do
{:ok, view, _html} = live(conn, ~p"/videos?page=1")
html = render(view)
- # Button is rendered as disabled when already on first page
- assert html =~ "phx-click=\"prev_page\""
- assert html =~ "disabled"
+
+ assert html =~ ~s(data-role="flop-pagination")
+ assert html =~ ~s(data-role="flop-pagination-label")
+ assert html =~ "0 results"
end
test "per_page event updates items per page", %{conn: conn} do
@@ -217,7 +218,25 @@ defmodule ReencodarrWeb.VideosLiveTest do
|> form("form[phx-change='set_per_page']", %{per_page: "100"})
|> render_change()
- assert_patch(view, "/videos?page=1&per_page=100&sort_by=updated_at&sort_dir=desc")
+ assert_patch(view, "/videos?per_page=100")
+ end
+
+ test "page beyond total clamps to last page", %{conn: conn} do
+ Enum.each(1..26, fn n ->
+ {:ok, _video} = Fixtures.video_fixture(%{path: "/media/videos_clamp_#{n}.mkv"})
+ end)
+
+ {:ok, view, _html} = live(conn, ~p"/videos?page=999&per_page=25")
+ html = render_async(view)
+
+ assert html =~ "26-26 of 26"
+ end
+
+ test "empty search clamps impossible page to page 1", %{conn: conn} do
+ {:ok, view, _html} = live(conn, ~p"/videos?q=no_such_video&page=999")
+ html = render_async(view)
+
+ assert html =~ "0 results"
end
end
@@ -339,7 +358,8 @@ defmodule ReencodarrWeb.VideosLiveTest do
assert html =~ "Marked as bad"
- [issue] = Reencodarr.Media.list_bad_file_issues()
+ {issues, _} = Reencodarr.Media.list_bad_file_issues(%{"page_size" => "250"})
+ [issue] = issues
assert issue.video_id == video.id
assert issue.issue_kind == :manual
assert issue.classification == :manual_bad
@@ -366,7 +386,8 @@ defmodule ReencodarrWeb.VideosLiveTest do
|> render_submit()
assert html =~ "Mark bad failed"
- assert Reencodarr.Media.list_bad_file_issues() == []
+ {issues, _} = Reencodarr.Media.list_bad_file_issues(%{"page_size" => "250"})
+ assert issues == []
end
end
@@ -457,10 +478,7 @@ defmodule ReencodarrWeb.VideosLiveTest do
|> form("#videos-filters", %{service: "sonarr"})
|> render_change()
- assert_patch(
- view,
- "/videos?page=1&per_page=50&service=sonarr&sort_by=updated_at&sort_dir=desc"
- )
+ assert_patch(view, "/videos?service=sonarr")
end
end
@@ -487,7 +505,7 @@ defmodule ReencodarrWeb.VideosLiveTest do
|> form("#videos-filters", %{hdr: "true"})
|> render_change()
- assert_patch(view, "/videos?hdr=true&page=1&per_page=50&sort_by=updated_at&sort_dir=desc")
+ assert_patch(view, "/videos?hdr=true")
end
end
diff --git a/test/support/flop_fixtures.ex b/test/support/flop_fixtures.ex
new file mode 100644
index 00000000..c6696be9
--- /dev/null
+++ b/test/support/flop_fixtures.ex
@@ -0,0 +1,41 @@
+defmodule Reencodarr.FlopFixtures do
+ @moduledoc false
+
+ alias Reencodarr.Media.Video
+
+ @doc """
+ Builds a `%Flop.Meta{}` for component and LiveView tests without hitting the DB.
+ """
+ @spec meta_fixture(keyword()) :: Flop.Meta.t()
+ def meta_fixture(opts \\ []) do
+ page = Keyword.get(opts, :page, 1)
+ page_size = Keyword.get(opts, :page_size, 20)
+ total_count = Keyword.get(opts, :total_count, 0)
+ total_pages = total_pages(total_count, page_size)
+ current_page = min(max(page, 1), max(total_pages, 1))
+
+ %Flop.Meta{
+ schema: Keyword.get(opts, :schema, Video),
+ current_page: current_page,
+ page_size: page_size,
+ total_count: total_count,
+ total_pages: total_pages,
+ previous_page: if(current_page > 1, do: current_page - 1),
+ next_page: if(current_page < total_pages, do: current_page + 1),
+ has_previous_page?: current_page > 1,
+ has_next_page?: current_page < total_pages,
+ flop: %Flop{
+ offset: (current_page - 1) * page_size,
+ limit: page_size,
+ page: current_page,
+ page_size: page_size
+ }
+ }
+ end
+
+ defp total_pages(0, _page_size), do: 0
+
+ defp total_pages(total_count, page_size) when total_count > 0 do
+ div(total_count + page_size - 1, page_size)
+ end
+end
diff --git a/test/support/flop_list_test_helpers.ex b/test/support/flop_list_test_helpers.ex
new file mode 100644
index 00000000..9c7e3d83
--- /dev/null
+++ b/test/support/flop_list_test_helpers.ex
@@ -0,0 +1,57 @@
+defmodule ReencodarrWeb.FlopListTestHelpers do
+ @moduledoc false
+
+ import Phoenix.LiveViewTest
+
+ @spec pagination_label_from_html(String.t()) :: String.t() | nil
+ def pagination_label_from_html(html) do
+ case Regex.run(~r/data-role="flop-pagination-label"[^>]*>([^<]+)/, html) do
+ [_, label] -> String.trim(label)
+ _ -> nil
+ end
+ end
+
+ @spec current_page_from_html(String.t()) :: pos_integer() | nil
+ def current_page_from_html(html) do
+ case Regex.run(~r/aria-current="page"[^>]*>\s*(\d+)/s, html) do
+ [_, page] -> String.to_integer(page)
+ _ -> if String.contains?(html, ~s(data-role="flop-pagination")), do: 1, else: nil
+ end
+ end
+
+ @spec current_page_from_meta(Flop.Meta.t()) :: pos_integer()
+ def current_page_from_meta(%Flop.Meta{current_page: page}) when is_integer(page), do: page
+ def current_page_from_meta(_meta), do: 1
+
+ @spec total_pages_from_html(String.t()) :: pos_integer()
+ def total_pages_from_html(html) do
+ case Regex.scan(~r/data-role="flop-pagination-page"/, html) do
+ [] -> 1
+ pages -> length(pages)
+ end
+ end
+
+ @spec assert_filter_in_url(String.t(), String.t(), String.t()) :: :ok
+ def assert_filter_in_url(path, key, value) do
+ query = path |> URI.parse() |> Map.get(:query, "") |> URI.decode_query()
+
+ if Map.get(query, key) != value do
+ raise ExUnit.AssertionError,
+ "expected #{inspect(key)}=#{inspect(value)} in #{path}, got #{inspect(query)}"
+ end
+
+ :ok
+ end
+
+ @spec assert_flop_patch(Phoenix.LiveViewTest.view(), String.t()) :: :ok
+ def assert_flop_patch(view, expected_path) do
+ assert_patch(view, expected_path)
+ end
+
+ @spec click_flop_next(Phoenix.LiveViewTest.view()) :: String.t()
+ def click_flop_next(view) do
+ view
+ |> element("a[data-role='flop-pagination-next']")
+ |> render_click()
+ end
+end