Ignore :into collectable for non-200 responses

lib/req.ex

@@ -285,6 +285,9 @@ defmodule Req do
 
                into: File.stream!("path")
 
+          Note that the collectable is only used, if the response status is 200. In other cases,
+          the body is accumulated and processed as usual.
+
         * `:self` - stream response body into the current process mailbox.
 
           Received messages should be parsed with `Req.parse_message/2`.

lib/req/finch.ex

@@ -131,12 +131,16 @@ defmodule Req.Finch do
   end
 
   defp finch_stream_into_collectable(req, finch_req, finch_name, finch_options, collectable) do
-    {acc, collector} = Collectable.into(collectable)
     resp = Req.Response.new()
 
     fun = fn
-      {:status, status}, {acc, req, resp} ->
-        {acc, req, %{resp | status: status}}
+      {:status, 200}, {nil, req, resp} ->
+        {acc, collector} = Collectable.into(collectable)
+        {{acc, collector}, req, %{resp | status: 200}}
+
+      {:status, status}, {nil, req, resp} ->
+        {acc, collector} = Collectable.into("")
+        {{acc, collector}, req, %{resp | status: status}}
 
       {:headers, fields}, {acc, req, resp} ->
         resp =
@@ -146,18 +150,18 @@ defmodule Req.Finch do
 
         {acc, req, resp}
 
-      {:data, data}, {acc, req, resp} ->
+      {:data, data}, {{acc, collector}, req, resp} ->
         acc = collector.(acc, {:cont, data})
-        {acc, req, resp}
+        {{acc, collector}, req, resp}
 
       {:trailers, fields}, {acc, req, resp} ->
         fields = finch_fields_to_map(fields)
         resp = update_in(resp.trailers, &Map.merge(&1, fields))
         {acc, req, resp}
     end
 
-    case Finch.stream(finch_req, finch_name, {acc, req, resp}, fun, finch_options) do
-      {:ok, {acc, req, resp}} ->
+    case Finch.stream(finch_req, finch_name, {nil, req, resp}, fun, finch_options) do
+      {:ok, {{acc, collector}, req, resp}} ->
         acc = collector.(acc, :done)
         {req, %{resp | body: acc}}
 

lib/req/request.ex

@@ -92,6 +92,9 @@ defmodule Req.Request do
 
               into: File.stream!("path")
 
+          Note that the collectable is only used, if the response status is 200. In other cases,
+          the body is accumulated and processed as usual.
+
     * `:options` - the options to be used by steps. The exact representation of options is private.
       Calling `request.options[key]`, `put_in(request.options[key], value)`, and
       `update_in(request.options[key], fun)` is allowed. `get_option/3` and `delete_option/2`

lib/req/steps.ex

@@ -1032,17 +1032,20 @@ defmodule Req.Steps do
           end
 
         collectable ->
-          {acc, collector} = Collectable.into(collectable)
-
           response =
             Req.Response.new(
               status: conn.status,
               headers: conn.resp_headers
             )
 
-          acc = collector.(acc, {:cont, conn.resp_body})
-          acc = collector.(acc, :done)
-          {request, %{response | body: acc}}
+          if conn.status == 200 do
+            {acc, collector} = Collectable.into(collectable)
+            acc = collector.(acc, {:cont, conn.resp_body})
+            acc = collector.(acc, :done)
+            {request, %{response | body: acc}}
+          else
+            {request, %{response | body: conn.resp_body}}
+          end
       end
     end
 

test/req/finch_test.exs

@@ -346,6 +346,42 @@ defmodule Req.FinchTest do
       assert resp.body == ["chunk1", "chunk2"]
     end
 
+    @tag :tmp_dir
+    test "into: collectable non-200", %{tmp_dir: tmp_dir} do
+      # Ignores the collectable and returns body as usual
+
+      File.mkdir_p!(tmp_dir)
+      file = Path.join(tmp_dir, "result.bin")
+
+      %{url: url} =
+        start_tcp_server(fn socket ->
+          {:ok, "GET / HTTP/1.1\r\n" <> _} = :gen_tcp.recv(socket, 0)
+
+          body = ~s|{"error": "not found"}|
+
+          data = """
+          HTTP/1.1 404 OK
+          content-length: #{byte_size(body)}
+          content-type: application/json
+
+          #{body}
+          """
+
+          :ok = :gen_tcp.send(socket, data)
+        end)
+
+      resp =
+        Req.get!(
+          url: url,
+          into: File.stream!(file)
+        )
+
+      assert resp.status == 404
+      assert resp.body == %{"error" => "not found"}
+
+      refute File.exists?(file)
+    end
+
     test "into: collectable handle error" do
       assert {:error, %Req.TransportError{reason: :econnrefused}} =
                Req.get(

test/req/steps_test.exs

@@ -1927,6 +1927,32 @@ defmodule Req.StepsTest do
       refute_receive _
     end
 
+    @tag :tmp_dir
+    test "into: collectable non-200", %{tmp_dir: tmp_dir} do
+      # Ignores the collectable and returns body as usual
+
+      File.mkdir_p!(tmp_dir)
+      file = Path.join(tmp_dir, "result.bin")
+
+      req =
+        Req.new(
+          plug: fn conn ->
+            conn = Plug.Conn.send_chunked(conn, 404)
+            {:ok, conn} = Plug.Conn.chunk(conn, "foo")
+            {:ok, conn} = Plug.Conn.chunk(conn, "bar")
+            conn
+          end,
+          into: File.stream!(file)
+        )
+
+      resp = Req.request!(req)
+      assert resp.status == 404
+      assert resp.body == "foobar"
+      refute_receive _
+
+      refute File.exists?(file)
+    end
+
     test "errors" do
       req =
         Req.new(