test(06-14): regression coverage for surf and bouncer gap closure

surf/bodylimit_test.go

@@ -179,3 +179,91 @@ func TestCompileRouteConflictReturnsError(t *testing.T) {
 		t.Fatal("expected conflict error")
 	}
 }
+
+type bodyProbePlugin struct {
+	id     string
+	raw    bool
+	use    []string
+	mw     map[string]pact.Middleware
+	routes func(pact.Router)
+}
+
+func (p bodyProbePlugin) ID() string                              { return p.id }
+func (p bodyProbePlugin) Requires() []string                      { return nil }
+func (p bodyProbePlugin) Register(*backpack.App) error            { return nil }
+func (p bodyProbePlugin) Boot(*backpack.App) error                { return nil }
+func (p bodyProbePlugin) Middlewares() map[string]pact.Middleware { return p.mw }
+func (p bodyProbePlugin) Routes(r pact.Router) error {
+	open := r.Group
+	if p.raw {
+		open = r.GroupRaw
+	}
+	open("/", Use(p.use...), func(g pact.Router) {
+		g.Post("/x", func(w http.ResponseWriter, _ *http.Request) { w.WriteHeader(http.StatusOK) })
+	})
+	return nil
+}
+
+func TestBodyLimitBoundsBodyConsumingMiddleware(t *testing.T) {
+	type result struct {
+		n   int
+		err error
+	}
+	run := func(t *testing.T, raw bool, use []string, bodyLen int, after func()) (result, *httptest.ResponseRecorder) {
+		t.Helper()
+		var res result
+		reader := func(next http.Handler) http.Handler {
+			return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				b, err := io.ReadAll(r.Body)
+				res = result{n: len(b), err: err}
+				if after != nil {
+					after()
+				}
+				next.ServeHTTP(w, r)
+			})
+		}
+		cfg := writeHTTPConfig(t, "body_limits:\n  default_bytes: 4\n  upload_bytes: 8\n")
+		h, err := Assemble(backpack.New(cfg), []party.Plugin{bodyProbePlugin{
+			id: "golem15.probe", raw: raw, use: use,
+			mw: map[string]pact.Middleware{"reader": reader},
+		}})
+		if err != nil {
+			t.Fatal(err)
+		}
+		rec := httptest.NewRecorder()
+		h.ServeHTTP(rec, httptest.NewRequest(http.MethodPost, "/x", strings.NewReader(strings.Repeat("a", bodyLen))))
+		return res, rec
+	}
+	var maxErr *http.MaxBytesError
+
+	t.Run("default limit", func(t *testing.T) {
+		res, _ := run(t, false, []string{"reader"}, 10, nil)
+		if !errors.As(res.err, &maxErr) || res.n > 4 {
+			t.Fatalf("read %d bytes, err = %v", res.n, res.err)
+		}
+	})
+	t.Run("body.limit override raises cap", func(t *testing.T) {
+		res, _ := run(t, false, []string{"reader", "body.limit:6"}, 5, nil)
+		if res.err != nil || res.n != 5 {
+			t.Fatalf("read %d bytes, err = %v", res.n, res.err)
+		}
+	})
+	t.Run("body.limit override still bounds", func(t *testing.T) {
+		res, _ := run(t, false, []string{"reader", "body.limit:6"}, 10, nil)
+		if !errors.As(res.err, &maxErr) || res.n > 6 {
+			t.Fatalf("read %d bytes, err = %v", res.n, res.err)
+		}
+	})
+	t.Run("raw route unaffected", func(t *testing.T) {
+		res, rec := run(t, true, []string{"reader"}, 10, nil)
+		if res.err != nil || res.n != 10 || rec.Code != http.StatusOK {
+			t.Fatalf("read %d bytes, err = %v, code %d", res.n, res.err, rec.Code)
+		}
+	})
+	t.Run("panic after read still clean 500", func(t *testing.T) {
+		_, rec := run(t, false, []string{"reader"}, 10, func() { panic("boom") })
+		if rec.Code != http.StatusInternalServerError || strings.Contains(rec.Body.String(), "boom") {
+			t.Fatalf("code %d body %q", rec.Code, rec.Body.String())
+		}
+	})
+}