BUG/MINOR: remove unused domainWildcard bucket to fix dropped routes

The `domainWildcard` bucket in `desiredBackendsMaps` was never applied to any HAProxy map file. As a result, HTTPRoutes combining wildcard hosts with exact path matches were silently dropped into this dead bucket.

This commit removes the unused `domainWildcard` bucket, since wildcard-host matching is already handled upstream by the listener/listener-route map pipeline. The `resolveEntry` function is updated to appropriately keep these entries in the `exact` bucket instead. Additionally, unit tests are introduced for `resolveEntry` to verify path match and host kind bucket resolution logic to prevent future regressions.

Author: oktalz

k8s/gate/haproxy/routes.go

@@ -229,21 +229,21 @@ func (b *RouteMgrImpl) onValidHTTPRouteUpserted(origin maps.ResourceOrigin, rout
 	return nil
 }
 
-// desiredBackendsMaps groups the four (hostname, path) → backends maps that
-// correspond to the four HAProxy map files (exact, prefix, regex, domain-wildcard).
+// desiredBackendsMaps groups the three (hostname, path) → backends maps that
+// correspond to the HAProxy path-match map files (exact, prefix, regex).
+// Wildcard-host matching is handled upstream by the listener/listener-route
+// map pipeline, not by a dedicated bucket here.
 type desiredBackendsMaps struct {
-	exact          map[maps.EntryKey]map[string]*maps.WeightedValue
-	prefix         map[maps.EntryKey]map[string]*maps.WeightedValue
-	regex          map[maps.EntryKey]map[string]*maps.WeightedValue
-	domainWildcard map[maps.EntryKey]map[string]*maps.WeightedValue
+	exact  map[maps.EntryKey]map[string]*maps.WeightedValue
+	prefix map[maps.EntryKey]map[string]*maps.WeightedValue
+	regex  map[maps.EntryKey]map[string]*maps.WeightedValue
 }
 
 func newDesiredBackendsMaps() desiredBackendsMaps {
 	return desiredBackendsMaps{
-		exact:          map[maps.EntryKey]map[string]*maps.WeightedValue{},
-		prefix:         map[maps.EntryKey]map[string]*maps.WeightedValue{},
-		regex:          map[maps.EntryKey]map[string]*maps.WeightedValue{},
-		domainWildcard: map[maps.EntryKey]map[string]*maps.WeightedValue{},
+		exact:  map[maps.EntryKey]map[string]*maps.WeightedValue{},
+		prefix: map[maps.EntryKey]map[string]*maps.WeightedValue{},
+		regex:  map[maps.EntryKey]map[string]*maps.WeightedValue{},
 	}
 }
 
@@ -265,9 +265,8 @@ func (d *desiredBackendsMaps) resolveEntry(hostname string, match gatewayv1.HTTP
 	selected := d.exact
 	switch pathType {
 	case gatewayv1.PathMatchExact:
-		if isDomainWildcard(originalHostname) {
-			selected = d.domainWildcard
-		}
+		// Wildcard-host + exact-path is routed via the listener/listener-route
+		// map pipeline upstream; the path bucket remains d.exact here.
 	case gatewayv1.PathMatchPathPrefix:
 		if isDomainWildcard(originalHostname) {
 			selected = d.regex

k8s/gate/haproxy/routes_test.go

@@ -2,6 +2,9 @@ package haproxy
 
 import (
 	"testing"
+
+	"github.com/haproxytech/haproxy-unified-gateway/k8s/gate/haproxy/storage/maps"
+	gatewayv1 "sigs.k8s.io/gateway-api/apis/v1"
 )
 
 func TestSanitizeRegexp(t *testing.T) {
@@ -61,3 +64,113 @@ func TestSanitizeRegexp(t *testing.T) {
 		})
 	}
 }
+
+// TestResolveEntry covers the pathMatch × hostKind combinations and guards
+// against regressions where wildcard-host + exact-path entries were silently
+// dropped into a dead `domainWildcard` bucket that was never applied to any
+// map file.
+func TestResolveEntry(t *testing.T) {
+	ptr := func(s gatewayv1.PathMatchType) *gatewayv1.PathMatchType { return &s }
+	strPtr := func(s string) *string { return &s }
+
+	type bucket int
+	const (
+		bucketExact bucket = iota
+		bucketPrefix
+		bucketRegex
+	)
+
+	tests := []struct {
+		name       string
+		hostname   string
+		pathType   gatewayv1.PathMatchType
+		path       string
+		wantBucket bucket
+		wantKey    maps.EntryKey
+	}{
+		{
+			name:       "exact-path exact-host",
+			hostname:   "example.com",
+			pathType:   gatewayv1.PathMatchExact,
+			path:       "/foo",
+			wantBucket: bucketExact,
+			wantKey:    maps.EntryKey{Hostname: "example.com", Path: "/foo"},
+		},
+		{
+			name:       "exact-path wildcard-host falls through to exact bucket",
+			hostname:   "*.example.com",
+			pathType:   gatewayv1.PathMatchExact,
+			path:       "/foo",
+			wantBucket: bucketExact,
+			wantKey:    maps.EntryKey{Hostname: ".example.com", Path: "/foo"},
+		},
+		{
+			name:       "prefix-path exact-host",
+			hostname:   "example.com",
+			pathType:   gatewayv1.PathMatchPathPrefix,
+			path:       "/foo",
+			wantBucket: bucketPrefix,
+			wantKey:    maps.EntryKey{Hostname: "example.com", Path: "/foo"},
+		},
+		{
+			name:       "prefix-path wildcard-host",
+			hostname:   "*.example.com",
+			pathType:   gatewayv1.PathMatchPathPrefix,
+			path:       "/foo",
+			wantBucket: bucketRegex,
+			wantKey:    maps.EntryKey{Hostname: `\.example\.com`, Path: "/foo.*"},
+		},
+		{
+			name:       "regex-path exact-host",
+			hostname:   "example.com",
+			pathType:   gatewayv1.PathMatchRegularExpression,
+			path:       "/foo",
+			wantBucket: bucketRegex,
+			wantKey:    maps.EntryKey{Hostname: `^example\.com`, Path: "/foo"},
+		},
+		{
+			name:       "regex-path wildcard-host",
+			hostname:   "*.example.com",
+			pathType:   gatewayv1.PathMatchRegularExpression,
+			path:       "/foo",
+			wantBucket: bucketRegex,
+			wantKey:    maps.EntryKey{Hostname: `\.example\.com`, Path: "/foo"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := newDesiredBackendsMaps()
+			match := gatewayv1.HTTPRouteMatch{
+				Path: &gatewayv1.HTTPPathMatch{
+					Type:  ptr(tt.pathType),
+					Value: strPtr(tt.path),
+				},
+			}
+			innerMap, key := d.resolveEntry(tt.hostname, match)
+
+			if key != tt.wantKey {
+				t.Errorf("resolveEntry key = %+v, want %+v", key, tt.wantKey)
+			}
+			if innerMap == nil {
+				t.Fatal("resolveEntry returned nil inner map")
+			}
+
+			buckets := map[bucket]map[maps.EntryKey]map[string]*maps.WeightedValue{
+				bucketExact:  d.exact,
+				bucketPrefix: d.prefix,
+				bucketRegex:  d.regex,
+			}
+			for b, m := range buckets {
+				_, present := m[tt.wantKey]
+				if b == tt.wantBucket {
+					if !present {
+						t.Errorf("key %+v missing from expected bucket %d", tt.wantKey, b)
+					}
+				} else if present {
+					t.Errorf("key %+v leaked into unexpected bucket %d", tt.wantKey, b)
+				}
+			}
+		})
+	}
+}