feat: add option to ignore unknown fields in gateway request parsing (#5058)

gateway/internal/requestparser_test.go

@@ -7,13 +7,14 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/golang/protobuf/proto"
 	"github.com/stretchr/testify/assert"
 	"github.com/zeromicro/go-zero/rest/pathvar"
 )
 
 func TestNewRequestParserNoVar(t *testing.T) {
 	req := httptest.NewRequest("GET", "/", http.NoBody)
-	parser, err := NewRequestParser(req, nil)
+	parser, err := NewRequestParser(req, nil, false)
 	assert.Nil(t, err)
 	assert.NotNil(t, parser)
 }
@@ -21,14 +22,14 @@ func TestNewRequestParserNoVar(t *testing.T) {
 func TestNewRequestParserWithVars(t *testing.T) {
 	req := httptest.NewRequest("GET", "/", http.NoBody)
 	req = pathvar.WithVars(req, map[string]string{"a": "b"})
-	parser, err := NewRequestParser(req, nil)
+	parser, err := NewRequestParser(req, nil, false)
 	assert.Nil(t, err)
 	assert.NotNil(t, parser)
 }
 
 func TestNewRequestParserNoVarWithBody(t *testing.T) {
 	req := httptest.NewRequest("GET", "/", strings.NewReader(`{"a": "b"}`))
-	parser, err := NewRequestParser(req, nil)
+	parser, err := NewRequestParser(req, nil, false)
 	assert.Nil(t, err)
 	assert.NotNil(t, parser)
 }
@@ -36,7 +37,7 @@ func TestNewRequestParserNoVarWithBody(t *testing.T) {
 func TestNewRequestParserWithNegativeContentLength(t *testing.T) {
 	req := httptest.NewRequest("GET", "/", strings.NewReader(`{"a": "b"}`))
 	req.ContentLength = -1
-	parser, err := NewRequestParser(req, nil)
+	parser, err := NewRequestParser(req, nil, false)
 	assert.Nil(t, err)
 	assert.NotNil(t, parser)
 }
@@ -44,7 +45,7 @@ func TestNewRequestParserWithNegativeContentLength(t *testing.T) {
 func TestNewRequestParserWithVarsWithBody(t *testing.T) {
 	req := httptest.NewRequest("GET", "/", strings.NewReader(`{"a": "b"}`))
 	req = pathvar.WithVars(req, map[string]string{"c": "d"})
-	parser, err := NewRequestParser(req, nil)
+	parser, err := NewRequestParser(req, nil, false)
 	assert.Nil(t, err)
 	assert.NotNil(t, parser)
 }
@@ -52,14 +53,14 @@ func TestNewRequestParserWithVarsWithBody(t *testing.T) {
 func TestNewRequestParserWithVarsWithWrongBody(t *testing.T) {
 	req := httptest.NewRequest("GET", "/", strings.NewReader(`{"a": "b"`))
 	req = pathvar.WithVars(req, map[string]string{"c": "d"})
-	parser, err := NewRequestParser(req, nil)
+	parser, err := NewRequestParser(req, nil, false)
 	assert.NotNil(t, err)
 	assert.Nil(t, parser)
 }
 
 func TestNewRequestParserWithForm(t *testing.T) {
 	req := httptest.NewRequest("GET", "/val?a=b", nil)
-	parser, err := NewRequestParser(req, nil)
+	parser, err := NewRequestParser(req, nil, false)
 	assert.Nil(t, err)
 	assert.NotNil(t, parser)
 }
@@ -67,7 +68,7 @@ func TestNewRequestParserWithForm(t *testing.T) {
 func TestNewRequestParserWithNilBody(t *testing.T) {
 	req := httptest.NewRequest("GET", "/val?a=b", http.NoBody)
 	req.Body = nil
-	parser, err := NewRequestParser(req, nil)
+	parser, err := NewRequestParser(req, nil, false)
 	assert.Nil(t, err)
 	assert.NotNil(t, parser)
 }
@@ -75,24 +76,135 @@ func TestNewRequestParserWithNilBody(t *testing.T) {
 func TestNewRequestParserWithBadBody(t *testing.T) {
 	req := httptest.NewRequest("GET", "/val?a=b", badBody{})
 	req.Body = badBody{}
-	parser, err := NewRequestParser(req, nil)
+	parser, err := NewRequestParser(req, nil, false)
 	assert.Nil(t, err)
 	assert.NotNil(t, parser)
 }
 
 func TestNewRequestParserWithBadForm(t *testing.T) {
 	req := httptest.NewRequest("GET", "/val?a%1=b", http.NoBody)
-	parser, err := NewRequestParser(req, nil)
+	parser, err := NewRequestParser(req, nil, false)
 	assert.NotNil(t, err)
 	assert.Nil(t, parser)
 }
 
-func TestRequestParser_buildJsonRequestParser(t *testing.T) {
-	parser, err := buildJsonRequestParser(map[string]any{"a": make(chan int)}, nil)
+func TestRequestParser_buildJsonRequestParserFromMap(t *testing.T) {
+	parser, err := buildJsonRequestParserFromMap(map[string]any{"a": make(chan int)}, nil, false)
 	assert.NotNil(t, err)
 	assert.Nil(t, parser)
 }
 
+// mockAnyResolver is a simple implementation of jsonpb.AnyResolver for testing
+type mockAnyResolver struct{}
+
+func (m *mockAnyResolver) Resolve(typeUrl string) (proto.Message, error) {
+	return nil, nil
+}
+
+func TestNewRequestParserWithIgnoreUnknownFields(t *testing.T) {
+	// Create a concrete resolver for testing
+	resolver := &mockAnyResolver{}
+
+	// Test case 1: No body, no vars - should work with both true and false
+	req1 := httptest.NewRequest("GET", "/", http.NoBody)
+	parser1, err1 := NewRequestParser(req1, resolver, true)
+	assert.Nil(t, err1)
+	assert.NotNil(t, parser1)
+
+	req2 := httptest.NewRequest("GET", "/", http.NoBody)
+	parser2, err2 := NewRequestParser(req2, resolver, false)
+	assert.Nil(t, err2)
+	assert.NotNil(t, parser2)
+
+	// Test case 2: With JSON body - tests the body parsing path
+	req3 := httptest.NewRequest("POST", "/", strings.NewReader(`{"field": "value"}`))
+	parser3, err3 := NewRequestParser(req3, resolver, true)
+	assert.Nil(t, err3)
+	assert.NotNil(t, parser3)
+
+	req4 := httptest.NewRequest("POST", "/", strings.NewReader(`{"field": "value"}`))
+	parser4, err4 := NewRequestParser(req4, resolver, false)
+	assert.Nil(t, err4)
+	assert.NotNil(t, parser4)
+}
+
+func TestNewRequestParserWithVarsAndIgnoreUnknownFields(t *testing.T) {
+	resolver := &mockAnyResolver{}
+
+	// Test with path variables and ignoreUnknownFields = true
+	req := httptest.NewRequest("GET", "/", http.NoBody)
+	req = pathvar.WithVars(req, map[string]string{"a": "b"})
+	parser, err := NewRequestParser(req, resolver, true)
+	assert.Nil(t, err)
+	assert.NotNil(t, parser)
+
+	// Test with path variables and ignoreUnknownFields = false
+	req2 := httptest.NewRequest("GET", "/", http.NoBody)
+	req2 = pathvar.WithVars(req2, map[string]string{"c": "d"})
+	parser2, err2 := NewRequestParser(req2, resolver, false)
+	assert.Nil(t, err2)
+	assert.NotNil(t, parser2)
+}
+
+func TestNewRequestParserWithBodyAndIgnoreUnknownFields(t *testing.T) {
+	resolver := &mockAnyResolver{}
+
+	// Test with body and ignoreUnknownFields = true
+	req := httptest.NewRequest("POST", "/", strings.NewReader(`{"a": "b"}`))
+	parser, err := NewRequestParser(req, resolver, true)
+	assert.Nil(t, err)
+	assert.NotNil(t, parser)
+
+	// Test with body and ignoreUnknownFields = false
+	req2 := httptest.NewRequest("POST", "/", strings.NewReader(`{"c": "d"}`))
+	parser2, err2 := NewRequestParser(req2, resolver, false)
+	assert.Nil(t, err2)
+	assert.NotNil(t, parser2)
+}
+
+func TestNewRequestParserWithVarsBodyAndIgnoreUnknownFields(t *testing.T) {
+	resolver := &mockAnyResolver{}
+
+	// Test with both path variables and body, ignoreUnknownFields = true
+	req := httptest.NewRequest("POST", "/", strings.NewReader(`{"a": "b"}`))
+	req = pathvar.WithVars(req, map[string]string{"c": "d"})
+	parser, err := NewRequestParser(req, resolver, true)
+	assert.Nil(t, err)
+	assert.NotNil(t, parser)
+
+	// Test with both path variables and body, ignoreUnknownFields = false
+	req2 := httptest.NewRequest("POST", "/", strings.NewReader(`{"e": "f"}`))
+	req2 = pathvar.WithVars(req2, map[string]string{"g": "h"})
+	parser2, err2 := NewRequestParser(req2, resolver, false)
+	assert.Nil(t, err2)
+	assert.NotNil(t, parser2)
+}
+
+func TestBuildJsonRequestParserFromMapWithIgnoreUnknownFields(t *testing.T) {
+	resolver := &mockAnyResolver{}
+
+	// Test buildJsonRequestParserFromMap with ignoreUnknownFields = true
+	data := map[string]any{"key": "value"}
+	parser, err := buildJsonRequestParserFromMap(data, resolver, true)
+	assert.Nil(t, err)
+	assert.NotNil(t, parser)
+
+	// Test buildJsonRequestParserFromMap with ignoreUnknownFields = false
+	parser2, err2 := buildJsonRequestParserFromMap(data, resolver, false)
+	assert.Nil(t, err2)
+	assert.NotNil(t, parser2)
+}
+
+func TestBuildJsonRequestParserWithUnknownFields(t *testing.T) {
+	resolver := &mockAnyResolver{}
+
+	// Test buildJsonRequestParserWithUnknownFields
+	data := strings.NewReader(`{"test": "value"}`)
+	parser, err := buildJsonRequestParserWithUnknownFields(data, resolver)
+	assert.Nil(t, err)
+	assert.NotNil(t, parser)
+}
+
 type badBody struct{}
 
 func (badBody) Read([]byte) (int, error) { return 0, errors.New("something bad") }