[Housekeeping] Refactor settings model (#165)

* [WIP] renamed current settings module and tables to have backup suffix

* Created new settings table, schema, and context

* Migrated from old settings module to new one

* Removed settings backup modules

* Added some tests and docs

test/pinchflat/boot/pre_job_startup_tasks_test.exs

@@ -1,25 +1,47 @@
 defmodule Pinchflat.Boot.PreJobStartupTasksTest do
   use Pinchflat.DataCase
 
+  import Pinchflat.JobFixtures
+
   alias Pinchflat.Settings
-  alias Pinchflat.Settings.Setting
   alias Pinchflat.Boot.PreJobStartupTasks
 
-  describe "apply_default_settings" do
-    setup do
-      Repo.delete_all(Setting)
+  describe "reset_executing_jobs" do
+    test "resets executing jobs" do
+      job = job_fixture()
+      Repo.update_all(Oban.Job, set: [state: "executing"])
 
-      :ok
-    end
-
-    test "sets default settings" do
-      assert_raise Ecto.NoResultsError, fn -> Settings.get!(:onboarding) end
-      assert_raise Ecto.NoResultsError, fn -> Settings.get!(:pro_enabled) end
+      assert Repo.reload!(job).state == "executing"
 
       PreJobStartupTasks.start_link()
 
-      assert Settings.get!(:onboarding)
-      refute Settings.get!(:pro_enabled)
+      assert Repo.reload!(job).state == "retryable"
+    end
+  end
+
+  describe "create_blank_cookie_file" do
+    test "creates a blank cookie file" do
+      base_dir = Application.get_env(:pinchflat, :extras_directory)
+      filepath = Path.join(base_dir, "cookies.txt")
+      File.rm(filepath)
+
+      refute File.exists?(filepath)
+
+      PreJobStartupTasks.start_link()
+
+      assert File.exists?(filepath)
+    end
+  end
+
+  describe "apply_default_settings" do
+    test "sets default settings" do
+      Settings.set(yt_dlp_version: nil)
+
+      refute Settings.get!(:yt_dlp_version)
+
+      PreJobStartupTasks.start_link()
+
+      assert Settings.get!(:yt_dlp_version)
     end
   end
 end

test/pinchflat/settings_test.exs

@@ -9,100 +9,55 @@ defmodule Pinchflat.SettingsTest do
   # are always created on app boot (including in the test env),
   # so we can't treat these like a clean slate.
 
-  describe "list_settings/0" do
-    test "returns all settings" do
-      Settings.set!("foo", "bar")
-      results = Settings.list_settings()
+  setup do
+    # Ensure we have a clean slate
+    Settings.set(onboarding: false)
+    Settings.set(pro_enabled: false)
+    Settings.set(yt_dlp_version: nil)
 
-      assert Enum.all?(results, fn setting -> match?(%Setting{}, setting) end)
+    :ok
+  end
+
+  describe "record/0" do
+    test "returns the only setting" do
+      assert %Setting{} = Settings.record()
     end
   end
 
-  describe "set/2" do
-    test "creates a new setting if one does not exist" do
-      original = Repo.aggregate(Setting, :count, :id)
-      Settings.set!("foo", "bar")
-      assert Repo.aggregate(Setting, :count, :id) == original + 1
+  describe "set/1" do
+    test "updates the setting" do
+      assert {:ok, true} = Settings.set(onboarding: true)
+      assert {:ok, true} = Settings.get(:onboarding)
     end
 
-    test "updates an existing setting if one exists" do
-      Settings.set!("foo", "bar")
-      original = Repo.aggregate(Setting, :count, :id)
-      Settings.set!("foo", "baz")
-      assert Repo.aggregate(Setting, :count, :id) == original
-      assert Settings.get!("foo") == "baz"
+    test "returns an error if the setting key doesn't exist" do
+      assert {:error, :invalid_key} = Settings.set(foo: "bar")
     end
 
-    test "returns the parsed value" do
-      assert Settings.set!("foo", true) == true
-      assert Settings.set!("foo", false) == false
-      assert Settings.set!("foo", 123) == 123
-      assert Settings.set!("foo", 12.34) == 12.34
-      assert Settings.set!("foo", "bar") == "bar"
-    end
-
-    test "allows for atom keys" do
-      assert Settings.set!(:foo, "bar") == "bar"
-    end
-
-    test "blows up when an unsupported datatype is used" do
-      assert_raise FunctionClauseError, fn ->
-        Settings.set!("foo", nil)
-      end
-    end
-  end
-
-  describe "set/3" do
-    test "allows manual specification of datatype" do
-      assert Settings.set!("foo", "true", :boolean) == true
-      assert Settings.set!("foo", "false", :boolean) == false
-      assert Settings.set!("foo", "123", :integer) == 123
-      assert Settings.set!("foo", "12.34", :float) == 12.34
+    test "returns an error if the setting value is invalid" do
+      assert {:error, %Ecto.Changeset{}} = Settings.set(onboarding: "bar")
     end
   end
 
   describe "get/1" do
-    test "returns the value of the setting" do
-      Settings.set!("str", "bar")
-      Settings.set!("bool", true)
-      Settings.set!("int", 123)
-      Settings.set!("float", 12.34)
-
-      assert Settings.get!("str") == "bar"
-      assert Settings.get!("bool") == true
-      assert Settings.get!("int") == 123
-      assert Settings.get!("float") == 12.34
+    test "returns the setting value" do
+      assert {:ok, false} = Settings.get(:onboarding)
     end
 
-    test "allows for atom keys" do
-      Settings.set!("str", "bar")
-      assert Settings.get!(:str) == "bar"
+    test "returns an error if the setting key doesn't exist" do
+      assert {:error, :invalid_key} = Settings.get(:foo)
+    end
+  end
+
+  describe "get!/1" do
+    test "returns the setting value" do
+      assert Settings.get!(:onboarding) == false
     end
 
-    test "blows up when the setting does not exist" do
-      assert_raise Ecto.NoResultsError, fn ->
-        Settings.get!("foo")
+    test "raises an error if the setting key doesn't exist" do
+      assert_raise RuntimeError, "Setting `foo` not found", fn ->
+        Settings.get!(:foo)
       end
     end
   end
-
-  describe "fetch/2" do
-    test "creates a setting if one doesn't exist" do
-      original = Repo.aggregate(Setting, :count, :id)
-      assert Settings.fetch!("foo", "bar") == "bar"
-      assert Repo.aggregate(Setting, :count, :id) == original + 1
-    end
-
-    test "returns an existing setting if one does exist" do
-      Settings.set!("foo", "bar")
-
-      assert Settings.fetch!("foo", "baz") == "bar"
-    end
-  end
-
-  describe "fetch/3" do
-    test "allows manual specification of datatype" do
-      assert Settings.fetch!("foo", "true", :boolean) == true
-    end
-  end
 end