[Enhancement] Add option for a source to only use cookies when needed (#640)

* Updated model with new attribute

* Update app logic to use new cookie logic

* lots of tests

* Updated UI and renamed attribute

* Updated tests

test/pinchflat/downloading/media_downloader_test.exs

@@ -157,15 +157,16 @@ defmodule Pinchflat.Downloading.MediaDownloaderTest do
           {:ok, ""}
       end)
 
-      source = source_fixture(%{use_cookies: true})
+      source = source_fixture(%{cookie_behaviour: :all_operations})
       media_item = media_item_fixture(%{source_id: source.id})
 
       assert {:ok, _} = MediaDownloader.download_for_media_item(media_item)
     end
 
-    test "does not set use_cookies if the source does not use cookies" do
+    test "does not set use_cookies if the source uses cookies when needed" do
       expect(YtDlpRunnerMock, :run, 3, fn
-        _url, :get_downloadable_status, _opts, _ot, _addl ->
+        _url, :get_downloadable_status, _opts, _ot, addl ->
+          assert {:use_cookies, false} in addl
           {:ok, "{}"}
 
         _url, :download, _opts, _ot, addl ->
@@ -176,7 +177,27 @@ defmodule Pinchflat.Downloading.MediaDownloaderTest do
           {:ok, ""}
       end)
 
-      source = source_fixture(%{use_cookies: false})
+      source = source_fixture(%{cookie_behaviour: :when_needed})
+      media_item = media_item_fixture(%{source_id: source.id})
+
+      assert {:ok, _} = MediaDownloader.download_for_media_item(media_item)
+    end
+
+    test "does not set use_cookies if the source does not use cookies" do
+      expect(YtDlpRunnerMock, :run, 3, fn
+        _url, :get_downloadable_status, _opts, _ot, addl ->
+          assert {:use_cookies, false} in addl
+          {:ok, "{}"}
+
+        _url, :download, _opts, _ot, addl ->
+          assert {:use_cookies, false} in addl
+          {:ok, render_metadata(:media_metadata)}
+
+        _url, :download_thumbnail, _opts, _ot, _addl ->
+          {:ok, ""}
+      end)
+
+      source = source_fixture(%{cookie_behaviour: :disabled})
       media_item = media_item_fixture(%{source_id: source.id})
 
       assert {:ok, _} = MediaDownloader.download_for_media_item(media_item)

test/pinchflat/fast_indexing/fast_indexing_helpers_test.exs

@@ -104,34 +104,6 @@ defmodule Pinchflat.FastIndexing.FastIndexingHelpersTest do
       FastIndexingHelpers.index_and_kickoff_downloads(source)
     end
 
-    test "sets use_cookies if the source uses cookies" do
-      expect(HTTPClientMock, :get, fn _url -> {:ok, "<yt:videoId>test_1</yt:videoId>"} end)
-
-      stub(YtDlpRunnerMock, :run, fn _url, :get_media_attributes, _opts, _ot, addl ->
-        assert {:use_cookies, true} in addl
-
-        {:ok, media_attributes_return_fixture()}
-      end)
-
-      source = source_fixture(%{use_cookies: true})
-
-      assert [%MediaItem{}] = FastIndexingHelpers.index_and_kickoff_downloads(source)
-    end
-
-    test "does not set use_cookies if the source does not use cookies" do
-      expect(HTTPClientMock, :get, fn _url -> {:ok, "<yt:videoId>test_1</yt:videoId>"} end)
-
-      stub(YtDlpRunnerMock, :run, fn _url, :get_media_attributes, _opts, _ot, addl ->
-        assert {:use_cookies, false} in addl
-
-        {:ok, media_attributes_return_fixture()}
-      end)
-
-      source = source_fixture(%{use_cookies: false})
-
-      assert [%MediaItem{}] = FastIndexingHelpers.index_and_kickoff_downloads(source)
-    end
-
     test "does not enqueue a download job if the media item does not match the format rules" do
       expect(HTTPClientMock, :get, fn _url -> {:ok, "<yt:videoId>test_1</yt:videoId>"} end)
 
@@ -180,6 +152,50 @@ defmodule Pinchflat.FastIndexing.FastIndexingHelpersTest do
     end
   end
 
+  describe "index_and_kickoff_downloads/1 when testing cookies" do
+    test "sets use_cookies if the source uses cookies" do
+      expect(HTTPClientMock, :get, fn _url -> {:ok, "<yt:videoId>test_1</yt:videoId>"} end)
+
+      stub(YtDlpRunnerMock, :run, fn _url, :get_media_attributes, _opts, _ot, addl ->
+        assert {:use_cookies, true} in addl
+
+        {:ok, media_attributes_return_fixture()}
+      end)
+
+      source = source_fixture(%{cookie_behaviour: :all_operations})
+
+      assert [%MediaItem{}] = FastIndexingHelpers.index_and_kickoff_downloads(source)
+    end
+
+    test "does not set use_cookies if the source uses cookies when needed" do
+      expect(HTTPClientMock, :get, fn _url -> {:ok, "<yt:videoId>test_1</yt:videoId>"} end)
+
+      stub(YtDlpRunnerMock, :run, fn _url, :get_media_attributes, _opts, _ot, addl ->
+        assert {:use_cookies, false} in addl
+
+        {:ok, media_attributes_return_fixture()}
+      end)
+
+      source = source_fixture(%{cookie_behaviour: :when_needed})
+
+      assert [%MediaItem{}] = FastIndexingHelpers.index_and_kickoff_downloads(source)
+    end
+
+    test "does not set use_cookies if the source does not use cookies" do
+      expect(HTTPClientMock, :get, fn _url -> {:ok, "<yt:videoId>test_1</yt:videoId>"} end)
+
+      stub(YtDlpRunnerMock, :run, fn _url, :get_media_attributes, _opts, _ot, addl ->
+        assert {:use_cookies, false} in addl
+
+        {:ok, media_attributes_return_fixture()}
+      end)
+
+      source = source_fixture(%{cookie_behaviour: :disabled})
+
+      assert [%MediaItem{}] = FastIndexingHelpers.index_and_kickoff_downloads(source)
+    end
+  end
+
   describe "index_and_kickoff_downloads/1 when testing backends" do
     test "uses the YouTube API if it is enabled", %{source: source} do
       expect(HTTPClientMock, :get, fn url, _headers ->

test/pinchflat/metadata/metadata_file_helpers_test.exs

@@ -88,13 +88,35 @@ defmodule Pinchflat.Metadata.MetadataFileHelpersTest do
       Helpers.download_and_store_thumbnail_for(media_item)
     end
 
+    test "returns nil if yt-dlp fails", %{media_item: media_item} do
+      stub(YtDlpRunnerMock, :run, fn _url, :download_thumbnail, _opts, _ot, _addl -> {:error, "error"} end)
+
+      filepath = Helpers.download_and_store_thumbnail_for(media_item)
+
+      assert filepath == nil
+    end
+  end
+
+  describe "download_and_store_thumbnail_for/2 when testing cookie usage" do
     test "sets use_cookies if the source uses cookies" do
       expect(YtDlpRunnerMock, :run, fn _url, :download_thumbnail, _opts, _ot, addl ->
         assert {:use_cookies, true} in addl
         {:ok, ""}
       end)
 
-      source = source_fixture(%{use_cookies: true})
+      source = source_fixture(%{cookie_behaviour: :all_operations})
+      media_item = Repo.preload(media_item_fixture(%{source_id: source.id}), :source)
+
+      Helpers.download_and_store_thumbnail_for(media_item)
+    end
+
+    test "does not set use_cookies if the source uses cookies when needed" do
+      expect(YtDlpRunnerMock, :run, fn _url, :download_thumbnail, _opts, _ot, addl ->
+        assert {:use_cookies, false} in addl
+        {:ok, ""}
+      end)
+
+      source = source_fixture(%{cookie_behaviour: :when_needed})
       media_item = Repo.preload(media_item_fixture(%{source_id: source.id}), :source)
 
       Helpers.download_and_store_thumbnail_for(media_item)
@@ -106,19 +128,11 @@ defmodule Pinchflat.Metadata.MetadataFileHelpersTest do
         {:ok, ""}
       end)
 
-      source = source_fixture(%{use_cookies: false})
+      source = source_fixture(%{cookie_behaviour: :disabled})
       media_item = Repo.preload(media_item_fixture(%{source_id: source.id}), :source)
 
       Helpers.download_and_store_thumbnail_for(media_item)
     end
-
-    test "returns nil if yt-dlp fails", %{media_item: media_item} do
-      stub(YtDlpRunnerMock, :run, fn _url, :download_thumbnail, _opts, _ot, _addl -> {:error, "error"} end)
-
-      filepath = Helpers.download_and_store_thumbnail_for(media_item)
-
-      assert filepath == nil
-    end
   end
 
   describe "parse_upload_date/1" do

test/pinchflat/metadata/source_metadata_storage_worker_test.exs

@@ -254,7 +254,23 @@ defmodule Pinchflat.Metadata.SourceMetadataStorageWorkerTest do
       end)
 
       profile = media_profile_fixture(%{download_source_images: true})
-      source = source_fixture(media_profile_id: profile.id, use_cookies: true)
+      source = source_fixture(media_profile_id: profile.id, cookie_behaviour: :all_operations)
+
+      perform_job(SourceMetadataStorageWorker, %{id: source.id})
+    end
+
+    test "does not set use_cookies if the source uses cookies when needed" do
+      expect(YtDlpRunnerMock, :run, 2, fn
+        _url, :get_source_details, _opts, _ot, _addl ->
+          {:ok, source_details_return_fixture()}
+
+        _url, :get_source_metadata, _opts, _ot, addl ->
+          assert {:use_cookies, false} in addl
+          {:ok, render_metadata(:channel_source_metadata)}
+      end)
+
+      profile = media_profile_fixture(%{download_source_images: true})
+      source = source_fixture(media_profile_id: profile.id, cookie_behaviour: :when_needed)
 
       perform_job(SourceMetadataStorageWorker, %{id: source.id})
     end
@@ -270,7 +286,7 @@ defmodule Pinchflat.Metadata.SourceMetadataStorageWorkerTest do
       end)
 
       profile = media_profile_fixture(%{download_source_images: true})
-      source = source_fixture(media_profile_id: profile.id, use_cookies: false)
+      source = source_fixture(media_profile_id: profile.id, cookie_behaviour: :disabled)
 
       perform_job(SourceMetadataStorageWorker, %{id: source.id})
     end
@@ -323,7 +339,21 @@ defmodule Pinchflat.Metadata.SourceMetadataStorageWorkerTest do
           {:ok, "{}"}
       end)
 
-      source = source_fixture(%{series_directory: nil, use_cookies: true})
+      source = source_fixture(%{series_directory: nil, cookie_behaviour: :all_operations})
+      perform_job(SourceMetadataStorageWorker, %{id: source.id})
+    end
+
+    test "does not set use_cookies if the source uses cookies when needed" do
+      expect(YtDlpRunnerMock, :run, 2, fn
+        _url, :get_source_details, _opts, _ot, addl ->
+          assert {:use_cookies, false} in addl
+          {:ok, source_details_return_fixture()}
+
+        _url, :get_source_metadata, _opts, _ot, _addl ->
+          {:ok, "{}"}
+      end)
+
+      source = source_fixture(%{series_directory: nil, cookie_behaviour: :when_needed})
       perform_job(SourceMetadataStorageWorker, %{id: source.id})
     end
 
@@ -337,7 +367,7 @@ defmodule Pinchflat.Metadata.SourceMetadataStorageWorkerTest do
           {:ok, "{}"}
       end)
 
-      source = source_fixture(%{series_directory: nil, use_cookies: false})
+      source = source_fixture(%{series_directory: nil, cookie_behaviour: :disabled})
       perform_job(SourceMetadataStorageWorker, %{id: source.id})
     end
   end

test/pinchflat/slow_indexing/slow_indexing_helpers_test.exs

@@ -302,14 +302,27 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpersTest do
 
       SlowIndexingHelpers.index_and_enqueue_download_for_media_items(source)
     end
+  end
 
+  describe "index_and_enqueue_download_for_media_items/2 when testing cookies" do
     test "sets use_cookies if the source uses cookies" do
       expect(YtDlpRunnerMock, :run, fn _url, :get_media_attributes_for_collection, _opts, _ot, addl_opts ->
         assert {:use_cookies, true} in addl_opts
         {:ok, source_attributes_return_fixture()}
       end)
 
-      source = source_fixture(%{use_cookies: true})
+      source = source_fixture(%{cookie_behaviour: :all_operations})
+
+      SlowIndexingHelpers.index_and_enqueue_download_for_media_items(source)
+    end
+
+    test "sets use_cookies if the source uses cookies when needed" do
+      expect(YtDlpRunnerMock, :run, fn _url, :get_media_attributes_for_collection, _opts, _ot, addl_opts ->
+        assert {:use_cookies, true} in addl_opts
+        {:ok, source_attributes_return_fixture()}
+      end)
+
+      source = source_fixture(%{cookie_behaviour: :when_needed})
 
       SlowIndexingHelpers.index_and_enqueue_download_for_media_items(source)
     end
@@ -320,7 +333,7 @@ defmodule Pinchflat.SlowIndexing.SlowIndexingHelpersTest do
         {:ok, source_attributes_return_fixture()}
       end)
 
-      source = source_fixture(%{use_cookies: false})
+      source = source_fixture(%{cookie_behaviour: :disabled})
 
       SlowIndexingHelpers.index_and_enqueue_download_for_media_items(source)
     end

test/pinchflat/sources_test.exs

@@ -60,6 +60,28 @@ defmodule Pinchflat.SourcesTest do
     end
   end
 
+  describe "use_cookies?/2" do
+    test "returns true if the source has been set to use cookies" do
+      source = source_fixture(%{cookie_behaviour: :all_operations})
+      assert Sources.use_cookies?(source, :downloading)
+    end
+
+    test "returns false if the source has not been set to use cookies" do
+      source = source_fixture(%{cookie_behaviour: :disabled})
+      refute Sources.use_cookies?(source, :downloading)
+    end
+
+    test "returns true if the action is indexing and the source is set to :when_needed" do
+      source = source_fixture(%{cookie_behaviour: :when_needed})
+      assert Sources.use_cookies?(source, :indexing)
+    end
+
+    test "returns false if the action is downloading and the source is set to :when_needed" do
+      source = source_fixture(%{cookie_behaviour: :when_needed})
+      refute Sources.use_cookies?(source, :downloading)
+    end
+  end
+
   describe "list_sources/0" do
     test "it returns all sources" do
       source = source_fixture()
@@ -393,13 +415,13 @@ defmodule Pinchflat.SourcesTest do
       valid_attrs = %{
         media_profile_id: media_profile_fixture().id,
         original_url: "https://www.youtube.com/channel/abc123",
-        use_cookies: true
+        cookie_behaviour: :all_operations
       }
 
       assert {:ok, %Source{}} = Sources.create_source(valid_attrs)
     end
 
-    test "does not set use_cookies to false if the source has not been set to use cookies" do
+    test "does not set use_cookies if the source uses cookies when needed" do
       expect(YtDlpRunnerMock, :run, fn _url, :get_source_details, _opts, _ot, addl ->
         refute Keyword.get(addl, :use_cookies)
 
@@ -409,7 +431,23 @@ defmodule Pinchflat.SourcesTest do
       valid_attrs = %{
         media_profile_id: media_profile_fixture().id,
         original_url: "https://www.youtube.com/channel/abc123",
-        use_cookies: false
+        cookie_behaviour: :when_needed
+      }
+
+      assert {:ok, %Source{}} = Sources.create_source(valid_attrs)
+    end
+
+    test "does not set use_cookies if the source has not been set to use cookies" do
+      expect(YtDlpRunnerMock, :run, fn _url, :get_source_details, _opts, _ot, addl ->
+        refute Keyword.get(addl, :use_cookies)
+
+        {:ok, playlist_return()}
+      end)
+
+      valid_attrs = %{
+        media_profile_id: media_profile_fixture().id,
+        original_url: "https://www.youtube.com/channel/abc123",
+        cookie_behaviour: :disabled
       }
 
       assert {:ok, %Source{}} = Sources.create_source(valid_attrs)