connection_unit_test.exs

defmodule ExUtcp.Transports.Graphql.ConnectionUnitTest do
  @moduledoc """
  Unit tests for GraphQL Connection module using direct GenServer callback testing.
  """

  use ExUnit.Case, async: true

  alias ExUtcp.Transports.Graphql.Connection

  @moduletag :unit

  describe "struct definition" do
    test "has expected fields" do
      state = %Connection{
        provider: %{name: "test", url: "http://example.com/graphql"},
        client: nil,
        connection_state: :disconnected,
        last_used: DateTime.utc_now(),
        retry_count: 0,
        max_retries: 3,
        subscription_handles: %{}
      }

      assert state.provider.name == "test"
      assert state.provider.url == "http://example.com/graphql"
      assert state.connection_state == :disconnected
      assert state.retry_count == 0
      assert state.max_retries == 3
      assert state.subscription_handles == %{}
    end
  end

  describe "public API functions exist" do
    test "start_link/2 is defined" do
      assert is_function(&Connection.start_link/2, 2)
    end

    test "query/4 is defined" do
      assert is_function(&Connection.query/4, 4)
    end

    test "mutation/4 is defined" do
      assert is_function(&Connection.mutation/4, 4)
    end

    test "subscription/4 is defined" do
      assert is_function(&Connection.subscription/4, 4)
    end

    test "introspect_schema/2 is defined" do
      assert is_function(&Connection.introspect_schema/2, 2)
    end

    test "close/1 is defined" do
      assert is_function(&Connection.close/1, 1)
    end

    test "healthy?/1 is defined" do
      assert is_function(&Connection.healthy?/1, 1)
    end

    test "get_last_used/1 is defined" do
      assert is_function(&Connection.get_last_used/1, 1)
    end

    test "update_last_used/1 is defined" do
      assert is_function(&Connection.update_last_used/1, 1)
    end
  end

  describe "init/1 callback" do
    @tag :skip
    test "initializes with provider and opts" do
      # Skipped: init calls establish_connection which makes HTTP requests
      provider = %{name: "test", url: "http://example.com/graphql"}
      opts = [max_retries: 5]

      # This would make actual HTTP request
      result = Connection.init({provider, opts})
      assert match?({:ok, _}, result) or match?({:stop, _}, result)
    end

    test "sets default max_retries when not provided" do
      provider = %{name: "test", url: "http://example.com/graphql"}
      # opts = []

      # Can't test init directly without HTTP, but struct creation works
      state = %Connection{
        provider: provider,
        client: nil,
        connection_state: :connecting,
        last_used: DateTime.utc_now(),
        retry_count: 0,
        max_retries: 3,
        subscription_handles: %{}
      }

      assert state.max_retries == 3
    end
  end

  describe "handle_call :query" do
    test "returns error when not connected" do
      state = %Connection{
        provider: %{name: "test", url: "http://example.com/graphql"},
        client: nil,
        connection_state: :disconnected,
        last_used: DateTime.utc_now(),
        retry_count: 0,
        max_retries: 3,
        subscription_handles: %{}
      }

      from = {self(), :test_ref}

      result = Connection.handle_call({:query, "{ test }", %{}, []}, from, state)
      assert match?({:reply, {:error, _}, ^state}, result)
    end

    @tag :skip
    test "executes query when connected" do
      # Skipped: requires actual HTTP client
      state = %Connection{
        provider: %{name: "test", url: "http://example.com/graphql"},
        client: :mock_client,
        connection_state: :connected,
        last_used: DateTime.utc_now(),
        retry_count: 0,
        max_retries: 3,
        subscription_handles: %{}
      }

      from = {self(), :test_ref}

      result = Connection.handle_call({:query, "{ test }", %{}, []}, from, state)
      # Will fail due to HTTP error but tests the code path
      assert match?({:reply, {:error, _}, _}, result)
    end
  end

  describe "handle_call :mutation" do
    test "returns error when not connected" do
      state = %Connection{
        provider: %{name: "test", url: "http://example.com/graphql"},
        client: nil,
        connection_state: :disconnected,
        last_used: DateTime.utc_now(),
        retry_count: 0,
        max_retries: 3,
        subscription_handles: %{}
      }

      from = {self(), :test_ref}

      result = Connection.handle_call({:mutation, "mutation { test }", %{}, []}, from, state)
      assert match?({:reply, {:error, _}, ^state}, result)
    end

    @tag :skip
    test "executes mutation when connected" do
      # Skipped: requires actual HTTP client
      state = %Connection{
        provider: %{name: "test", url: "http://example.com/graphql"},
        client: :mock_client,
        connection_state: :connected,
        last_used: DateTime.utc_now(),
        retry_count: 0,
        max_retries: 3,
        subscription_handles: %{}
      }

      from = {self(), :test_ref}

      result = Connection.handle_call({:mutation, "mutation { test }", %{}, []}, from, state)
      assert match?({:reply, {:error, _}, _}, result)
    end
  end

  describe "handle_call :subscription" do
    test "returns error when not connected" do
      state = %Connection{
        provider: %{name: "test", url: "http://example.com/graphql"},
        client: nil,
        connection_state: :disconnected,
        last_used: DateTime.utc_now(),
        retry_count: 0,
        max_retries: 3,
        subscription_handles: %{}
      }

      from = {self(), :test_ref}

      result =
        Connection.handle_call({:subscription, "subscription { test }", %{}, []}, from, state)

      assert match?({:reply, {:error, _}, ^state}, result)
    end

    @tag :skip
    test "executes subscription when connected" do
      # Skipped: requires actual HTTP client
      state = %Connection{
        provider: %{name: "test", url: "http://example.com/graphql"},
        client: :mock_client,
        connection_state: :connected,
        last_used: DateTime.utc_now(),
        retry_count: 0,
        max_retries: 3,
        subscription_handles: %{}
      }

      from = {self(), :test_ref}

      result =
        Connection.handle_call({:subscription, "subscription { test }", %{}, []}, from, state)

      assert match?({:reply, {:error, _}, _}, result)
    end
  end

  describe "handle_call :introspect_schema" do
    test "returns error when not connected" do
      state = %Connection{
        provider: %{name: "test", url: "http://example.com/graphql"},
        client: nil,
        connection_state: :disconnected,
        last_used: DateTime.utc_now(),
        retry_count: 0,
        max_retries: 3,
        subscription_handles: %{}
      }

      from = {self(), :test_ref}

      result = Connection.handle_call({:introspect_schema, []}, from, state)
      assert match?({:reply, {:error, _}, ^state}, result)
    end

    @tag :skip
    test "executes introspection when connected" do
      # Skipped: requires actual HTTP client
      state = %Connection{
        provider: %{name: "test", url: "http://example.com/graphql"},
        client: :mock_client,
        connection_state: :connected,
        last_used: DateTime.utc_now(),
        retry_count: 0,
        max_retries: 3,
        subscription_handles: %{}
      }

      from = {self(), :test_ref}

      result = Connection.handle_call({:introspect_schema, []}, from, state)
      assert match?({:reply, {:error, _}, _}, result)
    end
  end

  describe "handle_call :healthy?" do
    test "returns true when connected and client exists" do
      state = %Connection{
        provider: %{name: "test"},
        client: :mock_client,
        connection_state: :connected,
        last_used: DateTime.utc_now(),
        retry_count: 0,
        max_retries: 3,
        subscription_handles: %{}
      }

      from = {self(), :test_ref}

      result = Connection.handle_call(:healthy?, from, state)
      assert match?({:reply, true, ^state}, result)
    end

    test "returns false when disconnected" do
      state = %Connection{
        provider: %{name: "test"},
        client: :mock_client,
        connection_state: :disconnected,
        last_used: DateTime.utc_now(),
        retry_count: 0,
        max_retries: 3,
        subscription_handles: %{}
      }

      from = {self(), :test_ref}

      result = Connection.handle_call(:healthy?, from, state)
      assert match?({:reply, false, ^state}, result)
    end

    test "returns false when client is nil" do
      state = %Connection{
        provider: %{name: "test"},
        client: nil,
        connection_state: :connected,
        last_used: DateTime.utc_now(),
        retry_count: 0,
        max_retries: 3,
        subscription_handles: %{}
      }

      from = {self(), :test_ref}

      result = Connection.handle_call(:healthy?, from, state)
      assert match?({:reply, false, ^state}, result)
    end
  end

  describe "handle_call :get_last_used" do
    test "returns last_used timestamp" do
      last_used = DateTime.utc_now()

      state = %Connection{
        provider: %{name: "test"},
        client: nil,
        connection_state: :disconnected,
        last_used: last_used,
        retry_count: 0,
        max_retries: 3,
        subscription_handles: %{}
      }

      from = {self(), :test_ref}

      result = Connection.handle_call(:get_last_used, from, state)
      assert match?({:reply, ^last_used, ^state}, result)
    end
  end

  describe "handle_call :update_last_used" do
    test "updates last_used timestamp" do
      old_time = DateTime.utc_now()

      state = %Connection{
        provider: %{name: "test"},
        client: nil,
        connection_state: :disconnected,
        last_used: old_time,
        retry_count: 0,
        max_retries: 3,
        subscription_handles: %{}
      }

      from = {self(), :test_ref}

      result = Connection.handle_call(:update_last_used, from, state)
      assert {:reply, :ok, new_state} = result
      # last_used should be updated to monotonic time (integer)
      assert is_integer(new_state.last_used)
    end
  end

  describe "handle_info :reconnect" do
    test "returns noreply when connection fails" do
      state = %Connection{
        provider: %{name: "test", url: "http://invalid:9999/graphql"},
        client: nil,
        connection_state: :disconnected,
        last_used: DateTime.utc_now(),
        retry_count: 0,
        max_retries: 3,
        subscription_handles: %{}
      }

      # Will fail to connect, but returns noreply with original state
      result = Connection.handle_info(:reconnect, state)
      assert match?({:noreply, _}, result)
    end
  end

  describe "terminate/2 callback" do
    test "terminates with subscription handles" do
      # Create a dummy process to monitor
      {:ok, pid} = Agent.start(fn -> %{} end)

      state = %Connection{
        provider: %{name: "test"},
        client: nil,
        connection_state: :disconnected,
        last_used: DateTime.utc_now(),
        retry_count: 0,
        max_retries: 3,
        subscription_handles: %{"sub1" => pid}
      }

      # Terminate should exit the subscription process
      result = Connection.terminate(:normal, state)
      assert result == :ok

      # Clean up
      if Process.alive?(pid) do
        Agent.stop(pid)
      end
    end

    test "terminates with empty subscription handles" do
      state = %Connection{
        provider: %{name: "test"},
        client: nil,
        connection_state: :disconnected,
        last_used: DateTime.utc_now(),
        retry_count: 0,
        max_retries: 3,
        subscription_handles: %{}
      }

      result = Connection.terminate(:normal, state)
      assert result == :ok
    end

    test "handles already dead subscription processes gracefully" do
      # Create and immediately kill a process
      {:ok, pid} = Agent.start(fn -> %{} end)
      Agent.stop(pid)

      state = %Connection{
        provider: %{name: "test"},
        client: nil,
        connection_state: :disconnected,
        last_used: DateTime.utc_now(),
        retry_count: 0,
        max_retries: 3,
        subscription_handles: %{"sub1" => pid}
      }

      # Should not crash even though pid is dead
      result = Connection.terminate(:normal, state)
      assert result == :ok
    end
  end

  describe "close/1" do
    @tag :skip
    test "stops the GenServer" do
      # Skipped: requires actual GenServer process
      # This tests the close function exists and calls GenServer.stop
      # Cannot test without starting a real process
    end
  end

  describe "state transitions" do
    test "can transition from disconnected to connected" do
      state = %Connection{
        provider: %{name: "test"},
        client: nil,
        connection_state: :disconnected,
        last_used: DateTime.utc_now(),
        retry_count: 0,
        max_retries: 3,
        subscription_handles: %{}
      }

      # Manually transition state
      new_state = %{state | connection_state: :connected, client: :mock_client}
      assert new_state.connection_state == :connected
      assert new_state.client == :mock_client
    end

    test "can update retry count" do
      state = %Connection{
        provider: %{name: "test"},
        client: nil,
        connection_state: :disconnected,
        last_used: DateTime.utc_now(),
        retry_count: 0,
        max_retries: 3,
        subscription_handles: %{}
      }

      new_state = %{state | retry_count: 1}
      assert new_state.retry_count == 1
    end

    test "can add subscription handles" do
      state = %Connection{
        provider: %{name: "test"},
        client: nil,
        connection_state: :disconnected,
        last_used: DateTime.utc_now(),
        retry_count: 0,
        max_retries: 3,
        subscription_handles: %{}
      }

      {:ok, pid} = Agent.start(fn -> %{} end)
      new_state = %{state | subscription_handles: %{"sub1" => pid}}
      assert map_size(new_state.subscription_handles) == 1
      assert new_state.subscription_handles["sub1"] == pid
      Agent.stop(pid)
    end
  end

  describe "type specifications" do
    test "t type is defined" do
      # Test that the type struct can be created with all required fields
      state = %Connection{
        provider: %{name: "test"},
        client: nil,
        connection_state: :connecting,
        last_used: DateTime.utc_now(),
        retry_count: 0,
        max_retries: 3,
        subscription_handles: %{}
      }

      assert state.connection_state in [:connecting, :connected, :disconnected, :error]
    end
  end
end