Feedback

Signed-off-by: jukie <10012479+jukie@users.noreply.github.com>

Author: jukie

internal/gatewayapi/listener_test.go

@@ -1379,7 +1379,7 @@ func TestProcessBackendRefsBackendTLSPolicy(t *testing.T) {
 		},
 	}
 	backendEndpoints := []*ir.DestinationEndpoint{{Host: "otel.example.com", Port: 443}}
-	backendMetadata := &ir.ResourceMetadata{Name: backendName, Namespace: ns}
+	backendMetadata := &ir.ResourceMetadata{Kind: resource.KindBackend, Name: backendName, Namespace: ns}
 	backendPolicyTLS := &ir.TLSUpstreamConfig{
 		SNI: ptr.To("otel.example.com"), UseSystemTrustStore: true,
 		CACertificate: &ir.TLSCACertificate{Name: "otel-tls/test-ns-ca"}, SubjectAltNames: []ir.SubjectAltName{},
@@ -1417,7 +1417,7 @@ func TestProcessBackendRefsBackendTLSPolicy(t *testing.T) {
 		},
 	}
 	serviceEndpoints := []*ir.DestinationEndpoint{{Host: "7.7.7.7", Port: 4317}}
-	serviceMetadata := &ir.ResourceMetadata{Name: serviceName, Namespace: ns, SectionName: "4317"}
+	serviceMetadata := &ir.ResourceMetadata{Kind: resource.KindService, Name: serviceName, Namespace: ns, SectionName: "4317"}
 	servicePolicyTLS := &ir.TLSUpstreamConfig{
 		SNI: ptr.To("otel-svc.example.com"), UseSystemTrustStore: true,
 		CACertificate: &ir.TLSCACertificate{Name: "otel-svc-tls/test-ns-ca"}, SubjectAltNames: []ir.SubjectAltName{},

internal/gatewayapi/overlap_test.go

@@ -14,7 +14,13 @@ import (
 	"github.com/envoyproxy/gateway/internal/ir"
 )
 
-func TestRouteMatchesOverlap(t *testing.T) {
+// routesOverlap is a test helper that returns true if two routes produce the
+// same canonical overlap key (i.e., they match the same set of requests).
+func routesOverlap(a, b *ir.HTTPRoute) bool {
+	return buildOverlapKey(a) == buildOverlapKey(b)
+}
+
+func TestBuildOverlapKey(t *testing.T) {
 	tests := []struct {
 		name    string
 		a       *ir.HTTPRoute
@@ -143,156 +149,114 @@ func TestRouteMatchesOverlap(t *testing.T) {
 			overlap: false,
 		},
 		{
-			name: "identical exact path with identical query param matches",
+			name: "header names are compared case-insensitively",
 			a: &ir.HTTPRoute{
 				Hostname:  "example.com",
 				PathMatch: &ir.StringMatch{Exact: ptr.To("/foo")},
-				QueryParamMatches: []*ir.StringMatch{
-					{Name: "key", Exact: ptr.To("value")},
+				HeaderMatches: []*ir.StringMatch{
+					{Name: "X-Custom", Exact: ptr.To("val1")},
 				},
 			},
 			b: &ir.HTTPRoute{
 				Hostname:  "example.com",
 				PathMatch: &ir.StringMatch{Exact: ptr.To("/foo")},
-				QueryParamMatches: []*ir.StringMatch{
-					{Name: "key", Exact: ptr.To("value")},
+				HeaderMatches: []*ir.StringMatch{
+					{Name: "x-custom", Exact: ptr.To("val1")},
 				},
 			},
 			overlap: true,
 		},
 		{
-			name: "identical regex path matches are detected as overlap",
+			name: "header matches in different order still overlap",
 			a: &ir.HTTPRoute{
 				Hostname:  "example.com",
-				PathMatch: &ir.StringMatch{SafeRegex: ptr.To("/foo.*")},
+				PathMatch: &ir.StringMatch{Exact: ptr.To("/foo")},
+				HeaderMatches: []*ir.StringMatch{
+					{Name: "X-A", Exact: ptr.To("1")},
+					{Name: "X-B", Exact: ptr.To("2")},
+				},
 			},
 			b: &ir.HTTPRoute{
 				Hostname:  "example.com",
-				PathMatch: &ir.StringMatch{SafeRegex: ptr.To("/foo.*")},
+				PathMatch: &ir.StringMatch{Exact: ptr.To("/foo")},
+				HeaderMatches: []*ir.StringMatch{
+					{Name: "X-B", Exact: ptr.To("2")},
+					{Name: "X-A", Exact: ptr.To("1")},
+				},
 			},
 			overlap: true,
 		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			assert.Equal(t, tt.overlap, routeMatchesOverlap(tt.a, tt.b))
-		})
-	}
-}
-
-func TestStringMatchEqual(t *testing.T) {
-	tests := []struct {
-		name  string
-		a     *ir.StringMatch
-		b     *ir.StringMatch
-		equal bool
-	}{
-		{
-			name:  "both nil",
-			a:     nil,
-			b:     nil,
-			equal: true,
-		},
-		{
-			name:  "one nil",
-			a:     &ir.StringMatch{Exact: ptr.To("foo")},
-			b:     nil,
-			equal: false,
-		},
-		{
-			name:  "identical exact",
-			a:     &ir.StringMatch{Name: "h", Exact: ptr.To("v")},
-			b:     &ir.StringMatch{Name: "h", Exact: ptr.To("v")},
-			equal: true,
-		},
-		{
-			name:  "different name",
-			a:     &ir.StringMatch{Name: "a", Exact: ptr.To("v")},
-			b:     &ir.StringMatch{Name: "b", Exact: ptr.To("v")},
-			equal: false,
-		},
 		{
-			name:  "different value",
-			a:     &ir.StringMatch{Name: "h", Exact: ptr.To("v1")},
-			b:     &ir.StringMatch{Name: "h", Exact: ptr.To("v2")},
-			equal: false,
-		},
-		{
-			name:  "different distinct",
-			a:     &ir.StringMatch{Name: "h", Distinct: true},
-			b:     &ir.StringMatch{Name: "h", Distinct: false},
-			equal: false,
-		},
-		{
-			name:  "different invert",
-			a:     &ir.StringMatch{Name: "h", Exact: ptr.To("v"), Invert: ptr.To(true)},
-			b:     &ir.StringMatch{Name: "h", Exact: ptr.To("v")},
-			equal: false,
-		},
-		{
-			name:  "same invert",
-			a:     &ir.StringMatch{Name: "h", Exact: ptr.To("v"), Invert: ptr.To(true)},
-			b:     &ir.StringMatch{Name: "h", Exact: ptr.To("v"), Invert: ptr.To(true)},
-			equal: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			assert.Equal(t, tt.equal, stringMatchEqual(tt.a, tt.b))
-		})
-	}
-}
-
-func TestStringMatchSliceEqual(t *testing.T) {
-	tests := []struct {
-		name  string
-		a     []*ir.StringMatch
-		b     []*ir.StringMatch
-		equal bool
-	}{
-		{
-			name:  "both empty",
-			a:     nil,
-			b:     nil,
-			equal: true,
+			name: "identical exact path with identical query param matches",
+			a: &ir.HTTPRoute{
+				Hostname:  "example.com",
+				PathMatch: &ir.StringMatch{Exact: ptr.To("/foo")},
+				QueryParamMatches: []*ir.StringMatch{
+					{Name: "key", Exact: ptr.To("value")},
+				},
+			},
+			b: &ir.HTTPRoute{
+				Hostname:  "example.com",
+				PathMatch: &ir.StringMatch{Exact: ptr.To("/foo")},
+				QueryParamMatches: []*ir.StringMatch{
+					{Name: "key", Exact: ptr.To("value")},
+				},
+			},
+			overlap: true,
 		},
 		{
-			name:  "different lengths",
-			a:     []*ir.StringMatch{{Name: "a", Exact: ptr.To("1")}},
-			b:     nil,
-			equal: false,
+			name: "query param matches in different order still overlap",
+			a: &ir.HTTPRoute{
+				Hostname: "example.com",
+				QueryParamMatches: []*ir.StringMatch{
+					{Name: "a", Exact: ptr.To("1")},
+					{Name: "b", Exact: ptr.To("2")},
+				},
+			},
+			b: &ir.HTTPRoute{
+				Hostname: "example.com",
+				QueryParamMatches: []*ir.StringMatch{
+					{Name: "b", Exact: ptr.To("2")},
+					{Name: "a", Exact: ptr.To("1")},
+				},
+			},
+			overlap: true,
 		},
 		{
-			name: "identical",
-			a: []*ir.StringMatch{
-				{Name: "a", Exact: ptr.To("1")},
-				{Name: "b", Exact: ptr.To("2")},
+			name: "cookie matches in different order still overlap",
+			a: &ir.HTTPRoute{
+				Hostname: "example.com",
+				CookieMatches: []*ir.StringMatch{
+					{Name: "a", Exact: ptr.To("1")},
+					{Name: "b", Exact: ptr.To("2")},
+				},
 			},
-			b: []*ir.StringMatch{
-				{Name: "a", Exact: ptr.To("1")},
-				{Name: "b", Exact: ptr.To("2")},
+			b: &ir.HTTPRoute{
+				Hostname: "example.com",
+				CookieMatches: []*ir.StringMatch{
+					{Name: "b", Exact: ptr.To("2")},
+					{Name: "a", Exact: ptr.To("1")},
+				},
 			},
-			equal: true,
+			overlap: true,
 		},
 		{
-			name: "same elements different order",
-			a: []*ir.StringMatch{
-				{Name: "a", Exact: ptr.To("1")},
-				{Name: "b", Exact: ptr.To("2")},
+			name: "identical regex path matches are detected as overlap",
+			a: &ir.HTTPRoute{
+				Hostname:  "example.com",
+				PathMatch: &ir.StringMatch{SafeRegex: ptr.To("/foo.*")},
 			},
-			b: []*ir.StringMatch{
-				{Name: "b", Exact: ptr.To("2")},
-				{Name: "a", Exact: ptr.To("1")},
+			b: &ir.HTTPRoute{
+				Hostname:  "example.com",
+				PathMatch: &ir.StringMatch{SafeRegex: ptr.To("/foo.*")},
 			},
-			equal: false,
+			overlap: true,
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			assert.Equal(t, tt.equal, stringMatchSliceEqual(tt.a, tt.b))
+			assert.Equal(t, tt.overlap, routesOverlap(tt.a, tt.b))
 		})
 	}
 }