Feat/http client adapter (#969)

* feat: add support for customizable HTTP policies in network options

* refactor: simplify `defaultHTTPClient` creation logic and add `NewWithClient` constructor with tests

* refactor: rename `responseValidatingTransport` to `nilResponseGuardTransport` and consolidate response body handling into `Policy`

* refactor: enhance HTTP client and policy tests with improved error handling and typed-nil transport case handling

* feat: add support for custom HTTP transport in network options with `WithHTTPTransport`

Author: ziflex

pkg/net/http/client.go

@@ -38,43 +38,86 @@ func New(options ...PolicyOption) (Client, error) {
 	}
 
 	dialer := newPolicyDialer(policy)
-	transport := newResponseValidatingTransport(
-		newPolicyTransport(dialer, policy.maxResponseHeaderSize),
-	)
 
-	return &defaultHTTPClient{
+	return newDefaultHTTPClient(policy, stdhttp.Client{
+		Transport: newPolicyTransport(dialer, policy.MaxResponseHeaderSize()),
+	}), nil
+}
+
+// NewWithTransport constructs a policy-aware client that uses transport. The
+// supplied transport is shared with the returned Client, so closing idle
+// connections affects its connection pool.
+//
+// A nil transport, including a typed-nil *net/http.Transport, selects Ferret's
+// policy-aware transport. A non-nil transport remains responsible for proxy
+// behavior, DNS and concrete-address enforcement, and response-header limits.
+func NewWithTransport(
+	transport stdhttp.RoundTripper,
+	options ...PolicyOption,
+) (Client, error) {
+	return NewWithClient(&stdhttp.Client{Transport: transport}, options...)
+}
+
+// NewWithClient constructs a policy-aware client from a standard-library
+// client. It snapshots the supplied client's fields without mutating it.
+// Policy timeout and redirect settings take precedence over the corresponding
+// client fields.
+//
+// A nil Transport is replaced with Ferret's policy-aware transport. A non-nil
+// Transport is preserved and remains responsible for proxy behavior, DNS and
+// concrete-address enforcement, and response-header limits. The transport and
+// cookie jar remain shared with the supplied client; closing idle connections
+// through the returned Client affects the shared transport pool.
+func NewWithClient(client *stdhttp.Client, options ...PolicyOption) (Client, error) {
+	if client == nil {
+		return nil, ErrNilClient
+	}
+
+	policy, err := NewPolicy(options...)
+	if err != nil {
+		return nil, err
+	}
+
+	stdClient := *client
+	transport, isStandardTransport := stdClient.Transport.(*stdhttp.Transport)
+
+	if stdClient.Transport == nil || (isStandardTransport && transport == nil) {
+		dialer := newPolicyDialer(policy)
+		stdClient.Transport = newPolicyTransport(dialer, policy.MaxResponseHeaderSize())
+	}
+
+	return newDefaultHTTPClient(policy, stdClient), nil
+}
+
+// newDefaultHTTPClient snapshots and normalizes a standard-library client so
+// the stored client can be reused safely across concurrent requests.
+func newDefaultHTTPClient(policy *Policy, client stdhttp.Client) *defaultHTTPClient {
+	result := &defaultHTTPClient{
 		policy: policy,
-		client: stdhttp.Client{
-			Transport: transport,
-			Timeout:   policy.timeout,
-		},
-	}, nil
+		client: client,
+	}
+	result.client.Transport = newNilResponseGuardTransport(result.client.Transport)
+	result.client.Timeout = policy.Timeout()
+	result.client.CheckRedirect = policy.CheckRedirect
+
+	return result
 }
 
 func (d *defaultHTTPClient) Do(ctx context.Context, req *Request) (*Response, error) {
 	if ctx == nil {
 		ctx = context.Background()
 	}
 
-	p := d.policy
-	if p == nil {
-		p = &Policy{}
-	}
-
 	stdReq, err := toStdRequest(ctx, req)
 	if err != nil {
 		return nil, err
 	}
-	if err := p.Prepare(stdReq); err != nil {
+
+	if err := d.policy.Prepare(stdReq); err != nil {
 		return nil, err
 	}
 
-	client := d.client
-	client.Transport = newResponseValidatingTransport(client.Transport)
-	client.Timeout = p.timeout
-	client.CheckRedirect = d.checkRedirect
-
-	res, err := client.Do(stdReq)
+	res, err := d.client.Do(stdReq)
 	if err != nil {
 		var policyErr *PolicyError
 		if errors.As(err, &policyErr) {
@@ -84,28 +127,9 @@ func (d *defaultHTTPClient) Do(ctx context.Context, req *Request) (*Response, er
 		return nil, err
 	}
 
-	return fromStdResponse(res, p)
+	return fromStdResponse(res, d.policy)
 }
 
 func (d *defaultHTTPClient) CloseIdleConnections() {
 	d.client.CloseIdleConnections()
 }
-
-func (d *defaultHTTPClient) checkRedirect(req *stdhttp.Request, via []*stdhttp.Request) error {
-	p := d.policy
-
-	if p == nil {
-		p = &Policy{}
-	}
-
-	if !p.followRedirects {
-		return stdhttp.ErrUseLastResponse
-	}
-
-	limit := p.maxRedirects
-	if len(via) > limit {
-		return &RedirectLimitError{Limit: limit}
-	}
-
-	return p.eval(req, PolicyTargetRedirect)
-}

pkg/net/http/client_benchmark_test.go

@@ -88,19 +88,16 @@ func benchmarkClientDoPolicy(b *testing.B, policy *Policy) {
 }
 
 func benchmarkClientDoPolicyRequest(b *testing.B, policy *Policy, req *Request) {
-	client := &defaultHTTPClient{
-		policy: policy,
-		client: stdhttp.Client{
-			Transport: newResponseValidatingTransport(testRoundTripper(func(*stdhttp.Request) (*stdhttp.Response, error) {
-				return &stdhttp.Response{
-					StatusCode: stdhttp.StatusOK,
-					Status:     "200 OK",
-					Header:     make(stdhttp.Header),
-					Body:       io.NopCloser(strings.NewReader("ok")),
-				}, nil
-			})),
-		},
-	}
+	client := newDefaultHTTPClient(policy, stdhttp.Client{
+		Transport: testRoundTripper(func(*stdhttp.Request) (*stdhttp.Response, error) {
+			return &stdhttp.Response{
+				StatusCode: stdhttp.StatusOK,
+				Status:     "200 OK",
+				Header:     make(stdhttp.Header),
+				Body:       io.NopCloser(strings.NewReader("ok")),
+			}, nil
+		}),
+	})
 
 	b.ReportAllocs()
 	b.ResetTimer()
@@ -114,13 +111,14 @@ func benchmarkClientDoPolicyRequest(b *testing.B, policy *Policy, req *Request)
 
 func BenchmarkReadResponseBodyBounded(b *testing.B) {
 	body := strings.Repeat("x", 4<<10)
+	policy := newTestPolicy(b, WithMaxResponseSize(8<<10))
 
 	b.ReportAllocs()
 	b.SetBytes(int64(len(body)))
 	b.ResetTimer()
 
 	for b.Loop() {
-		if _, err := readResponseBody(strings.NewReader(body), 8<<10); err != nil {
+		if _, err := policy.ReadResponseBody(strings.NewReader(body)); err != nil {
 			b.Fatal(err)
 		}
 	}