Abstract away access to application env global state to avoid test flakiness

Author: nelsonkopliku

lib/trento/ai.ex

@@ -3,17 +3,16 @@ defmodule Trento.AI do
   The `Trento.AI` module provides functions to interact with the AI features of the Trento application.
   """
 
+  alias Trento.AI.ApplicationConfigLoader
+
   alias Trento.AI.Configurations
 
   @doc """
   Checks if the AI features are enabled.
   """
   @spec enabled?() :: boolean()
   def enabled?,
-    do:
-      :trento
-      |> Application.get_env(:ai, [])
-      |> Keyword.get(:enabled, false)
+    do: Keyword.get(ApplicationConfigLoader.load(), :enabled, false)
 
   @doc """
   Creates a user configuration for AI.
@@ -41,9 +40,6 @@ defmodule Trento.AI do
     end
   end
 
-  defp configurations do
-    :trento
-    |> Application.get_env(:ai)
-    |> Keyword.get(:configurations, Configurations)
-  end
+  defp configurations,
+    do: Keyword.get(ApplicationConfigLoader.load(), :configurations, Configurations)
 end

lib/trento/ai/application_config_loader.ex

@@ -0,0 +1,21 @@
+defmodule Trento.AI.ApplicationConfigLoader do
+  @moduledoc """
+  This module is responsible for loading the AI application configuration and providing access to it.
+  """
+
+  @behaviour Trento.AI.ApplicationConfigLoader
+
+  @callback load_config :: keyword()
+
+  @impl true
+  def load_config, do: Application.get_env(:trento, :ai, [])
+
+  @spec load :: keyword()
+  def load, do: impl().load_config()
+
+  defp impl,
+    do:
+      :trento
+      |> Application.get_env(:ai, [])
+      |> Keyword.get(:application_config_loader, __MODULE__)
+end

lib/trento/ai/llm_registry.ex

@@ -3,6 +3,8 @@ defmodule Trento.AI.LLMRegistry do
   This module is responsible for managing the registry of available LLM providers and their models.
   """
 
+  alias Trento.AI.ApplicationConfigLoader
+
   @doc """
   Returns the list of configured LLM providers.
   """
@@ -47,9 +49,5 @@ defmodule Trento.AI.LLMRegistry do
   @spec model_supported?(bitstring()) :: boolean()
   def model_supported?(model), do: model in get_provider_models(:all)
 
-  defp get_ai_providers_config do
-    :trento
-    |> Application.get_env(:ai, [])
-    |> Keyword.get(:providers, [])
-  end
+  defp get_ai_providers_config, do: Keyword.get(ApplicationConfigLoader.load(), :providers, [])
 end

test/support/ai/ai_case.ex

@@ -0,0 +1,18 @@
+defmodule Trento.AI.AICase do
+  @moduledoc false
+
+  use ExUnit.CaseTemplate
+
+  setup _ do
+    stub_config_loader()
+
+    :ok
+  end
+
+  def stub_config_loader do
+    Mox.stub_with(
+      Trento.AI.ApplicationConfigLoader.Mock,
+      Trento.AI.ApplicationConfigLoader
+    )
+  end
+end

test/support/factory.ex

@@ -1462,6 +1462,8 @@ defmodule Trento.Factory do
   end
 
   def random_ai_model do
+    Trento.AI.AICase.stub_config_loader()
+
     :all
     |> LLMRegistry.get_provider_models()
     |> Enum.random()

test/test_helper.exs

@@ -53,6 +53,19 @@ Mox.defmock(Trento.Support.DateService.Mock, for: Trento.Support.DateService)
 Mox.defmock(Joken.CurrentTime.Mock, for: Joken.CurrentTime)
 Application.put_env(:joken, :current_time_adapter, Joken.CurrentTime.Mock)
 
+Mox.defmock(Trento.AI.ApplicationConfigLoader.Mock,
+  for: Trento.AI.ApplicationConfigLoader
+)
+
+test_ai_config =
+  Keyword.put(
+    Application.get_env(:trento, :ai),
+    :application_config_loader,
+    Trento.AI.ApplicationConfigLoader.Mock
+  )
+
+Application.put_env(:trento, :ai, test_ai_config)
+
 Application.ensure_all_started(:ex_machina, :faker)
 
 if Application.get_env(:trento, :flaky_tests_detection)[:enabled?] == true do

test/trento/ai/configurations_test.exs

@@ -1,5 +1,6 @@
 defmodule Trento.Ai.ConfigurationsTest do
   use Trento.DataCase, async: true
+  use Trento.AI.AICase
 
   alias Trento.Users.User
 

test/trento/ai/llm_registry_test.exs

@@ -3,44 +3,50 @@ defmodule Trento.AI.LLMRegistryTest do
 
   alias Trento.AI.LLMRegistry
 
-  setup do
-    original_config = Application.get_env(:trento, :ai)
-
-    Application.put_env(:trento, :ai,
-      enabled: true,
-      providers: [
-        provider1: [
-          models: [
-            "model1",
-            "model2"
-          ]
-        ],
-        provider2: [
-          models: [
-            "model3",
-            "model4"
-          ]
-        ],
-        provider3: [
-          models: [
-            "model5",
-            "model6"
+  import Mox
+
+  setup :verify_on_exit!
+
+  defp expect_config_loader_to_be_called_times(times) do
+    expect(Trento.AI.ApplicationConfigLoader.Mock, :load_config, times, fn ->
+      [
+        enabled: true,
+        providers: [
+          provider1: [
+            models: [
+              "model1",
+              "model2"
+            ]
+          ],
+          provider2: [
+            models: [
+              "model3",
+              "model4"
+            ]
+          ],
+          provider3: [
+            models: [
+              "model5",
+              "model6"
+            ]
           ]
         ]
       ]
-    )
-
-    on_exit(fn -> Application.put_env(:trento, :ai, original_config) end)
+    end)
   end
 
   describe "providers/0" do
     test "returns the list of configured providers" do
+      expect_config_loader_to_be_called_times(1)
+
       assert LLMRegistry.providers() == [:provider1, :provider2, :provider3]
     end
   end
 
   describe "get_provider_models/1" do
     test "returns the list of models for a given provider" do
+      expect_config_loader_to_be_called_times(3)
+
       assert LLMRegistry.get_provider_models(:provider1) == [
                "model1",
                "model2"
@@ -58,11 +64,15 @@ defmodule Trento.AI.LLMRegistryTest do
     end
 
     test "returns an empty list for an unknown provider" do
+      expect_config_loader_to_be_called_times(1)
+
       assert LLMRegistry.get_provider_models(:unknown) == []
       assert LLMRegistry.get_provider_models("foo") == []
     end
 
     test "returns all available models" do
+      expect_config_loader_to_be_called_times(1)
+
       assert LLMRegistry.get_provider_models(:all) == [
                "model1",
                "model2",
@@ -76,22 +86,30 @@ defmodule Trento.AI.LLMRegistryTest do
 
   describe "get_model_provider/1" do
     test "returns the provider for a given model" do
+      expect_config_loader_to_be_called_times(2)
+
       assert LLMRegistry.get_model_provider("model6") == :provider3
       assert LLMRegistry.get_model_provider("model1") == :provider1
     end
 
     test "returns nil for an unknown model" do
+      expect_config_loader_to_be_called_times(1)
+
       assert LLMRegistry.get_model_provider("unknown-model") == nil
     end
   end
 
   describe "model_supported?/1" do
     test "returns true for a supported model" do
+      expect_config_loader_to_be_called_times(2)
+
       assert LLMRegistry.model_supported?("model1") == true
       assert LLMRegistry.model_supported?("model6") == true
     end
 
     test "returns false for an unsupported model" do
+      expect_config_loader_to_be_called_times(1)
+
       assert LLMRegistry.model_supported?("unknown-model") == false
     end
   end

test/trento/ai_test.exs

@@ -5,32 +5,31 @@ defmodule Trento.AITest do
 
   import Trento.Factory
 
-  setup do
-    original_config = Application.get_env(:trento, :ai)
+  import Mox
 
-    on_exit(fn -> Application.put_env(:trento, :ai, original_config) end)
-  end
+  setup :verify_on_exit!
 
   describe "enabled?/0" do
     test "returns true when AI features are enabled" do
-      Application.put_env(:trento, :ai, enabled: true)
+      expect(Trento.AI.ApplicationConfigLoader.Mock, :load_config, fn -> [enabled: true] end)
+
       assert AI.enabled?() == true
     end
 
     test "returns false when AI features are disabled" do
-      Application.put_env(:trento, :ai, enabled: false)
+      expect(Trento.AI.ApplicationConfigLoader.Mock, :load_config, fn -> [enabled: false] end)
       assert AI.enabled?() == false
     end
 
     test "returns false when AI features are not configured" do
-      Application.delete_env(:trento, :ai)
+      expect(Trento.AI.ApplicationConfigLoader.Mock, :load_config, fn -> [] end)
       assert AI.enabled?() == false
     end
   end
 
   describe "enabling/disabling features" do
     test "features are disabled" do
-      Application.put_env(:trento, :ai, enabled: false)
+      expect(Trento.AI.ApplicationConfigLoader.Mock, :load_config, 2, fn -> [enabled: false] end)
       user = build(:user)
 
       attrs = %{
@@ -43,10 +42,12 @@ defmodule Trento.AITest do
     end
 
     test "features are enabled" do
-      Application.put_env(:trento, :ai,
-        enabled: true,
-        configurations: DummyConfigurations
-      )
+      expect(Trento.AI.ApplicationConfigLoader.Mock, :load_config, 4, fn ->
+        [
+          enabled: true,
+          configurations: DummyConfigurations
+        ]
+      end)
 
       user = build(:user)