home: cover middleware with test

CHANGELOG.md

@@ -31,6 +31,10 @@ and this project adheres to
 ### Changed
 
 - Improved tests output ([#2273]).
+- Various internal improvements ([#2271], [#2297]).
+
+[#2271]: https://github.com/AdguardTeam/AdGuardHome/issues/2271
+[#2297]: https://github.com/AdguardTeam/AdGuardHome/issues/2297
 
 ### Fixed
 

internal/aghio/limitedreadcloser.go

@@ -9,17 +9,17 @@ import (
 
 // LimitReachedError records the limit and the operation that caused it.
 type LimitReachedError struct {
-	Op    string
 	Limit int64
 }
 
+// Error implements error interface for LimitReachedError.
+// TODO(a.garipov): Think about error string format.
 func (lre *LimitReachedError) Error() string {
 	b := &strings.Builder{}
 
-	b.WriteString(lre.Op)
-	b.WriteString(": limit reached with ")
+	b.WriteString("attempted to read more than ")
 	b.WriteString(strconv.FormatInt(lre.Limit, 10))
-	b.WriteString(" bytes read")
+	b.WriteString(" bytes")
 
 	return b.String()
 }
@@ -36,7 +36,6 @@ type limitedReadCloser struct {
 func (lrc *limitedReadCloser) Read(p []byte) (n int, err error) {
 	if lrc.n <= 0 {
 		return 0, &LimitReachedError{
-			Op:    "Read",
 			Limit: lrc.limit,
 		}
 	}

internal/aghio/limitedreadcloser_test.go

@@ -34,7 +34,6 @@ func TestLimitedReadCloser_Read(t *testing.T) {
 		rStr:  "abc",
 		want:  0,
 		err: &LimitReachedError{
-			Op:    "Read",
 			Limit: 0,
 		},
 	}, {
@@ -66,9 +65,8 @@ func TestLimitedReadCloser_LimitReachedError(t *testing.T) {
 		err  error
 	}{{
 		name: "simplest",
-		want: "test: limit reached with 0 bytes read",
+		want: "attempted to read more than 0 bytes",
 		err: &LimitReachedError{
-			Op:    "test",
 			Limit: 0,
 		},
 	}}

internal/home/middlewares.go

@@ -24,7 +24,8 @@ func withMiddlewares(h http.Handler, middlewares ...middleware) (wrapped http.Ha
 // RequestBodySizeLimit is maximum request body length in bytes.
 const RequestBodySizeLimit = 64 * 1024
 
-// LimitRequestBody substitutes body of the request with LimitedReadCloser.
+// LimitRequestBody wraps underlying handler h, making it's request's body Read
+// method limited.
 func limitRequestBody(h http.Handler) (limited http.Handler) {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		r.Body = aghio.LimitReadCloser(r.Body, RequestBodySizeLimit)

internal/home/middlewares_test.go

@@ -0,0 +1,64 @@
+package home
+
+import (
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/AdguardTeam/AdGuardHome/internal/aghio"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMiddlewares_LimitRequestBody(t *testing.T) {
+	errReqLimitReached := &aghio.LimitReachedError{
+		Limit: RequestBodySizeLimit,
+	}
+
+	testCases := []struct {
+		name    string
+		body    string
+		want    []byte
+		wantErr error
+	}{{
+		name:    "not_so_big",
+		body:    "somestr",
+		want:    []byte("somestr"),
+		wantErr: nil,
+	}, {
+		name:    "so_big",
+		body:    string(make([]byte, RequestBodySizeLimit+1)),
+		want:    make([]byte, RequestBodySizeLimit),
+		wantErr: errReqLimitReached,
+	}, {
+		name:    "empty",
+		body:    "",
+		want:    []byte(nil),
+		wantErr: nil,
+	}}
+
+	makeHandler := func(err *error) http.HandlerFunc {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			var b []byte
+			b, *err = ioutil.ReadAll(r.Body)
+			w.Write(b)
+		})
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			var err error
+			handler := makeHandler(&err)
+			lim := limitRequestBody(handler)
+
+			req := httptest.NewRequest(http.MethodPost, "https://www.example.com", strings.NewReader(tc.body))
+			res := httptest.NewRecorder()
+
+			lim.ServeHTTP(res, req)
+
+			assert.Equal(t, tc.want, res.Body.Bytes())
+			assert.Equal(t, tc.wantErr, err)
+		})
+	}
+}