fix: Timeout

Author: luopengift

.github/workflows/go.yml

@@ -23,13 +23,12 @@ jobs:
 
     - name: Build
       run: go build -v ./...
-
     - name: Test
-      run: go test -v ./...
-
+      run: go test -v -race ./...
+    - name: Benchmark
+      run: go test -race -run=^$ -bench=. -benchmem ./...
     - name: Coverage
       run: go test -coverprofile=coverage.txt
-
     - name: Upload coverage reports to Codecov
       uses: codecov/codecov-action@v5
       with:

api.go

@@ -8,36 +8,36 @@ import (
 	"strings"
 )
 
-var s = New()
+var session = New()
 
 // Get send get request
 func Get(url string) (*http.Response, error) {
-	return s.Do(context.Background(), MethodGet, URL(url))
+	return session.Do(context.Background(), MethodGet, URL(url))
 }
 
 // Post send post request
 func Post(url string, contentType string, body io.Reader) (*http.Response, error) {
-	return s.Do(context.TODO(), MethodPost, URL(url), Header("Content-Type", contentType), Body(body))
+	return session.Do(context.TODO(), MethodPost, URL(url), Header("Content-Type", contentType), Body(body))
 }
 
 // PUT send put request
 func PUT(url, contentType string, body io.Reader) (*http.Response, error) {
-	return s.Do(context.TODO(), Method("PUT"), URL(url), Header("Content-Type", contentType), Body(body))
+	return session.Do(context.TODO(), Method("PUT"), URL(url), Header("Content-Type", contentType), Body(body))
 }
 
 // Delete send delete request
 func Delete(url, contentType string, body io.Reader) (*http.Response, error) {
-	return s.Do(context.TODO(), Method("DELETE"), URL(url), Header("Content-Type", contentType), Body(body))
+	return session.Do(context.TODO(), Method("DELETE"), URL(url), Header("Content-Type", contentType), Body(body))
 }
 
 // Head send post request
 func Head(url string) (resp *http.Response, err error) {
-	return s.Do(context.Background(), Method("HEAD"), URL(url))
+	return session.Do(context.Background(), Method("HEAD"), URL(url))
 }
 
 // PostForm send post request,  content-type = application/x-www-form-urlencoded
 func PostForm(url string, data url.Values) (*http.Response, error) {
-	return s.Do(context.TODO(), MethodPost, URL(url), Header("Content-Type", "application/x-www-form-urlencoded"),
+	return session.Do(context.TODO(), MethodPost, URL(url), Header("Content-Type", "application/x-www-form-urlencoded"),
 		Body(strings.NewReader(data.Encode())),
 	)
 }

requests_test.go

@@ -4,32 +4,38 @@ import (
 	"context"
 	"fmt"
 	"io"
-	"log"
 	"net"
 	"net/http"
 	"net/http/httptest"
 	"net/url"
 	"os"
 	"path"
+	"strings"
 	"sync/atomic"
 	"testing"
 	"time"
 )
 
-func Test_Basic(t *testing.T) {
-	resp, err := Get("http://httpbin.org/get")
-	t.Logf("%#v, %v", resp, err)
-	//resp, _ = Post("http://httpbin.org/post", "application/json", strings.NewReader(`{"a": "b"}`))
-	//t.Log(resp.Text())
+var s *Server
+
+func TestMain(m *testing.M) {
+	mux := NewServeMux()
+	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		w.Write([]byte("hello world"))
+	})
+	s = NewServer(context.Background(), mux, URL("http://127.0.0.1:65534"))
+
+	go s.ListenAndServe()
+	defer s.Shutdown(context.Background())
+	os.Exit(m.Run())
 }
 
 func Test_ProxyGet(t *testing.T) {
-	t.Log("Testing get request")
 	sess := New(
 		Header("a", "b"),
 		Cookie(http.Cookie{Name: "username", Value: "golang"}),
 		BasicAuth("user", "123456"),
-		Timeout(3*time.Second),
+		Timeout(5*time.Second),
 		//Hosts(map[string][]string{"127.0.0.1:8080": {"192.168.1.1:80"}, "4.org:80": {"httpbin.org:80"}}),
 		//Proxy("http://127.0.0.1:8080"),
 	)
@@ -103,14 +109,14 @@ func Test_FormPost(t *testing.T) {
 		//TraceLv(9),
 	)
 	if err != nil {
-		log.Fatal(err)
+		t.Fatal(err)
 		return
 	}
 	t.Log(resp.StatusCode, err, resp.Response.ContentLength, resp.Request.ContentLength)
 
 }
 
-func Test_Race(t *testing.T) {
+func Test_DoRequestRace(t *testing.T) {
 	opts := Options{}
 	ctx := context.Background()
 	t.Logf("%#v", opts)
@@ -176,7 +182,7 @@ func TestResponse_Download(t *testing.T) {
 		sum += cnt
 		return err
 	})
-	resp, err := sess.DoRequest(context.Background(), Setup(Redirect))
+	resp, err := sess.DoRequest(context.Background(), Trace())
 	if err != nil {
 		t.Logf("resp=%d, err=%s", resp.Content, err)
 		return
@@ -197,11 +203,25 @@ func TestRequestWithTimeout(t *testing.T) {
 	}))
 	defer server.Close()
 
+	setup := func(name string) func(next http.RoundTripper) http.RoundTripper {
+		return func(next http.RoundTripper) http.RoundTripper {
+			return RoundTripperFunc(func(r *http.Request) (*http.Response, error) {
+				t.Logf("timeout %s test prev", name)
+				defer t.Logf("timeout %s test next", name)
+				return next.RoundTrip(r)
+			})
+		}
+	}
+
 	// 测试超时情况
-	sess := New(Timeout(10 * time.Millisecond))
-	_, err := sess.DoRequest(context.Background(), URL(server.URL))
+	sess := New(Timeout(10*time.Millisecond), Logf(LogS), Setup(setup("session0"), setup("session1")))
+	_, err := sess.DoRequest(context.Background(), URL(server.URL), Setup(setup("request0-0"), setup("request0-1")))
+	t.Logf("timeout err=%v", err)
 	if err == nil {
-		t.Skip("期望超时错误，但没有发生")
+		t.Error("期望发生超时错误，但没有")
+	}
+	if !strings.Contains(err.Error(), "Client.Timeout exceeded") {
+		t.Error("发生错误，但不是超时")
 	}
 
 	// 测试非超时情况

response.go

@@ -8,42 +8,61 @@ import (
 	"time"
 )
 
-// Response wrap `http.Response` struct.
+// Response 包装了 http.Response 结构体，提供了额外的功能：
+// 1. 记录请求开始时间和耗时
+// 2. 缓存响应内容
+// 3. 错误处理
+// 4. 统计信息收集
 type Response struct {
-	*http.Request
-	*http.Response
-	StartAt time.Time
-	Cost    time.Duration
-	Content *bytes.Buffer
-	Err     error
+	*http.Request                // 原始 HTTP 请求
+	*http.Response               // 原始 HTTP 响应
+	StartAt        time.Time     // 请求开始时间
+	Cost           time.Duration // 请求耗时
+	Content        *bytes.Buffer // 响应内容缓存
+	Err            error         // 请求过程中的错误
 }
 
+// newResponse 创建一个新的 Response 实例
+// 参数 r 是原始的 HTTP 请求
 func newResponse(r *http.Request) *Response {
-	return &Response{Request: r, StartAt: time.Now(), Response: &http.Response{}, Content: &bytes.Buffer{}}
+	return &Response{
+		Request:  r,
+		StartAt:  time.Now(),
+		Response: &http.Response{},
+		Content:  &bytes.Buffer{},
+	}
 }
 
-// String implement fmt.Stringer interface.
+// String 实现 fmt.Stringer 接口
+// 返回响应内容的字符串形式
 func (resp *Response) String() string {
 	return resp.Content.String()
 }
 
-// Error implement error interface.
+// Error 实现 error 接口
+// 返回请求过程中的错误信息
 func (resp *Response) Error() string {
 	if resp.Err == nil {
 		return ""
 	}
 	return resp.Err.Error()
 }
 
-// Stat stat
+// Stat 返回请求的统计信息
+// 包括请求/响应的详细信息、耗时等
 func (resp *Response) Stat() *Stat {
 	return responseLoad(resp)
 }
 
-// streamRead xx
+// streamRead 按行读取数据流
+// reader: 输入的数据流
+// fn: 处理每一行数据的回调函数，参数为行号和行内容
+// 返回值：读取的总字节数和可能的错误
 func streamRead(reader io.Reader, fn func(int64, []byte) error) (int64, error) {
+	// 创建一个 1MB 缓冲的读取器
 	i, cnt, r := int64(0), int64(0), bufio.NewReaderSize(reader, 1024*1024)
 	for {
+		// 读取直到遇到换行符
 		raw, err1 := r.ReadBytes(10) // ascii('\n') = 10
 		if err1 != nil && err1 != io.EOF {
 			return cnt, err1
@@ -52,32 +71,6 @@ func streamRead(reader io.Reader, fn func(int64, []byte) error) (int64, error) {
 		i, cnt = i+1, cnt+int64(len(raw))
 		if err2 := fn(i, raw); err1 == io.EOF || err2 != nil {
 			return cnt, err2
-
 		}
 	}
 }
-
-// streamRoundTrip 创建一个流式处理的RoundTripper中间件
-// 参数 f 是流处理回调函数，接收两个参数：
-//   - i int64: 当前处理的数据块序号（从1开始）
-//   - raw []byte: 原始数据块内容（按换行符分割）
-//
-// 返回值是可用于HTTP客户端中间件链的RoundTripper
-// 适用场景：大文件下载、实时事件流处理等需要边接收边处理的场景
-// 注意：与普通RoundTripper不同，此方法会流式处理响应体而不是缓存全部内容
-func streamRoundTrip(fn func(i int64, raw []byte) error) func(http.RoundTripper) http.RoundTripper {
-	return func(next http.RoundTripper) http.RoundTripper {
-		return RoundTripperFunc(func(r *http.Request) (*http.Response, error) {
-			resp := newResponse(r)
-			if resp.Response, resp.Err = next.RoundTrip(r); resp.Err != nil {
-				return resp.Response, resp.Err
-			}
-
-			if resp.Response.ContentLength, resp.Err = streamRead(resp.Response.Body, fn); resp.Err != nil {
-				return resp.Response, resp.Err
-			}
-			resp.Response.Body = io.NopCloser(bytes.NewReader([]byte("[stream]")))
-			return resp.Response, resp.Err
-		})
-	}
-}

response_test.go

@@ -3,8 +3,6 @@ package requests
 import (
 	"bytes"
 	"errors"
-	"fmt"
-	"io"
 	"net/http"
 	"strings"
 	"testing"
@@ -119,73 +117,6 @@ func TestStreamReadError(t *testing.T) {
 	}
 }
 
-// TestStreamRoundTrip 测试streamRoundTrip中间件
-func TestStreamRoundTrip(t *testing.T) {
-	// 创建一个模拟的响应体
-	responseBody := "line1\nline2\nline3"
-	expectedLines := []string{"line1", "line2", "line3"}
-
-	// 创建一个模拟的RoundTripper
-	mockTransport := RoundTripperFunc(func(req *http.Request) (*http.Response, error) {
-		return &http.Response{
-			StatusCode: 200,
-			Body:       io.NopCloser(strings.NewReader(responseBody)),
-		}, nil
-	})
-
-	// 创建请求
-	req, _ := http.NewRequest("GET", "http://example.com", nil)
-
-	// 收集处理的行
-	var lines []string
-	middleware := streamRoundTrip(func(_ int64, data []byte) error {
-		lines = append(lines, string(bytes.TrimRight(data, "\n")))
-		return nil
-	})
-
-	// 执行请求
-	resp, err := middleware(mockTransport).RoundTrip(req)
-	if err != nil {
-		t.Fatalf("RoundTrip failed: %v", err)
-	}
-
-	// 验证响应
-	if resp.StatusCode != 200 {
-		t.Errorf("Expected status 200, got %d", resp.StatusCode)
-	}
-
-	// 验证处理的行
-	if len(lines) != len(expectedLines) {
-		t.Errorf("Expected %d lines, got %d", len(expectedLines), len(lines))
-	}
-	for i, line := range expectedLines {
-		if lines[i] != line {
-			t.Errorf("Line %d: expected '%s', got '%s'", i, line, lines[i])
-		}
-	}
-}
-
-// BenchmarkStreamRead 性能测试
-func BenchmarkStreamRead(b *testing.B) {
-	// 准备测试数据
-	var testData strings.Builder
-	for i := 0; i < 1000; i++ {
-		fmt.Fprintf(&testData, "Line %d\n", i)
-	}
-	data := testData.String()
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		reader := strings.NewReader(data)
-		_, err := streamRead(reader, func(_ int64, _ []byte) error {
-			return nil
-		})
-		if err != nil {
-			b.Fatal(err)
-		}
-	}
-}
-
 // 用于测试的错误读取器
 type errorReader struct {
 	err error