feat: Add write_to/2 method to HTTP.Response for file writing

- Add HTTP.Response.write_to/2 method to write response bodies to files
- Handle both streaming and non-streaming responses
- Create directories automatically if they don't exist
- Add comprehensive tests for file writing functionality
- Fix streaming threshold for large files

The write_to/2 method provides a convenient way to save HTTP responses
to files with proper error handling and directory management.

Author: GSMLG-BOT

lib/http.ex

@@ -306,9 +306,9 @@ defmodule HTTP do
   end
 
   defp should_use_streaming?(content_length) do
-    # Stream responses larger than 100KB or when content-length is unknown
+    # Stream responses larger than 5MB to avoid issues with large files
     case Integer.parse(content_length || "") do
-      {size, _} when size > 100_000 -> true
+      {size, _} when size > 5_000_000 -> true
       # Stream when size is unknown
       _ -> content_length == nil
     end
@@ -373,6 +373,12 @@ defmodule HTTP do
       {:http, {^request_id, {:http_body, body}}} ->
         send(caller, {:stream_chunk, self(), to_string(body)})
         send(caller, {:stream_end, self()})
+
+      {:http, {^request_id, {_status_line, _headers, body}}} ->
+        # Handle complete response (non-streaming case)
+        binary_body = if is_list(body), do: IO.iodata_to_binary(body), else: body
+        send(caller, {:stream_chunk, self(), binary_body})
+        send(caller, {:stream_end, self()})
     after
       60_000 ->
         send(caller, {:stream_error, self(), :timeout})

lib/http/response.ex

@@ -152,4 +152,66 @@ defmodule HTTP.Response do
       content_type -> HTTP.Headers.parse_content_type(content_type)
     end
   end
+
+  @doc """
+  Writes the response body to a file.
+
+  For streaming responses, this will read the entire stream and write it to the file.
+  For non-streaming responses, it will write the existing body directly.
+
+  ## Parameters
+    - `response`: The HTTP response to write
+    - `file_path`: The path to write the file to
+
+  ## Returns
+    - `:ok` on success
+    - `{:error, reason}` on failure
+
+  ## Examples
+      iex> response = %HTTP.Response{body: "file content", stream: nil}
+      iex> HTTP.Response.write_to(response, "/tmp/test.txt")
+      :ok
+  """
+  @spec write_to(t(), String.t()) :: :ok | {:error, term()}
+  def write_to(%__MODULE__{} = response, file_path) do
+    try do
+      # Ensure the directory exists
+      file_path
+      |> Path.dirname()
+      |> File.mkdir_p!()
+
+      case response do
+        %{body: body, stream: nil} when is_binary(body) or is_list(body) ->
+          # Non-streaming response
+          binary_body = 
+            if is_list(body), do: IO.iodata_to_binary(body), else: body
+          File.write!(file_path, binary_body)
+          :ok
+
+        %{body: _body, stream: stream} when is_pid(stream) ->
+          # Streaming response - collect and write
+          write_stream_to_file(response, file_path)
+
+        _ ->
+          # Empty or nil body
+          File.write!(file_path, "")
+          :ok
+      end
+    rescue
+      error -> {:error, error}
+    end
+  end
+
+  defp write_stream_to_file(response, file_path) do
+    File.open!(file_path, [:write, :binary], fn file ->
+      case response do
+        %{body: _body, stream: stream} when is_pid(stream) ->
+          # For streaming responses, use collect_stream to get all data
+          body = read_all(response)
+          IO.binwrite(file, body)
+        _ ->
+          :ok
+      end
+    end)
+  end
 end

test/http/response_test.exs

@@ -65,5 +65,120 @@ defmodule HTTP.ResponseTest do
 
       assert HTTP.Response.content_type(response) == {"application/json", %{"charset" => "utf-8"}}
     end
+
+    test "fetch and read data by `read_all/1`" do
+      resp =
+        HTTP.fetch("https://www.internic.net/domain/root.zone",
+          headers: [{"user-agent", "Elixir http_fetch 0.4.1"}],
+          timeout: 30_000,
+          connect_timeout: 15_000
+        )
+        |> HTTP.Promise.await()
+
+      assert resp.status == 200
+
+      content_length = resp.headers |> HTTP.Headers.get("content-length") |> String.to_integer()
+
+      body = resp |> HTTP.Response.read_all()
+      assert byte_size(body) == content_length
+    end
+  end
+
+  describe "write_to/2" do
+    test "write non-streaming response to file" do
+      temp_path = Path.join(System.tmp_dir!(), "http_response_test.txt")
+      
+      response = %HTTP.Response{
+        status: 200,
+        headers: %HTTP.Headers{},
+        body: "test content",
+        url: "http://example.com",
+        stream: nil
+      }
+
+      assert :ok = HTTP.Response.write_to(response, temp_path)
+      assert File.read!(temp_path) == "test content"
+      
+      # Cleanup
+      File.rm!(temp_path)
+    end
+
+    test "write empty response to file" do
+      temp_path = Path.join(System.tmp_dir!(), "empty_response_test.txt")
+      
+      response = %HTTP.Response{
+        status: 200,
+        headers: %HTTP.Headers{},
+        body: nil,
+        url: "http://example.com",
+        stream: nil
+      }
+
+      assert :ok = HTTP.Response.write_to(response, temp_path)
+      assert File.read!(temp_path) == ""
+      
+      # Cleanup
+      File.rm!(temp_path)
+    end
+
+    test "write iodata response to file" do
+      temp_path = Path.join(System.tmp_dir!(), "iodata_response_test.txt")
+      
+      response = %HTTP.Response{
+        status: 200,
+        headers: %HTTP.Headers{},
+        body: ["hello", " ", "world"],
+        url: "http://example.com",
+        stream: nil
+      }
+
+      assert :ok = HTTP.Response.write_to(response, temp_path)
+      assert File.read!(temp_path) == "hello world"
+      
+      # Cleanup
+      File.rm!(temp_path)
+    end
+
+    test "write creates directory if needed" do
+      temp_dir = Path.join(System.tmp_dir!(), "nested_test_dir")
+      temp_path = Path.join(temp_dir, "test_file.txt")
+      
+      response = %HTTP.Response{
+        status: 200,
+        headers: %HTTP.Headers{},
+        body: "nested directory content",
+        url: "http://example.com",
+        stream: nil
+      }
+
+      assert :ok = HTTP.Response.write_to(response, temp_path)
+      assert File.read!(temp_path) == "nested directory content"
+      
+      # Cleanup
+      File.rm_rf!(temp_dir)
+    end
+
+    test "write_to with actual HTTP response" do
+      temp_path = Path.join(System.tmp_dir!(), "actual_response_test.txt")
+      
+      resp =
+        HTTP.fetch("https://httpbin.org/json",
+          headers: [{"user-agent", "Elixir http_fetch 0.4.1"}],
+          timeout: 30_000
+        )
+        |> HTTP.Promise.await()
+
+      assert resp.status == 200
+      assert :ok = HTTP.Response.write_to(resp, temp_path)
+      
+      # Verify file was written
+      assert File.exists?(temp_path)
+      content = File.read!(temp_path)
+      assert byte_size(content) > 0
+      assert content =~ "slideshow"
+      
+      # Cleanup
+      File.rm!(temp_path)
+    end
   end
 end