fix(mint): standardize adapter_payload shape on disconnect

grpc_client/lib/grpc/client/adapters/mint.ex

@@ -58,15 +58,15 @@ defmodule GRPC.Client.Adapters.Mint do
   def disconnect(%{adapter_payload: %{conn_pid: pid}} = channel)
       when is_pid(pid) do
     :ok = ConnectionProcess.disconnect(pid)
-    {:ok, %{channel | adapter_payload: nil}}
+    {:ok, %{channel | adapter_payload: %{conn_pid: nil}}}
   end
 
-  def disconnect(%{adapter_payload: nil} = channel) do
+  def disconnect(%{adapter_payload: %{conn_pid: nil}} = channel) do
     {:ok, channel}
   end
 
   @impl true
-  def send_request(%{channel: %{adapter_payload: nil}}, _message, _opts),
+  def send_request(%{channel: %{adapter_payload: %{conn_pid: nil}}}, _message, _opts),
     do: raise(ArgumentError, "Can't perform a request without a connection process")
 
   def send_request(stream, message, opts) do
@@ -84,7 +84,7 @@ defmodule GRPC.Client.Adapters.Mint do
   end
 
   @impl true
-  def send_headers(%{channel: %{adapter_payload: nil}}, _opts),
+  def send_headers(%{channel: %{adapter_payload: %{conn_pid: nil}}}, _opts),
     do: raise("Can't start a client stream without a connection process")
 
   def send_headers(stream, opts) do

grpc_client/lib/grpc/stub.ex

@@ -316,12 +316,14 @@ defmodule GRPC.Stub do
 
     ch =
       case Connection.pick_channel(channel, opts) do
-        {:ok, ch} ->
-          if Process.alive?(ch.adapter_payload.conn_pid) do
+        {:ok, %Channel{adapter_payload: adapter_payload} = ch} when is_map(adapter_payload) ->
+          conn_pid = Map.get(adapter_payload, :conn_pid)
+
+          if is_pid(conn_pid) and Process.alive?(conn_pid) do
             ch
           else
             Logger.warning(
-              "The connection process #{inspect(ch.adapter_payload.conn_pid)} is not alive, " <>
+              "The connection process #{inspect(conn_pid)} is not alive, " <>
                 "please create a new channel via GRPC.Stub.connect/2"
             )
 

grpc_client/test/grpc/adapters/gun_test.exs

@@ -3,23 +3,23 @@ defmodule GRPC.Client.Adapters.GunTest do
 
   alias GRPC.Client.Adapters.Gun
 
-  describe "connect/2" do
-    setup do
-      server_credential = build(:credential)
+  setup do
+    server_credential = build(:credential)
 
-      {:ok, _, port} =
-        GRPC.Server.start(FeatureServer, 0, adapter_opts: [cred: server_credential])
+    {:ok, _, port} =
+      GRPC.Server.start(FeatureServer, 0, adapter_opts: [cred: server_credential])
 
-      on_exit(fn ->
-        :ok = GRPC.Server.stop(FeatureServer)
-      end)
+    on_exit(fn ->
+      :ok = GRPC.Server.stop(FeatureServer)
+    end)
 
-      %{
-        port: port,
-        credential: server_credential
-      }
-    end
+    %{
+      port: port,
+      credential: server_credential
+    }
+  end
 
+  describe "connect/2" do
     test "connects insecurely (default options)", %{port: port, credential: credential} do
       channel = build(:channel, port: port, host: "localhost", cred: credential)
 
@@ -86,4 +86,34 @@ defmodule GRPC.Client.Adapters.GunTest do
                )
     end
   end
+
+  describe "disconnect/1" do
+    test "keeps adapter_payload as a map with conn_pid set to nil", %{
+      port: port,
+      credential: credential
+    } do
+      channel = build(:channel, port: port, host: "localhost", cred: credential)
+
+      {:ok, connected} = Gun.connect(channel, [])
+      assert %{conn_pid: pid} = connected.adapter_payload
+      assert is_pid(pid)
+
+      {:ok, disconnected} = Gun.disconnect(connected)
+
+      assert %{conn_pid: nil} = disconnected.adapter_payload
+    end
+
+    test "disconnect is idempotent — calling it twice succeeds", %{
+      port: port,
+      credential: credential
+    } do
+      channel = build(:channel, port: port, host: "localhost", cred: credential)
+
+      {:ok, connected} = Gun.connect(channel, [])
+      {:ok, disconnected} = Gun.disconnect(connected)
+      {:ok, disconnected_again} = Gun.disconnect(disconnected)
+
+      assert %{conn_pid: nil} = disconnected_again.adapter_payload
+    end
+  end
 end

grpc_client/test/grpc/adapters/mint_test.exs

@@ -3,17 +3,17 @@ defmodule GRPC.Client.Adapters.MintTest do
 
   alias GRPC.Client.Adapters.Mint
 
-  describe "connect/2" do
-    setup do
-      {:ok, _, port} = GRPC.Server.start(FeatureServer, 0)
+  setup do
+    {:ok, _, port} = GRPC.Server.start(FeatureServer, 0)
 
-      on_exit(fn ->
-        :ok = GRPC.Server.stop(FeatureServer)
-      end)
+    on_exit(fn ->
+      :ok = GRPC.Server.stop(FeatureServer)
+    end)
 
-      %{port: port}
-    end
+    %{port: port}
+  end
 
+  describe "connect/2" do
     test "connects insecurely (default options)", %{port: port} do
       channel = build(:channel, adapter: Mint, port: port, host: "localhost")
 
@@ -79,4 +79,41 @@ defmodule GRPC.Client.Adapters.MintTest do
                Map.get(state.conn, :client_settings)
     end
   end
+
+  describe "disconnect/1" do
+    test "keeps adapter_payload as a map with conn_pid set to nil", %{port: port} do
+      channel = build(:channel, adapter: Mint, port: port, host: "localhost")
+
+      {:ok, connected} = Mint.connect(channel, [])
+      assert %{conn_pid: pid} = connected.adapter_payload
+      assert is_pid(pid)
+
+      {:ok, disconnected} = Mint.disconnect(connected)
+
+      assert %{conn_pid: nil} = disconnected.adapter_payload
+    end
+
+    test "disconnect is idempotent — calling it twice succeeds", %{port: port} do
+      channel = build(:channel, adapter: Mint, port: port, host: "localhost")
+
+      {:ok, connected} = Mint.connect(channel, [])
+      {:ok, disconnected} = Mint.disconnect(connected)
+      {:ok, disconnected_again} = Mint.disconnect(disconnected)
+
+      assert %{conn_pid: nil} = disconnected_again.adapter_payload
+    end
+
+    test "send_request/3 raises ArgumentError when conn_pid is nil", %{port: port} do
+      channel = build(:channel, adapter: Mint, port: port, host: "localhost")
+
+      {:ok, connected} = Mint.connect(channel, [])
+      {:ok, disconnected} = Mint.disconnect(connected)
+
+      stream = build(:client_stream, channel: disconnected)
+
+      assert_raise ArgumentError, ~r/Can't perform a request without a connection process/, fn ->
+        Mint.send_request(stream, %Helloworld.HelloRequest{name: "test"}, [])
+      end
+    end
+  end
 end