complete unit tests

Author: sarthyparty

internal/mode/static/nginx/config/generator_test.go

@@ -63,8 +63,13 @@ func TestGenerate(t *testing.T) {
 		},
 		StreamUpstreams: []dataplane.Upstream{
 			{
-				Name:      "stream_up",
-				Endpoints: make([]resolver.Endpoint, 1),
+				Name: "stream_up",
+				Endpoints: []resolver.Endpoint{
+					{
+						Address: "1.1.1.1",
+						Port:    80,
+					},
+				},
 			},
 		},
 		BackendGroups: []dataplane.BackendGroup{bg},

internal/mode/static/nginx/config/maps_test.go

@@ -217,12 +217,22 @@ func TestExecuteStreamMaps(t *testing.T) {
 		},
 		StreamUpstreams: []dataplane.Upstream{
 			{
-				Name:      "backend1",
-				Endpoints: make([]resolver.Endpoint, 1),
+				Name: "backend1",
+				Endpoints: []resolver.Endpoint{
+					{
+						Address: "1.1.1.1",
+						Port:    80,
+					},
+				},
 			},
 			{
-				Name:      "backend2",
-				Endpoints: make([]resolver.Endpoint, 1),
+				Name: "backend2",
+				Endpoints: []resolver.Endpoint{
+					{
+						Address: "1.1.1.1",
+						Port:    80,
+					},
+				},
 			},
 		},
 	}
@@ -278,6 +288,11 @@ func TestCreateStreamMaps(t *testing.T) {
 				Port:      8080,
 				IsDefault: true,
 			},
+			{
+				Hostname:     "wrong2.example.com",
+				Port:         8080,
+				UpstreamName: "backend3",
+			},
 		},
 		SSLServers: []dataplane.VirtualServer{
 			{
@@ -291,12 +306,26 @@ func TestCreateStreamMaps(t *testing.T) {
 		},
 		StreamUpstreams: []dataplane.Upstream{
 			{
-				Name:      "backend1",
-				Endpoints: make([]resolver.Endpoint, 1),
+				Name: "backend1",
+				Endpoints: []resolver.Endpoint{
+					{
+						Address: "1.1.1.1",
+						Port:    80,
+					},
+				},
+			},
+			{
+				Name: "backend2",
+				Endpoints: []resolver.Endpoint{
+					{
+						Address: "1.1.1.1",
+						Port:    80,
+					},
+				},
 			},
 			{
-				Name:      "backend2",
-				Endpoints: make([]resolver.Endpoint, 1),
+				Name:      "backend3",
+				Endpoints: nil,
 			},
 		},
 	}
@@ -329,6 +358,7 @@ func TestCreateStreamMaps(t *testing.T) {
 				{Value: "cafe.example.com", Result: getSocketNameTLS(8080, "cafe.example.com")},
 				{Value: "wrong.example.com", Result: `""`},
 				{Value: "*.example.com", Result: connectionClosedStreamServerSocket},
+				{Value: "wrong2.example.com", Result: `""`},
 				{Value: "app.example.com", Result: getSocketNameHTTPS(8080)},
 				{Value: "default", Result: getSocketNameHTTPS(8080)},
 			},

internal/mode/static/nginx/config/stream_servers_test.go

@@ -33,12 +33,22 @@ func TestExecuteStreamServers(t *testing.T) {
 		},
 		StreamUpstreams: []dataplane.Upstream{
 			{
-				Name:      "backend1",
-				Endpoints: make([]resolver.Endpoint, 1),
+				Name: "backend1",
+				Endpoints: []resolver.Endpoint{
+					{
+						Address: "1.1.1.1",
+						Port:    80,
+					},
+				},
 			},
 			{
-				Name:      "backend2",
-				Endpoints: make([]resolver.Endpoint, 1),
+				Name: "backend2",
+				Endpoints: []resolver.Endpoint{
+					{
+						Address: "1.1.1.1",
+						Port:    80,
+					},
+				},
 			},
 		},
 	}
@@ -87,12 +97,22 @@ func TestCreateStreamServers(t *testing.T) {
 		},
 		StreamUpstreams: []dataplane.Upstream{
 			{
-				Name:      "backend1",
-				Endpoints: make([]resolver.Endpoint, 1),
+				Name: "backend1",
+				Endpoints: []resolver.Endpoint{
+					{
+						Address: "1.1.1.1",
+						Port:    80,
+					},
+				},
 			},
 			{
-				Name:      "backend2",
-				Endpoints: make([]resolver.Endpoint, 1),
+				Name: "backend2",
+				Endpoints: []resolver.Endpoint{
+					{
+						Address: "1.1.1.1",
+						Port:    80,
+					},
+				},
 			},
 		},
 	}

internal/mode/static/nginx/config/upstreams_test.go

@@ -372,6 +372,10 @@ func TestCreateStreamUpstreams(t *testing.T) {
 					Address: "10.0.0.2",
 					Port:    80,
 				},
+				{
+					Address: "2001:db8::1",
+					IPv6:    true,
+				},
 			},
 		},
 		{
@@ -403,6 +407,9 @@ func TestCreateStreamUpstreams(t *testing.T) {
 				{
 					Address: "10.0.0.2:80",
 				},
+				{
+					Address: "[2001:db8::1]:0",
+				},
 			},
 		},
 		{

internal/mode/static/state/graph/route_common_test.go

@@ -2065,3 +2065,18 @@ func TestBuildL4RoutesForGateways(t *testing.T) {
 
 	g.Expect(buildL4RoutesForGateways(nil, nil, nil, nil)).To(BeNil())
 }
+
+func TestTryToAttachL4RouteToListeners(t *testing.T) {
+	g := NewWithT(t)
+
+	cond, attachable := tryToAttachL4RouteToListeners(
+		nil,
+		nil,
+		nil,
+		nil,
+		nil,
+		nil,
+	)
+	g.Expect(cond).To(Equal(staticConds.NewRouteInvalidListener()))
+	g.Expect(attachable).To(BeFalse())
+}

internal/mode/static/status/prepare_requests_test.go

@@ -222,6 +222,7 @@ func TestBuildHTTPRouteStatuses(t *testing.T) {
 			CommonRouteSpec: commonRouteSpecValid,
 		},
 	}
+
 	hrInvalid := &v1.HTTPRoute{
 		ObjectMeta: metav1.ObjectMeta{
 			Namespace:  "test",
@@ -367,6 +368,82 @@ func TestBuildGRPCRouteStatuses(t *testing.T) {
 	}
 }
 
+func TestBuildTLSRouteStatuses(t *testing.T) {
+	trValid := &v1alpha2.TLSRoute{
+		ObjectMeta: metav1.ObjectMeta{
+			Namespace:  "test",
+			Name:       "tr-valid",
+			Generation: 3,
+		},
+		Spec: v1alpha2.TLSRouteSpec{
+			CommonRouteSpec: commonRouteSpecValid,
+		},
+	}
+	trInvalid := &v1alpha2.TLSRoute{
+		ObjectMeta: metav1.ObjectMeta{
+			Namespace:  "test",
+			Name:       "tr-invalid",
+			Generation: 3,
+		},
+		Spec: v1alpha2.TLSRouteSpec{
+			CommonRouteSpec: commonRouteSpecInvalid,
+		},
+	}
+	routes := map[graph.L4RouteKey]*graph.L4Route{
+		graph.CreateRouteKeyL4(trValid): {
+			Valid:      true,
+			Source:     trValid,
+			ParentRefs: parentRefsValid,
+		},
+		graph.CreateRouteKeyL4(trInvalid): {
+			Valid:      false,
+			Conditions: []conditions.Condition{invalidRouteCondition},
+			Source:     trInvalid,
+			ParentRefs: parentRefsInvalid,
+		},
+	}
+
+	expectedStatuses := map[types.NamespacedName]v1alpha2.TLSRouteStatus{
+		{Namespace: "test", Name: "tr-valid"}: {
+			RouteStatus: routeStatusValid,
+		},
+		{Namespace: "test", Name: "tr-invalid"}: {
+			RouteStatus: routeStatusInvalid,
+		},
+	}
+
+	g := NewWithT(t)
+
+	k8sClient := createK8sClientFor(&v1alpha2.TLSRoute{})
+
+	for _, r := range routes {
+		err := k8sClient.Create(context.Background(), r.Source)
+		g.Expect(err).ToNot(HaveOccurred())
+	}
+
+	updater := statusFramework.NewUpdater(k8sClient, zap.New())
+
+	reqs := PrepareRouteRequests(
+		routes,
+		map[graph.RouteKey]*graph.L7Route{},
+		transitionTime,
+		NginxReloadResult{},
+		gatewayCtlrName,
+	)
+
+	updater.Update(context.Background(), reqs...)
+
+	g.Expect(reqs).To(HaveLen(len(expectedStatuses)))
+
+	for nsname, expected := range expectedStatuses {
+		var hr v1alpha2.TLSRoute
+
+		err := k8sClient.Get(context.Background(), nsname, &hr)
+		g.Expect(err).ToNot(HaveOccurred())
+		g.Expect(helpers.Diff(expected, hr.Status)).To(BeEmpty())
+	}
+}
+
 func TestBuildRouteStatusesNginxErr(t *testing.T) {
 	const gatewayCtlrName = "controller"