fix(http): add transport timeouts so tea fails fast on stalled servers (#1020)

Fixes #1018

Co-authored-by: dinsmoor <204368+dinsmoor@noreply.gitea.com>
Co-committed-by: dinsmoor <204368+dinsmoor@noreply.gitea.com>

modules/httputil/transport_stall_test.go

@@ -0,0 +1,91 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package httputil
+
+import (
+	"net"
+	"net/http"
+	"testing"
+	"time"
+)
+
+// TestWrapTransportTimeouts verifies the transport returned by WrapTransport
+// carries tea's standard timeout values, so a stalled server can't make tea
+// hang forever (issue #1018).
+func TestWrapTransportTimeouts(t *testing.T) {
+	rt := WrapTransport(nil)
+	uat, ok := rt.(*userAgentTransport)
+	if !ok {
+		t.Fatalf("WrapTransport returned %T, want *userAgentTransport", rt)
+	}
+	tr, ok := uat.base.(*http.Transport)
+	if !ok {
+		t.Fatalf("underlying base is %T, want *http.Transport", uat.base)
+	}
+	if tr.TLSHandshakeTimeout != TLSHandshakeTimeout {
+		t.Errorf("TLSHandshakeTimeout = %v, want %v", tr.TLSHandshakeTimeout, TLSHandshakeTimeout)
+	}
+	if tr.ResponseHeaderTimeout != ResponseHeaderTimeout {
+		t.Errorf("ResponseHeaderTimeout = %v, want %v", tr.ResponseHeaderTimeout, ResponseHeaderTimeout)
+	}
+	if tr.DialContext == nil {
+		t.Error("DialContext is nil, want a dialer with DialTimeout")
+	}
+}
+
+// newStallListener returns a listener that accepts connections, reads the
+// request, then goes silent without ever sending response headers — the
+// "server accepts the connection but never responds" case ResponseHeaderTimeout
+// guards against. The returned closer stops the listener.
+func newStallListener(t *testing.T) (addr string, closer func()) {
+	t.Helper()
+	ln, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatalf("listen: %v", err)
+	}
+	done := make(chan struct{})
+	go func() {
+		for {
+			conn, err := ln.Accept()
+			if err != nil {
+				return
+			}
+			go func(c net.Conn) {
+				buf := make([]byte, 4096)
+				_, _ = c.Read(buf) // drain the request, then never respond
+				<-done             // hold the connection open until the test ends
+				c.Close()
+			}(conn)
+		}
+	}()
+	return ln.Addr().String(), func() {
+		close(done)
+		ln.Close()
+	}
+}
+
+// TestResponseHeaderTimeoutFires proves a request to a server that accepts the
+// connection and request but never sends response headers aborts via
+// ResponseHeaderTimeout rather than hanging. It builds the transport the same
+// way WrapTransport does, with a short ResponseHeaderTimeout so the test is fast.
+func TestResponseHeaderTimeoutFires(t *testing.T) {
+	addr, closer := newStallListener(t)
+	defer closer()
+
+	tr := timeoutTransport(nil)
+	tr.ResponseHeaderTimeout = 2 * time.Second
+	client := &http.Client{Transport: &userAgentTransport{base: tr}}
+
+	start := time.Now()
+	_, err := client.Get("http://" + addr + "/")
+	elapsed := time.Since(start)
+
+	if err == nil {
+		t.Fatal("expected a timeout error from stalled server, got nil")
+	}
+	if elapsed > 10*time.Second {
+		t.Errorf("request took %v; ResponseHeaderTimeout did not fire", elapsed)
+	}
+	t.Logf("request failed as expected after %v: %v", elapsed, err)
+}