Add more tests

Author: wojtekmach

lib/mint/http.ex

@@ -965,15 +965,19 @@ defmodule Mint.HTTP do
   defp recv_response([], acc, conn, ref, timeout) do
     start_time = System.monotonic_time(:millisecond)
 
-    with {:ok, conn, entries} <- recv(conn, 0, timeout) do
-      timeout =
-        if is_integer(timeout) do
-          timeout - System.monotonic_time(:millisecond) - start_time
-        else
-          timeout
-        end
+    case recv(conn, 0, timeout) do
+      {:ok, conn, entries} ->
+        timeout =
+          if is_integer(timeout) do
+            timeout - System.monotonic_time(:millisecond) - start_time
+          else
+            timeout
+          end
+
+        recv_response(entries, acc, conn, ref, timeout)
 
-      recv_response(entries, acc, conn, ref, timeout)
+      {:error, conn, reason, _responses} ->
+        {:error, conn, reason}
     end
   end
 

test/mint/http1/conn_test.exs

@@ -460,26 +460,50 @@ defmodule Mint.HTTP1Test do
     assert responses == [{:status, ref, 200}]
   end
 
-  test "starting a connection in :passive mode and using Mint.HTTP.recv_response/3",
-       %{port: port, server_ref: server_ref} do
-    assert {:ok, conn} = HTTP1.connect(:http, "localhost", port, mode: :passive)
-    assert_receive {^server_ref, server_socket}
+  describe "Mint.HTTP.recv_response/3" do
+    test "receives response", %{port: port, server_ref: server_ref} do
+      assert {:ok, conn} = HTTP1.connect(:http, "localhost", port, mode: :passive)
+      assert_receive {^server_ref, server_socket}
 
-    {:ok, conn, ref} = HTTP1.request(conn, "GET", "/", [], nil)
+      {:ok, conn, ref} = HTTP1.request(conn, "GET", "/", [], nil)
 
-    :ok = :gen_tcp.send(server_socket, "HTTP/1.1 200 OK\r\n")
-    :ok = :gen_tcp.send(server_socket, "content-type: text/plain\r\n")
-    :ok = :gen_tcp.send(server_socket, "content-length: 10\r\n\r\n")
-    :ok = :gen_tcp.send(server_socket, "hello")
-    :ok = :gen_tcp.send(server_socket, "world")
-
-    assert {:ok, _conn, response} = Mint.HTTP.recv_response(conn, ref, 100)
-
-    assert response == %{
-             body: "helloworld",
-             headers: [{"content-type", "text/plain"}, {"content-length", "10"}],
-             status: 200
-           }
+      :ok = :gen_tcp.send(server_socket, "HTTP/1.1 200 OK\r\n")
+      :ok = :gen_tcp.send(server_socket, "content-type: text/plain\r\n")
+      :ok = :gen_tcp.send(server_socket, "content-length: 10\r\n\r\n")
+      :ok = :gen_tcp.send(server_socket, "hello")
+      :ok = :gen_tcp.send(server_socket, "world")
+
+      assert {:ok, _conn, response} = Mint.HTTP.recv_response(conn, ref, 100)
+
+      assert response == %{
+               body: "helloworld",
+               headers: [{"content-type", "text/plain"}, {"content-length", "10"}],
+               status: 200
+             }
+    end
+
+    test "handles errors", %{port: port, server_ref: server_ref} do
+      assert {:ok, conn} = HTTP1.connect(:http, "localhost", port, mode: :passive)
+      assert_receive {^server_ref, server_socket}
+
+      {:ok, conn, ref} = HTTP1.request(conn, "GET", "/", [], nil)
+
+      :ok = :gen_tcp.send(server_socket, "HTTP/1.1 200 OK\r\n")
+      :ok = :gen_tcp.close(server_socket)
+
+      assert {:error, _conn, %Mint.TransportError{reason: :closed}} =
+               Mint.HTTP.recv_response(conn, ref, 100)
+    end
+
+    test "handles timeout", %{port: port, server_ref: server_ref} do
+      assert {:ok, conn} = HTTP1.connect(:http, "localhost", port, mode: :passive)
+      assert_receive {^server_ref, _server_socket}
+
+      {:ok, conn, ref} = HTTP1.request(conn, "GET", "/", [], nil)
+
+      assert {:error, _conn, %Mint.TransportError{reason: :timeout}} =
+               Mint.HTTP.recv_response(conn, ref, 1)
+    end
   end
 
   test "changing the connection mode with set_mode/2",

test/mint/http2/conn_test.exs

@@ -2087,45 +2087,6 @@ defmodule Mint.HTTP2Test do
       assert HTTP2.open?(conn)
     end
 
-    @tag connect_options: [mode: :passive]
-    test "starting a connection with :passive mode and using Mint.HTTP.recv_response/3", %{
-      conn: conn
-    } do
-      {conn, ref} = open_request(conn)
-
-      assert_recv_frames [headers(stream_id: stream_id)]
-
-      data =
-        server_encode_frames([
-          headers(
-            stream_id: stream_id,
-            hbf:
-              server_encode_headers([
-                {":status", "200"},
-                {"content-type", "text/plain"},
-                {"content-length", "10"}
-              ]),
-            flags: set_flags(:headers, [:end_headers])
-          ),
-          data(
-            stream_id: stream_id,
-            data: "helloworld",
-            flags: set_flags(:data, [:end_stream])
-          )
-        ])
-
-      :ok = :ssl.send(server_get_socket(), data)
-      assert {:ok, _conn, response} = Mint.HTTP.recv_response(conn, ref, 100)
-
-      assert response == %{
-               body: "helloworld",
-               headers: [{"content-type", "text/plain"}, {"content-length", "10"}],
-               status: 200
-             }
-
-      assert HTTP2.open?(conn)
-    end
-
     test "changing the mode of a connection with set_mode/2", %{conn: conn} do
       assert_raise ArgumentError, ~r"^can't use recv/3", fn ->
         HTTP2.recv(conn, 0, 100)
@@ -2206,6 +2167,67 @@ defmodule Mint.HTTP2Test do
     end
   end
 
+  describe "Mint.HTTP.recv_response/3" do
+    @describetag connect_options: [mode: :passive]
+
+    test "receives response", %{conn: conn} do
+      {conn, ref} = open_request(conn)
+
+      assert_recv_frames [headers(stream_id: stream_id)]
+
+      data =
+        server_encode_frames([
+          headers(
+            stream_id: stream_id,
+            hbf:
+              server_encode_headers([
+                {":status", "200"},
+                {"content-type", "text/plain"},
+                {"content-length", "10"}
+              ]),
+            flags: set_flags(:headers, [:end_headers])
+          ),
+          data(
+            stream_id: stream_id,
+            data: "helloworld",
+            flags: set_flags(:data, [:end_stream])
+          )
+        ])
+
+      :ok = :ssl.send(server_get_socket(), data)
+      assert {:ok, _conn, response} = Mint.HTTP.recv_response(conn, ref, 100)
+
+      assert response == %{
+               body: "helloworld",
+               headers: [{"content-type", "text/plain"}, {"content-length", "10"}],
+               status: 200
+             }
+
+      assert HTTP2.open?(conn)
+    end
+
+    test "handles errors", %{conn: conn} do
+      {conn, ref} = open_request(conn)
+      assert_recv_frames [headers(stream_id: _stream_id)]
+      :ok = :ssl.close(server_get_socket())
+
+      assert {:error, _conn, %Mint.TransportError{reason: :closed}} =
+               Mint.HTTP.recv_response(conn, ref, 100)
+
+      assert HTTP2.open?(conn)
+    end
+
+    test "handles timeout", %{conn: conn} do
+      {conn, ref} = open_request(conn)
+      assert_recv_frames [headers(stream_id: _stream_id)]
+
+      assert {:error, _conn, %Mint.TransportError{reason: :timeout}} =
+               Mint.HTTP.recv_response(conn, ref, 1)
+
+      assert HTTP2.open?(conn)
+    end
+  end
+
   describe "ping" do
     test "if we send a PING we then get a :pong reply", %{conn: conn} do
       assert {:ok, conn, ref} = HTTP2.ping(conn)