fix:

Author: dspo

test/e2e/framework/assertion.go

@@ -34,8 +34,8 @@ import (
 )
 
 func GatewayClassMustHaveCondition(t testing.TestingT, cli client.Client, timeout time.Duration, gcNN types.NamespacedName, condition metav1.Condition) {
-	err := PollUntilGatewayClassMustHaveStatus(cli, timeout, gcNN, func(gc gatewayv1.GatewayClass) bool {
-		if err := kubernetes.ConditionsHaveLatestObservedGeneration(&gc, gc.Status.Conditions); err != nil {
+	err := PollUntilGatewayClassMustHaveStatus(cli, timeout, gcNN, func(gc *gatewayv1.GatewayClass) bool {
+		if err := kubernetes.ConditionsHaveLatestObservedGeneration(gc, gc.Status.Conditions); err != nil {
 			log.Printf("GatewayClass %s %v", gcNN, err)
 			return false
 		}
@@ -48,63 +48,51 @@ func GatewayClassMustHaveCondition(t testing.TestingT, cli client.Client, timeou
 	require.NoError(t, err, "waiting for GatewayClass to have condition %+v", condition)
 }
 
-func PollUntilGatewayClassMustHaveStatus(cli client.Client, timeout time.Duration, gcNN types.NamespacedName, f func(gc gatewayv1.GatewayClass) bool) error {
+func PollUntilGatewayClassMustHaveStatus(cli client.Client, timeout time.Duration, gcNN types.NamespacedName, f func(gc *gatewayv1.GatewayClass) bool) error {
 	if err := gatewayv1.Install(cli.Scheme()); err != nil {
 		return err
 	}
-	return wait.PollUntilContextTimeout(context.Background(), time.Second, timeout, true, func(ctx context.Context) (done bool, err error) {
-		var gc gatewayv1.GatewayClass
-		if err := cli.Get(ctx, gcNN, &gc); err != nil {
-			return false, errors.Wrapf(err, "failed to get GatewayClass %s", gcNN)
-		}
-		return f(gc), nil
-	})
+	return genericPollResource(new(gatewayv1.GatewayClass), cli, timeout, gcNN, f)
 }
 
 func GatewayMustHaveCondition(t testing.TestingT, cli client.Client, timeout time.Duration, gwNN types.NamespacedName, condition metav1.Condition) {
-	err := PollUntilGatewayHaveStatus(cli, timeout, gwNN, func(gw gatewayv1.Gateway) bool {
-		if err := kubernetes.ConditionsHaveLatestObservedGeneration(&gw, gw.Status.Conditions); err != nil {
+	err := PollUntilGatewayHaveStatus(cli, timeout, gwNN, func(gw *gatewayv1.Gateway) bool {
+		if err := kubernetes.ConditionsHaveLatestObservedGeneration(gw, gw.Status.Conditions); err != nil {
 			log.Printf("Gateway %s %v", gwNN, err)
 			return false
 		}
 		if findConditionInList(gw.Status.Conditions, condition) {
-			log.Printf("found condition %v in list [%v]", condition, gw.Status.Conditions)
+			log.Printf("found condition %v in list %v", condition, gw.Status.Conditions)
 			return true
 		} else {
-			log.Printf("not found condition %v in list [%v]", condition, gw.Status.Conditions)
+			log.Printf("NOT FOUND condition %v in %v", condition, gw.Status.Conditions)
 			return false
 		}
 	})
 	require.NoError(t, err, "waiting for Gateway to have condition %+v", condition)
 }
 
-func PollUntilGatewayHaveStatus(cli client.Client, timeout time.Duration, gwNN types.NamespacedName, f func(gateway gatewayv1.Gateway) bool) error {
+func PollUntilGatewayHaveStatus(cli client.Client, timeout time.Duration, gwNN types.NamespacedName, f func(gateway *gatewayv1.Gateway) bool) error {
 	if err := gatewayv1.Install(cli.Scheme()); err != nil {
 		return err
 	}
-	return wait.PollUntilContextTimeout(context.Background(), time.Second, timeout, true, func(ctx context.Context) (done bool, err error) {
-		var gw gatewayv1.Gateway
-		if err := cli.Get(ctx, gwNN, &gw); err != nil {
-			return false, errors.Wrapf(err, "failed to get Gateway %s", gwNN)
-		}
-		return f(gw), nil
-	})
+	return genericPollResource(new(gatewayv1.Gateway), cli, timeout, gwNN, f)
 }
 
 func HTTPRouteMustHaveCondition(t testing.TestingT, cli client.Client, timeout time.Duration, refNN, hrNN types.NamespacedName, condition metav1.Condition) {
-	err := PollUntilHTTPRouteHaveStatus(cli, timeout, hrNN, func(hr gatewayv1.HTTPRoute) bool {
+	err := PollUntilHTTPRouteHaveStatus(cli, timeout, hrNN, func(hr *gatewayv1.HTTPRoute) bool {
 		for _, parent := range hr.Status.Parents {
-			if err := kubernetes.ConditionsHaveLatestObservedGeneration(&hr, parent.Conditions); err != nil {
+			if err := kubernetes.ConditionsHaveLatestObservedGeneration(hr, parent.Conditions); err != nil {
 				log.Printf("HTTPRoute %s (parentRef=%v) %v", hrNN, parentRefToString(parent.ParentRef), err)
 				return false
 			}
 			if (refNN.Name == "" || parent.ParentRef.Name == gatewayv1.ObjectName(refNN.Name)) &&
 				(refNN.Namespace == "" || (parent.ParentRef.Namespace != nil && string(*parent.ParentRef.Namespace) == refNN.Namespace)) {
 				if findConditionInList(parent.Conditions, condition) {
-					log.Printf("found condition %v in list [%v] for %s reference %s", condition, parent.Conditions, hrNN, refNN)
+					log.Printf("found condition %v in %v for %s reference %s", condition, parent.Conditions, hrNN, refNN)
 					return true
 				} else {
-					log.Printf("found condition %v in list [%v] for %s reference %s", condition, parent.Conditions, hrNN, refNN)
+					log.Printf("NOT FOUND condition %v in %v for %s reference %s", condition, parent.Conditions, hrNN, refNN)
 				}
 			}
 		}
@@ -113,35 +101,29 @@ func HTTPRouteMustHaveCondition(t testing.TestingT, cli client.Client, timeout t
 	require.NoError(t, err, "error waiting for HTTPRoute status to have a Condition matching %+v", condition)
 }
 
-func PollUntilHTTPRouteHaveStatus(cli client.Client, timeout time.Duration, hrNN types.NamespacedName, f func(route gatewayv1.HTTPRoute) bool) error {
+func PollUntilHTTPRouteHaveStatus(cli client.Client, timeout time.Duration, hrNN types.NamespacedName, f func(route *gatewayv1.HTTPRoute) bool) error {
 	if err := gatewayv1.Install(cli.Scheme()); err != nil {
 		return err
 	}
-	return wait.PollUntilContextTimeout(context.Background(), time.Second, timeout, true, func(ctx context.Context) (done bool, err error) {
-		var httpRoute gatewayv1.HTTPRoute
-		if err := cli.Get(ctx, hrNN, &httpRoute); err != nil {
-			return false, errors.Wrapf(err, "failed to get HTTPRoute %s", hrNN)
-		}
-		return f(httpRoute), nil
-	})
+	return genericPollResource(new(gatewayv1.HTTPRoute), cli, timeout, hrNN, f)
 }
 
 func HTTPRoutePolicyMustHaveCondition(t testing.TestingT, client client.Client, timeout time.Duration, refNN, hrpNN types.NamespacedName,
 	condition metav1.Condition) {
-	err := PollUntilHTTPRoutePolicyHaveStatus(client, timeout, hrpNN, func(httpRoutePolicy v1alpha1.HTTPRoutePolicy, status v1alpha1.PolicyStatus) bool {
-		for _, ancestor := range status.Ancestors {
-			if err := kubernetes.ConditionsHaveLatestObservedGeneration(&httpRoutePolicy, ancestor.Conditions); err != nil {
+	err := PollUntilHTTPRoutePolicyHaveStatus(client, timeout, hrpNN, func(httpRoutePolicy *v1alpha1.HTTPRoutePolicy) bool {
+		for _, ancestor := range httpRoutePolicy.Status.Ancestors {
+			if err := kubernetes.ConditionsHaveLatestObservedGeneration(httpRoutePolicy, ancestor.Conditions); err != nil {
 				log.Printf("HTTPRoutePolicy %s (parentRef=%v) %v", hrpNN, parentRefToString(ancestor.AncestorRef), err)
 				return false
 			}
 
 			if ancestor.AncestorRef.Name == gatewayv1.ObjectName(refNN.Name) &&
 				(refNN.Namespace == "" || (ancestor.AncestorRef.Namespace != nil && string(*ancestor.AncestorRef.Namespace) == refNN.Namespace)) {
 				if findConditionInList(ancestor.Conditions, condition) {
-					log.Printf("found condition %v in list [%v] for %s reference %s", condition, ancestor.Conditions, hrpNN, refNN)
+					log.Printf("found condition %v in list %v for %s reference %s", condition, ancestor.Conditions, hrpNN, refNN)
 					return true
 				} else {
-					log.Printf("not found condition %v in list [%v] for %s reference %s", condition, ancestor.Conditions, hrpNN, refNN)
+					log.Printf("NOT FOUND condition %v in %v for %s reference %s", condition, ancestor.Conditions, hrpNN, refNN)
 				}
 			}
 		}
@@ -151,16 +133,12 @@ func HTTPRoutePolicyMustHaveCondition(t testing.TestingT, client client.Client,
 	require.NoError(t, err, "error waiting for HTTPRoutePolicy %s status to have a Condition matching %+v", hrpNN, condition)
 }
 
-func PollUntilHTTPRoutePolicyHaveStatus(client client.Client, timeout time.Duration, hrpNN types.NamespacedName,
-	f func(httpRoutePolicy v1alpha1.HTTPRoutePolicy, status v1alpha1.PolicyStatus) bool) error {
-	_ = v1alpha1.AddToScheme(client.Scheme())
-	return wait.PollUntilContextTimeout(context.Background(), time.Second, timeout, true, func(ctx context.Context) (done bool, err error) {
-		var httpRoutePolicy v1alpha1.HTTPRoutePolicy
-		if err = client.Get(ctx, hrpNN, &httpRoutePolicy); err != nil {
-			return false, errors.Wrapf(err, "error fetching HTTPRoutePolicy %s", hrpNN)
-		}
-		return f(httpRoutePolicy, httpRoutePolicy.Status), nil
-	})
+func PollUntilHTTPRoutePolicyHaveStatus(cli client.Client, timeout time.Duration, hrpNN types.NamespacedName,
+	f func(httpRoutePolicy *v1alpha1.HTTPRoutePolicy) bool) error {
+	if err := v1alpha1.AddToScheme(cli.Scheme()); err != nil {
+		return err
+	}
+	return genericPollResource(new(v1alpha1.HTTPRoutePolicy), cli, timeout, hrpNN, f)
 }
 
 func parentRefToString(p gatewayv1.ParentReference) string {
@@ -180,3 +158,12 @@ func findConditionInList(conditions []metav1.Condition, expected metav1.Conditio
 			(expected.Message == "" || strings.Contains(item.Message, expected.Message))
 	})
 }
+
+func genericPollResource[Obj client.Object](obj Obj, cli client.Client, timeout time.Duration, nn types.NamespacedName, predicate func(Obj) bool) error {
+	return wait.PollUntilContextTimeout(context.Background(), time.Second, timeout, true, func(ctx context.Context) (done bool, err error) {
+		if err := cli.Get(ctx, nn, obj); err != nil {
+			return false, errors.Wrapf(err, "error fetching Object %s", nn)
+		}
+		return predicate(obj), nil
+	})
+}

test/e2e/gatewayapi/httproute.go

@@ -26,6 +26,7 @@ import (
 	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/utils/ptr"
 	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
 	"sigs.k8s.io/gateway-api/apis/v1alpha2"
 
@@ -1046,8 +1047,8 @@ spec:
 			s.Logf(message)
 
 			err = framework.PollUntilHTTPRoutePolicyHaveStatus(s.K8sClient, 8*time.Second, types.NamespacedName{Namespace: s.Namespace(), Name: "http-route-policy-0"},
-				func(_ v1alpha1.HTTPRoutePolicy, status v1alpha1.PolicyStatus) bool {
-					return len(status.Ancestors) == 0
+				func(hrp *v1alpha1.HTTPRoutePolicy) bool {
+					return len(hrp.Status.Ancestors) == 0
 				},
 			)
 			Expect(err).NotTo(HaveOccurred(), "HTPRoutePolicy.Status should has no ancestor")
@@ -1320,7 +1321,11 @@ spec:
 
 		It("HTTPRoute RequestRedirect", func() {
 			By("create HTTPRoute")
-			s.ApplyHTTPRoute(types.NamespacedName{Namespace: s.Namespace(), Name: "httpbin"}, httpsRedirectByHeaders)
+			s.ApplyHTTPRoute(types.NamespacedName{Namespace: s.Namespace(), Name: "httpbin"}, httpsRedirectByHeaders, func(_ context.Context) (done bool, err error) {
+				return s.NewAPISIXClient().GET("/headers").
+					WithHeader("Host", "httpbin.example").
+					Expect().Raw().Header.Get("Location") == "https://httpbin.example:9443/headers", nil
+			})
 
 			s.NewAPISIXClient().GET("/headers").
 				WithHeader("Host", "httpbin.example").
@@ -1329,7 +1334,11 @@ spec:
 				Header("Location").IsEqual("https://httpbin.example:9443/headers")
 
 			By("update HTTPRoute")
-			s.ApplyHTTPRoute(types.NamespacedName{Namespace: s.Namespace(), Name: "httpbin"}, hostnameRedirectByHeaders)
+			s.ApplyHTTPRoute(types.NamespacedName{Namespace: s.Namespace(), Name: "httpbin"}, hostnameRedirectByHeaders, func(_ context.Context) (done bool, err error) {
+				return s.NewAPISIXClient().GET("/headers").
+					WithHeader("Host", "httpbin.example").
+					Expect().Raw().Header.Get("Location") == "http://httpbin.org/headers", nil
+			})
 
 			s.NewAPISIXClient().GET("/headers").
 				WithHeader("Host", "httpbin.example").
@@ -1339,7 +1348,7 @@ spec:
 		})
 
 		It("HTTPRoute RequestMirror", func() {
-			echoRoute := `
+			const echoService = `
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -1372,7 +1381,9 @@ spec:
     port: 80
     protocol: TCP
     targetPort: 8080
----
+`
+
+			const echoRoute = `
 apiVersion: gateway.networking.k8s.io/v1
 kind: HTTPRoute
 metadata:
@@ -1397,13 +1408,22 @@ spec:
     - name: httpbin-service-e2e-test
       port: 80
 `
+			// apply echo server Deployment and Service
+			err := s.CreateResourceFromString(echoService)
+			Expect(err).NotTo(HaveOccurred(), "create echo service")
+			err = framework.WaitPodsAvailable(s.GinkgoT, s.KubectlOpts(), metav1.ListOptions{
+				LabelSelector:  "app=echo",
+				TimeoutSeconds: ptr.To(int64(10)),
+			})
+			Expect(err).NotTo(HaveOccurred(), "wait for echo available")
+
 			s.ApplyHTTPRoute(types.NamespacedName{Namespace: s.Namespace(), Name: "httpbin"}, echoRoute, func(_ context.Context) (done bool, err error) {
 				return s.NewAPISIXClient().GET("/headers").
 					WithHeader("Host", "httpbin.example").
 					Expect().Raw().StatusCode == http.StatusOK, nil
 			})
 
-			time.Sleep(time.Second * 6)
+			time.Sleep(time.Second)
 
 			echoLogs := s.GetDeploymentLogs("echo")
 			Expect(echoLogs).To(ContainSubstring("GET /headers"))
@@ -1565,6 +1585,20 @@ spec:
 
 			s.ApplyHTTPRoute(types.NamespacedName{Namespace: s.Namespace(), Name: "httpbin"}, oneWeight)
 
+			var cnt int
+			for cnt < 5 {
+				body := s.NewAPISIXClient().GET("/get").
+					WithHeader("Host", "httpbin.example").
+					Expect().
+					Status(http.StatusOK).
+					Body().Raw()
+				if strings.Contains(body, "Hello") {
+					cnt = 0
+				} else {
+					cnt++
+				}
+			}
+
 			hitNginxCnt = 0
 			hitHttpbinCnt = 0
 			for i := 0; i < 100; i++ {

test/e2e/ingress/ingress.go

@@ -742,8 +742,8 @@ spec:
 
 			err = framework.PollUntilHTTPRoutePolicyHaveStatus(s.K8sClient, 8*time.Second,
 				types.NamespacedName{Namespace: s.Namespace(), Name: "http-route-policy-0"},
-				func(_ v1alpha1.HTTPRoutePolicy, status v1alpha1.PolicyStatus) bool {
-					return len(status.Ancestors) == 0
+				func(hrp *v1alpha1.HTTPRoutePolicy) bool {
+					return len(hrp.Status.Ancestors) == 0
 				},
 			)
 			Expect(err).NotTo(HaveOccurred(), "expected HTTPRoutePolicy.Status has no Ancestor")

test/e2e/scaffold/scaffold.go

@@ -812,3 +812,7 @@ func (s *Scaffold) GetGatewayGroupHTTPSEndpoint(gatewayGroupID string) (string,
 func (s *Scaffold) CurrentGatewayGroupID() string {
 	return s.gatewaygroupid
 }
+
+func (s *Scaffold) KubectlOpts() *k8s.KubectlOptions {
+	return s.kubectlOptions
+}