add functional tests

Author: salonichf5

internal/mode/static/state/dataplane/convert_test.go

@@ -413,14 +413,14 @@ func TestConvertMatchType(t *testing.T) {
 		shouldPanic     bool
 	}{
 		{
-			name:            "exact match for header and query param",
+			name:            "exact match type for header and query param",
 			headerMatchType: helpers.GetPointer(v1.HeaderMatchExact),
 			queryMatchType:  helpers.GetPointer(v1.QueryParamMatchExact),
 			expectedType:    MatchTypeExact,
 			shouldPanic:     false,
 		},
 		{
-			name:            "regex match for header and query param",
+			name:            "regular expression match type for header and query param",
 			headerMatchType: helpers.GetPointer(v1.HeaderMatchRegularExpression),
 			queryMatchType:  helpers.GetPointer(v1.QueryParamMatchRegularExpression),
 			expectedType:    MatchTypeRegularExpression,

internal/mode/static/state/graph/grpcroute.go

@@ -225,15 +225,6 @@ func ConvertGRPCMatches(grpcMatches []v1.GRPCRouteMatch) []v1.HTTPRouteMatch {
 }
 
 func convertGRPCHeaderMatchType(matchType *v1.GRPCHeaderMatchType) *v1.HeaderMatchType {
-	// these condition checks are added for the unit tests where matchType is not empty
-	// but length is zero. In general case, this error would be caught by validateGRPCMatch.
-	if matchType == nil {
-		return helpers.GetPointer(v1.HeaderMatchExact)
-	}
-	if len(*matchType) == 0 {
-		return helpers.GetPointer(v1.HeaderMatchExact)
-	}
-
 	switch *matchType {
 	case v1.GRPCHeaderMatchExact:
 		return helpers.GetPointer(v1.HeaderMatchExact)

internal/mode/static/state/graph/grpcroute_test.go

@@ -496,6 +496,7 @@ func TestBuildGRPCRoute(t *testing.T) {
 		expected      *L7Route
 		name          string
 		http2disabled bool
+		shouldPanic   bool
 	}{
 		{
 			validator: createAllValidValidator(),
@@ -726,126 +727,22 @@ func TestBuildGRPCRoute(t *testing.T) {
 			name:          "invalid route with disabled http2",
 		},
 		{
-			validator: createAllValidValidator(),
-			gr:        grOneInvalid,
-			expected: &L7Route{
-				Source:     grOneInvalid,
-				RouteType:  RouteTypeGRPC,
-				Valid:      true,
-				Attachable: true,
-				ParentRefs: []ParentRef{
-					{
-						Idx:         0,
-						Gateway:     gatewayNsName,
-						SectionName: grOneInvalid.Spec.ParentRefs[0].SectionName,
-					},
-				},
-				Conditions: []conditions.Condition{
-					staticConds.NewRoutePartiallyInvalid(
-						`spec.rules[1].matches[0].headers[0].type: Unsupported value: "": supported values: "Exact", "RegularExpression"`,
-					),
-				},
-				Spec: L7RouteSpec{
-					Hostnames: grOneInvalid.Spec.Hostnames,
-					Rules: []RouteRule{
-						{
-							ValidMatches: true,
-							Filters: RouteRuleFilters{
-								Valid:   true,
-								Filters: []Filter{},
-							},
-							Matches:          ConvertGRPCMatches(grOneInvalid.Spec.Rules[0].Matches),
-							RouteBackendRefs: []RouteBackendRef{},
-						},
-						{
-							ValidMatches: false,
-							Filters: RouteRuleFilters{
-								Valid:   true,
-								Filters: []Filter{},
-							},
-							Matches:          ConvertGRPCMatches(grOneInvalid.Spec.Rules[1].Matches),
-							RouteBackendRefs: []RouteBackendRef{},
-						},
-					},
-				},
-			},
-			name: "invalid headers and valid method",
+			validator:   createAllValidValidator(),
+			gr:          grOneInvalid,
+			shouldPanic: true,
+			name:        "invalid headers and valid method",
 		},
 		{
-			validator: createAllValidValidator(),
-			gr:        grInvalidHeadersInvalidType,
-			expected: &L7Route{
-				Source:     grInvalidHeadersInvalidType,
-				RouteType:  RouteTypeGRPC,
-				Valid:      false,
-				Attachable: true,
-				ParentRefs: []ParentRef{
-					{
-						Idx:         0,
-						Gateway:     gatewayNsName,
-						SectionName: grInvalidHeadersInvalidType.Spec.ParentRefs[0].SectionName,
-					},
-				},
-				Conditions: []conditions.Condition{
-					staticConds.NewRouteUnsupportedValue(
-						`All rules are invalid: spec.rules[0].matches[0].headers[0].type: ` +
-							`Unsupported value: "": supported values: "Exact", "RegularExpression"`,
-					),
-				},
-				Spec: L7RouteSpec{
-					Hostnames: grInvalidHeadersInvalidType.Spec.Hostnames,
-					Rules: []RouteRule{
-						{
-							ValidMatches: false,
-							Filters: RouteRuleFilters{
-								Valid:   true,
-								Filters: []Filter{},
-							},
-							Matches:          ConvertGRPCMatches(grInvalidHeadersInvalidType.Spec.Rules[0].Matches),
-							RouteBackendRefs: []RouteBackendRef{},
-						},
-					},
-				},
-			},
-			name: "invalid headers with invalid type",
+			validator:   createAllValidValidator(),
+			gr:          grInvalidHeadersInvalidType,
+			shouldPanic: true,
+			name:        "invalid headers with invalid type",
 		},
 		{
-			validator: createAllValidValidator(),
-			gr:        grInvalidHeadersEmptyType,
-			expected: &L7Route{
-				Source:     grInvalidHeadersEmptyType,
-				RouteType:  RouteTypeGRPC,
-				Valid:      false,
-				Attachable: true,
-				ParentRefs: []ParentRef{
-					{
-						Idx:         0,
-						Gateway:     gatewayNsName,
-						SectionName: grInvalidHeadersEmptyType.Spec.ParentRefs[0].SectionName,
-					},
-				},
-				Conditions: []conditions.Condition{
-					staticConds.NewRouteUnsupportedValue(
-						`All rules are invalid: spec.rules[0].matches[0].headers[0].type: ` +
-							`Required value: cannot be empty`,
-					),
-				},
-				Spec: L7RouteSpec{
-					Hostnames: grInvalidHeadersEmptyType.Spec.Hostnames,
-					Rules: []RouteRule{
-						{
-							ValidMatches: false,
-							Filters: RouteRuleFilters{
-								Valid:   true,
-								Filters: []Filter{},
-							},
-							Matches:          ConvertGRPCMatches(grInvalidHeadersEmptyType.Spec.Rules[0].Matches),
-							RouteBackendRefs: []RouteBackendRef{},
-						},
-					},
-				},
-			},
-			name: "invalid headers with no header type specified",
+			validator:   createAllValidValidator(),
+			gr:          grInvalidHeadersEmptyType,
+			shouldPanic: true,
+			name:        "invalid headers with no header type specified",
 		},
 		{
 			validator: createAllValidValidator(),
@@ -988,7 +885,6 @@ func TestBuildGRPCRoute(t *testing.T) {
 					},
 				},
 			},
-
 			name: "invalid snippet filter extension ref",
 		},
 		{
@@ -1028,7 +924,6 @@ func TestBuildGRPCRoute(t *testing.T) {
 					},
 				},
 			},
-
 			name: "unresolvable snippet filter extension ref",
 		},
 		{
@@ -1072,7 +967,6 @@ func TestBuildGRPCRoute(t *testing.T) {
 					},
 				},
 			},
-
 			name: "one invalid and one unresolvable snippet filter extension ref",
 		},
 	}
@@ -1088,8 +982,20 @@ func TestBuildGRPCRoute(t *testing.T) {
 				{Namespace: "test", Name: "sf"}: {Valid: true},
 			}
 
-			route := buildGRPCRoute(test.validator, test.gr, gatewayNsNames, test.http2disabled, snippetsFilters)
-			g.Expect(helpers.Diff(test.expected, route)).To(BeEmpty())
+			if test.shouldPanic {
+				g.Expect(func() {
+					buildGRPCRoute(
+						test.validator,
+						test.gr,
+						gatewayNsNames,
+						test.http2disabled,
+						snippetsFilters,
+					)
+				}).To(Panic())
+			} else {
+				route := buildGRPCRoute(test.validator, test.gr, gatewayNsNames, test.http2disabled, snippetsFilters)
+				g.Expect(helpers.Diff(test.expected, route)).To(BeEmpty())
+			}
 		})
 	}
 }
@@ -1215,10 +1121,6 @@ func TestConvertGRPCHeaderMatchType(t *testing.T) {
 			expected:    helpers.GetPointer(v1.HeaderMatchType("unsupported")),
 			shouldPanic: true,
 		},
-		{
-			name:     "nil match type",
-			expected: helpers.GetPointer(v1.HeaderMatchExact),
-		},
 	}
 
 	for _, test := range tests {

tests/framework/prometheus.go

@@ -566,7 +566,7 @@ func CreateEndTimeFinder(
 // CreateResponseChecker returns a function that checks if there is a successful response from a url.
 func CreateResponseChecker(url, address string, requestTimeout time.Duration) func() error {
 	return func() error {
-		status, _, err := Get(url, address, requestTimeout)
+		status, _, err := Get(url, address, requestTimeout, nil, nil)
 		if err != nil {
 			return fmt.Errorf("bad response: %w", err)
 		}

tests/framework/request.go

@@ -16,8 +16,12 @@ import (
 // Get sends a GET request to the specified url.
 // It resolves to the specified address instead of using DNS.
 // The status and body of the response is returned, or an error.
-func Get(url, address string, timeout time.Duration) (int, string, error) {
-	resp, err := makeRequest(http.MethodGet, url, address, nil, timeout)
+func Get(
+	url, address string,
+	timeout time.Duration,
+	headers, queryParams map[string]string,
+) (int, string, error) {
+	resp, err := makeRequest(http.MethodGet, url, address, nil, timeout, headers, queryParams)
 	if err != nil {
 		return 0, "", err
 	}
@@ -35,11 +39,21 @@ func Get(url, address string, timeout time.Duration) (int, string, error) {
 
 // Post sends a POST request to the specified url with the body as the payload.
 // It resolves to the specified address instead of using DNS.
-func Post(url, address string, body io.Reader, timeout time.Duration) (*http.Response, error) {
-	return makeRequest(http.MethodPost, url, address, body, timeout)
+func Post(
+	url, address string,
+	body io.Reader,
+	timeout time.Duration,
+	headers, queryParams map[string]string,
+) (*http.Response, error) {
+	return makeRequest(http.MethodPost, url, address, body, timeout, headers, queryParams)
 }
 
-func makeRequest(method, url, address string, body io.Reader, timeout time.Duration) (*http.Response, error) {
+func makeRequest(
+	method, url, address string,
+	body io.Reader,
+	timeout time.Duration,
+	headers, queryParams map[string]string,
+) (*http.Response, error) {
 	dialer := &net.Dialer{}
 
 	transport, ok := http.DefaultTransport.(*http.Transport)
@@ -65,6 +79,18 @@ func makeRequest(method, url, address string, body io.Reader, timeout time.Durat
 		return nil, err
 	}
 
+	for key, value := range headers {
+		req.Header.Add(key, value)
+	}
+
+	if queryParams != nil {
+		q := req.URL.Query()
+		for key, value := range queryParams {
+			q.Add(key, value)
+		}
+		req.URL.RawQuery = q.Encode()
+	}
+
 	var resp *http.Response
 	if strings.HasPrefix(url, "https") {
 		transport, ok := http.DefaultTransport.(*http.Transport)