2022-01-20 07:46:51 -06:00
|
|
|
package httpapi_test
|
|
|
|
|
|
|
|
|
|
import (
|
2025-03-28 17:13:20 -04:00
|
|
|
"bufio"
|
2022-01-20 07:46:51 -06:00
|
|
|
"bytes"
|
2022-09-21 17:07:00 -05:00
|
|
|
"context"
|
2022-01-20 07:46:51 -06:00
|
|
|
"encoding/json"
|
2023-02-17 11:50:21 -06:00
|
|
|
"fmt"
|
2025-03-28 17:13:20 -04:00
|
|
|
"io"
|
|
|
|
|
"net"
|
2022-01-20 07:46:51 -06:00
|
|
|
"net/http"
|
|
|
|
|
"net/http/httptest"
|
2026-08-18 12:54:45 -07:00
|
|
|
"strconv"
|
2022-04-01 13:17:45 -05:00
|
|
|
"strings"
|
2022-01-20 07:46:51 -06:00
|
|
|
"testing"
|
2025-03-28 17:13:20 -04:00
|
|
|
"time"
|
2022-01-20 07:46:51 -06:00
|
|
|
|
2022-04-01 13:17:45 -05:00
|
|
|
"github.com/stretchr/testify/assert"
|
2022-01-20 07:46:51 -06:00
|
|
|
"github.com/stretchr/testify/require"
|
2026-08-18 12:54:45 -07:00
|
|
|
"go.uber.org/mock/gomock"
|
2022-08-29 17:00:52 -05:00
|
|
|
"golang.org/x/xerrors"
|
2022-01-20 07:46:51 -06:00
|
|
|
|
2026-08-18 12:54:45 -07:00
|
|
|
"cdr.dev/slog/v3"
|
2026-01-26 12:11:40 +00:00
|
|
|
"cdr.dev/slog/v3/sloggers/slogtest"
|
2023-08-18 13:55:43 -05:00
|
|
|
"github.com/coder/coder/v2/coderd/httpapi"
|
2026-08-18 12:54:45 -07:00
|
|
|
"github.com/coder/coder/v2/coderd/httpmw/loggermw"
|
|
|
|
|
"github.com/coder/coder/v2/coderd/httpmw/loggermw/loggermock"
|
2023-08-18 13:55:43 -05:00
|
|
|
"github.com/coder/coder/v2/codersdk"
|
2025-03-28 17:13:20 -04:00
|
|
|
"github.com/coder/coder/v2/testutil"
|
2026-06-03 10:46:07 +01:00
|
|
|
"github.com/coder/quartz"
|
2022-01-20 07:46:51 -06:00
|
|
|
)
|
|
|
|
|
|
2022-08-29 17:00:52 -05:00
|
|
|
func TestInternalServerError(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
|
|
t.Run("NoError", func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
w := httptest.NewRecorder()
|
|
|
|
|
httpapi.InternalServerError(w, nil)
|
|
|
|
|
|
|
|
|
|
var resp codersdk.Response
|
|
|
|
|
err := json.NewDecoder(w.Body).Decode(&resp)
|
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
require.Equal(t, http.StatusInternalServerError, w.Code)
|
|
|
|
|
require.NotEmpty(t, resp.Message)
|
|
|
|
|
require.Empty(t, resp.Detail)
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
t.Run("WithError", func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
var (
|
|
|
|
|
w = httptest.NewRecorder()
|
|
|
|
|
httpErr = xerrors.New("error!")
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
httpapi.InternalServerError(w, httpErr)
|
|
|
|
|
|
|
|
|
|
var resp codersdk.Response
|
|
|
|
|
err := json.NewDecoder(w.Body).Decode(&resp)
|
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
require.Equal(t, http.StatusInternalServerError, w.Code)
|
|
|
|
|
require.NotEmpty(t, resp.Message)
|
|
|
|
|
require.Equal(t, httpErr.Error(), resp.Detail)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
2022-01-20 07:46:51 -06:00
|
|
|
func TestWrite(t *testing.T) {
|
2022-01-24 11:07:42 -06:00
|
|
|
t.Parallel()
|
2022-01-20 07:46:51 -06:00
|
|
|
t.Run("NoErrors", func(t *testing.T) {
|
2022-01-24 11:07:42 -06:00
|
|
|
t.Parallel()
|
2022-09-21 17:07:00 -05:00
|
|
|
ctx := context.Background()
|
2022-01-20 07:46:51 -06:00
|
|
|
rw := httptest.NewRecorder()
|
2022-09-21 17:07:00 -05:00
|
|
|
httpapi.Write(ctx, rw, http.StatusOK, codersdk.Response{
|
2022-06-07 09:33:06 -05:00
|
|
|
Message: "Wow.",
|
2022-01-20 07:46:51 -06:00
|
|
|
})
|
|
|
|
|
var m map[string]interface{}
|
|
|
|
|
err := json.NewDecoder(rw.Body).Decode(&m)
|
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
_, ok := m["errors"]
|
|
|
|
|
require.False(t, ok)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestRead(t *testing.T) {
|
2022-01-24 11:07:42 -06:00
|
|
|
t.Parallel()
|
2022-01-20 07:46:51 -06:00
|
|
|
t.Run("EmptyStruct", func(t *testing.T) {
|
2022-01-24 11:07:42 -06:00
|
|
|
t.Parallel()
|
2022-09-21 17:07:00 -05:00
|
|
|
ctx := context.Background()
|
2022-01-20 07:46:51 -06:00
|
|
|
rw := httptest.NewRecorder()
|
|
|
|
|
r := httptest.NewRequest("POST", "/", bytes.NewBufferString("{}"))
|
|
|
|
|
v := struct{}{}
|
2022-09-21 17:07:00 -05:00
|
|
|
require.True(t, httpapi.Read(ctx, rw, r, &v))
|
2022-01-20 07:46:51 -06:00
|
|
|
})
|
|
|
|
|
|
|
|
|
|
t.Run("NoBody", func(t *testing.T) {
|
2022-01-24 11:07:42 -06:00
|
|
|
t.Parallel()
|
2022-09-21 17:07:00 -05:00
|
|
|
ctx := context.Background()
|
2022-01-20 07:46:51 -06:00
|
|
|
rw := httptest.NewRecorder()
|
|
|
|
|
r := httptest.NewRequest("POST", "/", nil)
|
|
|
|
|
var v json.RawMessage
|
2022-09-21 17:07:00 -05:00
|
|
|
require.False(t, httpapi.Read(ctx, rw, r, v))
|
2022-01-20 07:46:51 -06:00
|
|
|
})
|
|
|
|
|
|
2026-07-23 17:55:34 -04:00
|
|
|
t.Run("BodyTooLarge", func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
ctx := context.Background()
|
|
|
|
|
rw := httptest.NewRecorder()
|
|
|
|
|
r := httptest.NewRequest("POST", "/", strings.NewReader(`{"value":"too large"}`))
|
|
|
|
|
r.Body = http.MaxBytesReader(rw, r.Body, 4)
|
|
|
|
|
var v json.RawMessage
|
|
|
|
|
require.False(t, httpapi.Read(ctx, rw, r, &v))
|
|
|
|
|
require.Equal(t, http.StatusRequestEntityTooLarge, rw.Code)
|
|
|
|
|
})
|
|
|
|
|
|
2022-01-20 07:46:51 -06:00
|
|
|
t.Run("Validate", func(t *testing.T) {
|
2022-01-24 11:07:42 -06:00
|
|
|
t.Parallel()
|
2022-01-20 07:46:51 -06:00
|
|
|
type toValidate struct {
|
|
|
|
|
Value string `json:"value" validate:"required"`
|
|
|
|
|
}
|
2022-09-21 17:07:00 -05:00
|
|
|
ctx := context.Background()
|
2022-01-20 07:46:51 -06:00
|
|
|
rw := httptest.NewRecorder()
|
|
|
|
|
r := httptest.NewRequest("POST", "/", bytes.NewBufferString(`{"value":"hi"}`))
|
|
|
|
|
|
|
|
|
|
var validate toValidate
|
2022-09-21 17:07:00 -05:00
|
|
|
require.True(t, httpapi.Read(ctx, rw, r, &validate))
|
2022-05-27 10:13:13 -04:00
|
|
|
require.Equal(t, "hi", validate.Value)
|
2022-01-20 07:46:51 -06:00
|
|
|
})
|
|
|
|
|
|
|
|
|
|
t.Run("ValidateFailure", func(t *testing.T) {
|
2022-01-24 11:07:42 -06:00
|
|
|
t.Parallel()
|
2022-01-20 07:46:51 -06:00
|
|
|
type toValidate struct {
|
|
|
|
|
Value string `json:"value" validate:"required"`
|
|
|
|
|
}
|
2022-09-21 17:07:00 -05:00
|
|
|
ctx := context.Background()
|
2022-01-20 07:46:51 -06:00
|
|
|
rw := httptest.NewRecorder()
|
|
|
|
|
r := httptest.NewRequest("POST", "/", bytes.NewBufferString("{}"))
|
|
|
|
|
|
|
|
|
|
var validate toValidate
|
2022-09-21 17:07:00 -05:00
|
|
|
require.False(t, httpapi.Read(ctx, rw, r, &validate))
|
2022-07-12 19:15:02 -05:00
|
|
|
var v codersdk.Response
|
2022-01-20 07:46:51 -06:00
|
|
|
err := json.NewDecoder(rw.Body).Decode(&v)
|
|
|
|
|
require.NoError(t, err)
|
2022-06-03 16:48:09 -05:00
|
|
|
require.Len(t, v.Validations, 1)
|
|
|
|
|
require.Equal(t, "value", v.Validations[0].Field)
|
|
|
|
|
require.Equal(t, "Validation failed for tag \"required\" with value: \"\"", v.Validations[0].Detail)
|
2022-01-20 07:46:51 -06:00
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
2026-08-18 12:54:45 -07:00
|
|
|
// readBody is decoded by the request body limit tests. It carries no validate
|
|
|
|
|
// tags so that a decode failure is unambiguously a body-size failure.
|
|
|
|
|
type readBody struct {
|
|
|
|
|
Value string `json:"value"`
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// jsonBodyOfSize returns a JSON object that decodes into readBody and is
|
|
|
|
|
// exactly size bytes long.
|
|
|
|
|
func jsonBodyOfSize(size int) string {
|
|
|
|
|
const (
|
|
|
|
|
prefix = `{"value":"`
|
|
|
|
|
suffix = `"}`
|
|
|
|
|
)
|
|
|
|
|
return prefix + strings.Repeat("a", size-len(prefix)-len(suffix)) + suffix
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestReadDefaultLimit(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
|
|
// requireTooLarge asserts the 413 response shape shared by every
|
|
|
|
|
// over-limit case.
|
|
|
|
|
requireTooLarge := func(t *testing.T, rw *httptest.ResponseRecorder, limit int) {
|
|
|
|
|
t.Helper()
|
|
|
|
|
require.Equal(t, http.StatusRequestEntityTooLarge, rw.Code)
|
|
|
|
|
var resp codersdk.Response
|
|
|
|
|
require.NoError(t, json.NewDecoder(rw.Body).Decode(&resp))
|
|
|
|
|
require.Equal(t, "Request body too large.", resp.Message)
|
|
|
|
|
require.Contains(t, resp.Detail, strconv.Itoa(limit),
|
|
|
|
|
"the detail must name the limit so the error is actionable")
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
t.Run("AtDefaultLimit", func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
body := jsonBodyOfSize(httpapi.DefaultMaxRequestBodyBytes)
|
|
|
|
|
rw := httptest.NewRecorder()
|
|
|
|
|
r := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(body))
|
|
|
|
|
|
|
|
|
|
var v readBody
|
|
|
|
|
require.True(t, httpapi.Read(context.Background(), rw, r, &v))
|
|
|
|
|
require.Len(t, v.Value, httpapi.DefaultMaxRequestBodyBytes-len(`{"value":""}`))
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
t.Run("OverDefaultLimitByOneByte", func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
body := jsonBodyOfSize(httpapi.DefaultMaxRequestBodyBytes + 1)
|
|
|
|
|
rw := httptest.NewRecorder()
|
|
|
|
|
r := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(body))
|
|
|
|
|
|
|
|
|
|
var v readBody
|
|
|
|
|
require.False(t, httpapi.Read(context.Background(), rw, r, &v))
|
|
|
|
|
requireTooLarge(t, rw, httpapi.DefaultMaxRequestBodyBytes)
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
// The limit is enforced on bytes actually read, so neither an absent nor a
|
|
|
|
|
// dishonest Content-Length can raise it. Asserted in-process rather than
|
|
|
|
|
// over a connection because a client still streaming an oversized body may
|
|
|
|
|
// see the connection reset instead of the 413, which would make a
|
|
|
|
|
// network-driven assertion racy.
|
|
|
|
|
t.Run("NoContentLength", func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
body := jsonBodyOfSize(httpapi.DefaultMaxRequestBodyBytes + 1)
|
|
|
|
|
rw := httptest.NewRecorder()
|
|
|
|
|
// io.NopCloser hides the length, which is what net/http sees for a
|
|
|
|
|
// chunked request.
|
|
|
|
|
r := httptest.NewRequest(http.MethodPost, "/", io.NopCloser(strings.NewReader(body)))
|
|
|
|
|
r.TransferEncoding = []string{"chunked"}
|
|
|
|
|
require.EqualValues(t, -1, r.ContentLength)
|
|
|
|
|
|
|
|
|
|
var v readBody
|
|
|
|
|
require.False(t, httpapi.Read(context.Background(), rw, r, &v))
|
|
|
|
|
requireTooLarge(t, rw, httpapi.DefaultMaxRequestBodyBytes)
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
t.Run("UnderstatedContentLength", func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
body := jsonBodyOfSize(httpapi.DefaultMaxRequestBodyBytes + 1)
|
|
|
|
|
rw := httptest.NewRecorder()
|
|
|
|
|
r := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(body))
|
|
|
|
|
r.ContentLength = 10
|
|
|
|
|
|
|
|
|
|
var v readBody
|
|
|
|
|
require.False(t, httpapi.Read(context.Background(), rw, r, &v))
|
|
|
|
|
requireTooLarge(t, rw, httpapi.DefaultMaxRequestBodyBytes)
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
t.Run("ChunkedUnderLimit", func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
body := jsonBodyOfSize(httpapi.DefaultMaxRequestBodyBytes)
|
|
|
|
|
rw := httptest.NewRecorder()
|
|
|
|
|
r := httptest.NewRequest(http.MethodPost, "/", io.NopCloser(strings.NewReader(body)))
|
|
|
|
|
r.TransferEncoding = []string{"chunked"}
|
|
|
|
|
|
|
|
|
|
var v readBody
|
|
|
|
|
require.True(t, httpapi.Read(context.Background(), rw, r, &v))
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestReadLimit(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
|
|
// A limit above the default must not be tightened by the default that Read
|
|
|
|
|
// installs. This is the unit-level regression test for the endpoints that
|
|
|
|
|
// legitimately accept more than DefaultMaxRequestBodyBytes; without
|
|
|
|
|
// ReadLimit they would be silently capped at the default.
|
|
|
|
|
t.Run("AboveDefaultIsNotTightened", func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
const limit = 8 << 20
|
|
|
|
|
body := jsonBodyOfSize(6 << 20)
|
|
|
|
|
require.Greater(t, len(body), httpapi.DefaultMaxRequestBodyBytes)
|
|
|
|
|
|
|
|
|
|
rw := httptest.NewRecorder()
|
|
|
|
|
r := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(body))
|
|
|
|
|
|
|
|
|
|
var v readBody
|
|
|
|
|
require.True(t, httpapi.ReadLimit(context.Background(), rw, r, limit, &v))
|
|
|
|
|
require.Len(t, v.Value, len(body)-len(`{"value":""}`))
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
t.Run("BelowDefaultIsEnforced", func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
const limit = 1024
|
|
|
|
|
rw := httptest.NewRecorder()
|
|
|
|
|
r := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(jsonBodyOfSize(limit+1)))
|
|
|
|
|
|
|
|
|
|
var v readBody
|
|
|
|
|
require.False(t, httpapi.ReadLimit(context.Background(), rw, r, limit, &v))
|
|
|
|
|
require.Equal(t, http.StatusRequestEntityTooLarge, rw.Code)
|
|
|
|
|
|
|
|
|
|
var resp codersdk.Response
|
|
|
|
|
require.NoError(t, json.NewDecoder(rw.Body).Decode(&resp))
|
|
|
|
|
require.Contains(t, resp.Detail, strconv.Itoa(limit))
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
t.Run("AtLimit", func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
const limit = 1024
|
|
|
|
|
rw := httptest.NewRecorder()
|
|
|
|
|
r := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(jsonBodyOfSize(limit)))
|
|
|
|
|
|
|
|
|
|
var v readBody
|
|
|
|
|
require.True(t, httpapi.ReadLimit(context.Background(), rw, r, limit, &v))
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
// The limit lands on the request's existing log line rather than one of its
|
|
|
|
|
// own: a caller can produce 413s at will, so a dedicated line would let them
|
|
|
|
|
// drive log volume.
|
|
|
|
|
t.Run("RecordsLimitOnRequestLog", func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
const limit = 1024
|
|
|
|
|
|
|
|
|
|
ctrl := gomock.NewController(t)
|
|
|
|
|
requestLogger := loggermock.NewMockRequestLogger(ctrl)
|
|
|
|
|
requestLogger.EXPECT().
|
|
|
|
|
WithFields(slog.F("max_request_body_bytes", int64(limit))).
|
|
|
|
|
Times(1)
|
|
|
|
|
|
|
|
|
|
ctx := loggermw.WithRequestLogger(context.Background(), requestLogger)
|
|
|
|
|
rw := httptest.NewRecorder()
|
|
|
|
|
r := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(jsonBodyOfSize(limit+1))).WithContext(ctx)
|
|
|
|
|
|
|
|
|
|
var v readBody
|
|
|
|
|
require.False(t, httpapi.ReadLimit(ctx, rw, r, limit, &v))
|
|
|
|
|
require.Equal(t, http.StatusRequestEntityTooLarge, rw.Code)
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
// A caller that installs its own reader is doing what the docstring
|
|
|
|
|
// forbids, but the number reported must still be the one that rejected the
|
|
|
|
|
// request. Nested readers compose as tightest-wins, so reporting the limit
|
|
|
|
|
// this call installed would tell the client and the log a cap that is not
|
|
|
|
|
// the one it hit.
|
|
|
|
|
t.Run("ReportsLimitThatTripped", func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
|
|
const (
|
|
|
|
|
tight = 1024
|
|
|
|
|
loose = 1 << 20
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
for _, tc := range []struct {
|
|
|
|
|
name string
|
|
|
|
|
callerWrap int64
|
|
|
|
|
readLimit int64
|
|
|
|
|
}{
|
|
|
|
|
{name: "CallerWrapsTighter", callerWrap: tight, readLimit: loose},
|
|
|
|
|
{name: "CallerWrapsLooser", callerWrap: loose, readLimit: tight},
|
|
|
|
|
} {
|
|
|
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
|
|
ctrl := gomock.NewController(t)
|
|
|
|
|
requestLogger := loggermock.NewMockRequestLogger(ctrl)
|
|
|
|
|
requestLogger.EXPECT().
|
|
|
|
|
WithFields(slog.F("max_request_body_bytes", int64(tight))).
|
|
|
|
|
Times(1)
|
|
|
|
|
|
|
|
|
|
ctx := loggermw.WithRequestLogger(context.Background(), requestLogger)
|
|
|
|
|
rw := httptest.NewRecorder()
|
|
|
|
|
r := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(jsonBodyOfSize(tight+1))).WithContext(ctx)
|
|
|
|
|
r.Body = http.MaxBytesReader(rw, r.Body, tc.callerWrap)
|
|
|
|
|
|
|
|
|
|
var v readBody
|
|
|
|
|
require.False(t, httpapi.ReadLimit(ctx, rw, r, tc.readLimit, &v))
|
|
|
|
|
require.Equal(t, http.StatusRequestEntityTooLarge, rw.Code)
|
|
|
|
|
|
|
|
|
|
var resp codersdk.Response
|
|
|
|
|
require.NoError(t, json.NewDecoder(rw.Body).Decode(&resp))
|
|
|
|
|
require.Contains(t, resp.Detail, strconv.Itoa(tight))
|
|
|
|
|
require.NotContains(t, resp.Detail, strconv.Itoa(loose))
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
2023-02-17 11:50:21 -06:00
|
|
|
func TestWebsocketCloseMsg(t *testing.T) {
|
2022-04-01 13:17:45 -05:00
|
|
|
t.Parallel()
|
|
|
|
|
|
2023-02-17 11:50:21 -06:00
|
|
|
t.Run("Sprintf", func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
|
|
var (
|
|
|
|
|
msg = "this is my message %q %q"
|
|
|
|
|
opts = []any{"colin", "kyle"}
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
expected := fmt.Sprintf(msg, opts...)
|
|
|
|
|
got := httpapi.WebsocketCloseSprintf(msg, opts...)
|
|
|
|
|
assert.Equal(t, expected, got)
|
|
|
|
|
})
|
|
|
|
|
|
2022-04-01 13:17:45 -05:00
|
|
|
t.Run("TruncateSingleByteCharacters", func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
|
|
msg := strings.Repeat("d", 255)
|
2025-01-29 18:06:22 +02:00
|
|
|
trunc := httpapi.WebsocketCloseSprintf("%s", msg)
|
2023-02-17 11:50:21 -06:00
|
|
|
assert.Equal(t, len(trunc), 123)
|
2022-04-01 13:17:45 -05:00
|
|
|
})
|
|
|
|
|
|
|
|
|
|
t.Run("TruncateMultiByteCharacters", func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
|
|
msg := strings.Repeat("こんにちは", 10)
|
2025-01-29 18:06:22 +02:00
|
|
|
trunc := httpapi.WebsocketCloseSprintf("%s", msg)
|
2023-02-17 11:50:21 -06:00
|
|
|
assert.Equal(t, len(trunc), 123)
|
2022-04-01 13:17:45 -05:00
|
|
|
})
|
|
|
|
|
}
|
2025-03-28 17:13:20 -04:00
|
|
|
|
|
|
|
|
// Our WebSocket library accepts any arbitrary ResponseWriter at the type level,
|
|
|
|
|
// but the writer must also implement http.Hijacker for long-lived connections.
|
|
|
|
|
type mockOneWaySocketWriter struct {
|
|
|
|
|
serverRecorder *httptest.ResponseRecorder
|
|
|
|
|
serverConn net.Conn
|
|
|
|
|
clientConn net.Conn
|
|
|
|
|
serverReadWriter *bufio.ReadWriter
|
|
|
|
|
testContext *testing.T
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (m mockOneWaySocketWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
|
|
|
return m.serverConn, m.serverReadWriter, nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (m mockOneWaySocketWriter) Flush() {
|
|
|
|
|
err := m.serverReadWriter.Flush()
|
|
|
|
|
require.NoError(m.testContext, err)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (m mockOneWaySocketWriter) Header() http.Header {
|
|
|
|
|
return m.serverRecorder.Header()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (m mockOneWaySocketWriter) Write(b []byte) (int, error) {
|
|
|
|
|
return m.serverReadWriter.Write(b)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (m mockOneWaySocketWriter) WriteHeader(code int) {
|
|
|
|
|
m.serverRecorder.WriteHeader(code)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestOneWayWebSocketEventSender(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
|
|
newBaseRequest := func(ctx context.Context) *http.Request {
|
|
|
|
|
url := "ws://www.fake-website.com/logs"
|
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
|
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
|
|
h := req.Header
|
|
|
|
|
h.Add("Connection", "Upgrade")
|
|
|
|
|
h.Add("Upgrade", "websocket")
|
|
|
|
|
h.Add("Sec-WebSocket-Version", "13")
|
|
|
|
|
h.Add("Sec-WebSocket-Key", "dGhlIHNhbXBsZSBub25jZQ==") // Just need any string
|
|
|
|
|
|
|
|
|
|
return req
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
newOneWayWriter := func(t *testing.T) mockOneWaySocketWriter {
|
|
|
|
|
mockServer, mockClient := net.Pipe()
|
|
|
|
|
recorder := httptest.NewRecorder()
|
|
|
|
|
|
|
|
|
|
return mockOneWaySocketWriter{
|
|
|
|
|
testContext: t,
|
|
|
|
|
serverConn: mockServer,
|
|
|
|
|
clientConn: mockClient,
|
|
|
|
|
serverRecorder: recorder,
|
|
|
|
|
serverReadWriter: bufio.NewReadWriter(
|
|
|
|
|
bufio.NewReader(mockServer),
|
2026-05-14 09:15:14 +01:00
|
|
|
bufio.NewWriter(mockServer),
|
2025-03-28 17:13:20 -04:00
|
|
|
),
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
t.Run("Produces error if the socket connection could not be established", func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
|
|
incorrectProtocols := []struct {
|
|
|
|
|
major int
|
|
|
|
|
minor int
|
|
|
|
|
proto string
|
|
|
|
|
}{
|
|
|
|
|
{0, 9, "HTTP/0.9"},
|
|
|
|
|
{1, 0, "HTTP/1.0"},
|
|
|
|
|
}
|
|
|
|
|
for _, p := range incorrectProtocols {
|
|
|
|
|
ctx := testutil.Context(t, testutil.WaitShort)
|
|
|
|
|
req := newBaseRequest(ctx)
|
|
|
|
|
req.ProtoMajor = p.major
|
|
|
|
|
req.ProtoMinor = p.minor
|
|
|
|
|
req.Proto = p.proto
|
|
|
|
|
|
|
|
|
|
writer := newOneWayWriter(t)
|
2026-06-03 10:46:07 +01:00
|
|
|
_, _, err := httpapi.OneWayWebSocketEventSender(slogtest.Make(t, nil), nil)(writer, req)
|
2025-03-28 17:13:20 -04:00
|
|
|
require.ErrorContains(t, err, p.proto)
|
|
|
|
|
}
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
t.Run("Returned callback can publish new event to WebSocket connection", func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
|
|
ctx := testutil.Context(t, testutil.WaitShort)
|
2026-06-03 10:46:07 +01:00
|
|
|
wsw := httpapi.NewWSWatcher(quartz.NewReal(), nil)
|
|
|
|
|
|
2025-03-28 17:13:20 -04:00
|
|
|
req := newBaseRequest(ctx)
|
|
|
|
|
writer := newOneWayWriter(t)
|
2026-06-03 10:46:07 +01:00
|
|
|
send, _, err := httpapi.OneWayWebSocketEventSender(slogtest.Make(t, nil), wsw)(writer, req)
|
2025-03-28 17:13:20 -04:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
|
|
serverPayload := codersdk.ServerSentEvent{
|
|
|
|
|
Type: codersdk.ServerSentEventTypeData,
|
|
|
|
|
Data: "Blah",
|
|
|
|
|
}
|
|
|
|
|
err = send(serverPayload)
|
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
|
|
// The client connection will receive a little bit of additional data on
|
|
|
|
|
// top of the main payload. Have to make sure check has tolerance for
|
2026-09-23 20:08:31 +02:00
|
|
|
// extra data being present. Read until the payload shows up; EOF only
|
|
|
|
|
// arrives after the close handshake times out against this raw pipe.
|
2025-03-28 17:13:20 -04:00
|
|
|
serverBytes, err := json.Marshal(serverPayload)
|
|
|
|
|
require.NoError(t, err)
|
2026-09-23 20:08:31 +02:00
|
|
|
deadline, ok := ctx.Deadline()
|
|
|
|
|
require.True(t, ok)
|
|
|
|
|
require.NoError(t, writer.clientConn.SetReadDeadline(deadline))
|
|
|
|
|
var clientBytes []byte
|
|
|
|
|
buf := make([]byte, 1024)
|
|
|
|
|
for !bytes.Contains(clientBytes, serverBytes) {
|
|
|
|
|
n, err := writer.clientConn.Read(buf)
|
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
clientBytes = append(clientBytes, buf[:n]...)
|
|
|
|
|
}
|
2025-03-28 17:13:20 -04:00
|
|
|
})
|
|
|
|
|
|
|
|
|
|
t.Run("Signals to outside consumer when socket has been closed", func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
|
|
ctx, cancel := context.WithCancel(testutil.Context(t, testutil.WaitShort))
|
2026-06-03 10:46:07 +01:00
|
|
|
wsw := httpapi.NewWSWatcher(quartz.NewReal(), nil)
|
2025-03-28 17:13:20 -04:00
|
|
|
req := newBaseRequest(ctx)
|
|
|
|
|
writer := newOneWayWriter(t)
|
2026-06-03 10:46:07 +01:00
|
|
|
_, done, err := httpapi.OneWayWebSocketEventSender(slogtest.Make(t, nil), wsw)(writer, req)
|
2025-03-28 17:13:20 -04:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
|
|
successC := make(chan bool)
|
|
|
|
|
ticker := time.NewTicker(testutil.WaitShort)
|
|
|
|
|
go func() {
|
|
|
|
|
select {
|
|
|
|
|
case <-done:
|
|
|
|
|
successC <- true
|
|
|
|
|
case <-ticker.C:
|
|
|
|
|
successC <- false
|
|
|
|
|
}
|
|
|
|
|
}()
|
|
|
|
|
|
|
|
|
|
cancel()
|
|
|
|
|
require.True(t, <-successC)
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
t.Run("Socket will immediately close if client sends any message", func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
|
|
ctx := testutil.Context(t, testutil.WaitShort)
|
2026-06-03 10:46:07 +01:00
|
|
|
wsw := httpapi.NewWSWatcher(quartz.NewReal(), nil)
|
2025-03-28 17:13:20 -04:00
|
|
|
req := newBaseRequest(ctx)
|
|
|
|
|
writer := newOneWayWriter(t)
|
2026-06-03 10:46:07 +01:00
|
|
|
_, done, err := httpapi.OneWayWebSocketEventSender(slogtest.Make(t, nil), wsw)(writer, req)
|
2025-03-28 17:13:20 -04:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
|
|
successC := make(chan bool)
|
|
|
|
|
ticker := time.NewTicker(testutil.WaitShort)
|
|
|
|
|
go func() {
|
|
|
|
|
select {
|
|
|
|
|
case <-done:
|
|
|
|
|
successC <- true
|
|
|
|
|
case <-ticker.C:
|
|
|
|
|
successC <- false
|
|
|
|
|
}
|
|
|
|
|
}()
|
|
|
|
|
|
|
|
|
|
type JunkClientEvent struct {
|
|
|
|
|
Value string
|
|
|
|
|
}
|
|
|
|
|
b, err := json.Marshal(JunkClientEvent{"Hi :)"})
|
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
_, err = writer.clientConn.Write(b)
|
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
require.True(t, <-successC)
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
t.Run("Renders the socket inert if the request context cancels", func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
|
|
ctx, cancel := context.WithCancel(testutil.Context(t, testutil.WaitShort))
|
2026-06-03 10:46:07 +01:00
|
|
|
wsw := httpapi.NewWSWatcher(quartz.NewReal(), nil)
|
2025-03-28 17:13:20 -04:00
|
|
|
req := newBaseRequest(ctx)
|
|
|
|
|
writer := newOneWayWriter(t)
|
2026-06-03 10:46:07 +01:00
|
|
|
send, done, err := httpapi.OneWayWebSocketEventSender(slogtest.Make(t, nil), wsw)(writer, req)
|
2025-03-28 17:13:20 -04:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
|
|
successC := make(chan bool)
|
|
|
|
|
ticker := time.NewTicker(testutil.WaitShort)
|
|
|
|
|
go func() {
|
|
|
|
|
select {
|
|
|
|
|
case <-done:
|
|
|
|
|
successC <- true
|
|
|
|
|
case <-ticker.C:
|
|
|
|
|
successC <- false
|
|
|
|
|
}
|
|
|
|
|
}()
|
|
|
|
|
|
|
|
|
|
cancel()
|
|
|
|
|
require.True(t, <-successC)
|
|
|
|
|
err = send(codersdk.ServerSentEvent{
|
|
|
|
|
Type: codersdk.ServerSentEventTypeData,
|
|
|
|
|
Data: "Didn't realize you were closed - sorry! I'll try coming back tomorrow.",
|
|
|
|
|
})
|
|
|
|
|
require.Equal(t, err, ctx.Err())
|
|
|
|
|
_, open := <-done
|
|
|
|
|
require.False(t, open)
|
|
|
|
|
_, err = writer.serverConn.Write([]byte{})
|
|
|
|
|
require.Equal(t, err, io.ErrClosedPipe)
|
|
|
|
|
_, err = writer.clientConn.Read([]byte{})
|
|
|
|
|
require.Equal(t, err, io.EOF)
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
t.Run("Sends a heartbeat to the socket on a fixed internal of time to keep connections alive", func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
|
2026-09-23 20:08:31 +02:00
|
|
|
// One tick of the mock clock must produce a heartbeat; read a few
|
|
|
|
|
// bytes of it to prove it was written.
|
2025-03-28 17:13:20 -04:00
|
|
|
heartbeatCount := 3
|
2026-09-23 20:08:31 +02:00
|
|
|
timeout := testutil.WaitShort
|
2025-03-28 17:13:20 -04:00
|
|
|
|
|
|
|
|
ctx := testutil.Context(t, timeout)
|
2026-09-23 20:08:31 +02:00
|
|
|
mClock := quartz.NewMock(t)
|
|
|
|
|
trap := mClock.Trap().NewTicker("WSWatcher")
|
|
|
|
|
defer trap.Close()
|
|
|
|
|
wsw := httpapi.NewWSWatcher(mClock, nil)
|
2025-03-28 17:13:20 -04:00
|
|
|
req := newBaseRequest(ctx)
|
|
|
|
|
writer := newOneWayWriter(t)
|
2026-06-03 10:46:07 +01:00
|
|
|
_, _, err := httpapi.OneWayWebSocketEventSender(slogtest.Make(t, nil), wsw)(writer, req)
|
2025-03-28 17:13:20 -04:00
|
|
|
require.NoError(t, err)
|
2026-09-23 20:08:31 +02:00
|
|
|
trap.MustWait(ctx).MustRelease(ctx)
|
2025-03-28 17:13:20 -04:00
|
|
|
|
|
|
|
|
type Result struct {
|
|
|
|
|
Err error
|
|
|
|
|
Success bool
|
|
|
|
|
}
|
|
|
|
|
resultC := make(chan Result)
|
|
|
|
|
go func() {
|
|
|
|
|
err := writer.
|
|
|
|
|
clientConn.
|
|
|
|
|
SetReadDeadline(time.Now().Add(timeout))
|
|
|
|
|
if err != nil {
|
|
|
|
|
resultC <- Result{err, false}
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
for range heartbeatCount {
|
|
|
|
|
pingBuffer := make([]byte, 1)
|
|
|
|
|
pingSize, err := writer.clientConn.Read(pingBuffer)
|
|
|
|
|
if err != nil || pingSize != 1 {
|
|
|
|
|
resultC <- Result{err, false}
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
resultC <- Result{nil, true}
|
|
|
|
|
}()
|
|
|
|
|
|
2026-09-23 20:08:31 +02:00
|
|
|
mClock.Advance(httpapi.HeartbeatInterval).MustWait(ctx)
|
2025-03-28 17:13:20 -04:00
|
|
|
result := <-resultC
|
|
|
|
|
require.NoError(t, result.Err)
|
|
|
|
|
require.True(t, result.Success)
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ServerSentEventSender accepts any arbitrary ResponseWriter at the type level,
|
|
|
|
|
// but the writer must also implement http.Flusher for long-lived connections
|
|
|
|
|
type mockServerSentWriter struct {
|
|
|
|
|
serverRecorder *httptest.ResponseRecorder
|
|
|
|
|
serverConn net.Conn
|
|
|
|
|
clientConn net.Conn
|
|
|
|
|
buffer *bytes.Buffer
|
|
|
|
|
testContext *testing.T
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (m mockServerSentWriter) Flush() {
|
|
|
|
|
b := m.buffer.Bytes()
|
|
|
|
|
_, err := m.serverConn.Write(b)
|
|
|
|
|
require.NoError(m.testContext, err)
|
|
|
|
|
m.buffer.Reset()
|
|
|
|
|
|
|
|
|
|
// Must close server connection to indicate EOF for any reads from the
|
|
|
|
|
// client connection; otherwise reads block forever. This is a testing
|
|
|
|
|
// limitation compared to the one-way websockets, since we have no way to
|
|
|
|
|
// frame the data and auto-indicate EOF for each message
|
|
|
|
|
err = m.serverConn.Close()
|
|
|
|
|
require.NoError(m.testContext, err)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (m mockServerSentWriter) Header() http.Header {
|
|
|
|
|
return m.serverRecorder.Header()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (m mockServerSentWriter) Write(b []byte) (int, error) {
|
|
|
|
|
return m.buffer.Write(b)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (m mockServerSentWriter) WriteHeader(code int) {
|
|
|
|
|
m.serverRecorder.WriteHeader(code)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func TestServerSentEventSender(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
|
|
newBaseRequest := func(ctx context.Context) *http.Request {
|
|
|
|
|
url := "ws://www.fake-website.com/logs"
|
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
|
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
return req
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
newServerSentWriter := func(t *testing.T) mockServerSentWriter {
|
|
|
|
|
mockServer, mockClient := net.Pipe()
|
|
|
|
|
return mockServerSentWriter{
|
|
|
|
|
testContext: t,
|
|
|
|
|
serverRecorder: httptest.NewRecorder(),
|
|
|
|
|
clientConn: mockClient,
|
|
|
|
|
serverConn: mockServer,
|
|
|
|
|
buffer: &bytes.Buffer{},
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
t.Run("Mutates response headers to support SSE connections", func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
|
|
ctx := testutil.Context(t, testutil.WaitShort)
|
|
|
|
|
req := newBaseRequest(ctx)
|
|
|
|
|
writer := newServerSentWriter(t)
|
|
|
|
|
_, _, err := httpapi.ServerSentEventSender(writer, req)
|
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
|
|
h := writer.Header()
|
|
|
|
|
require.Equal(t, h.Get("Content-Type"), "text/event-stream")
|
|
|
|
|
require.Equal(t, h.Get("Cache-Control"), "no-cache")
|
|
|
|
|
require.Equal(t, h.Get("Connection"), "keep-alive")
|
|
|
|
|
require.Equal(t, h.Get("X-Accel-Buffering"), "no")
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
t.Run("Returned callback can publish new event to SSE connection", func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
|
|
ctx := testutil.Context(t, testutil.WaitShort)
|
|
|
|
|
req := newBaseRequest(ctx)
|
|
|
|
|
writer := newServerSentWriter(t)
|
|
|
|
|
send, _, err := httpapi.ServerSentEventSender(writer, req)
|
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
|
|
serverPayload := codersdk.ServerSentEvent{
|
|
|
|
|
Type: codersdk.ServerSentEventTypeData,
|
|
|
|
|
Data: "Blah",
|
|
|
|
|
}
|
|
|
|
|
err = send(serverPayload)
|
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
|
|
clientBytes, err := io.ReadAll(writer.clientConn)
|
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
require.Equal(
|
|
|
|
|
t,
|
|
|
|
|
string(clientBytes),
|
|
|
|
|
"event: data\ndata: \"Blah\"\n\n",
|
|
|
|
|
)
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
t.Run("Signals to outside consumer when connection has been closed", func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
|
|
ctx, cancel := context.WithCancel(testutil.Context(t, testutil.WaitShort))
|
|
|
|
|
req := newBaseRequest(ctx)
|
|
|
|
|
writer := newServerSentWriter(t)
|
|
|
|
|
_, done, err := httpapi.ServerSentEventSender(writer, req)
|
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
|
|
successC := make(chan bool)
|
|
|
|
|
ticker := time.NewTicker(testutil.WaitShort)
|
|
|
|
|
go func() {
|
|
|
|
|
select {
|
|
|
|
|
case <-done:
|
|
|
|
|
successC <- true
|
|
|
|
|
case <-ticker.C:
|
|
|
|
|
successC <- false
|
|
|
|
|
}
|
|
|
|
|
}()
|
|
|
|
|
|
|
|
|
|
cancel()
|
|
|
|
|
require.True(t, <-successC)
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
t.Run("Sends a heartbeat to the client on a fixed internal of time to keep connections alive", func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
|
2026-09-23 20:08:31 +02:00
|
|
|
// One tick of the mock clock must produce a heartbeat; read a few
|
|
|
|
|
// bytes of it to prove it was written.
|
2025-03-28 17:13:20 -04:00
|
|
|
heartbeatCount := 3
|
2026-09-23 20:08:31 +02:00
|
|
|
timeout := testutil.WaitShort
|
2025-03-28 17:13:20 -04:00
|
|
|
|
|
|
|
|
ctx := testutil.Context(t, timeout)
|
2026-09-23 20:08:31 +02:00
|
|
|
mClock := quartz.NewMock(t)
|
|
|
|
|
trap := mClock.Trap().NewTicker("ServerSentEventSender")
|
|
|
|
|
defer trap.Close()
|
2025-03-28 17:13:20 -04:00
|
|
|
req := newBaseRequest(ctx)
|
|
|
|
|
writer := newServerSentWriter(t)
|
2026-09-23 20:08:31 +02:00
|
|
|
_, _, err := httpapi.ServerSentEventSenderWithClock(mClock)(writer, req)
|
2025-03-28 17:13:20 -04:00
|
|
|
require.NoError(t, err)
|
2026-09-23 20:08:31 +02:00
|
|
|
trap.MustWait(ctx).MustRelease(ctx)
|
2025-03-28 17:13:20 -04:00
|
|
|
|
|
|
|
|
type Result struct {
|
|
|
|
|
Err error
|
|
|
|
|
Success bool
|
|
|
|
|
}
|
|
|
|
|
resultC := make(chan Result)
|
|
|
|
|
go func() {
|
|
|
|
|
err := writer.
|
|
|
|
|
clientConn.
|
|
|
|
|
SetReadDeadline(time.Now().Add(timeout))
|
|
|
|
|
if err != nil {
|
|
|
|
|
resultC <- Result{err, false}
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
for range heartbeatCount {
|
|
|
|
|
pingBuffer := make([]byte, 1)
|
|
|
|
|
pingSize, err := writer.clientConn.Read(pingBuffer)
|
|
|
|
|
if err != nil || pingSize != 1 {
|
|
|
|
|
resultC <- Result{err, false}
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
resultC <- Result{nil, true}
|
|
|
|
|
}()
|
|
|
|
|
|
2026-09-23 20:08:31 +02:00
|
|
|
mClock.Advance(httpapi.HeartbeatInterval).MustWait(ctx)
|
2025-03-28 17:13:20 -04:00
|
|
|
result := <-resultC
|
|
|
|
|
require.NoError(t, result.Err)
|
|
|
|
|
require.True(t, result.Success)
|
|
|
|
|
})
|
|
|
|
|
}
|
2026-08-18 12:54:45 -07:00
|
|
|
|
|
|
|
|
// TestRecordRequestBodyLimit pins both halves of the call every oversized-body
|
|
|
|
|
// 413 site shares: the log field naming the limit, and the metric tracker.
|
|
|
|
|
func TestRecordRequestBodyLimit(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
|
|
t.Run("RecordsFieldAndMarksTracker", func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
const limit = int64(4096)
|
|
|
|
|
|
|
|
|
|
ctrl := gomock.NewController(t)
|
|
|
|
|
requestLogger := loggermock.NewMockRequestLogger(ctrl)
|
|
|
|
|
requestLogger.EXPECT().
|
|
|
|
|
WithFields(slog.F("max_request_body_bytes", limit)).
|
|
|
|
|
Times(1)
|
|
|
|
|
|
|
|
|
|
tracker := &httpapi.RequestBodyLimitTracker{}
|
|
|
|
|
ctx := httpapi.WithRequestBodyLimitTracker(
|
|
|
|
|
loggermw.WithRequestLogger(context.Background(), requestLogger), tracker)
|
|
|
|
|
|
|
|
|
|
require.False(t, tracker.Exceeded())
|
|
|
|
|
httpapi.RecordRequestBodyLimit(ctx, limit)
|
|
|
|
|
require.True(t, tracker.Exceeded())
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
// The middleware that installs the tracker is not mounted on every route, so
|
|
|
|
|
// a call without one must not panic.
|
|
|
|
|
t.Run("NoTrackerInContext", func(t *testing.T) {
|
|
|
|
|
t.Parallel()
|
|
|
|
|
httpapi.RecordRequestBodyLimit(context.Background(), 4096)
|
|
|
|
|
})
|
|
|
|
|
}
|