add tests for loader.go

Author: zac-nixon

pkg/gateway/routeutils/loader.go

@@ -2,7 +2,7 @@ package routeutils
 
 import (
 	"context"
-	"k8s.io/apimachinery/pkg/types"
+	"fmt"
 	"k8s.io/apimachinery/pkg/util/sets"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	gwv1 "sigs.k8s.io/gateway-api/apis/v1"
@@ -20,6 +20,17 @@ func (r *routeFilterImpl) IsApplicable(kind string) bool {
 	return r.acceptedKinds.Has(kind)
 }
 
+/*
+
+TLS mappings -- Should we enforce that here?
+
+Listener Protocol |	TLS Mode 	 | Route Type Supported
+TLS 	          | Passthrough  | TLSRoute
+TLS 	          | Terminate 	 | TCPRoute
+HTTPS 	          | Terminate 	 | HTTPRoute
+GRPC 	          | Terminate 	 | GRPCRoute
+*/
+
 // L4RouteFilter use this to load routes only pertaining to the L4 Gateway Implementation (AWS NLB)
 var L4RouteFilter LoadRouteFilter = &routeFilterImpl{
 	acceptedKinds: sets.New(UDPRouteKind, TCPRouteKind, TLSRouteKind),
@@ -69,23 +80,17 @@ func (l *loaderImpl) LoadRoutesForGateway(ctx context.Context, gw *gwv1.Gateway,
 func (l *loaderImpl) loadChildResources(ctx context.Context, preloadedRoutes map[int][]preLoadRouteDescriptor) (map[int][]RouteDescriptor, error) {
 	// Cache to reduce duplicate route look ups.
 	// Kind -> [NamespacedName:Previously Loaded Descriptor]
-	resourceCache := make(map[string]map[types.NamespacedName]RouteDescriptor)
+	resourceCache := make(map[string]RouteDescriptor)
 
 	loadedRouteData := make(map[int][]RouteDescriptor)
 
 	for port, preloadedRouteList := range preloadedRoutes {
 		for _, preloadedRoute := range preloadedRouteList {
 			namespacedNameRoute := preloadedRoute.GetRouteNamespacedName()
 			routeKind := preloadedRoute.GetRouteKind()
+			cacheKey := fmt.Sprintf("%s-%s-%s", routeKind, namespacedNameRoute.Name, namespacedNameRoute.Namespace)
 
-			kindSpecificCache, ok := resourceCache[routeKind]
-
-			if !ok {
-				resourceCache[routeKind] = make(map[types.NamespacedName]RouteDescriptor)
-				kindSpecificCache = resourceCache[routeKind]
-			}
-
-			cachedRoute, ok := kindSpecificCache[namespacedNameRoute]
+			cachedRoute, ok := resourceCache[cacheKey]
 			if ok {
 				loadedRouteData[port] = append(loadedRouteData[port], cachedRoute)
 				continue
@@ -96,7 +101,7 @@ func (l *loaderImpl) loadChildResources(ctx context.Context, preloadedRoutes map
 				return nil, err
 			}
 			loadedRouteData[port] = append(loadedRouteData[port], generatedRoute)
-			kindSpecificCache[namespacedNameRoute] = generatedRoute
+			resourceCache[cacheKey] = generatedRoute
 		}
 	}
 

pkg/gateway/routeutils/loader_test.go

@@ -11,60 +11,199 @@ import (
 )
 
 type mockMapper struct {
+	t              *testing.T
+	expectedRoutes []preLoadRouteDescriptor
+	mapToReturn    map[int][]preLoadRouteDescriptor
 }
 
-func (m mockMapper) Map(context context.Context, gw *gwv1.Gateway, routes []preLoadRouteDescriptor) (map[int][]preLoadRouteDescriptor, error) {
-	return map[int][]preLoadRouteDescriptor{}, nil
+func (m *mockMapper) Map(context context.Context, gw *gwv1.Gateway, routes []preLoadRouteDescriptor) (map[int][]preLoadRouteDescriptor, error) {
+	assert.ElementsMatch(m.t, m.expectedRoutes, routes)
+	return m.mapToReturn, nil
+}
+
+var _ RouteDescriptor = &mockRoute{}
+
+type mockRoute struct {
+	namespacedName types.NamespacedName
+	routeKind      string
+}
+
+func (m *mockRoute) loadAttachedRules(context context.Context, k8sClient client.Client) (RouteDescriptor, error) {
+	return m, nil
+}
+
+func (m *mockRoute) GetRouteNamespacedName() types.NamespacedName {
+	return m.namespacedName
+}
+
+func (m *mockRoute) GetRouteKind() string {
+	return m.routeKind
+}
+
+func (m *mockRoute) GetHostnames() []gwv1.Hostname {
+	//TODO implement me
+	panic("implement me")
+}
+
+func (m *mockRoute) GetParentRefs() []gwv1.ParentReference {
+	//TODO implement me
+	panic("implement me")
+}
+
+func (m *mockRoute) GetRawRoute() interface{} {
+	//TODO implement me
+	panic("implement me")
+}
+
+func (m *mockRoute) GetAttachedRules() []RouteRule {
+	//TODO implement me
+	panic("implement me")
 }
 
 func TestLoadRoutesForGateway(t *testing.T) {
+	preLoadHTTPRoutes := []preLoadRouteDescriptor{
+		&mockRoute{
+			namespacedName: types.NamespacedName{
+				Namespace: "http1-ns",
+				Name:      "http1",
+			},
+			routeKind: HTTPRouteKind,
+		},
+		&mockRoute{
+			namespacedName: types.NamespacedName{
+				Namespace: "http2-ns",
+				Name:      "http2",
+			},
+			routeKind: HTTPRouteKind,
+		},
+		&mockRoute{
+			namespacedName: types.NamespacedName{
+				Namespace: "http3-ns",
+				Name:      "http3",
+			},
+			routeKind: HTTPRouteKind,
+		},
+	}
+
+	loadedHTTPRoutes := make([]RouteDescriptor, 0)
+	for _, preload := range preLoadHTTPRoutes {
+		r, _ := preload.loadAttachedRules(nil, nil)
+		loadedHTTPRoutes = append(loadedHTTPRoutes, r)
+	}
+
+	preLoadTCPRoutes := []preLoadRouteDescriptor{
+		&mockRoute{
+			namespacedName: types.NamespacedName{
+				Namespace: "tcp1-ns",
+				Name:      "tcp1",
+			},
+			routeKind: TCPRouteKind,
+		},
+		&mockRoute{
+			namespacedName: types.NamespacedName{
+				Namespace: "tcp2-ns",
+				Name:      "tcp2",
+			},
+			routeKind: TCPRouteKind,
+		},
+		&mockRoute{
+			namespacedName: types.NamespacedName{
+				Namespace: "tcp3-ns",
+				Name:      "tcp3",
+			},
+			routeKind: TCPRouteKind,
+		},
+	}
 
-	noOpLoader := func(ctx context.Context, k8sClient client.Client, typeSpecificBackend interface{}, backendRef gwv1.BackendRef, routeIdentifier types.NamespacedName, routeKind string) (*Backend, error) {
-		return &Backend{}, nil
+	loadedTCPRoutes := make([]RouteDescriptor, 0)
+	for _, preload := range preLoadTCPRoutes {
+		r, _ := preload.loadAttachedRules(nil, nil)
+		loadedTCPRoutes = append(loadedTCPRoutes, r)
 	}
 
 	allRouteLoaders := map[string]func(ctx context.Context, k8sClient client.Client) ([]preLoadRouteDescriptor, error){
 		HTTPRouteKind: func(ctx context.Context, k8sClient client.Client) ([]preLoadRouteDescriptor, error) {
-			return []preLoadRouteDescriptor{
-				&httpRouteDescription{backendLoader: noOpLoader},
-				&httpRouteDescription{backendLoader: noOpLoader},
-				&httpRouteDescription{backendLoader: noOpLoader},
-			}, nil
+			return preLoadHTTPRoutes, nil
 		},
 		TCPRouteKind: func(ctx context.Context, k8sClient client.Client) ([]preLoadRouteDescriptor, error) {
-			return []preLoadRouteDescriptor{
-				&tcpRouteDescription{backendLoader: noOpLoader},
-				&tcpRouteDescription{backendLoader: noOpLoader},
-				&tcpRouteDescription{backendLoader: noOpLoader},
-			}, nil
+			return preLoadTCPRoutes, nil
 		},
 	}
 
-	loader := loaderImpl{
-		mapper:          &mockMapper{},
-		allRouteLoaders: allRouteLoaders,
-	}
-
 	testCases := []struct {
-		name          string
-		acceptedKinds sets.Set[string]
-		expectedMap   map[int][]RouteDescriptor
-		expectError   bool
+		name                    string
+		acceptedKinds           sets.Set[string]
+		expectedMap             map[int][]RouteDescriptor
+		expectedPreloadMap      map[int][]preLoadRouteDescriptor
+		expectedPreMappedRoutes []preLoadRouteDescriptor
+		expectError             bool
 	}{
 		{
-			name:          "filter allows no routes",
-			acceptedKinds: make(sets.Set[string]),
-			expectedMap:   make(map[int][]RouteDescriptor),
+			name:                    "filter allows no routes",
+			acceptedKinds:           make(sets.Set[string]),
+			expectedPreMappedRoutes: make([]preLoadRouteDescriptor, 0),
+			expectedMap:             make(map[int][]RouteDescriptor),
 		},
 		{
-			name:          "filter only allows http route",
-			acceptedKinds: sets.New[string](HTTPRouteKind),
-			expectedMap:   make(map[int][]RouteDescriptor),
+			name:                    "filter only allows http route",
+			acceptedKinds:           sets.New[string](HTTPRouteKind),
+			expectedPreMappedRoutes: preLoadHTTPRoutes,
+			expectedPreloadMap: map[int][]preLoadRouteDescriptor{
+				80: preLoadHTTPRoutes,
+			},
+			expectedMap: map[int][]RouteDescriptor{
+				80: loadedHTTPRoutes,
+			},
+		},
+		{
+			name:                    "filter only allows http route, multiple ports",
+			acceptedKinds:           sets.New[string](HTTPRouteKind),
+			expectedPreMappedRoutes: preLoadHTTPRoutes,
+			expectedPreloadMap: map[int][]preLoadRouteDescriptor{
+				80:  preLoadHTTPRoutes,
+				443: preLoadHTTPRoutes,
+			},
+			expectedMap: map[int][]RouteDescriptor{
+				80:  loadedHTTPRoutes,
+				443: loadedHTTPRoutes,
+			},
+		},
+		{
+			name:                    "filter only allows tcp route",
+			acceptedKinds:           sets.New[string](TCPRouteKind),
+			expectedPreMappedRoutes: preLoadTCPRoutes,
+			expectedPreloadMap: map[int][]preLoadRouteDescriptor{
+				80: preLoadTCPRoutes,
+			},
+			expectedMap: map[int][]RouteDescriptor{
+				80: loadedTCPRoutes,
+			},
+		},
+		{
+			name:                    "filter allows both route kinds",
+			acceptedKinds:           sets.New[string](TCPRouteKind, HTTPRouteKind),
+			expectedPreMappedRoutes: append(preLoadHTTPRoutes, preLoadTCPRoutes...),
+			expectedPreloadMap: map[int][]preLoadRouteDescriptor{
+				80:  preLoadTCPRoutes,
+				443: preLoadHTTPRoutes,
+			},
+			expectedMap: map[int][]RouteDescriptor{
+				80:  loadedTCPRoutes,
+				443: loadedHTTPRoutes,
+			},
 		},
 	}
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
+			loader := loaderImpl{
+				mapper: &mockMapper{
+					t:              t,
+					expectedRoutes: tc.expectedPreMappedRoutes,
+					mapToReturn:    tc.expectedPreloadMap,
+				},
+				allRouteLoaders: allRouteLoaders,
+			}
 
 			filter := &routeFilterImpl{acceptedKinds: tc.acceptedKinds}
 			result, err := loader.LoadRoutesForGateway(context.Background(), &gwv1.Gateway{}, filter)