Skip to content

Modern Docker Management, Designed for Everyone

fix: image pull progress not streaming from remote environments (#1175)

Kyle Mendellc79cfaf0449e
diff --git a/backend/internal/middleware/environment_middleware.go b/backend/internal/middleware/environment_middleware.go
index 31334c493..347401667 100644
--- a/backend/internal/middleware/environment_middleware.go
+++ b/backend/internal/middleware/environment_middleware.go
@@ -18,8 +18,23 @@ import (
)
const (
+ apiEnvironmentsPrefix = "/api/environments/"
environmentsPathMarker = "/environments/"
- proxyTimeout = 60 * time.Second
+
+ managementEndpointTest = "/test"
+ managementEndpointHeartbeat = "/heartbeat"
+ managementEndpointSyncRegistries = "/sync-registries"
+ managementEndpointDeployment = "/deployment"
+ managementEndpointAgentPair = "/agent/pair"
+
+ errEnvironmentNotFound = "Environment not found"
+ errEnvironmentDisabled = "Environment is disabled"
+ errFailedCreateProxyRequest = "Failed to create proxy request"
+ errProxyRequestFailedPrefix = "Proxy request failed:"
+
+ // proxyTimeout is intentionally generous because some proxied operations
+ // (e.g., image pulls with progress streaming) can take multiple minutes.
+ proxyTimeout = 30 * time.Minute
)
// EnvResolver resolves an environment ID to its connection details.
@@ -74,7 +89,7 @@ func (m *EnvironmentMiddleware) Handle(c *gin.Context) {
if err != nil || apiURL == "" {
c.JSON(http.StatusNotFound, gin.H{
"success": false,
- "data": gin.H{"error": "Environment not found"},
+ "data": gin.H{"error": errEnvironmentNotFound},
})
c.Abort()
return
@@ -83,7 +98,7 @@ func (m *EnvironmentMiddleware) Handle(c *gin.Context) {
if !enabled {
c.JSON(http.StatusBadRequest, gin.H{
"success": false,
- "data": gin.H{"error": "Environment is disabled"},
+ "data": gin.H{"error": errEnvironmentDisabled},
})
c.Abort()
return
@@ -104,7 +119,7 @@ func (m *EnvironmentMiddleware) Handle(c *gin.Context) {
// Returns false for paths like /api/environments/{id} or management endpoints (should be handled locally)
func (m *EnvironmentMiddleware) hasResourcePath(c *gin.Context, envID string) bool {
path := c.Request.URL.Path
- prefix := "/api/environments/" + envID
+ prefix := apiEnvironmentsPrefix + envID
// If there's content after the environment ID path, check if it's a management endpoint
suffix := strings.TrimPrefix(path, prefix)
@@ -117,11 +132,11 @@ func (m *EnvironmentMiddleware) hasResourcePath(c *gin.Context, envID string) bo
// Check if it's a management endpoint that should NOT be proxied
// These are environment management operations handled by the manager
managementEndpoints := []string{
- "/test",
- "/heartbeat",
- "/sync-registries",
- "/deployment",
- "/agent/pair",
+ managementEndpointTest,
+ managementEndpointHeartbeat,
+ managementEndpointSyncRegistries,
+ managementEndpointDeployment,
+ managementEndpointAgentPair,
}
for _, endpoint := range managementEndpoints {
@@ -163,14 +178,14 @@ func (m *EnvironmentMiddleware) extractEnvironmentID(c *gin.Context) string {
// buildTargetURL constructs the proxy target URL.
func (m *EnvironmentMiddleware) buildTargetURL(c *gin.Context, envID, apiURL string) string {
// Remove the environment prefix from the path
- prefix := "/api/environments/" + envID
+ prefix := apiEnvironmentsPrefix + envID
suffix := strings.TrimPrefix(c.Request.URL.Path, prefix)
if suffix != "" && !strings.HasPrefix(suffix, "/") {
suffix = "/" + suffix
}
// Build target: apiURL + /api/environments/{localID} + suffix
- target := strings.TrimRight(apiURL, "/") + path.Join("/api/environments/", m.localID) + suffix
+ target := strings.TrimRight(apiURL, "/") + path.Join(apiEnvironmentsPrefix, m.localID) + suffix
// Append query string if present
if qs := c.Request.URL.RawQuery; qs != "" {
@@ -182,14 +197,14 @@ func (m *EnvironmentMiddleware) buildTargetURL(c *gin.Context, envID, apiURL str
// isWebSocketUpgrade checks if this is a WebSocket upgrade request.
func (m *EnvironmentMiddleware) isWebSocketUpgrade(c *gin.Context) bool {
- return strings.EqualFold(c.GetHeader("Upgrade"), "websocket") ||
- strings.Contains(strings.ToLower(c.GetHeader("Connection")), "upgrade")
+ return strings.EqualFold(c.GetHeader(remenv.HeaderUpgrade), "websocket") ||
+ strings.Contains(strings.ToLower(c.GetHeader(remenv.HeaderConnection)), remenv.ConnectionUpgradeToken)
}
// proxyWebSocket handles WebSocket proxy requests.
func (m *EnvironmentMiddleware) proxyWebSocket(c *gin.Context, target string, accessToken *string, envID string) {
- wsTarget := httpToWebSocketURL(target)
- headers := m.buildWebSocketHeaders(c, accessToken)
+ wsTarget := remenv.HTTPToWebSocketURL(target)
+ headers := remenv.BuildWebSocketHeaders(c, accessToken)
if err := wsutil.ProxyHTTP(c.Writer, c.Request, wsTarget, headers); err != nil {
slog.Error("websocket proxy failed", "env_id", envID, "target", wsTarget, "err", err)
@@ -203,7 +218,7 @@ func (m *EnvironmentMiddleware) proxyHTTP(c *gin.Context, target string, accessT
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"success": false,
- "data": gin.H{"error": "Failed to create proxy request"},
+ "data": gin.H{"error": errFailedCreateProxyRequest},
})
c.Abort()
return
@@ -213,7 +228,7 @@ func (m *EnvironmentMiddleware) proxyHTTP(c *gin.Context, target string, accessT
if err != nil {
c.JSON(http.StatusBadGateway, gin.H{
"success": false,
- "data": gin.H{"error": fmt.Sprintf("Proxy request failed: %v", err)},
+ "data": gin.H{"error": fmt.Sprintf("%s %v", errProxyRequestFailedPrefix, err)},
})
c.Abort()
return
@@ -238,13 +253,7 @@ func (m *EnvironmentMiddleware) createProxyRequest(c *gin.Context, target string
c.Request.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))
}
- slog.DebugContext(c.Request.Context(), "Creating proxy request",
- "method", c.Request.Method,
- "target", target,
- "contentLength", c.Request.ContentLength,
- "contentType", c.GetHeader("Content-Type"),
- "bodyLength", len(bodyBytes),
- "body", string(bodyBytes))
+ slog.DebugContext(c.Request.Context(), "Creating proxy request", "method", c.Request.Method, "target", target, "contentLength", c.Request.ContentLength, "contentType", c.GetHeader("Content-Type"), "bodyLength", len(bodyBytes), "body", string(bodyBytes))
req, err := http.NewRequestWithContext(c.Request.Context(), c.Request.Method, target, bytes.NewBuffer(bodyBytes))
if err != nil {
@@ -272,49 +281,10 @@ func (m *EnvironmentMiddleware) writeProxyResponse(c *gin.Context, resp *http.Re
c.Status(resp.StatusCode)
if c.Request.Method != http.MethodHead {
- _, _ = io.Copy(c.Writer, resp.Body)
- }
-}
-
-// buildWebSocketHeaders creates headers for WebSocket proxy requests.
-func (m *EnvironmentMiddleware) buildWebSocketHeaders(c *gin.Context, accessToken *string) http.Header {
- headers := http.Header{}
-
- // Forward API key if present
- if apiKey := c.GetHeader("X-Api-Key"); apiKey != "" {
- headers.Set("X-Api-Key", apiKey)
- }
-
- // Forward authorization (header or cookie)
- if auth := c.GetHeader("Authorization"); auth != "" {
- headers.Set("Authorization", auth)
- } else if token, err := c.Cookie("token"); err == nil && token != "" {
- headers.Set("Authorization", "Bearer "+token)
- }
-
- // Forward cookies if no other auth is present
- if headers.Get("Authorization") == "" && headers.Get("X-Api-Token") == "" {
- if cookies := c.Request.Header.Get("Cookie"); cookies != "" {
- headers.Set("Cookie", cookies)
- }
- }
-
- // Set agent token for remote environment authentication
- if accessToken != nil && *accessToken != "" {
- headers.Set("X-Arcane-Agent-Token", *accessToken)
- }
-
- return headers
-}
-
-// httpToWebSocketURL converts an HTTP(S) URL to WS(S).
-func httpToWebSocketURL(url string) string {
- switch {
- case strings.HasPrefix(url, "https://"):
- return "wss://" + strings.TrimPrefix(url, "https://")
- case strings.HasPrefix(url, "http://"):
- return "ws://" + strings.TrimPrefix(url, "http://")
- default:
- return url
+ // Ensure headers are sent before streaming the body.
+ // This is critical for streaming responses (e.g., JSON line streams) where
+ // clients expect incremental updates.
+ c.Writer.WriteHeaderNow()
+ remenv.CopyBodyWithFlush(c.Writer, resp.Body)
}
}
diff --git a/backend/internal/utils/remenv/remenv.go b/backend/internal/utils/remenv/remenv.go
index b1f9c1e3d..8da5ac838 100644
--- a/backend/internal/utils/remenv/remenv.go
+++ b/backend/internal/utils/remenv/remenv.go
@@ -1,18 +1,29 @@
package remenv
import (
+ "io"
"net/http"
"strings"
"github.com/gin-gonic/gin"
)
-const headerApiToken = "X-Api-Token" // #nosec G101: header name, not a credential
+const (
+ HeaderAPIKey = "X-Api-Key" // #nosec G101: header name, not a credential
+ HeaderAPIToken = "X-Api-Token" // #nosec G101: header name, not a credential
+ HeaderAuthorization = "Authorization"
+ HeaderCookie = "Cookie"
+ HeaderAgentToken = "X-Arcane-Agent-Token" // #nosec G101: header name, not a credential
+ HeaderUpgrade = "Upgrade"
+ HeaderConnection = "Connection"
+
+ ConnectionUpgradeToken = "upgrade"
+)
func CopyRequestHeaders(from http.Header, to http.Header, skip map[string]struct{}) {
for k, vs := range from {
ck := http.CanonicalHeaderKey(k)
- if _, ok := skip[ck]; ok || ck == "Authorization" || ck == http.CanonicalHeaderKey(headerApiToken) {
+ if _, ok := skip[ck]; ok || ck == http.CanonicalHeaderKey(HeaderAuthorization) || ck == http.CanonicalHeaderKey(HeaderAPIToken) {
continue
}
for _, v := range vs {
@@ -23,21 +34,87 @@ func CopyRequestHeaders(from http.Header, to http.Header, skip map[string]struct
func SetAuthHeader(req *http.Request, c *gin.Context) {
// Forward API key header if present
- if apiKey := c.GetHeader(headerApiToken); apiKey != "" {
- req.Header.Set(headerApiToken, apiKey)
+ if apiKey := c.GetHeader(HeaderAPIToken); apiKey != "" {
+ req.Header.Set(HeaderAPIToken, apiKey)
}
// Forward Authorization header or cookie token
- if auth := c.GetHeader("Authorization"); auth != "" {
- req.Header.Set("Authorization", auth)
+ if auth := c.GetHeader(HeaderAuthorization); auth != "" {
+ req.Header.Set(HeaderAuthorization, auth)
} else if cookieToken, err := c.Cookie("token"); err == nil && cookieToken != "" {
- req.Header.Set("Authorization", "Bearer "+cookieToken)
+ req.Header.Set(HeaderAuthorization, "Bearer "+cookieToken)
}
}
func SetAgentToken(req *http.Request, accessToken *string) {
if accessToken != nil && *accessToken != "" {
- req.Header.Set("X-Arcane-Agent-Token", *accessToken)
+ req.Header.Set(HeaderAgentToken, *accessToken)
+ }
+}
+
+// BuildWebSocketHeaders constructs a header set for proxying WebSocket requests
+// to a remote environment, forwarding authentication in the same way as HTTP proxying.
+func BuildWebSocketHeaders(c *gin.Context, accessToken *string) http.Header {
+ headers := http.Header{}
+
+ // Forward API key if present
+ if apiKey := c.GetHeader(HeaderAPIKey); apiKey != "" {
+ headers.Set(HeaderAPIKey, apiKey)
+ }
+
+ // Forward authorization (header or cookie)
+ if auth := c.GetHeader(HeaderAuthorization); auth != "" {
+ headers.Set(HeaderAuthorization, auth)
+ } else if token, err := c.Cookie("token"); err == nil && token != "" {
+ headers.Set(HeaderAuthorization, "Bearer "+token)
+ }
+
+ // Forward cookies if no other auth is present
+ if headers.Get(HeaderAuthorization) == "" && headers.Get(HeaderAPIToken) == "" {
+ if cookies := c.Request.Header.Get(HeaderCookie); cookies != "" {
+ headers.Set(HeaderCookie, cookies)
+ }
+ }
+
+ // Set agent token for remote environment authentication
+ if accessToken != nil && *accessToken != "" {
+ headers.Set(HeaderAgentToken, *accessToken)
+ }
+
+ return headers
+}
+
+// HTTPToWebSocketURL converts an HTTP(S) URL to WS(S).
+func HTTPToWebSocketURL(url string) string {
+ switch {
+ case strings.HasPrefix(url, "https://"):
+ return "wss://" + strings.TrimPrefix(url, "https://")
+ case strings.HasPrefix(url, "http://"):
+ return "ws://" + strings.TrimPrefix(url, "http://")
+ default:
+ return url
+ }
+}
+
+// CopyBodyWithFlush streams bytes from body to w, flushing when supported.
+// Useful for progress/streaming endpoints where incremental delivery matters.
+func CopyBodyWithFlush(w http.ResponseWriter, body io.Reader) {
+ buf := make([]byte, 32*1024)
+ flusher, canFlush := w.(http.Flusher)
+
+ for {
+ n, readErr := body.Read(buf)
+ if n > 0 {
+ if _, writeErr := w.Write(buf[:n]); writeErr != nil {
+ return
+ }
+ if canFlush {
+ flusher.Flush()
+ }
+ }
+ if readErr != nil {
+ return
+ }
}
}
diff --git a/backend/internal/utils/remenv/remenv_test.go b/backend/internal/utils/remenv/remenv_test.go
new file mode 100644
index 000000000..0822f856b
--- /dev/null
+++ b/backend/internal/utils/remenv/remenv_test.go
@@ -0,0 +1,252 @@
+package remenv
+
+import (
+ "bytes"
+ "context"
+ "io"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+
+ "github.com/gin-gonic/gin"
+ "github.com/stretchr/testify/require"
+)
+
+type chunkReader struct {
+ chunks [][]byte
+ idx int
+}
+
+func (r *chunkReader) Read(p []byte) (int, error) {
+ if r.idx >= len(r.chunks) {
+ return 0, io.EOF
+ }
+ c := r.chunks[r.idx]
+ r.idx++
+ return copy(p, c), nil
+}
+
+type flushResponseWriter struct {
+ header http.Header
+ buf bytes.Buffer
+ status int
+ flushes int
+}
+
+func newFlushResponseWriter() *flushResponseWriter {
+ return &flushResponseWriter{header: make(http.Header)}
+}
+
+func (w *flushResponseWriter) Header() http.Header { return w.header }
+
+func (w *flushResponseWriter) Write(b []byte) (int, error) {
+ return w.buf.Write(b)
+}
+
+func (w *flushResponseWriter) WriteHeader(statusCode int) { w.status = statusCode }
+
+func (w *flushResponseWriter) Flush() { w.flushes++ }
+
+type noFlushResponseWriter struct {
+ header http.Header
+ buf bytes.Buffer
+ status int
+}
+
+func newNoFlushResponseWriter() *noFlushResponseWriter {
+ return &noFlushResponseWriter{header: make(http.Header)}
+}
+
+func (w *noFlushResponseWriter) Header() http.Header { return w.header }
+
+func (w *noFlushResponseWriter) Write(b []byte) (int, error) {
+ return w.buf.Write(b)
+}
+
+func (w *noFlushResponseWriter) WriteHeader(statusCode int) { w.status = statusCode }
+
+func TestCopyRequestHeaders_SkipsExpectedHeaders(t *testing.T) {
+ skip := GetSkipHeaders()
+ from := http.Header{}
+ from.Add("X-Test", "a")
+ from.Add("X-Test", "b")
+ from.Set(HeaderAuthorization, "Bearer should-not-copy")
+ from.Set(HeaderAPIToken, "token-should-not-copy")
+ from.Set("Host", "example.com")
+ from.Set(HeaderCookie, "session=abc")
+ from.Set("Transfer-Encoding", "chunked")
+
+ to := http.Header{}
+ CopyRequestHeaders(from, to, skip)
+
+ require.Equal(t, []string{"a", "b"}, to.Values("X-Test"))
+ require.Empty(t, to.Get(HeaderAuthorization))
+ require.Empty(t, to.Get(HeaderAPIToken))
+ require.Empty(t, to.Get("Host"))
+ require.Empty(t, to.Get(HeaderCookie))
+ require.Empty(t, to.Get("Transfer-Encoding"))
+}
+
+func TestSetAuthHeader_ForwardsAPITokenAndAuthorization(t *testing.T) {
+ gin.SetMode(gin.TestMode)
+ w := httptest.NewRecorder()
+ c, _ := gin.CreateTestContext(w)
+ c.Request = httptest.NewRequest(http.MethodGet, "http://example.com", nil)
+ c.Request.Header.Set(HeaderAPIToken, "api-token")
+ c.Request.Header.Set(HeaderAuthorization, "Bearer auth")
+
+ req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, "http://remote", nil)
+ require.NoError(t, err)
+
+ SetAuthHeader(req, c)
+ require.Equal(t, "api-token", req.Header.Get(HeaderAPIToken))
+ require.Equal(t, "Bearer auth", req.Header.Get(HeaderAuthorization))
+}
+
+func TestSetAuthHeader_UsesCookieTokenWhenNoAuthorization(t *testing.T) {
+ gin.SetMode(gin.TestMode)
+ w := httptest.NewRecorder()
+ c, _ := gin.CreateTestContext(w)
+ c.Request = httptest.NewRequest(http.MethodGet, "http://example.com", nil)
+ c.Request.AddCookie(&http.Cookie{Name: "token", Value: "cookie-token"})
+
+ req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, "http://remote", nil)
+ require.NoError(t, err)
+
+ SetAuthHeader(req, c)
+ require.Equal(t, "Bearer cookie-token", req.Header.Get(HeaderAuthorization))
+}
+
+func TestSetAgentToken(t *testing.T) {
+ req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, "http://remote", nil)
+ require.NoError(t, err)
+
+ SetAgentToken(req, nil)
+ require.Empty(t, req.Header.Get(HeaderAgentToken))
+
+ tok := "agent-token"
+ SetAgentToken(req, &tok)
+ require.Equal(t, tok, req.Header.Get(HeaderAgentToken))
+}
+
+func TestSetForwardedHeaders(t *testing.T) {
+ req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, "http://remote", nil)
+ require.NoError(t, err)
+
+ SetForwardedHeaders(req, "1.2.3.4", "example.com")
+ require.Equal(t, "1.2.3.4", req.Header.Get("X-Forwarded-For"))
+ require.Equal(t, "example.com", req.Header.Get("X-Forwarded-Host"))
+}
+
+func TestGetHopByHopHeaders_IncludesStandardHeaders(t *testing.T) {
+ h := GetHopByHopHeaders()
+ _, ok := h[http.CanonicalHeaderKey("Connection")]
+ require.True(t, ok)
+ _, ok = h[http.CanonicalHeaderKey("Transfer-Encoding")]
+ require.True(t, ok)
+ _, ok = h[http.CanonicalHeaderKey("Upgrade")]
+ require.True(t, ok)
+}
+
+func TestBuildHopByHopHeaders_AddsConnectionTokens(t *testing.T) {
+ respHeader := http.Header{}
+ respHeader.Add("Connection", "X-Foo, keep-alive")
+ respHeader.Add("Connection", "x-bar")
+
+ hop := BuildHopByHopHeaders(respHeader)
+ require.Contains(t, hop, http.CanonicalHeaderKey("X-Foo"))
+ require.Contains(t, hop, http.CanonicalHeaderKey("Keep-Alive"))
+ require.Contains(t, hop, http.CanonicalHeaderKey("X-Bar"))
+}
+
+func TestCopyResponseHeaders_SkipsHopByHopAndConnectionNamedHeaders(t *testing.T) {
+ from := http.Header{}
+ from.Set("Content-Type", "application/json")
+ from.Set("Transfer-Encoding", "chunked")
+ from.Set("X-Foo", "bar")
+ from.Add("Connection", "X-Foo")
+
+ hop := BuildHopByHopHeaders(from)
+ to := http.Header{}
+ CopyResponseHeaders(from, to, hop)
+
+ require.Equal(t, "application/json", to.Get("Content-Type"))
+ require.Empty(t, to.Get("Transfer-Encoding"))
+ require.Empty(t, to.Get("X-Foo"))
+ require.Empty(t, to.Get("Connection"))
+}
+
+func TestGetSkipHeaders_ContainsExpectedEntries(t *testing.T) {
+ skip := GetSkipHeaders()
+ require.Contains(t, skip, "Host")
+ require.Contains(t, skip, "Connection")
+ require.Contains(t, skip, "Transfer-Encoding")
+ require.Contains(t, skip, "Upgrade")
+ require.Contains(t, skip, "Content-Length")
+ require.Contains(t, skip, "Cookie")
+ require.Contains(t, skip, "Origin")
+ require.Contains(t, skip, "Referer")
+}
+
+func TestBuildWebSocketHeaders_UsesAuthorizationHeaderAndAddsAgentToken(t *testing.T) {
+ gin.SetMode(gin.TestMode)
+ w := httptest.NewRecorder()
+ c, _ := gin.CreateTestContext(w)
+ c.Request = httptest.NewRequest(http.MethodGet, "http://example.com", nil)
+ c.Request.Header.Set(HeaderAPIKey, "api-key")
+ c.Request.Header.Set(HeaderAuthorization, "Bearer auth")
+ c.Request.Header.Set(HeaderCookie, "session=abc")
+
+ agent := "agent-token"
+ headers := BuildWebSocketHeaders(c, &agent)
+
+ require.Equal(t, "api-key", headers.Get(HeaderAPIKey))
+ require.Equal(t, "Bearer auth", headers.Get(HeaderAuthorization))
+ require.Empty(t, headers.Get(HeaderCookie))
+ require.Equal(t, agent, headers.Get(HeaderAgentToken))
+}
+
+func TestBuildWebSocketHeaders_UsesCookieTokenAsBearer(t *testing.T) {
+ gin.SetMode(gin.TestMode)
+ w := httptest.NewRecorder()
+ c, _ := gin.CreateTestContext(w)
+ c.Request = httptest.NewRequest(http.MethodGet, "http://example.com", nil)
+ c.Request.AddCookie(&http.Cookie{Name: "token", Value: "cookie-token"})
+
+ headers := BuildWebSocketHeaders(c, nil)
+ require.Equal(t, "Bearer cookie-token", headers.Get(HeaderAuthorization))
+}
+
+func TestBuildWebSocketHeaders_ForwardsCookieHeaderWhenNoAuthPresent(t *testing.T) {
+ gin.SetMode(gin.TestMode)
+ w := httptest.NewRecorder()
+ c, _ := gin.CreateTestContext(w)
+ c.Request = httptest.NewRequest(http.MethodGet, "http://example.com", nil)
+ c.Request.Header.Set(HeaderCookie, "session=abc")
+
+ headers := BuildWebSocketHeaders(c, nil)
+ require.Equal(t, "session=abc", headers.Get(HeaderCookie))
+}
+
+func TestHTTPToWebSocketURL(t *testing.T) {
+ require.Equal(t, "wss://example.com/path", HTTPToWebSocketURL("https://example.com/path"))
+ require.Equal(t, "ws://example.com/path", HTTPToWebSocketURL("http://example.com/path"))
+ require.Equal(t, "ws://already", HTTPToWebSocketURL("ws://already"))
+}
+
+func TestCopyBodyWithFlush_FlushesWhenSupported(t *testing.T) {
+ w := newFlushResponseWriter()
+ body := &chunkReader{chunks: [][]byte{[]byte("hello "), []byte("world")}}
+
+ CopyBodyWithFlush(w, body)
+ require.Equal(t, "hello world", w.buf.String())
+ require.Equal(t, 2, w.flushes)
+}
+
+func TestCopyBodyWithFlush_DoesNotRequireFlusher(t *testing.T) {
+ w := newNoFlushResponseWriter()
+ body := &chunkReader{chunks: [][]byte{[]byte("a"), []byte("b"), []byte("c")}}
+
+ CopyBodyWithFlush(w, body)
+ require.Equal(t, "abc", w.buf.String())
+}