From 12d6a7667459d50350d4e1e1ae8b6d4c68078ca3 Mon Sep 17 00:00:00 2001 From: ismail simsek Date: Sun, 8 Sep 2024 13:20:27 +0200 Subject: [PATCH] Chore: Update max bytes reader middleware error message (#1072) * update max bytes reader middleware error message * attempt to improve the naming * rename --- backend/httpclient/max_bytes_reader.go | 23 ++++++++++--------- backend/httpclient/max_bytes_reader_test.go | 20 ++++++++-------- .../response_limit_middleware_test.go | 18 +++++++-------- 3 files changed, 31 insertions(+), 30 deletions(-) diff --git a/backend/httpclient/max_bytes_reader.go b/backend/httpclient/max_bytes_reader.go index 9bbdce1e3..4a9d1cea0 100644 --- a/backend/httpclient/max_bytes_reader.go +++ b/backend/httpclient/max_bytes_reader.go @@ -24,13 +24,14 @@ var ErrResponseBodyTooLarge = errors.New("http: response body too large") // MaxBytesReader prevents clients from accidentally or maliciously // sending a large request and wasting server resources. func MaxBytesReader(r io.ReadCloser, n int64) io.ReadCloser { - return &maxBytesReader{r: r, n: n} + return &maxBytesReader{r: r, remainingBytes: n, limit: n} } type maxBytesReader struct { - r io.ReadCloser // underlying reader - n int64 // max bytes remaining - err error // sticky error + r io.ReadCloser // underlying reader + remainingBytes int64 // max bytes remaining + limit int64 // the actual limit + err error // sticky error } func (l *maxBytesReader) Read(p []byte) (n int, err error) { @@ -43,21 +44,21 @@ func (l *maxBytesReader) Read(p []byte) (n int, err error) { // If they asked for a 32KB byte read but only 5 bytes are // remaining, no need to read 32KB. 6 bytes will answer the // question of the whether we hit the limit or go past it. - if int64(len(p)) > l.n+1 { - p = p[:l.n+1] + if int64(len(p)) > l.remainingBytes+1 { + p = p[:l.remainingBytes+1] } n, err = l.r.Read(p) - if int64(n) <= l.n { - l.n -= int64(n) + if int64(n) <= l.remainingBytes { + l.remainingBytes -= int64(n) l.err = err return n, err } - n = int(l.n) - l.n = 0 + n = int(l.remainingBytes) + l.remainingBytes = 0 - l.err = fmt.Errorf("error: %w, response limit is set to: %d", ErrResponseBodyTooLarge, n) + l.err = fmt.Errorf("error: %w, response limit is set to: %d", ErrResponseBodyTooLarge, l.limit) return n, l.err } diff --git a/backend/httpclient/max_bytes_reader_test.go b/backend/httpclient/max_bytes_reader_test.go index 1f48be0bb..9ee01bc0d 100644 --- a/backend/httpclient/max_bytes_reader_test.go +++ b/backend/httpclient/max_bytes_reader_test.go @@ -12,14 +12,14 @@ import ( func TestMaxBytesReader(t *testing.T) { tcs := []struct { - limit int64 - bodyLength int - body string - err error + limit int64 + expectedBodyLength int + expectedBody string + err error }{ - {limit: 1, bodyLength: 1, body: "d", err: errors.New("error: http: response body too large, response limit is set to: 1")}, - {limit: 1000000, bodyLength: 5, body: "dummy", err: nil}, - {limit: 0, bodyLength: 0, body: "", err: errors.New("error: http: response body too large, response limit is set to: 0")}, + {limit: 1, expectedBodyLength: 1, expectedBody: "d", err: errors.New("error: http: response body too large, response limit is set to: 1")}, + {limit: 1000000, expectedBodyLength: 5, expectedBody: "dummy", err: nil}, + {limit: 0, expectedBodyLength: 0, expectedBody: "", err: errors.New("error: http: response body too large, response limit is set to: 0")}, } for _, tc := range tcs { t.Run(fmt.Sprintf("Test MaxBytesReader with limit: %d", tc.limit), func(t *testing.T) { @@ -28,13 +28,13 @@ func TestMaxBytesReader(t *testing.T) { bodyBytes, err := io.ReadAll(readCloser) if err != nil { - require.EqualError(t, tc.err, err.Error()) + require.EqualError(t, err, tc.err.Error()) } else { require.NoError(t, tc.err) } - require.Len(t, bodyBytes, tc.bodyLength) - require.Equal(t, string(bodyBytes), tc.body) + require.Len(t, bodyBytes, tc.expectedBodyLength) + require.Equal(t, tc.expectedBody, string(bodyBytes)) }) } } diff --git a/backend/httpclient/response_limit_middleware_test.go b/backend/httpclient/response_limit_middleware_test.go index 7948fb3ab..ec5b3b810 100644 --- a/backend/httpclient/response_limit_middleware_test.go +++ b/backend/httpclient/response_limit_middleware_test.go @@ -14,14 +14,14 @@ import ( func TestResponseLimitMiddleware(t *testing.T) { tcs := []struct { - limit int64 - bodyLength int - body string - err error + limit int64 + expectedBodyLength int + expectedBody string + err error }{ - {limit: 1, bodyLength: 1, body: "d", err: errors.New("error: http: response body too large, response limit is set to: 1")}, - {limit: 1000000, bodyLength: 5, body: "dummy", err: nil}, - {limit: 0, bodyLength: 5, body: "dummy", err: nil}, + {limit: 1, expectedBodyLength: 1, expectedBody: "d", err: errors.New("error: http: response body too large, response limit is set to: 1")}, + {limit: 1000000, expectedBodyLength: 5, expectedBody: "dummy", err: nil}, + {limit: 0, expectedBodyLength: 5, expectedBody: "dummy", err: nil}, } for _, tc := range tcs { t.Run(fmt.Sprintf("Test ResponseLimitMiddleware with limit: %d", tc.limit), func(t *testing.T) { @@ -51,8 +51,8 @@ func TestResponseLimitMiddleware(t *testing.T) { } require.NoError(t, res.Body.Close()) - require.Len(t, bodyBytes, tc.bodyLength) - require.Equal(t, string(bodyBytes), tc.body) + require.Len(t, bodyBytes, tc.expectedBodyLength) + require.Equal(t, string(bodyBytes), tc.expectedBody) }) } }