fix: providers are equal

lib/open_feature.ex

@@ -22,7 +22,7 @@ defmodule OpenFeature do
   @spec set_provider(domain :: Types.domain(), provider :: Provider.t()) :: {:ok, Provider.t()} | {:error, atom}
   def set_provider(domain \\ "default", provider) do
     with {:ok, provider} <- Provider.validate_provider(provider),
-         {:not_set, old_provider} <- check_if_already_set(domain, provider),
+         {:replace, old_provider} <- check_if_already_set(domain, provider),
          context = get_global_context(),
          {:ok, provider} <- Provider.initialize(domain, provider, context) do
       Store.set_provider(domain, provider)
@@ -79,19 +79,19 @@ defmodule OpenFeature do
   @spec shutdown() :: :ok
   def shutdown, do: Enum.each(Store.list_providers(), &Provider.shutdown/1)
 
-  defp check_if_already_set(domain, %provider_module{} = provider) do
-    case Store.get_provider(domain) do
-      %^provider_module{} = domain_provider -> {:ok, domain_provider}
-      _provider -> {:not_set, provider}
+  defp check_if_already_set(domain, provider) do
+    domain_provider = Store.get_provider(domain)
+
+    if Provider.equal?(domain_provider, provider) do
+      {:ok, domain_provider}
+    else
+      {:replace, domain_provider}
     end
   end
 
-  defp maybe_shutdown_old_provider(%old_provider_module{} = old_provider) do
+  defp maybe_shutdown_old_provider(old_provider) do
     Store.list_providers()
-    |> Enum.any?(fn
-      %^old_provider_module{} = _provider -> true
-      _provider -> false
-    end)
+    |> Enum.any?(&Provider.equal?(&1, old_provider))
     |> then(fn
       false -> Provider.shutdown(old_provider)
       true -> :ok

lib/open_feature/provider.ex

@@ -122,16 +122,12 @@ defmodule OpenFeature.Provider do
   end
 
   @doc """
-  Checks if two providers are equal based on their name, domain, and state.
+  Checks if two providers are equal based on their module and name.
   """
   @doc since: "0.1.0"
-  @doc deprecated: "This function will be removed in the next major version."
   @spec equal?(t, t) :: boolean
   def equal?(%module1{} = provider1, %module2{} = provider2) do
-    module1 == module2 &&
-      provider1.name == provider2.name &&
-      provider1.domain == provider2.domain &&
-      provider1.state == provider2.state
+    module1 == module2 && provider1.name == provider2.name
   end
 
   def equal?(_, _), do: false

test/unit/open_feature/provider_test.exs

@@ -100,7 +100,7 @@ defmodule OpenFeature.ProviderTest do
     test "should return false if the provided providers are not equal" do
       refute Provider.equal?(@no_op_provider, @in_memory_provider)
 
-      different_no_op = Map.put(@no_op_provider, :domain, "some_domain")
+      different_no_op = Map.put(@no_op_provider, :name, "some_name")
       refute Provider.equal?(@no_op_provider, different_no_op)
     end
   end