testing: Migrate as many tests as possible to internal/assert

Needed to update some aliases in internal/assert to cover all the cases.

Updates projectcontour#2786.

Signed-off-by: Nick Young <ynick@vmware.com>

internal/assert/assert.go

@@ -26,6 +26,14 @@ var (
 	Equal         = tassert.Equal
 	Equalf        = tassert.Equalf
 	ElementsMatch = tassert.ElementsMatch
+	Error         = tassert.Error
+	Errorf        = tassert.Errorf
+	NoError       = tassert.NoError
+	NoErrorf      = tassert.NoErrorf
+	True          = tassert.True
+	Truef         = tassert.Truef
+	False         = tassert.False
+	Falsef        = tassert.Falsef
 )
 
 // EqualProto will test that want == got for protobufs, call t.Error if it does not,

internal/certgen/certgen_test.go

@@ -19,6 +19,8 @@ import (
 	"fmt"
 	"testing"
 	"time"
+
+	"github.com/projectcontour/contour/internal/assert"
 )
 
 func TestGeneratedCertsValid(t *testing.T) {
@@ -27,24 +29,17 @@ func TestGeneratedCertsValid(t *testing.T) {
 	expiry := now.Add(24 * 365 * time.Hour)
 
 	cacert, cakey, err := NewCA("contour", expiry)
-	if err != nil {
-		t.Fatalf("Failed to generate CA cert: %s", err)
-	}
+	assert.NoErrorf(t, err, "Failed to generate CA cert")
 
 	contourcert, _, err := NewCert(cacert, cakey, expiry, "contour", "projectcontour")
-	if err != nil {
-		t.Fatalf("Failed to generate Contour cert: %s", err)
-	}
+	assert.NoErrorf(t, err, "Failed to generate Contour cert")
 
 	roots := x509.NewCertPool()
 	ok := roots.AppendCertsFromPEM(cacert)
-	if !ok {
-		t.Fatal("Failed to set up CA cert for testing, maybe it's an invalid PEM")
-	}
+	assert.Truef(t, ok, "Failed to set up CA cert for testing, maybe it's an invalid PEM")
+
 	envoycert, _, err := NewCert(cacert, cakey, expiry, "envoy", "projectcontour")
-	if err != nil {
-		t.Fatalf("Failed to generate Envoy cert: %s", err)
-	}
+	assert.NoErrorf(t, err, "Failed to generate Envoy cert")
 
 	tests := map[string]struct {
 		cert    []byte
@@ -63,9 +58,7 @@ func TestGeneratedCertsValid(t *testing.T) {
 	for name, tc := range tests {
 		t.Run(name, func(t *testing.T) {
 			err := verifyCert(tc.cert, roots, tc.dnsname)
-			if err != nil {
-				t.Fatalf("Validating %s failed: %s", name, err)
-			}
+			assert.NoErrorf(t, err, "Validating %s failed", name)
 		})
 	}
 

internal/contour/server_test.go

@@ -23,6 +23,7 @@ import (
 	v2 "github.com/envoyproxy/go-control-plane/envoy/api/v2"
 	discovery "github.com/envoyproxy/go-control-plane/envoy/service/discovery/v2"
 	resource "github.com/envoyproxy/go-control-plane/pkg/resource/v2"
+	"github.com/projectcontour/contour/internal/assert"
 	"github.com/projectcontour/contour/internal/dag"
 	"github.com/projectcontour/contour/internal/xds"
 	"github.com/sirupsen/logrus"
@@ -63,7 +64,7 @@ func TestGRPC(t *testing.T) {
 			ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
 			defer cancel()
 			stream, err := sds.StreamClusters(ctx)
-			check(t, err)
+			assert.NoError(t, err)
 			sendreq(t, stream, resource.ClusterType) // send initial notification
 			checkrecv(t, stream)                     // check we receive one notification
 			checktimeout(t, stream)                  // check that the second receive times out
@@ -90,7 +91,7 @@ func TestGRPC(t *testing.T) {
 			ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
 			defer cancel()
 			stream, err := eds.StreamEndpoints(ctx)
-			check(t, err)
+			assert.NoError(t, err)
 			sendreq(t, stream, resource.EndpointType) // send initial notification
 			checkrecv(t, stream)                      // check we receive one notification
 			checktimeout(t, stream)                   // check that the second receive times out
@@ -123,7 +124,7 @@ func TestGRPC(t *testing.T) {
 			ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
 			defer cancel()
 			stream, err := lds.StreamListeners(ctx)
-			check(t, err)
+			assert.NoError(t, err)
 			sendreq(t, stream, resource.ListenerType) // send initial notification
 			checkrecv(t, stream)                      // check we receive one notification
 			checktimeout(t, stream)                   // check that the second receive times out
@@ -155,7 +156,7 @@ func TestGRPC(t *testing.T) {
 			ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
 			defer cancel()
 			stream, err := rds.StreamRoutes(ctx)
-			check(t, err)
+			assert.NoError(t, err)
 			sendreq(t, stream, resource.RouteType) // send initial notification
 			checkrecv(t, stream)                   // check we receive one notification
 			checktimeout(t, stream)                // check that the second receive times out
@@ -176,7 +177,7 @@ func TestGRPC(t *testing.T) {
 			ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
 			defer cancel()
 			stream, err := sds.StreamSecrets(ctx)
-			check(t, err)
+			assert.NoError(t, err)
 			sendreq(t, stream, resource.SecretType) // send initial notification
 			checkrecv(t, stream)                    // check we receive one notification
 			checktimeout(t, stream)                 // check that the second receive times out
@@ -206,7 +207,7 @@ func TestGRPC(t *testing.T) {
 
 			srv := xds.RegisterServer(xds.NewContourServer(log, ResourcesOf(resources)...), nil)
 			l, err := net.Listen("tcp", "127.0.0.1:0")
-			check(t, err)
+			assert.NoError(t, err)
 			done := make(chan error, 1)
 			stop := make(chan struct{})
 			run := eh.Start()
@@ -220,50 +221,39 @@ func TestGRPC(t *testing.T) {
 				<-done
 			}()
 			cc, err := grpc.Dial(l.Addr().String(), grpc.WithInsecure())
-			check(t, err)
+			assert.NoError(t, err)
 			defer cc.Close()
 			fn(t, cc)
 		})
 	}
 }
 
-func check(t *testing.T, err error) {
-	t.Helper()
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
 func sendreq(t *testing.T, stream interface {
 	Send(*v2.DiscoveryRequest) error
 }, typeurl string) {
 	t.Helper()
 	err := stream.Send(&v2.DiscoveryRequest{
 		TypeUrl: typeurl,
 	})
-	check(t, err)
+	assert.NoError(t, err)
 }
 
 func checkrecv(t *testing.T, stream interface {
 	Recv() (*v2.DiscoveryResponse, error)
 }) {
 	t.Helper()
 	_, err := stream.Recv()
-	check(t, err)
+	assert.NoError(t, err)
 }
 
 func checktimeout(t *testing.T, stream interface {
 	Recv() (*v2.DiscoveryResponse, error)
 }) {
 	t.Helper()
 	_, err := stream.Recv()
-	if err == nil {
-		t.Fatal("expected timeout")
-	}
+	assert.Errorf(t, err, "expected timeout")
 	s, ok := status.FromError(err)
-	if !ok {
-		t.Fatalf("%T %v", err, err)
-	}
+	assert.True(t, ok, "Error wasn't what was expected: %T %v", err, err)
 
 	// Work around grpc/grpc-go#1645 which sometimes seems to
 	// set the status code to Unknown, even when the message is derived from context.DeadlineExceeded.

internal/dag/builder_test.go

@@ -19,8 +19,8 @@ import (
 	"time"
 
 	envoy_api_v2_auth "github.com/envoyproxy/go-control-plane/envoy/api/v2/auth"
-	"github.com/google/go-cmp/cmp"
 	projcontour "github.com/projectcontour/contour/apis/projectcontour/v1"
+	"github.com/projectcontour/contour/internal/assert"
 	"github.com/projectcontour/contour/internal/fixture"
 	"github.com/projectcontour/contour/internal/timeout"
 	v1 "k8s.io/api/core/v1"
@@ -6025,13 +6025,7 @@ func TestDAGInsert(t *testing.T) {
 					want[l.Port] = l
 				}
 			}
-			opts := []cmp.Option{
-				cmp.AllowUnexported(VirtualHost{}),
-				cmp.AllowUnexported(timeout.Setting{}),
-			}
-			if diff := cmp.Diff(want, got, opts...); diff != "" {
-				t.Fatal(diff)
-			}
+			assert.Equal(t, want, got)
 		})
 	}
 }
@@ -6129,14 +6123,8 @@ func TestBuilderLookupService(t *testing.T) {
 			b.reset()
 
 			got, gotErr := b.lookupService(tc.NamespacedName, tc.port)
-			if diff := cmp.Diff(tc.want, got); diff != "" {
-				t.Fatal(diff)
-			}
-			if (tc.wantErr != nil) != (gotErr != nil) {
-				t.Errorf("got err = %v, wanted %v", gotErr, tc.wantErr)
-			} else if tc.wantErr != nil && gotErr != nil && tc.wantErr.Error() != gotErr.Error() {
-				t.Errorf("got err = %v, wanted %v", gotErr, tc.wantErr)
-			}
+			assert.Equal(t, tc.want, got)
+			assert.Equal(t, tc.wantErr, gotErr)
 		})
 	}
 }
@@ -6423,9 +6411,7 @@ func TestHttpPaths(t *testing.T) {
 	for name, tc := range tests {
 		t.Run(name, func(t *testing.T) {
 			got := httppaths(tc.rule)
-			if diff := cmp.Diff(tc.want, got); diff != "" {
-				t.Fatalf(diff)
-			}
+			assert.Equal(t, tc.want, got)
 		})
 	}
 }
@@ -6502,9 +6488,7 @@ func TestDetermineSNI(t *testing.T) {
 	for name, tc := range tests {
 		t.Run(name, func(t *testing.T) {
 			got := determineSNI(tc.routeRequestHeaders, tc.clusterRequestHeaders, tc.service)
-			if diff := cmp.Diff(tc.want, got); diff != "" {
-				t.Fatalf(diff)
-			}
+			assert.Equal(t, tc.want, got)
 		})
 	}
 }
@@ -6540,9 +6524,7 @@ func TestEnforceRoute(t *testing.T) {
 	for name, tc := range tests {
 		t.Run(name, func(t *testing.T) {
 			got := routeEnforceTLS(tc.tlsEnabled, tc.permitInsecure)
-			if diff := cmp.Diff(tc.want, got); diff != "" {
-				t.Fatalf(diff)
-			}
+			assert.Equal(t, tc.want, got)
 		})
 	}
 }
@@ -6642,14 +6624,8 @@ func TestValidateHeaderAlteration(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			got, gotErr := headersPolicy(test.in, false)
-			if !cmp.Equal(test.want, got) {
-				t.Errorf("set (-want, +got) = %s", cmp.Diff(test.want, got))
-			}
-			if (test.wantErr != nil) != (gotErr != nil) {
-				t.Errorf("err = %v, wanted %v", gotErr, test.wantErr)
-			} else if test.wantErr != nil && gotErr != nil && test.wantErr.Error() != gotErr.Error() {
-				t.Errorf("err = %v, wanted %v", gotErr, test.wantErr)
-			}
+			assert.Equal(t, test.want, got)
+			assert.Equal(t, test.wantErr, gotErr)
 		})
 	}
 }

internal/dag/cache_test.go

@@ -19,6 +19,7 @@ import (
 	projcontour "github.com/projectcontour/contour/apis/projectcontour/v1"
 	projectcontourv1alpha1 "github.com/projectcontour/contour/apis/projectcontour/v1alpha1"
 	"github.com/projectcontour/contour/internal/annotation"
+	"github.com/projectcontour/contour/internal/assert"
 	"github.com/projectcontour/contour/internal/fixture"
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/api/networking/v1beta1"
@@ -742,9 +743,7 @@ func TestKubernetesCacheInsert(t *testing.T) {
 				cache.Insert(p)
 			}
 			got := cache.Insert(tc.obj)
-			if tc.want != got {
-				t.Fatalf("Insert(%v): expected %v, got %v", tc.obj, tc.want, got)
-			}
+			assert.Equal(t, tc.want, got)
 		})
 	}
 }
@@ -952,9 +951,7 @@ func TestKubernetesCacheRemove(t *testing.T) {
 	for name, tc := range tests {
 		t.Run(name, func(t *testing.T) {
 			got := tc.cache.Remove(tc.obj)
-			if tc.want != got {
-				t.Fatalf("Remove(%v): expected %v, got %v", tc.obj, tc.want, got)
-			}
+			assert.Equal(t, tc.want, got)
 		})
 	}
 }

internal/envoy/auth_test.go

@@ -19,7 +19,7 @@ import (
 	envoy_api_v2_auth "github.com/envoyproxy/go-control-plane/envoy/api/v2/auth"
 	envoy_api_v2_core "github.com/envoyproxy/go-control-plane/envoy/api/v2/core"
 	matcher "github.com/envoyproxy/go-control-plane/envoy/type/matcher"
-	"github.com/google/go-cmp/cmp"
+	"github.com/projectcontour/contour/internal/assert"
 	"github.com/projectcontour/contour/internal/dag"
 	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -108,9 +108,7 @@ func TestUpstreamTLSContext(t *testing.T) {
 	for name, tc := range tests {
 		t.Run(name, func(t *testing.T) {
 			got := UpstreamTLSContext(tc.validation, tc.externalName, tc.alpnProtocols...)
-			if diff := cmp.Diff(tc.want, got); diff != "" {
-				t.Fatal(diff)
-			}
+			assert.EqualProto(t, tc.want, got)
 		})
 	}
 }

internal/envoy/endpoint_test.go

@@ -18,7 +18,7 @@ import (
 
 	v2 "github.com/envoyproxy/go-control-plane/envoy/api/v2"
 	envoy_api_v2_endpoint "github.com/envoyproxy/go-control-plane/envoy/api/v2/endpoint"
-	"github.com/google/go-cmp/cmp"
+	"github.com/projectcontour/contour/internal/assert"
 )
 
 func TestLBEndpoint(t *testing.T) {
@@ -30,9 +30,7 @@ func TestLBEndpoint(t *testing.T) {
 			},
 		},
 	}
-	if diff := cmp.Diff(want, got); diff != "" {
-		t.Fatal(diff)
-	}
+	assert.EqualProto(t, want, got)
 }
 
 func TestEndpoints(t *testing.T) {
@@ -55,9 +53,7 @@ func TestEndpoints(t *testing.T) {
 			},
 		}},
 	}}
-	if diff := cmp.Diff(want, got); diff != "" {
-		t.Fatal(diff)
-	}
+	assert.EqualProto(t, want, got)
 }
 
 func TestClusterLoadAssignment(t *testing.T) {
@@ -66,19 +62,15 @@ func TestClusterLoadAssignment(t *testing.T) {
 		ClusterName: "empty",
 	}
 
-	if diff := cmp.Diff(want, got); diff != "" {
-		t.Fatal(diff)
-	}
+	assert.EqualProto(t, want, got)
 
 	got = ClusterLoadAssignment("one addr", SocketAddress("microsoft.com", 81))
 	want = &v2.ClusterLoadAssignment{
 		ClusterName: "one addr",
 		Endpoints:   Endpoints(SocketAddress("microsoft.com", 81)),
 	}
 
-	if diff := cmp.Diff(want, got); diff != "" {
-		t.Fatal(diff)
-	}
+	assert.EqualProto(t, want, got)
 
 	got = ClusterLoadAssignment("two addrs",
 		SocketAddress("microsoft.com", 81),
@@ -92,7 +84,5 @@ func TestClusterLoadAssignment(t *testing.T) {
 		),
 	}
 
-	if diff := cmp.Diff(want, got); diff != "" {
-		t.Fatal(diff)
-	}
+	assert.EqualProto(t, want, got)
 }