Rename to Mint.HTTP.request_and_response/6

Author: wojtekmach

lib/mint/http.ex

@@ -876,14 +876,11 @@ defmodule Mint.HTTP do
   @version Mix.Project.config()[:version]
 
   @doc """
-  Receives response from the socket in a blocking way.
+  Sends a request and receives a response from the socket in a blocking way.
 
-  This function receives a response for the request identified by `request_ref` on the connection
-  `conn`.
+  This function is a convenience for sending a request with `request/5` and repeatedly calling `recv/3`.
 
-  `timeout` is the maximum time to wait before returning an error.
-
-  This function is a convenience for repeatedly calling `Mint.HTTP.recv/3`. The result is either:
+  The result is either:
 
     * `{:ok, conn, response}` where `conn` is the updated connection and `response` is a map
       with the following keys:
@@ -903,30 +900,48 @@ defmodule Mint.HTTP do
       Contrary to `recv/3`, this function does not return partial responses on errors. Use
       `recv/3` for full control.
 
-  This function only handles responses for the given `request_ref`. Do not use it when making
-  concurrent requests as responses other than for `request_ref` are ignored.
+  ## Options
+
+    * `:timeout` - the maximum amount of time in milliseconds waiting to receive the response.
+      Setting to `:infinity`, disables the timeout. Defaults to `:infinity`.
 
   ## Examples
 
       iex> {:ok, conn} = Mint.HTTP.connect(:https, "httpbin.org", 443, mode: :passive)
-      iex> {:ok, conn, request_ref} = Mint.HTTP.request(conn, "GET", "/user-agent", [], nil)
-      iex> {:ok, _conn, response} = Mint.HTTP.recv_response(conn, request_ref, 5000)
+      iex> {:ok, conn, response} = Mint.HTTP.request_and_response(conn, "GET", "/user-agent", [], nil)
       iex> response
       %{
         status: 200,
         headers: [{"date", ...}, ...],
         body: "{\\n  \\"user-agent\\": \\"#{@version}\\"\\n}\\n"
       }
+      iex> Mint.HTTP.open?(conn)
+      true
   """
-  @spec recv_response(t(), Types.request_ref(), timeout()) ::
-          {:ok, t(), response} | {:error, Types.error()}
+  @spec request_and_response(
+          t(),
+          method :: String.t(),
+          path :: String.t(),
+          Types.headers(),
+          body :: iodata() | nil | :stream,
+          options :: [{:timeout, timeout()}]
+        ) ::
+          {:ok, t(), response}
+          | {:error, t(), Types.error()}
         when response: %{
                status: non_neg_integer(),
                headers: [{binary(), binary()}],
                body: binary()
              }
-  def recv_response(conn, request_ref, timeout)
-      when is_reference(request_ref) and Util.is_timeout(timeout) do
+  def request_and_response(conn, method, path, headers, body, options \\ []) do
+    options = Keyword.validate!(options, timeout: :infinity)
+
+    with {:ok, conn, ref} <- request(conn, method, path, headers, body) do
+      recv_response(conn, ref, options[:timeout])
+    end
+  end
+
+  defp recv_response(conn, request_ref, timeout) when Util.is_timeout(timeout) do
     recv_response([], {nil, [], ""}, conn, request_ref, timeout)
   end
 

test/http_test.exs

@@ -1,4 +1,4 @@
 defmodule Mint.HTTPTest do
   use ExUnit.Case, async: true
-  doctest Mint.HTTP, except: [recv_response: 3]
+  doctest Mint.HTTP, except: [request_and_response: 6]
 end

test/mint/http1/conn_test.exs

@@ -460,42 +460,40 @@ defmodule Mint.HTTP1Test do
     assert responses == [{:status, ref, 200}]
   end
 
-  describe "Mint.HTTP.recv_response/3" do
+  describe "Mint.HTTP.request_and_response/6" 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 = :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)
+      {:ok, conn, response} = Mint.HTTP.request_and_response(conn, "GET", "/", [], nil)
 
       assert response == %{
                body: "helloworld",
                headers: [{"content-type", "text/plain"}, {"content-length", "10"}],
                status: 200
              }
+
+      assert HTTP1.open?(conn)
     end
 
     test "handles trailers", %{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.send(server_socket, "transfer-encoding: chunked\r\n")
       :ok = :gen_tcp.send(server_socket, "trailer: x-trailer\r\n\r\n")
       :ok = :gen_tcp.send(server_socket, "5\r\nhello\r\n")
       :ok = :gen_tcp.send(server_socket, "5\r\nworld\r\n0\r\n")
       :ok = :gen_tcp.send(server_socket, "x-trailer: foo\r\n\r\n")
 
-      assert {:ok, _conn, response} = Mint.HTTP.recv_response(conn, ref, 100)
+      {:ok, conn, response} = Mint.HTTP.request_and_response(conn, "GET", "/", [], nil)
 
       assert response == %{
                body: "helloworld",
@@ -506,29 +504,29 @@ defmodule Mint.HTTP1Test do
                ],
                status: 200
              }
+
+      assert HTTP1.open?(conn)
     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)
+               Mint.HTTP.request_and_response(conn, "GET", "/", [], nil)
     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.request_and_response(conn, "GET", "/", [], nil, timeout: 0)
 
-      assert {:error, _conn, %Mint.TransportError{reason: :timeout}} =
-               Mint.HTTP.recv_response(conn, ref, 1)
+      refute HTTP1.open?(conn)
     end
   end
 

test/mint/http2/conn_test.exs

@@ -2167,35 +2167,44 @@ defmodule Mint.HTTP2Test do
     end
   end
 
-  describe "Mint.HTTP.recv_response/3" do
+  describe "Mint.HTTP.request_and_response/6" 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])
-          )
-        ])
+    test "receives response", context do
+      pid = self()
+
+      Task.start_link(fn ->
+        context = Map.merge(context, start_server_async(context))
+        [conn: conn] = start_connection(context)
+        send(pid, {:conn, 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)
+        Process.sleep(:infinity)
+      end)
 
-      :ok = :ssl.send(server_get_socket(), data)
-      assert {:ok, _conn, response} = Mint.HTTP.recv_response(conn, ref, 100)
+      assert_receive {:conn, conn}
+      assert {:ok, conn, response} = Mint.HTTP.request_and_response(conn, "GET", "/", [], nil)
 
       assert response == %{
                body: "helloworld",
@@ -2206,45 +2215,53 @@ defmodule Mint.HTTP2Test do
       assert HTTP2.open?(conn)
     end
 
-    test "handles trailers", %{conn: conn} do
-      {conn, ref} = open_request(conn)
-
-      assert_recv_frames [headers(stream_id: stream_id)]
-
-      <<trailer_hbf1::1-bytes, trailer_hbf2::binary>> =
-        server_encode_headers([{"x-trailer", "foo"}])
-
-      data =
-        server_encode_frames([
-          headers(
-            stream_id: stream_id,
-            hbf:
-              server_encode_headers([
-                {":status", "200"},
-                {"content-type", "text/plain"}
-              ]),
-            flags: set_flags(:headers, [:end_headers])
-          ),
-          data(
-            stream_id: stream_id,
-            data: "helloworld",
-            flags: set_flags(:data, [])
-          ),
-          headers(
-            stream_id: stream_id,
-            hbf: trailer_hbf1,
-            flags: set_flags(:headers, [:end_stream])
-          ),
-          continuation(
-            stream_id: stream_id,
-            hbf: trailer_hbf2,
-            flags: set_flags(:continuation, [:end_headers])
-          )
-        ])
-
-      :ok = :ssl.send(server_get_socket(), data)
+    test "handles trailers", context do
+      pid = self()
+
+      Task.start_link(fn ->
+        context = Map.merge(context, start_server_async(context))
+        [conn: conn] = start_connection(context)
+        send(pid, {:conn, conn})
+
+        assert_recv_frames [headers(stream_id: stream_id)]
+
+        <<trailer_hbf1::1-bytes, trailer_hbf2::binary>> =
+          server_encode_headers([{"x-trailer", "foo"}])
+
+        data =
+          server_encode_frames([
+            headers(
+              stream_id: stream_id,
+              hbf:
+                server_encode_headers([
+                  {":status", "200"},
+                  {"content-type", "text/plain"}
+                ]),
+              flags: set_flags(:headers, [:end_headers])
+            ),
+            data(
+              stream_id: stream_id,
+              data: "helloworld",
+              flags: set_flags(:data, [])
+            ),
+            headers(
+              stream_id: stream_id,
+              hbf: trailer_hbf1,
+              flags: set_flags(:headers, [:end_stream])
+            ),
+            continuation(
+              stream_id: stream_id,
+              hbf: trailer_hbf2,
+              flags: set_flags(:continuation, [:end_headers])
+            )
+          ])
+
+        :ok = :ssl.send(server_get_socket(), data)
+        Process.sleep(:infinity)
+      end)
 
-      assert {:ok, _conn, response} = Mint.HTTP.recv_response(conn, ref, 100)
+      assert_receive {:conn, conn}
+      assert {:ok, conn, response} = Mint.HTTP.request_and_response(conn, "GET", "/", [], nil)
 
       assert response == %{
                body: "helloworld",
@@ -2255,25 +2272,42 @@ defmodule Mint.HTTP2Test do
       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())
+    test "handles errors", context do
+      pid = self()
 
-      assert {:error, _conn, %Mint.TransportError{reason: :closed}} =
-               Mint.HTTP.recv_response(conn, ref, 100)
+      Task.start_link(fn ->
+        context = Map.merge(context, start_server_async(context))
+        [conn: conn] = start_connection(context)
+        send(pid, {:conn, conn})
 
-      assert HTTP2.open?(conn)
+        assert_recv_frames [headers(stream_id: _stream_id)]
+        :ok = :ssl.close(server_get_socket())
+      end)
+
+      assert_receive {:conn, conn}
+
+      assert {:error, conn, %Mint.TransportError{reason: :closed}} =
+               Mint.HTTP.request_and_response(conn, "GET", "/", [], nil)
+
+      refute HTTP2.open?(conn)
     end
 
-    test "handles timeout", %{conn: conn} do
-      {conn, ref} = open_request(conn)
-      assert_recv_frames [headers(stream_id: _stream_id)]
+    test "handles timeout", context do
+      pid = self()
 
-      assert {:error, _conn, %Mint.TransportError{reason: :timeout}} =
-               Mint.HTTP.recv_response(conn, ref, 1)
+      Task.start_link(fn ->
+        context = Map.merge(context, start_server_async(context))
+        [conn: conn] = start_connection(context)
+        send(pid, {:conn, conn})
+        Process.sleep(:infinity)
+      end)
 
-      assert HTTP2.open?(conn)
+      assert_receive {:conn, conn}
+
+      assert {:error, conn, %Mint.TransportError{reason: :timeout}} =
+               Mint.HTTP.request_and_response(conn, "GET", "/", [], nil, timeout: 0)
+
+      refute HTTP2.open?(conn)
     end
   end