add functional tests

Author: salonichf5

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)

tests/suite/advanced_routing_test.go

@@ -0,0 +1,283 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"regexp"
+	"strings"
+	"time"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	core "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/util/wait"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
+
+	"github.com/nginx/nginx-gateway-fabric/tests/framework"
+)
+
+var _ = Describe("AdvancedRouting", Ordered, Label("functional", "routing"), func() {
+	var (
+		files = []string{
+			"advanced-routing/cafe.yaml",
+			"advanced-routing/gateway.yaml",
+			"advanced-routing/grpc-backends.yaml",
+			"advanced-routing/routes.yaml",
+		}
+
+		namespace = "routing"
+	)
+
+	BeforeAll(func() {
+		ns := &core.Namespace{
+			ObjectMeta: metav1.ObjectMeta{
+				Name: namespace,
+			},
+		}
+
+		Expect(resourceManager.Apply([]client.Object{ns})).To(Succeed())
+		Expect(resourceManager.ApplyFromFiles(files, namespace)).To(Succeed())
+		Expect(resourceManager.WaitForAppsToBeReady(namespace)).To(Succeed())
+	})
+
+	AfterAll(func() {
+		Expect(resourceManager.DeleteFromFiles(files, namespace)).To(Succeed())
+		Expect(resourceManager.DeleteNamespace(namespace)).To(Succeed())
+	})
+
+	When("valid advanced routing settings are configured for Routes", func() {
+		var baseURL string
+		BeforeAll(func() {
+			port := 80
+			if portFwdPort != 0 {
+				port = portFwdPort
+			}
+
+			baseURL = fmt.Sprintf("http://cafe.example.com:%d", port)
+		})
+
+		Specify("routes have the Accepted/True/Accepted condition", func() {
+			httpRoute := "http-header-and-query-matching"
+			grpcRoute := "grpc-header-matching"
+
+			nsname := types.NamespacedName{Name: httpRoute, Namespace: namespace}
+			err := waitForHTTPRouteToBeAccepted(nsname)
+			Expect(err).ToNot(HaveOccurred(), fmt.Sprintf("%s was not accepted", httpRoute))
+
+			nsname = types.NamespacedName{Name: grpcRoute, Namespace: namespace}
+			err = waitForGRPCRouteToBeAccepted(nsname)
+			Expect(err).ToNot(HaveOccurred(), fmt.Sprintf("%s was not accepted", httpRoute))
+		})
+
+		DescribeTable("verify working traffic for HTTPRoute",
+			func(uri string, serverName string, headers map[string]string, queryParams map[string]string) {
+				url := baseURL + uri
+				Eventually(
+					func() error {
+						return expectRequestToRespondFromExpectedServer(url, address, serverName, headers, queryParams)
+					}).
+					WithTimeout(timeoutConfig.ContainerRestartTimeout).
+					WithPolling(500 * time.Millisecond).
+					Should(Succeed())
+			},
+			Entry("request with no headers or params", "/coffee", "coffee-v1", nil, nil),
+			Entry("request with Exact match header", "/coffee", "coffee-v2", map[string]string{"version": "v2"}, nil),
+			Entry("request with Exact match query param", "/coffee", "coffee-v2", nil, map[string]string{"TEST": "v2"}),
+			Entry(
+				"request with RegularExpression match header",
+				"/coffee",
+				"coffee-v3",
+				map[string]string{"headerRegex": "header-regex"},
+				nil,
+			),
+			Entry(
+				"request with RegularExpression match query param",
+				"/coffee",
+				"coffee-v3",
+				nil,
+				map[string]string{"queryRegex": "query-regex"},
+			),
+			Entry(
+				"request with non-matching regex header",
+				"/coffee",
+				"coffee-v1",
+				map[string]string{"headerRegex": "headerInvalid"},
+				nil,
+			),
+			Entry(
+				"request with non-matching regex query param",
+				"/coffee",
+				"coffee-v1",
+				nil,
+				map[string]string{"queryRegex": "queryInvalid"},
+			),
+		)
+	})
+})
+
+func expectRequestToRespondFromExpectedServer(
+	appURL, address, expServerName string,
+	headers, queryParams map[string]string,
+) error {
+	status, body, err := framework.Get(appURL, address, timeoutConfig.RequestTimeout, headers, queryParams)
+	if err != nil {
+		return err
+	}
+
+	if status != http.StatusOK {
+		return errors.New("http status was not 200")
+	}
+
+	actualServerName, err := extractServerName(body)
+	if err != nil {
+		return err
+	}
+
+	fmt.Println("server", actualServerName, expServerName)
+	if !strings.Contains(actualServerName, expServerName) {
+		return errors.New("expected response body to contain correct server name")
+	}
+
+	return err
+}
+
+func extractServerName(responseBody string) (string, error) {
+	re := regexp.MustCompile(`Server name:\s*(\S+)`)
+	matches := re.FindStringSubmatch(responseBody)
+	if len(matches) < 2 {
+		return "", errors.New("server name not found")
+	}
+	return matches[1], nil
+}
+
+func waitForHTTPRouteToBeAccepted(nsname types.NamespacedName) error {
+	ctx, cancel := context.WithTimeout(context.Background(), timeoutConfig.GetStatusTimeout*2)
+	defer cancel()
+
+	GinkgoWriter.Printf(
+		"Waiting for HTTPRoute %q to have the condition Accepted/True/Accepted\n",
+		nsname,
+	)
+
+	return waitForHTTPRouteToHaveExpectedCondition(
+		ctx,
+		nsname,
+		metav1.ConditionTrue,
+		string(gatewayv1.RouteConditionAccepted),
+	)
+}
+
+func waitForGRPCRouteToBeAccepted(nsname types.NamespacedName) error {
+	ctx, cancel := context.WithTimeout(context.Background(), timeoutConfig.GetStatusTimeout*2)
+	defer cancel()
+
+	GinkgoWriter.Printf(
+		"Waiting for GRPCRoute %q to have the condition Accepted/True/Accepted\n",
+		nsname,
+	)
+
+	return waitForGRPCRouteToHaveExpectedCondition(
+		ctx,
+		nsname,
+		metav1.ConditionTrue,
+		string(gatewayv1.RouteConditionAccepted),
+	)
+}
+
+func waitForHTTPRouteToHaveExpectedCondition(
+	ctx context.Context,
+	nsname types.NamespacedName,
+	conditionStatus metav1.ConditionStatus,
+	reason string,
+) error {
+	return wait.PollUntilContextCancel(
+		ctx,
+		500*time.Millisecond,
+		true, /* poll immediately */
+		func(ctx context.Context) (bool, error) {
+			var route gatewayv1.HTTPRoute
+
+			if err := k8sClient.Get(ctx, nsname, &route); err != nil {
+				return false, err
+			}
+
+			return verifyConditions(route, nsname, conditionStatus, reason)
+		},
+	)
+}
+
+func waitForGRPCRouteToHaveExpectedCondition(
+	ctx context.Context,
+	nsname types.NamespacedName,
+	conditionStatus metav1.ConditionStatus,
+	reason string,
+) error {
+	return wait.PollUntilContextCancel(
+		ctx,
+		500*time.Millisecond,
+		true, /* poll immediately */
+		func(ctx context.Context) (bool, error) {
+			var route gatewayv1.GRPCRoute
+
+			if err := k8sClient.Get(ctx, nsname, &route); err != nil {
+				return false, err
+			}
+
+			return verifyConditions(route, nsname, conditionStatus, reason)
+		},
+	)
+}
+
+func verifyConditions(
+	route interface{},
+	nsname types.NamespacedName,
+	conditionStatus metav1.ConditionStatus,
+	reason string,
+) (bool, error) {
+	var err error
+	var parents []gatewayv1.RouteParentStatus
+
+	switch r := route.(type) {
+	case gatewayv1.HTTPRoute:
+		parents = r.Status.Parents
+	case gatewayv1.GRPCRoute:
+		parents = r.Status.Parents
+	default:
+		return false, fmt.Errorf("unsupported route type")
+	}
+
+	if len(parents) == 0 {
+		GinkgoWriter.Printf("Route %q does not have a parent status yet\n", nsname)
+
+		return false, nil
+	}
+
+	if len(parents) != 1 {
+		return false, fmt.Errorf("route has %d parents, expected 1", len(parents))
+	}
+
+	parent := parents[0]
+	if parent.Conditions == nil {
+		return false, fmt.Errorf("expected parent conditions to not be nil")
+	}
+
+	cond := parent.Conditions[0]
+	if cond.Type != string(gatewayv1.RouteConditionAccepted) {
+		return false, fmt.Errorf("expected condition type to be Accepted, got %s", cond.Type)
+	}
+
+	if cond.Status != conditionStatus {
+		return false, fmt.Errorf("expected condition status to be True, got %s", cond.Status)
+	}
+
+	if cond.Reason != reason {
+		return false, fmt.Errorf("expected condition reason to be Accepted, got %s", cond.Reason)
+	}
+
+	return err == nil, err
+}

tests/suite/client_settings_test.go

@@ -220,7 +220,7 @@ var _ = Describe("ClientSettingsPolicy", Ordered, Label("functional", "cspolicy"
 				_, err := rand.Read(payload)
 				Expect(err).ToNot(HaveOccurred())
 
-				resp, err := framework.Post(url, address, bytes.NewReader(payload), timeoutConfig.RequestTimeout)
+				resp, err := framework.Post(url, address, bytes.NewReader(payload), timeoutConfig.RequestTimeout, nil, nil)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(resp).To(HaveHTTPStatus(expStatus))
 

tests/suite/graceful_recovery_test.go

@@ -294,7 +294,7 @@ func checkForFailingTraffic(teaURL, coffeeURL string) error {
 }
 
 func expectRequestToSucceed(appURL, address string, responseBodyMessage string) error {
-	status, body, err := framework.Get(appURL, address, timeoutConfig.RequestTimeout)
+	status, body, err := framework.Get(appURL, address, timeoutConfig.RequestTimeout, nil, nil)
 
 	if status != http.StatusOK {
 		return errors.New("http status was not 200")
@@ -308,7 +308,7 @@ func expectRequestToSucceed(appURL, address string, responseBodyMessage string)
 }
 
 func expectRequestToFail(appURL, address string) error {
-	status, body, err := framework.Get(appURL, address, timeoutConfig.RequestTimeout)
+	status, body, err := framework.Get(appURL, address, timeoutConfig.RequestTimeout, nil, nil)
 	if status != 0 {
 		return errors.New("expected http status to be 0")
 	}