chore: remove inappropriate IO.puts debugging output from tests

- Remove all IO.puts statements from comprehensive fixture tests
- Tests should not pollute output during normal test runs
- Fix unused variable warning for ignored_count
- Keep assertion logic intact for proper test validation

Author: mjc

test/reencodarr/ab_av1/output_parser_test.exs

@@ -240,12 +240,15 @@ defmodule Reencodarr.AbAv1.OutputParserTest do
       end
     end
 
-    test "comprehensive fixture coverage analysis", %{crf_search_lines: crf_lines, encoding_lines: enc_lines} do
+    test "comprehensive fixture coverage analysis", %{
+      crf_search_lines: crf_lines,
+      encoding_lines: enc_lines
+    } do
       # Analyze all fixture lines to ensure comprehensive coverage
       all_lines = crf_lines ++ enc_lines
 
       # Test every single line in the fixtures
-      {parsed_count, ignored_count, pattern_counts} = 
+      {parsed_count, _ignored_count, pattern_counts} =
         Enum.reduce(all_lines, {0, 0, %{}}, fn line, {parsed, ignored, patterns} ->
           case OutputParser.parse_line(line) do
             {:ok, %{type: type, data: _data}} ->
@@ -261,17 +264,6 @@ defmodule Reencodarr.AbAv1.OutputParserTest do
       assert total_lines > 0, "No fixture lines found"
       assert parsed_count > 0, "No lines were successfully parsed"
 
-      # Log the analysis for debugging
-      IO.puts "\n=== Fixture Coverage Analysis ==="
-      IO.puts "Total fixture lines: #{total_lines}"
-      IO.puts "Successfully parsed: #{parsed_count}"
-      IO.puts "Ignored lines: #{ignored_count}"
-      IO.puts "Parse success rate: #{Float.round(parsed_count / total_lines * 100, 1)}%"
-      IO.puts "Pattern counts:"
-      Enum.each(pattern_counts, fn {pattern, count} ->
-        IO.puts "  #{pattern}: #{count}"
-      end)
-
       # Ensure we're parsing most patterns we expect from ab-av1 output
       found_patterns = Map.keys(pattern_counts)
 
@@ -280,7 +272,8 @@ defmodule Reencodarr.AbAv1.OutputParserTest do
 
       # CRF search fixtures should contain sample VMAF and eta VMAF patterns
       if length(crf_lines) > 0 do
-        assert Map.has_key?(pattern_counts, :sample_vmaf) or Map.has_key?(pattern_counts, :vmaf_result),
+        assert Map.has_key?(pattern_counts, :sample_vmaf) or
+                 Map.has_key?(pattern_counts, :vmaf_result),
                "CRF search fixtures should contain VMAF patterns"
       end
 

test/reencodarr/ab_av1/progress_parser_test.exs

@@ -469,21 +469,23 @@ defmodule Reencodarr.AbAv1.ProgressParserTest do
       assert vmaf.percent == 75.0
     end
 
-    test "comprehensive fixture processing coverage", %{video: video, crf_search_lines: crf_lines, encoding_lines: enc_lines} do
+    test "comprehensive fixture processing coverage", %{
+      video: video,
+      crf_search_lines: crf_lines,
+      encoding_lines: enc_lines
+    } do
       # Test that ProgressParser can handle ALL fixture lines without errors
       all_lines = crf_lines ++ enc_lines
 
       # Test CRF search context with all lines
-      {processed_crf, error_crf} = 
+      {processed_crf, error_crf} =
         Enum.reduce(crf_lines, {0, 0}, fn line, {processed, errors} ->
           try do
             ProgressParser.process_line(line, {video, [], 95})
             {processed + 1, errors}
           rescue
-            error ->
-            IO.puts "Error processing CRF line: #{line}"
-            IO.puts "Error: #{inspect(error)}"
-            {processed, errors + 1}
+            _error ->
+              {processed, errors + 1}
           end
         end)
 
@@ -496,38 +498,29 @@ defmodule Reencodarr.AbAv1.ProgressParserTest do
         partial_line_buffer: ""
       }
 
-      {processed_enc, error_enc} = 
+      {processed_enc, error_enc} =
         Enum.reduce(enc_lines, {0, 0}, fn line, {processed, errors} ->
           try do
             ProgressParser.process_line(line, encoding_state)
             {processed + 1, errors}
           rescue
-            error ->
-            IO.puts "Error processing encoding line: #{line}"
-            IO.puts "Error: #{inspect(error)}"
-            {processed, errors + 1}
+            _error ->
+              {processed, errors + 1}
           end
         end)
 
       total_lines = length(all_lines)
       total_processed = processed_crf + processed_enc
       total_errors = error_crf + error_enc
 
-      # Log comprehensive analysis
-      IO.puts "\n=== ProgressParser Fixture Coverage Analysis ==="
-      IO.puts "Total fixture lines processed: #{total_lines}"
-      IO.puts "Successfully processed: #{total_processed}"
-      IO.puts "Errors encountered: #{total_errors}"
-      if total_lines > 0 do
-        IO.puts "Success rate: #{Float.round(total_processed / total_lines * 100, 1)}%"
-      end
-      IO.puts "CRF search lines: #{processed_crf}"
-      IO.puts "Encoding lines: #{processed_enc}"
-
       # Verify we processed lines without major errors
       assert total_lines > 0, "No fixture lines found"
-      assert total_errors == 0, "ProgressParser encountered #{total_errors} errors processing fixture lines"
-      assert total_processed == total_lines, "Expected to process all #{total_lines} lines, but only processed #{total_processed}"
+
+      assert total_errors == 0,
+             "ProgressParser encountered #{total_errors} errors processing fixture lines"
+
+      assert total_processed == total_lines,
+             "Expected to process all #{total_lines} lines, but only processed #{total_processed}"
     end
   end
 
@@ -639,21 +632,35 @@ defmodule Reencodarr.AbAv1.ProgressParserTest do
   describe "NimbleParsec size parser" do
     test "parses various size formats correctly" do
       # Test decimal sizes
-      assert {:ok, [%{size: 2.5, unit: "gb"}], "", %{}, {1, 0}, _} = ProgressParser.parse_size("2.5 GB")
-      assert {:ok, [%{size: 800.0, unit: "mb"}], "", %{}, {1, 0}, _} = ProgressParser.parse_size("800.0 MB")
-      assert {:ok, [%{size: 1.2, unit: "tb"}], "", %{}, {1, 0}, _} = ProgressParser.parse_size("1.2TB")
+      assert {:ok, [%{size: 2.5, unit: "gb"}], "", %{}, {1, 0}, _} =
+               ProgressParser.parse_size("2.5 GB")
+
+      assert {:ok, [%{size: 800.0, unit: "mb"}], "", %{}, {1, 0}, _} =
+               ProgressParser.parse_size("800.0 MB")
+
+      assert {:ok, [%{size: 1.2, unit: "tb"}], "", %{}, {1, 0}, _} =
+               ProgressParser.parse_size("1.2TB")
 
       # Test integer sizes
-      assert {:ok, [%{size: 500, unit: "mb"}], "", %{}, {1, 0}, _} = ProgressParser.parse_size("500 MB")
-      assert {:ok, [%{size: 1024, unit: "kb"}], "", %{}, {1, 0}, _} = ProgressParser.parse_size("1024KB")
+      assert {:ok, [%{size: 500, unit: "mb"}], "", %{}, {1, 0}, _} =
+               ProgressParser.parse_size("500 MB")
+
+      assert {:ok, [%{size: 1024, unit: "kb"}], "", %{}, {1, 0}, _} =
+               ProgressParser.parse_size("1024KB")
 
       # Test binary units
-      assert {:ok, [%{size: 2, unit: "gib"}], "", %{}, {1, 0}, _} = ProgressParser.parse_size("2 GiB")
-      assert {:ok, [%{size: 512, unit: "mib"}], "", %{}, {1, 0}, _} = ProgressParser.parse_size("512MiB")
+      assert {:ok, [%{size: 2, unit: "gib"}], "", %{}, {1, 0}, _} =
+               ProgressParser.parse_size("2 GiB")
+
+      assert {:ok, [%{size: 512, unit: "mib"}], "", %{}, {1, 0}, _} =
+               ProgressParser.parse_size("512MiB")
 
       # Test case insensitive
-      assert {:ok, [%{size: 100, unit: "gb"}], "", %{}, {1, 0}, _} = ProgressParser.parse_size("100gb")
-      assert {:ok, [%{size: 50, unit: "mb"}], "", %{}, {1, 0}, _} = ProgressParser.parse_size("50mb")
+      assert {:ok, [%{size: 100, unit: "gb"}], "", %{}, {1, 0}, _} =
+               ProgressParser.parse_size("100gb")
+
+      assert {:ok, [%{size: 50, unit: "mb"}], "", %{}, {1, 0}, _} =
+               ProgressParser.parse_size("50mb")
     end
 
     test "handles invalid size formats" do
@@ -667,19 +674,22 @@ defmodule Reencodarr.AbAv1.ProgressParserTest do
     test "size string parsing integration" do
       # Test the public interface that uses NimbleParsec internally
       # This tests the private parse_size_string function indirectly through vmaf size checking
-      video = Fixtures.video_fixture(%{
-        path: "/test/size_test_#{System.unique_integer([:positive])}/video.mkv",
-        service_id: "test_size",
-        service_type: :sonarr,
-        size: 1_000_000_000
-      })
+      video =
+        Fixtures.video_fixture(%{
+          path: "/test/size_test_#{System.unique_integer([:positive])}/video.mkv",
+          service_id: "test_size",
+          service_type: :sonarr,
+          size: 1_000_000_000
+        })
 
       # Create vmaf record with size data
       vmaf_params = %{
         crf: 24,
         score: 95.5,
-        size: "2.5 GB",  # This will be parsed by our NimbleParsec parser
-        params: ["--crf", "24"],  # Required field
+        # This will be parsed by our NimbleParsec parser
+        size: "2.5 GB",
+        # Required field
+        params: ["--crf", "24"],
         video_id: video.id
       }