Eliminate global state from tests via injectable :config option

Add a :config option to create/1 and create/2 that overrides
Application.get_env lookups. All tests now run with async: true
and never call Application.put_env.

Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>

Author: 2 people

lib/terrarium.ex

@@ -79,12 +79,14 @@ defmodule Terrarium do
   def create(provider_or_opts \\ [], opts \\ [])
 
   def create(name, opts) when is_atom(name) and name != nil do
-    {provider, provider_opts} = resolve_named_or_module(name)
+    {config, opts} = Keyword.pop(opts, :config)
+    {provider, provider_opts} = resolve_named_or_module(name, config)
     provider.create(Keyword.merge(provider_opts, opts))
   end
 
   def create(opts, []) when is_list(opts) do
-    {provider, provider_opts, opts} = resolve_from_opts(opts)
+    {config, opts} = Keyword.pop(opts, :config)
+    {provider, provider_opts, opts} = resolve_from_opts(opts, config)
     provider.create(Keyword.merge(provider_opts, opts))
   end
 
@@ -205,10 +207,13 @@ defmodule Terrarium do
     provider.ls(sandbox, path)
   end
 
+  defp get_config(nil, key, default), do: Application.get_env(:terrarium, key, default)
+  defp get_config(config, key, default), do: Keyword.get(config, key, default)
+
   # Resolves an atom that could be either a named provider from config
   # or a direct provider module.
-  defp resolve_named_or_module(name) do
-    providers = Application.get_env(:terrarium, :providers, [])
+  defp resolve_named_or_module(name, config) do
+    providers = get_config(config, :providers, [])
 
     case Keyword.fetch(providers, name) do
       {:ok, {module, opts}} -> {module, opts}
@@ -219,30 +224,30 @@ defmodule Terrarium do
 
   # Resolves the provider from opts (inline :provider key) or falls back
   # to the configured default.
-  defp resolve_from_opts(opts) do
+  defp resolve_from_opts(opts, config) do
     case Keyword.pop(opts, :provider) do
       {nil, opts} ->
-        {provider, provider_opts} = resolve_default!()
+        {provider, provider_opts} = resolve_default!(config)
         {provider, provider_opts, opts}
 
       {{module, provider_opts}, opts} when is_atom(module) ->
         {module, provider_opts, opts}
 
       {module, opts} when is_atom(module) ->
-        {provider, provider_opts} = resolve_named_or_module(module)
+        {provider, provider_opts} = resolve_named_or_module(module, config)
         {provider, provider_opts, opts}
     end
   end
 
-  defp resolve_default! do
-    case Application.get_env(:terrarium, :default) do
+  defp resolve_default!(config) do
+    case get_config(config, :default, nil) do
       nil ->
         raise ArgumentError,
               "no default provider configured. Either pass a provider explicitly " <>
                 "or configure one: config :terrarium, default: :local, providers: [local: Terrarium.Providers.Local]"
 
       name ->
-        resolve_named_or_module(name)
+        resolve_named_or_module(name, config)
     end
   end
 end

test/terrarium/config_test.exs

@@ -1,45 +1,37 @@
 defmodule Terrarium.ConfigTest do
-  use ExUnit.Case, async: false
+  use ExUnit.Case, async: true
 
   alias Terrarium.Sandbox
 
-  # These tests modify Application config and must run sequentially.
-
-  setup do
-    on_exit(fn ->
-      Application.delete_env(:terrarium, :default)
-      Application.delete_env(:terrarium, :providers)
-    end)
-  end
+  @config [
+    default: :test,
+    providers: [
+      test: {Terrarium.TestProvider, from_config: true},
+      bare: Terrarium.TestProvider
+    ]
+  ]
 
   describe "named providers from config" do
     test "resolves a named provider" do
-      Application.put_env(:terrarium, :providers, test: Terrarium.TestProvider)
-
-      assert {:ok, %Sandbox{provider: Terrarium.TestProvider}} = Terrarium.create(:test)
+      assert {:ok, %Sandbox{provider: Terrarium.TestProvider}} =
+               Terrarium.create(:bare, config: @config)
     end
 
     test "resolves a named provider with {module, opts} tuple" do
-      Application.put_env(:terrarium, :providers, test: {Terrarium.TestProvider, some: "config"})
-
-      assert {:ok, %Sandbox{provider: Terrarium.TestProvider}} = Terrarium.create(:test)
+      assert {:ok, %Sandbox{provider: Terrarium.TestProvider}} =
+               Terrarium.create(:test, config: @config)
     end
   end
 
   describe "default provider from config" do
     test "uses the configured default provider" do
-      Application.put_env(:terrarium, :default, :test)
-      Application.put_env(:terrarium, :providers, test: Terrarium.TestProvider)
-
-      assert {:ok, %Sandbox{provider: Terrarium.TestProvider}} = Terrarium.create()
+      assert {:ok, %Sandbox{provider: Terrarium.TestProvider}} =
+               Terrarium.create(config: @config)
     end
 
     test "merges config opts with call-site opts" do
-      Application.put_env(:terrarium, :default, :test)
-      Application.put_env(:terrarium, :providers, test: {Terrarium.TestProvider, from_config: true})
-
       assert {:ok, %Sandbox{provider: Terrarium.TestProvider}} =
-               Terrarium.create(from_call: true)
+               Terrarium.create(config: @config, from_call: true)
     end
   end
 end