@@ -6,6 +6,7 @@ import (
66 "net/http/httptest"
77 "strings"
88 "testing"
9+ "time"
910 )
1011
1112 func TestStreamParsing(t *testing.T) {
@@ -54,3 +55,83 @@ func TestStreamParsing(t *testing.T) {
5455 t.Fatalf("event data mismatch: %s", string(events[0].Data))
5556 }
5657 }
58+
59+// TestDefaultClientHasNoBodyTimeout asserts that the http.Client constructed
60+// by NewClient has Timeout == 0 (unlimited body read) and that its transport
61+// carries a ResponseHeaderTimeout. This is the regression test for the bug
62+// where a 60-second http.Client.Timeout killed long-running SSE streams.
63+func TestDefaultClientHasNoBodyTimeout(t *testing.T) {
64+ c, err := NewClient(Config{APIKey: "key"})
65+ if err != nil {
66+ t.Fatalf("NewClient: %v", err)
67+ }
68+
69+ if c.httpClient.Timeout != 0 {
70+ t.Fatalf("expected http.Client.Timeout == 0 (unlimited), got %v", c.httpClient.Timeout)
71+ }
72+
73+ transport, ok := c.httpClient.Transport.(*http.Transport)
74+ if !ok {
75+ t.Fatalf("expected *http.Transport, got %T", c.httpClient.Transport)
76+ }
77+
78+ if transport.ResponseHeaderTimeout == 0 {
79+ t.Fatal("expected ResponseHeaderTimeout to be set on transport, got 0")
80+ }
81+}
82+
83+// TestSlowStreamNotKilledByClientTimeout verifies that a streaming response
84+// whose events are separated by pauses longer than the old 60-second default
85+// (simulated here with a short delay to keep the test fast) is fully received
86+// without error.
87+func TestSlowStreamNotKilledByClientTimeout(t *testing.T) {
88+ const delay = 200 * time.Millisecond
89+
90+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
91+ flusher, ok := w.(http.Flusher)
92+ if !ok {
93+ http.Error(w, "streaming unsupported", http.StatusInternalServerError)
94+ return
95+ }
96+ w.Header().Set("Content-Type", "text/event-stream")
97+ w.WriteHeader(http.StatusOK)
98+
99+ for i := 0; i < 3; i++ {
100+ _, _ = w.Write([]byte("data: {\"i\":" + string(rune('0'+i)) + "}\n\n"))
101+ flusher.Flush()
102+ time.Sleep(delay)
103+ }
104+ _, _ = w.Write([]byte("data: [DONE]\n\n"))
105+ flusher.Flush()
106+ }))
107+ defer server.Close()
108+
109+ // No Config.Timeout is set (defaults to 0 = unlimited). The test
110+ // confirms that the default client configuration does not kill a stream
111+ // body that is actively delivering events over an extended duration.
112+ client, err := NewClient(Config{
113+ APIKey: "key",
114+ BaseURL: server.URL,
115+ })
116+ if err != nil {
117+ t.Fatalf("NewClient: %v", err)
118+ }
119+
120+ stream, err := client.startStream(context.Background(), "POST", "/responses", []byte("{}"))
121+ if err != nil {
122+ t.Fatalf("startStream: %v", err)
123+ }
124+ defer func() { _ = stream.Close() }()
125+
126+ var events []StreamEvent
127+ for ev := range stream.Events {
128+ events = append(events, ev)
129+ }
130+
131+ if stream.Err != nil {
132+ t.Fatalf("stream terminated with error: %v", stream.Err)
133+ }
134+ if len(events) != 3 {
135+ t.Fatalf("expected 3 events, got %d", len(events))
136+ }
137+}