Merge pull request #76066 from SataQiu/golint-test-20190403

hack/.golint_failures

@@ -632,7 +632,6 @@ staging/src/k8s.io/sample-apiserver/pkg/registry/wardle/flunder
 staging/src/k8s.io/sample-controller/pkg/apis/samplecontroller
 staging/src/k8s.io/sample-controller/pkg/apis/samplecontroller/v1alpha1
 test/e2e
-test/e2e/apimachinery
 test/e2e/apps
 test/e2e/auth
 test/e2e/autoscaling

test/e2e/apimachinery/aggregator.go

@@ -44,7 +44,7 @@ import (
 	samplev1alpha1 "k8s.io/sample-apiserver/pkg/apis/wardle/v1alpha1"
 	"k8s.io/utils/pointer"
 
-	. "github.com/onsi/ginkgo"
+	"github.com/onsi/ginkgo"
 )
 
 var serverAggregatorVersion = utilversion.MustParseSemantic("v1.10.0")
@@ -62,7 +62,7 @@ var _ = SIGDescribe("Aggregator", func() {
 	// We want cleanTest to happen before the namespace cleanup AfterEach
 	// inserted by NewDefaultFramework, so we put this AfterEach in front
 	// of NewDefaultFramework.
-	AfterEach(func() {
+	ginkgo.AfterEach(func() {
 		cleanTest(c, aggrclient, ns)
 	})
 
@@ -71,7 +71,7 @@ var _ = SIGDescribe("Aggregator", func() {
 	// We want namespace initialization BeforeEach inserted by
 	// NewDefaultFramework to happen before this, so we put this BeforeEach
 	// after NewDefaultFramework.
-	BeforeEach(func() {
+	ginkgo.BeforeEach(func() {
 		c = f.ClientSet
 		ns = f.Namespace.Name
 		aggrclient = f.AggregatorClient
@@ -102,10 +102,10 @@ func cleanTest(client clientset.Interface, aggrclient *aggregatorclient.Clientse
 	_ = client.RbacV1beta1().ClusterRoleBindings().Delete("wardler:"+namespace+":sample-apiserver-reader", nil)
 }
 
-// A basic test if the sample-apiserver code from 1.10 and compiled against 1.10
+// TestSampleAPIServer is a basic test if the sample-apiserver code from 1.10 and compiled against 1.10
 // will work on the current Aggregator/API-Server.
 func TestSampleAPIServer(f *framework.Framework, image string) {
-	By("Registering the sample API server.")
+	ginkgo.By("Registering the sample API server.")
 	client := f.ClientSet
 	restClient := client.Discovery().RESTClient()
 	aggrclient := f.AggregatorClient

test/e2e/apimachinery/chunking.go

@@ -23,8 +23,8 @@ import (
 	"reflect"
 	"time"
 
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
+	"github.com/onsi/ginkgo"
+	"github.com/onsi/gomega"
 
 	"k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
@@ -40,11 +40,11 @@ const numberOfTotalResources = 400
 var _ = SIGDescribe("Servers with support for API chunking", func() {
 	f := framework.NewDefaultFramework("chunking")
 
-	BeforeEach(func() {
+	ginkgo.BeforeEach(func() {
 		ns := f.Namespace.Name
 		c := f.ClientSet
 		client := c.CoreV1().PodTemplates(ns)
-		By("creating a large number of resources")
+		ginkgo.By("creating a large number of resources")
 		workqueue.ParallelizeUntil(context.TODO(), 20, numberOfTotalResources, func(i int) {
 			for tries := 3; tries >= 0; tries-- {
 				_, err := client.Create(&v1.PodTemplate{
@@ -64,15 +64,15 @@ var _ = SIGDescribe("Servers with support for API chunking", func() {
 				}
 				framework.Logf("Got an error creating template %d: %v", i, err)
 			}
-			Fail("Unable to create template %d, exiting", i)
+			ginkgo.Fail("Unable to create template %d, exiting", i)
 		})
 	})
 
-	It("should return chunks of results for list calls", func() {
+	ginkgo.It("should return chunks of results for list calls", func() {
 		ns := f.Namespace.Name
 		c := f.ClientSet
 		client := c.CoreV1().PodTemplates(ns)
-		By("retrieving those results in paged fashion several times")
+		ginkgo.By("retrieving those results in paged fashion several times")
 		for i := 0; i < 3; i++ {
 			opts := metav1.ListOptions{}
 			found := 0
@@ -80,16 +80,16 @@ var _ = SIGDescribe("Servers with support for API chunking", func() {
 			for {
 				opts.Limit = int64(rand.Int31n(numberOfTotalResources/10) + 1)
 				list, err := client.List(opts)
-				Expect(err).ToNot(HaveOccurred(), "failed to list pod templates in namespace: %s, given limit: %d", ns, opts.Limit)
+				gomega.Expect(err).ToNot(gomega.HaveOccurred(), "failed to list pod templates in namespace: %s, given limit: %d", ns, opts.Limit)
 				framework.Logf("Retrieved %d/%d results with rv %s and continue %s", len(list.Items), opts.Limit, list.ResourceVersion, list.Continue)
-				Expect(len(list.Items)).To(BeNumerically("<=", opts.Limit))
+				gomega.Expect(len(list.Items)).To(gomega.BeNumerically("<=", opts.Limit))
 
 				if len(lastRV) == 0 {
 					lastRV = list.ResourceVersion
 				}
-				Expect(list.ResourceVersion).To(Equal(lastRV))
+				gomega.Expect(list.ResourceVersion).To(gomega.Equal(lastRV))
 				for _, item := range list.Items {
-					Expect(item.Name).To(Equal(fmt.Sprintf("template-%04d", found)))
+					gomega.Expect(item.Name).To(gomega.Equal(fmt.Sprintf("template-%04d", found)))
 					found++
 				}
 				if len(list.Continue) == 0 {
@@ -97,32 +97,32 @@ var _ = SIGDescribe("Servers with support for API chunking", func() {
 				}
 				opts.Continue = list.Continue
 			}
-			Expect(found).To(BeNumerically("==", numberOfTotalResources))
+			gomega.Expect(found).To(gomega.BeNumerically("==", numberOfTotalResources))
 		}
 
-		By("retrieving those results all at once")
+		ginkgo.By("retrieving those results all at once")
 		opts := metav1.ListOptions{Limit: numberOfTotalResources + 1}
 		list, err := client.List(opts)
-		Expect(err).ToNot(HaveOccurred(), "failed to list pod templates in namespace: %s, given limit: %d", ns, opts.Limit)
-		Expect(list.Items).To(HaveLen(numberOfTotalResources))
+		gomega.Expect(err).ToNot(gomega.HaveOccurred(), "failed to list pod templates in namespace: %s, given limit: %d", ns, opts.Limit)
+		gomega.Expect(list.Items).To(gomega.HaveLen(numberOfTotalResources))
 	})
 
-	It("should support continue listing from the last key if the original version has been compacted away, though the list is inconsistent", func() {
+	ginkgo.It("should support continue listing from the last key if the original version has been compacted away, though the list is inconsistent", func() {
 		ns := f.Namespace.Name
 		c := f.ClientSet
 		client := c.CoreV1().PodTemplates(ns)
 
-		By("retrieving the first page")
+		ginkgo.By("retrieving the first page")
 		oneTenth := int64(numberOfTotalResources / 10)
 		opts := metav1.ListOptions{}
 		opts.Limit = oneTenth
 		list, err := client.List(opts)
-		Expect(err).ToNot(HaveOccurred(), "failed to list pod templates in namespace: %s, given limit: %d", ns, opts.Limit)
+		gomega.Expect(err).ToNot(gomega.HaveOccurred(), "failed to list pod templates in namespace: %s, given limit: %d", ns, opts.Limit)
 		firstToken := list.Continue
 		firstRV := list.ResourceVersion
 		framework.Logf("Retrieved %d/%d results with rv %s and continue %s", len(list.Items), opts.Limit, list.ResourceVersion, firstToken)
 
-		By("retrieving the second page until the token expires")
+		ginkgo.By("retrieving the second page until the token expires")
 		opts.Continue = firstToken
 		var inconsistentToken string
 		wait.Poll(20*time.Second, 2*storagebackend.DefaultCompactInterval, func() (bool, error) {
@@ -147,29 +147,29 @@ var _ = SIGDescribe("Servers with support for API chunking", func() {
 			return true, nil
 		})
 
-		By("retrieving the second page again with the token received with the error message")
+		ginkgo.By("retrieving the second page again with the token received with the error message")
 		opts.Continue = inconsistentToken
 		list, err = client.List(opts)
-		Expect(err).ToNot(HaveOccurred(), "failed to list pod templates in namespace: %s, given inconsistent continue token %s and limit: %d", ns, opts.Continue, opts.Limit)
-		Expect(list.ResourceVersion).ToNot(Equal(firstRV))
-		Expect(len(list.Items)).To(BeNumerically("==", opts.Limit))
+		gomega.Expect(err).ToNot(gomega.HaveOccurred(), "failed to list pod templates in namespace: %s, given inconsistent continue token %s and limit: %d", ns, opts.Continue, opts.Limit)
+		gomega.Expect(list.ResourceVersion).ToNot(gomega.Equal(firstRV))
+		gomega.Expect(len(list.Items)).To(gomega.BeNumerically("==", opts.Limit))
 		found := oneTenth
 		for _, item := range list.Items {
-			Expect(item.Name).To(Equal(fmt.Sprintf("template-%04d", found)))
+			gomega.Expect(item.Name).To(gomega.Equal(fmt.Sprintf("template-%04d", found)))
 			found++
 		}
 
-		By("retrieving all remaining pages")
+		ginkgo.By("retrieving all remaining pages")
 		opts.Continue = list.Continue
 		lastRV := list.ResourceVersion
 		for {
 			list, err := client.List(opts)
-			Expect(err).ToNot(HaveOccurred(), "failed to list pod templates in namespace: %s, given limit: %d", ns, opts.Limit)
+			gomega.Expect(err).ToNot(gomega.HaveOccurred(), "failed to list pod templates in namespace: %s, given limit: %d", ns, opts.Limit)
 			framework.Logf("Retrieved %d/%d results with rv %s and continue %s", len(list.Items), opts.Limit, list.ResourceVersion, list.Continue)
-			Expect(len(list.Items)).To(BeNumerically("<=", opts.Limit))
-			Expect(list.ResourceVersion).To(Equal(lastRV))
+			gomega.Expect(len(list.Items)).To(gomega.BeNumerically("<=", opts.Limit))
+			gomega.Expect(list.ResourceVersion).To(gomega.Equal(lastRV))
 			for _, item := range list.Items {
-				Expect(item.Name).To(Equal(fmt.Sprintf("template-%04d", found)))
+				gomega.Expect(item.Name).To(gomega.Equal(fmt.Sprintf("template-%04d", found)))
 				found++
 			}
 			if len(list.Continue) == 0 {
@@ -177,6 +177,6 @@ var _ = SIGDescribe("Servers with support for API chunking", func() {
 			}
 			opts.Continue = list.Continue
 		}
-		Expect(found).To(BeNumerically("==", numberOfTotalResources))
+		gomega.Expect(found).To(gomega.BeNumerically("==", numberOfTotalResources))
 	})
 })

test/e2e/apimachinery/crd_watch.go

@@ -30,21 +30,21 @@ import (
 	"k8s.io/client-go/dynamic"
 	"k8s.io/kubernetes/test/e2e/framework"
 
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
+	"github.com/onsi/ginkgo"
+	"github.com/onsi/gomega"
 )
 
 var _ = SIGDescribe("CustomResourceDefinition Watch", func() {
 
 	f := framework.NewDefaultFramework("crd-watch")
 
-	Context("CustomResourceDefinition Watch", func() {
+	ginkgo.Context("CustomResourceDefinition Watch", func() {
 		/*
 			   	   Testname: crd-watch
 			   	   Description: Create a Custom Resource Definition and make sure
 				   watches observe events on create/delete.
 		*/
-		It("watch on custom resource definition objects", func() {
+		ginkgo.It("watch on custom resource definition objects", func() {
 
 			framework.SkipUnlessServerVersionGTE(crdVersion, f.ClientSet.Discovery())
 
@@ -80,35 +80,35 @@ var _ = SIGDescribe("CustomResourceDefinition Watch", func() {
 			noxuResourceClient := newNamespacedCustomResourceClient(ns, f.DynamicClient, noxuDefinition)
 
 			watchA, err := watchCRWithName(noxuResourceClient, watchCRNameA)
-			Expect(err).NotTo(HaveOccurred(), "failed to watch custom resource: %s", watchCRNameA)
+			gomega.Expect(err).NotTo(gomega.HaveOccurred(), "failed to watch custom resource: %s", watchCRNameA)
 
 			watchB, err := watchCRWithName(noxuResourceClient, watchCRNameB)
-			Expect(err).NotTo(HaveOccurred(), "failed to watch custom resource: %s", watchCRNameB)
+			gomega.Expect(err).NotTo(gomega.HaveOccurred(), "failed to watch custom resource: %s", watchCRNameB)
 
 			testCrA := fixtures.NewNoxuInstance(ns, watchCRNameA)
 			testCrB := fixtures.NewNoxuInstance(ns, watchCRNameB)
 
-			By("Creating first CR ")
+			ginkgo.By("Creating first CR ")
 			testCrA, err = instantiateCustomResource(testCrA, noxuResourceClient, noxuDefinition)
-			Expect(err).NotTo(HaveOccurred(), "failed to instantiate custom resource: %+v", testCrA)
+			gomega.Expect(err).NotTo(gomega.HaveOccurred(), "failed to instantiate custom resource: %+v", testCrA)
 			expectEvent(watchA, watch.Added, testCrA)
 			expectNoEvent(watchB, watch.Added, testCrA)
 
-			By("Creating second CR")
+			ginkgo.By("Creating second CR")
 			testCrB, err = instantiateCustomResource(testCrB, noxuResourceClient, noxuDefinition)
-			Expect(err).NotTo(HaveOccurred(), "failed to instantiate custom resource: %+v", testCrB)
+			gomega.Expect(err).NotTo(gomega.HaveOccurred(), "failed to instantiate custom resource: %+v", testCrB)
 			expectEvent(watchB, watch.Added, testCrB)
 			expectNoEvent(watchA, watch.Added, testCrB)
 
-			By("Deleting first CR")
+			ginkgo.By("Deleting first CR")
 			err = deleteCustomResource(noxuResourceClient, watchCRNameA)
-			Expect(err).NotTo(HaveOccurred(), "failed to delete custom resource: %s", watchCRNameA)
+			gomega.Expect(err).NotTo(gomega.HaveOccurred(), "failed to delete custom resource: %s", watchCRNameA)
 			expectEvent(watchA, watch.Deleted, nil)
 			expectNoEvent(watchB, watch.Deleted, nil)
 
-			By("Deleting second CR")
+			ginkgo.By("Deleting second CR")
 			err = deleteCustomResource(noxuResourceClient, watchCRNameB)
-			Expect(err).NotTo(HaveOccurred(), "failed to delete custom resource: %s", watchCRNameB)
+			gomega.Expect(err).NotTo(gomega.HaveOccurred(), "failed to delete custom resource: %s", watchCRNameB)
 			expectEvent(watchB, watch.Deleted, nil)
 			expectNoEvent(watchA, watch.Deleted, nil)
 		})
@@ -159,8 +159,7 @@ func newNamespacedCustomResourceClient(ns string, client dynamic.Interface, crd
 
 	if crd.Spec.Scope != apiextensionsv1beta1.ClusterScoped {
 		return client.Resource(gvr).Namespace(ns)
-	} else {
-		return client.Resource(gvr)
 	}
+	return client.Resource(gvr)
 
 }

test/e2e/apimachinery/custom_resource_definition.go

@@ -23,7 +23,7 @@ import (
 	utilversion "k8s.io/apimachinery/pkg/util/version"
 	"k8s.io/kubernetes/test/e2e/framework"
 
-	. "github.com/onsi/ginkgo"
+	"github.com/onsi/ginkgo"
 )
 
 var crdVersion = utilversion.MustParseSemantic("v1.7.0")
@@ -32,7 +32,7 @@ var _ = SIGDescribe("CustomResourceDefinition resources", func() {
 
 	f := framework.NewDefaultFramework("custom-resource-definition")
 
-	Context("Simple CustomResourceDefinition", func() {
+	ginkgo.Context("Simple CustomResourceDefinition", func() {
 		/*
 			Release : v1.9
 			Testname: Custom Resource Definition, create

test/e2e/apimachinery/discovery.go

@@ -22,7 +22,7 @@ import (
 	"k8s.io/kubernetes/test/e2e/framework"
 	"k8s.io/kubernetes/test/utils/crd"
 
-	. "github.com/onsi/ginkgo"
+	"github.com/onsi/ginkgo"
 )
 
 var storageVersionServerVersion = utilversion.MustParseSemantic("v1.13.99")
@@ -31,16 +31,16 @@ var _ = SIGDescribe("Discovery", func() {
 
 	var namespaceName string
 
-	BeforeEach(func() {
+	ginkgo.BeforeEach(func() {
 		namespaceName = f.Namespace.Name
 
 		framework.SkipUnlessServerVersionGTE(storageVersionServerVersion, f.ClientSet.Discovery())
 
-		By("Setting up server cert")
+		ginkgo.By("Setting up server cert")
 		setupServerCert(namespaceName, serviceName)
 	})
 
-	It("[Feature:StorageVersionHash] Custom resource should have storage version hash", func() {
+	ginkgo.It("[Feature:StorageVersionHash] Custom resource should have storage version hash", func() {
 		testcrd, err := crd.CreateTestCRD(f)
 		if err != nil {
 			return

test/e2e/apimachinery/etcd_failure.go

@@ -28,15 +28,15 @@ import (
 	testutils "k8s.io/kubernetes/test/utils"
 	imageutils "k8s.io/kubernetes/test/utils/image"
 
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
+	"github.com/onsi/ginkgo"
+	"github.com/onsi/gomega"
 )
 
 var _ = SIGDescribe("Etcd failure [Disruptive]", func() {
 
 	f := framework.NewDefaultFramework("etcd-failure")
 
-	BeforeEach(func() {
+	ginkgo.BeforeEach(func() {
 		// This test requires:
 		// - SSH
 		// - master access
@@ -44,16 +44,16 @@ var _ = SIGDescribe("Etcd failure [Disruptive]", func() {
 		// providers that provide those capabilities.
 		framework.SkipUnlessProviderIs("gce")
 
-		Expect(framework.RunRC(testutils.RCConfig{
+		gomega.Expect(framework.RunRC(testutils.RCConfig{
 			Client:    f.ClientSet,
 			Name:      "baz",
 			Namespace: f.Namespace.Name,
 			Image:     imageutils.GetPauseImageName(),
 			Replicas:  1,
-		})).NotTo(HaveOccurred())
+		})).NotTo(gomega.HaveOccurred())
 	})
 
-	It("should recover from network partition with master", func() {
+	ginkgo.It("should recover from network partition with master", func() {
 		etcdFailTest(
 			f,
 			"sudo iptables -A INPUT -p tcp --destination-port 2379 -j DROP",
@@ -61,7 +61,7 @@ var _ = SIGDescribe("Etcd failure [Disruptive]", func() {
 		)
 	})
 
-	It("should recover from SIGKILL", func() {
+	ginkgo.It("should recover from SIGKILL", func() {
 		etcdFailTest(
 			f,
 			"pgrep etcd | xargs -I {} sudo kill -9 {}",
@@ -86,7 +86,7 @@ func etcdFailTest(f *framework.Framework, failCommand, fixCommand string) {
 const etcdFailureDuration = 20 * time.Second
 
 func doEtcdFailure(failCommand, fixCommand string) {
-	By("failing etcd")
+	ginkgo.By("failing etcd")
 
 	masterExec(failCommand)
 	time.Sleep(etcdFailureDuration)
@@ -96,7 +96,7 @@ func doEtcdFailure(failCommand, fixCommand string) {
 func masterExec(cmd string) {
 	host := framework.GetMasterHost() + ":22"
 	result, err := framework.SSH(cmd, host, framework.TestContext.Provider)
-	Expect(err).NotTo(HaveOccurred(), "failed to SSH to host %s on provider %s and run command: %q", host, framework.TestContext.Provider, cmd)
+	gomega.Expect(err).NotTo(gomega.HaveOccurred(), "failed to SSH to host %s on provider %s and run command: %q", host, framework.TestContext.Provider, cmd)
 	if result.Code != 0 {
 		framework.LogSSHResult(result)
 		framework.Failf("master exec command returned non-zero")
@@ -104,11 +104,11 @@ func masterExec(cmd string) {
 }
 
 func checkExistingRCRecovers(f *framework.Framework) {
-	By("assert that the pre-existing replication controller recovers")
+	ginkgo.By("assert that the pre-existing replication controller recovers")
 	podClient := f.ClientSet.CoreV1().Pods(f.Namespace.Name)
 	rcSelector := labels.Set{"name": "baz"}.AsSelector()
 
-	By("deleting pods from existing replication controller")
+	ginkgo.By("deleting pods from existing replication controller")
 	framework.ExpectNoError(wait.Poll(time.Millisecond*500, time.Second*60, func() (bool, error) {
 		options := metav1.ListOptions{LabelSelector: rcSelector.String()}
 		pods, err := podClient.List(options)
@@ -121,17 +121,17 @@ func checkExistingRCRecovers(f *framework.Framework) {
 		}
 		for _, pod := range pods.Items {
 			err = podClient.Delete(pod.Name, metav1.NewDeleteOptions(0))
-			Expect(err).NotTo(HaveOccurred(), "failed to delete pod %s in namespace: %s", pod.Name, f.Namespace.Name)
+			gomega.Expect(err).NotTo(gomega.HaveOccurred(), "failed to delete pod %s in namespace: %s", pod.Name, f.Namespace.Name)
 		}
 		framework.Logf("apiserver has recovered")
 		return true, nil
 	}))
 
-	By("waiting for replication controller to recover")
+	ginkgo.By("waiting for replication controller to recover")
 	framework.ExpectNoError(wait.Poll(time.Millisecond*500, time.Second*60, func() (bool, error) {
 		options := metav1.ListOptions{LabelSelector: rcSelector.String()}
 		pods, err := podClient.List(options)
-		Expect(err).NotTo(HaveOccurred(), "failed to list pods in namespace: %s, that match label selector: %s", f.Namespace.Name, rcSelector.String())
+		gomega.Expect(err).NotTo(gomega.HaveOccurred(), "failed to list pods in namespace: %s, that match label selector: %s", f.Namespace.Name, rcSelector.String())
 		for _, pod := range pods.Items {
 			if pod.DeletionTimestamp == nil && podutil.IsPodReady(&pod) {
 				return true, nil

test/e2e/apimachinery/framework.go

@@ -18,6 +18,7 @@ package apimachinery
 
 import "github.com/onsi/ginkgo"
 
+// SIGDescribe annotates the test with the SIG label.
 func SIGDescribe(text string, body func()) bool {
 	return ginkgo.Describe("[sig-api-machinery] "+text, body)
 }

test/e2e/apimachinery/generated_clientset.go

@@ -31,8 +31,8 @@ import (
 	"k8s.io/apimachinery/pkg/watch"
 	"k8s.io/kubernetes/test/e2e/framework"
 
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
+	"github.com/onsi/ginkgo"
+	"github.com/onsi/gomega"
 	imageutils "k8s.io/kubernetes/test/utils/image"
 )
 
@@ -150,21 +150,21 @@ func observerUpdate(w watch.Interface, expectedUpdate func(runtime.Object) bool)
 
 var _ = SIGDescribe("Generated clientset", func() {
 	f := framework.NewDefaultFramework("clientset")
-	It("should create pods, set the deletionTimestamp and deletionGracePeriodSeconds of the pod", func() {
+	ginkgo.It("should create pods, set the deletionTimestamp and deletionGracePeriodSeconds of the pod", func() {
 		podClient := f.ClientSet.CoreV1().Pods(f.Namespace.Name)
-		By("constructing the pod")
+		ginkgo.By("constructing the pod")
 		name := "pod" + string(uuid.NewUUID())
 		value := strconv.Itoa(time.Now().Nanosecond())
 		podCopy := testingPod(name, value)
 		pod := &podCopy
-		By("setting up watch")
+		ginkgo.By("setting up watch")
 		selector := labels.SelectorFromSet(labels.Set(map[string]string{"time": value})).String()
 		options := metav1.ListOptions{LabelSelector: selector}
 		pods, err := podClient.List(options)
 		if err != nil {
 			framework.Failf("Failed to query for pods: %v", err)
 		}
-		Expect(len(pods.Items)).To(Equal(0))
+		gomega.Expect(len(pods.Items)).To(gomega.Equal(0))
 		options = metav1.ListOptions{
 			LabelSelector:   selector,
 			ResourceVersion: pods.ListMeta.ResourceVersion,
@@ -174,13 +174,13 @@ var _ = SIGDescribe("Generated clientset", func() {
 			framework.Failf("Failed to set up watch: %v", err)
 		}
 
-		By("creating the pod")
+		ginkgo.By("creating the pod")
 		pod, err = podClient.Create(pod)
 		if err != nil {
 			framework.Failf("Failed to create pod: %v", err)
 		}
 
-		By("verifying the pod is in kubernetes")
+		ginkgo.By("verifying the pod is in kubernetes")
 		options = metav1.ListOptions{
 			LabelSelector:   selector,
 			ResourceVersion: pod.ResourceVersion,
@@ -189,22 +189,22 @@ var _ = SIGDescribe("Generated clientset", func() {
 		if err != nil {
 			framework.Failf("Failed to query for pods: %v", err)
 		}
-		Expect(len(pods.Items)).To(Equal(1))
+		gomega.Expect(len(pods.Items)).To(gomega.Equal(1))
 
-		By("verifying pod creation was observed")
+		ginkgo.By("verifying pod creation was observed")
 		observeCreation(w)
 
 		// We need to wait for the pod to be scheduled, otherwise the deletion
 		// will be carried out immediately rather than gracefully.
 		framework.ExpectNoError(f.WaitForPodRunning(pod.Name))
 
-		By("deleting the pod gracefully")
+		ginkgo.By("deleting the pod gracefully")
 		gracePeriod := int64(31)
 		if err := podClient.Delete(pod.Name, metav1.NewDeleteOptions(gracePeriod)); err != nil {
 			framework.Failf("Failed to delete pod: %v", err)
 		}
 
-		By("verifying the deletionTimestamp and deletionGracePeriodSeconds of the pod is set")
+		ginkgo.By("verifying the deletionTimestamp and deletionGracePeriodSeconds of the pod is set")
 		observerUpdate(w, func(obj runtime.Object) bool {
 			pod := obj.(*v1.Pod)
 			return pod.ObjectMeta.DeletionTimestamp != nil && *pod.ObjectMeta.DeletionGracePeriodSeconds == gracePeriod
@@ -263,24 +263,24 @@ func newTestingCronJob(name string, value string) *batchv1beta1.CronJob {
 var _ = SIGDescribe("Generated clientset", func() {
 	f := framework.NewDefaultFramework("clientset")
 
-	BeforeEach(func() {
+	ginkgo.BeforeEach(func() {
 		framework.SkipIfMissingResource(f.DynamicClient, CronJobGroupVersionResource, f.Namespace.Name)
 	})
 
-	It("should create v1beta1 cronJobs, delete cronJobs, watch cronJobs", func() {
+	ginkgo.It("should create v1beta1 cronJobs, delete cronJobs, watch cronJobs", func() {
 		cronJobClient := f.ClientSet.BatchV1beta1().CronJobs(f.Namespace.Name)
-		By("constructing the cronJob")
+		ginkgo.By("constructing the cronJob")
 		name := "cronjob" + string(uuid.NewUUID())
 		value := strconv.Itoa(time.Now().Nanosecond())
 		cronJob := newTestingCronJob(name, value)
-		By("setting up watch")
+		ginkgo.By("setting up watch")
 		selector := labels.SelectorFromSet(labels.Set(map[string]string{"time": value})).String()
 		options := metav1.ListOptions{LabelSelector: selector}
 		cronJobs, err := cronJobClient.List(options)
 		if err != nil {
 			framework.Failf("Failed to query for cronJobs: %v", err)
 		}
-		Expect(len(cronJobs.Items)).To(Equal(0))
+		gomega.Expect(len(cronJobs.Items)).To(gomega.Equal(0))
 		options = metav1.ListOptions{
 			LabelSelector:   selector,
 			ResourceVersion: cronJobs.ListMeta.ResourceVersion,
@@ -290,13 +290,13 @@ var _ = SIGDescribe("Generated clientset", func() {
 			framework.Failf("Failed to set up watch: %v", err)
 		}
 
-		By("creating the cronJob")
+		ginkgo.By("creating the cronJob")
 		cronJob, err = cronJobClient.Create(cronJob)
 		if err != nil {
 			framework.Failf("Failed to create cronJob: %v", err)
 		}
 
-		By("verifying the cronJob is in kubernetes")
+		ginkgo.By("verifying the cronJob is in kubernetes")
 		options = metav1.ListOptions{
 			LabelSelector:   selector,
 			ResourceVersion: cronJob.ResourceVersion,
@@ -305,12 +305,12 @@ var _ = SIGDescribe("Generated clientset", func() {
 		if err != nil {
 			framework.Failf("Failed to query for cronJobs: %v", err)
 		}
-		Expect(len(cronJobs.Items)).To(Equal(1))
+		gomega.Expect(len(cronJobs.Items)).To(gomega.Equal(1))
 
-		By("verifying cronJob creation was observed")
+		ginkgo.By("verifying cronJob creation was observed")
 		observeCreation(w)
 
-		By("deleting the cronJob")
+		ginkgo.By("deleting the cronJob")
 		// Use DeletePropagationBackground so the CronJob is really gone when the call returns.
 		propagationPolicy := metav1.DeletePropagationBackground
 		if err := cronJobClient.Delete(cronJob.Name, &metav1.DeleteOptions{PropagationPolicy: &propagationPolicy}); err != nil {
@@ -322,6 +322,6 @@ var _ = SIGDescribe("Generated clientset", func() {
 		if err != nil {
 			framework.Failf("Failed to list cronJobs to verify deletion: %v", err)
 		}
-		Expect(len(cronJobs.Items)).To(Equal(0))
+		gomega.Expect(len(cronJobs.Items)).To(gomega.Equal(0))
 	})
 })

test/e2e/apimachinery/namespace.go

@@ -31,36 +31,36 @@ import (
 	"k8s.io/kubernetes/test/e2e/framework"
 	imageutils "k8s.io/kubernetes/test/utils/image"
 
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
+	"github.com/onsi/ginkgo"
+	"github.com/onsi/gomega"
 )
 
 func extinguish(f *framework.Framework, totalNS int, maxAllowedAfterDel int, maxSeconds int) {
 	var err error
 
-	By("Creating testing namespaces")
+	ginkgo.By("Creating testing namespaces")
 	wg := &sync.WaitGroup{}
 	wg.Add(totalNS)
-	for n := 0; n < totalNS; n += 1 {
+	for n := 0; n < totalNS; n++ {
 		go func(n int) {
 			defer wg.Done()
-			defer GinkgoRecover()
+			defer ginkgo.GinkgoRecover()
 			ns := fmt.Sprintf("nslifetest-%v", n)
 			_, err = f.CreateNamespace(ns, nil)
-			Expect(err).NotTo(HaveOccurred(), "failed to create namespace: %s", ns)
+			gomega.Expect(err).NotTo(gomega.HaveOccurred(), "failed to create namespace: %s", ns)
 		}(n)
 	}
 	wg.Wait()
 
 	//Wait 10 seconds, then SEND delete requests for all the namespaces.
-	By("Waiting 10 seconds")
+	ginkgo.By("Waiting 10 seconds")
 	time.Sleep(time.Duration(10 * time.Second))
 	deleteFilter := []string{"nslifetest"}
 	deleted, err := framework.DeleteNamespaces(f.ClientSet, deleteFilter, nil /* skipFilter */)
-	Expect(err).NotTo(HaveOccurred(), "failed to delete namespace(s) containing: %s", deleteFilter)
-	Expect(len(deleted)).To(Equal(totalNS))
+	gomega.Expect(err).NotTo(gomega.HaveOccurred(), "failed to delete namespace(s) containing: %s", deleteFilter)
+	gomega.Expect(len(deleted)).To(gomega.Equal(totalNS))
 
-	By("Waiting for namespaces to vanish")
+	ginkgo.By("Waiting for namespaces to vanish")
 	//Now POLL until all namespaces have been eradicated.
 	framework.ExpectNoError(wait.Poll(2*time.Second, time.Duration(maxSeconds)*time.Second,
 		func() (bool, error) {
@@ -95,21 +95,21 @@ func waitForPodInNamespace(c clientset.Interface, ns, podName string) *v1.Pod {
 		}
 		return true, nil
 	})
-	Expect(err).NotTo(HaveOccurred(), "failed to get pod %s in namespace: %s", podName, ns)
+	gomega.Expect(err).NotTo(gomega.HaveOccurred(), "failed to get pod %s in namespace: %s", podName, ns)
 	return pod
 }
 
 func ensurePodsAreRemovedWhenNamespaceIsDeleted(f *framework.Framework) {
-	By("Creating a test namespace")
+	ginkgo.By("Creating a test namespace")
 	namespaceName := "nsdeletetest"
 	namespace, err := f.CreateNamespace(namespaceName, nil)
-	Expect(err).NotTo(HaveOccurred(), "failed to create namespace: %s", namespaceName)
+	gomega.Expect(err).NotTo(gomega.HaveOccurred(), "failed to create namespace: %s", namespaceName)
 
-	By("Waiting for a default service account to be provisioned in namespace")
+	ginkgo.By("Waiting for a default service account to be provisioned in namespace")
 	err = framework.WaitForDefaultServiceAccountInNamespace(f.ClientSet, namespace.Name)
-	Expect(err).NotTo(HaveOccurred(), "failure while waiting for a default service account to be provisioned in namespace: %s", namespace.Name)
+	gomega.Expect(err).NotTo(gomega.HaveOccurred(), "failure while waiting for a default service account to be provisioned in namespace: %s", namespace.Name)
 
-	By("Creating a pod in the namespace")
+	ginkgo.By("Creating a pod in the namespace")
 	podName := "test-pod"
 	pod := &v1.Pod{
 		ObjectMeta: metav1.ObjectMeta{
@@ -125,16 +125,16 @@ func ensurePodsAreRemovedWhenNamespaceIsDeleted(f *framework.Framework) {
 		},
 	}
 	pod, err = f.ClientSet.CoreV1().Pods(namespace.Name).Create(pod)
-	Expect(err).NotTo(HaveOccurred(), "failed to create pod %s in namespace: %s", podName, namespace.Name)
+	gomega.Expect(err).NotTo(gomega.HaveOccurred(), "failed to create pod %s in namespace: %s", podName, namespace.Name)
 
-	By("Waiting for the pod to have running status")
+	ginkgo.By("Waiting for the pod to have running status")
 	framework.ExpectNoError(framework.WaitForPodRunningInNamespace(f.ClientSet, pod))
 
-	By("Deleting the namespace")
+	ginkgo.By("Deleting the namespace")
 	err = f.ClientSet.CoreV1().Namespaces().Delete(namespace.Name, nil)
-	Expect(err).NotTo(HaveOccurred(), "failed to delete namespace: %s", namespace.Name)
+	gomega.Expect(err).NotTo(gomega.HaveOccurred(), "failed to delete namespace: %s", namespace.Name)
 
-	By("Waiting for the namespace to be removed.")
+	ginkgo.By("Waiting for the namespace to be removed.")
 	maxWaitSeconds := int64(60) + *pod.Spec.TerminationGracePeriodSeconds
 	framework.ExpectNoError(wait.Poll(1*time.Second, time.Duration(maxWaitSeconds)*time.Second,
 		func() (bool, error) {
@@ -145,28 +145,28 @@ func ensurePodsAreRemovedWhenNamespaceIsDeleted(f *framework.Framework) {
 			return false, nil
 		}))
 
-	By("Recreating the namespace")
+	ginkgo.By("Recreating the namespace")
 	namespace, err = f.CreateNamespace(namespaceName, nil)
-	Expect(err).NotTo(HaveOccurred(), "failed to create namespace: %s", namespaceName)
+	gomega.Expect(err).NotTo(gomega.HaveOccurred(), "failed to create namespace: %s", namespaceName)
 
-	By("Verifying there are no pods in the namespace")
+	ginkgo.By("Verifying there are no pods in the namespace")
 	_, err = f.ClientSet.CoreV1().Pods(namespace.Name).Get(pod.Name, metav1.GetOptions{})
-	Expect(err).To(HaveOccurred(), "failed to get pod %s in namespace: %s", pod.Name, namespace.Name)
+	gomega.Expect(err).To(gomega.HaveOccurred(), "failed to get pod %s in namespace: %s", pod.Name, namespace.Name)
 }
 
 func ensureServicesAreRemovedWhenNamespaceIsDeleted(f *framework.Framework) {
 	var err error
 
-	By("Creating a test namespace")
+	ginkgo.By("Creating a test namespace")
 	namespaceName := "nsdeletetest"
 	namespace, err := f.CreateNamespace(namespaceName, nil)
-	Expect(err).NotTo(HaveOccurred(), "failed to create namespace: %s", namespaceName)
+	gomega.Expect(err).NotTo(gomega.HaveOccurred(), "failed to create namespace: %s", namespaceName)
 
-	By("Waiting for a default service account to be provisioned in namespace")
+	ginkgo.By("Waiting for a default service account to be provisioned in namespace")
 	err = framework.WaitForDefaultServiceAccountInNamespace(f.ClientSet, namespace.Name)
-	Expect(err).NotTo(HaveOccurred(), "failure while waiting for a default service account to be provisioned in namespace: %s", namespace.Name)
+	gomega.Expect(err).NotTo(gomega.HaveOccurred(), "failure while waiting for a default service account to be provisioned in namespace: %s", namespace.Name)
 
-	By("Creating a service in the namespace")
+	ginkgo.By("Creating a service in the namespace")
 	serviceName := "test-service"
 	labels := map[string]string{
 		"foo": "bar",
@@ -185,13 +185,13 @@ func ensureServicesAreRemovedWhenNamespaceIsDeleted(f *framework.Framework) {
 		},
 	}
 	service, err = f.ClientSet.CoreV1().Services(namespace.Name).Create(service)
-	Expect(err).NotTo(HaveOccurred(), "failed to create service %s in namespace %s", serviceName, namespace.Name)
+	gomega.Expect(err).NotTo(gomega.HaveOccurred(), "failed to create service %s in namespace %s", serviceName, namespace.Name)
 
-	By("Deleting the namespace")
+	ginkgo.By("Deleting the namespace")
 	err = f.ClientSet.CoreV1().Namespaces().Delete(namespace.Name, nil)
-	Expect(err).NotTo(HaveOccurred(), "failed to delete namespace: %s", namespace.Name)
+	gomega.Expect(err).NotTo(gomega.HaveOccurred(), "failed to delete namespace: %s", namespace.Name)
 
-	By("Waiting for the namespace to be removed.")
+	ginkgo.By("Waiting for the namespace to be removed.")
 	maxWaitSeconds := int64(60)
 	framework.ExpectNoError(wait.Poll(1*time.Second, time.Duration(maxWaitSeconds)*time.Second,
 		func() (bool, error) {
@@ -202,13 +202,13 @@ func ensureServicesAreRemovedWhenNamespaceIsDeleted(f *framework.Framework) {
 			return false, nil
 		}))
 
-	By("Recreating the namespace")
+	ginkgo.By("Recreating the namespace")
 	namespace, err = f.CreateNamespace(namespaceName, nil)
-	Expect(err).NotTo(HaveOccurred(), "failed to create namespace: %s", namespaceName)
+	gomega.Expect(err).NotTo(gomega.HaveOccurred(), "failed to create namespace: %s", namespaceName)
 
-	By("Verifying there is no service in the namespace")
+	ginkgo.By("Verifying there is no service in the namespace")
 	_, err = f.ClientSet.CoreV1().Services(namespace.Name).Get(service.Name, metav1.GetOptions{})
-	Expect(err).To(HaveOccurred(), "failed to get service %s in namespace: %s", service.Name, namespace.Name)
+	gomega.Expect(err).To(gomega.HaveOccurred(), "failed to get service %s in namespace: %s", service.Name, namespace.Name)
 }
 
 // This test must run [Serial] due to the impact of running other parallel
@@ -257,11 +257,11 @@ var _ = SIGDescribe("Namespaces [Serial]", func() {
 	framework.ConformanceIt("should ensure that all services are removed when a namespace is deleted",
 		func() { ensureServicesAreRemovedWhenNamespaceIsDeleted(f) })
 
-	It("should delete fast enough (90 percent of 100 namespaces in 150 seconds)",
+	ginkgo.It("should delete fast enough (90 percent of 100 namespaces in 150 seconds)",
 		func() { extinguish(f, 100, 10, 150) })
 
 	// On hold until etcd3; see #7372
-	It("should always delete fast (ALL of 100 namespaces in 150 seconds) [Feature:ComprehensiveNamespaceDraining]",
+	ginkgo.It("should always delete fast (ALL of 100 namespaces in 150 seconds) [Feature:ComprehensiveNamespaceDraining]",
 		func() { extinguish(f, 100, 0, 150) })
 
 })

test/e2e/apimachinery/table_conversion.go

@@ -22,8 +22,8 @@ import (
 	"fmt"
 	"text/tabwriter"
 
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
+	"github.com/onsi/ginkgo"
+	"github.com/onsi/gomega"
 
 	authorizationv1 "k8s.io/api/authorization/v1"
 	"k8s.io/api/core/v1"
@@ -43,11 +43,11 @@ var serverPrintVersion = utilversion.MustParseSemantic("v1.10.0")
 var _ = SIGDescribe("Servers with support for Table transformation", func() {
 	f := framework.NewDefaultFramework("tables")
 
-	BeforeEach(func() {
+	ginkgo.BeforeEach(func() {
 		framework.SkipUnlessServerVersionGTE(serverPrintVersion, f.ClientSet.Discovery())
 	})
 
-	It("should return pod details", func() {
+	ginkgo.It("should return pod details", func() {
 		ns := f.Namespace.Name
 		c := f.ClientSet
 
@@ -55,31 +55,31 @@ var _ = SIGDescribe("Servers with support for Table transformation", func() {
 		framework.Logf("Creating pod %s", podName)
 
 		_, err := c.CoreV1().Pods(ns).Create(newTablePod(podName))
-		Expect(err).NotTo(HaveOccurred(), "failed to create pod %s in namespace: %s", podName, ns)
+		gomega.Expect(err).NotTo(gomega.HaveOccurred(), "failed to create pod %s in namespace: %s", podName, ns)
 
 		table := &metav1beta1.Table{}
 		err = c.CoreV1().RESTClient().Get().Resource("pods").Namespace(ns).Name(podName).SetHeader("Accept", "application/json;as=Table;v=v1beta1;g=meta.k8s.io").Do().Into(table)
-		Expect(err).NotTo(HaveOccurred(), "failed to get pod %s in Table form in namespace: %s", podName, ns)
+		gomega.Expect(err).NotTo(gomega.HaveOccurred(), "failed to get pod %s in Table form in namespace: %s", podName, ns)
 		framework.Logf("Table: %#v", table)
 
-		Expect(len(table.ColumnDefinitions)).To(BeNumerically(">", 2))
-		Expect(len(table.Rows)).To(Equal(1))
-		Expect(len(table.Rows[0].Cells)).To(Equal(len(table.ColumnDefinitions)))
-		Expect(table.ColumnDefinitions[0].Name).To(Equal("Name"))
-		Expect(table.Rows[0].Cells[0]).To(Equal(podName))
+		gomega.Expect(len(table.ColumnDefinitions)).To(gomega.BeNumerically(">", 2))
+		gomega.Expect(len(table.Rows)).To(gomega.Equal(1))
+		gomega.Expect(len(table.Rows[0].Cells)).To(gomega.Equal(len(table.ColumnDefinitions)))
+		gomega.Expect(table.ColumnDefinitions[0].Name).To(gomega.Equal("Name"))
+		gomega.Expect(table.Rows[0].Cells[0]).To(gomega.Equal(podName))
 
 		out := printTable(table)
-		Expect(out).To(MatchRegexp("^NAME\\s"))
-		Expect(out).To(MatchRegexp("\npod-1\\s"))
+		gomega.Expect(out).To(gomega.MatchRegexp("^NAME\\s"))
+		gomega.Expect(out).To(gomega.MatchRegexp("\npod-1\\s"))
 		framework.Logf("Table:\n%s", out)
 	})
 
-	It("should return chunks of table results for list calls", func() {
+	ginkgo.It("should return chunks of table results for list calls", func() {
 		ns := f.Namespace.Name
 		c := f.ClientSet
 		client := c.CoreV1().PodTemplates(ns)
 
-		By("creating a large number of resources")
+		ginkgo.By("creating a large number of resources")
 		workqueue.ParallelizeUntil(context.TODO(), 5, 20, func(i int) {
 			for tries := 3; tries >= 0; tries-- {
 				_, err := client.Create(&v1.PodTemplate{
@@ -99,7 +99,7 @@ var _ = SIGDescribe("Servers with support for Table transformation", func() {
 				}
 				framework.Logf("Got an error creating template %d: %v", i, err)
 			}
-			Fail("Unable to create template %d, exiting", i)
+			ginkgo.Fail("Unable to create template %d, exiting", i)
 		})
 
 		pagedTable := &metav1beta1.Table{}
@@ -107,44 +107,44 @@ var _ = SIGDescribe("Servers with support for Table transformation", func() {
 			VersionedParams(&metav1.ListOptions{Limit: 2}, metav1.ParameterCodec).
 			SetHeader("Accept", "application/json;as=Table;v=v1beta1;g=meta.k8s.io").
 			Do().Into(pagedTable)
-		Expect(err).NotTo(HaveOccurred(), "failed to get pod templates in Table form in namespace: %s", ns)
-		Expect(len(pagedTable.Rows)).To(Equal(2))
-		Expect(pagedTable.ResourceVersion).ToNot(Equal(""))
-		Expect(pagedTable.SelfLink).ToNot(Equal(""))
-		Expect(pagedTable.Continue).ToNot(Equal(""))
-		Expect(pagedTable.Rows[0].Cells[0]).To(Equal("template-0000"))
-		Expect(pagedTable.Rows[1].Cells[0]).To(Equal("template-0001"))
+		gomega.Expect(err).NotTo(gomega.HaveOccurred(), "failed to get pod templates in Table form in namespace: %s", ns)
+		gomega.Expect(len(pagedTable.Rows)).To(gomega.Equal(2))
+		gomega.Expect(pagedTable.ResourceVersion).ToNot(gomega.Equal(""))
+		gomega.Expect(pagedTable.SelfLink).ToNot(gomega.Equal(""))
+		gomega.Expect(pagedTable.Continue).ToNot(gomega.Equal(""))
+		gomega.Expect(pagedTable.Rows[0].Cells[0]).To(gomega.Equal("template-0000"))
+		gomega.Expect(pagedTable.Rows[1].Cells[0]).To(gomega.Equal("template-0001"))
 
 		err = c.CoreV1().RESTClient().Get().Namespace(ns).Resource("podtemplates").
 			VersionedParams(&metav1.ListOptions{Continue: pagedTable.Continue}, metav1.ParameterCodec).
 			SetHeader("Accept", "application/json;as=Table;v=v1beta1;g=meta.k8s.io").
 			Do().Into(pagedTable)
-		Expect(err).NotTo(HaveOccurred(), "failed to get pod templates in Table form in namespace: %s", ns)
-		Expect(len(pagedTable.Rows)).To(BeNumerically(">", 0))
-		Expect(pagedTable.Rows[0].Cells[0]).To(Equal("template-0002"))
+		gomega.Expect(err).NotTo(gomega.HaveOccurred(), "failed to get pod templates in Table form in namespace: %s", ns)
+		gomega.Expect(len(pagedTable.Rows)).To(gomega.BeNumerically(">", 0))
+		gomega.Expect(pagedTable.Rows[0].Cells[0]).To(gomega.Equal("template-0002"))
 	})
 
-	It("should return generic metadata details across all namespaces for nodes", func() {
+	ginkgo.It("should return generic metadata details across all namespaces for nodes", func() {
 		c := f.ClientSet
 
 		table := &metav1beta1.Table{}
 		err := c.CoreV1().RESTClient().Get().Resource("nodes").SetHeader("Accept", "application/json;as=Table;v=v1beta1;g=meta.k8s.io").Do().Into(table)
-		Expect(err).NotTo(HaveOccurred(), "failed to get nodes in Table form across all namespaces")
+		gomega.Expect(err).NotTo(gomega.HaveOccurred(), "failed to get nodes in Table form across all namespaces")
 		framework.Logf("Table: %#v", table)
 
-		Expect(len(table.ColumnDefinitions)).To(BeNumerically(">=", 2))
-		Expect(len(table.Rows)).To(BeNumerically(">=", 1))
-		Expect(len(table.Rows[0].Cells)).To(Equal(len(table.ColumnDefinitions)))
-		Expect(table.ColumnDefinitions[0].Name).To(Equal("Name"))
-		Expect(table.ResourceVersion).ToNot(Equal(""))
-		Expect(table.SelfLink).ToNot(Equal(""))
+		gomega.Expect(len(table.ColumnDefinitions)).To(gomega.BeNumerically(">=", 2))
+		gomega.Expect(len(table.Rows)).To(gomega.BeNumerically(">=", 1))
+		gomega.Expect(len(table.Rows[0].Cells)).To(gomega.Equal(len(table.ColumnDefinitions)))
+		gomega.Expect(table.ColumnDefinitions[0].Name).To(gomega.Equal("Name"))
+		gomega.Expect(table.ResourceVersion).ToNot(gomega.Equal(""))
+		gomega.Expect(table.SelfLink).ToNot(gomega.Equal(""))
 
 		out := printTable(table)
-		Expect(out).To(MatchRegexp("^NAME\\s"))
+		gomega.Expect(out).To(gomega.MatchRegexp("^NAME\\s"))
 		framework.Logf("Table:\n%s", out)
 	})
 
-	It("should return a 406 for a backend which does not implement metadata", func() {
+	ginkgo.It("should return a 406 for a backend which does not implement metadata", func() {
 		c := f.ClientSet
 
 		table := &metav1beta1.Table{}
@@ -157,8 +157,8 @@ var _ = SIGDescribe("Servers with support for Table transformation", func() {
 			},
 		}
 		err := c.AuthorizationV1().RESTClient().Post().Resource("selfsubjectaccessreviews").SetHeader("Accept", "application/json;as=Table;v=v1beta1;g=meta.k8s.io").Body(sar).Do().Into(table)
-		Expect(err).To(HaveOccurred(), "failed to return error when posting self subject access review: %+v, to a backend that does not implement metadata", sar)
-		Expect(err.(errors.APIStatus).Status().Code).To(Equal(int32(406)))
+		gomega.Expect(err).To(gomega.HaveOccurred(), "failed to return error when posting self subject access review: %+v, to a backend that does not implement metadata", sar)
+		gomega.Expect(err.(errors.APIStatus).Status().Code).To(gomega.Equal(int32(406)))
 	})
 })
 
@@ -166,7 +166,7 @@ func printTable(table *metav1beta1.Table) string {
 	buf := &bytes.Buffer{}
 	tw := tabwriter.NewWriter(buf, 5, 8, 1, ' ', 0)
 	err := printers.PrintTable(table, tw, printers.PrintOptions{})
-	Expect(err).NotTo(HaveOccurred(), "failed to print table: %+v", table)
+	gomega.Expect(err).NotTo(gomega.HaveOccurred(), "failed to print table: %+v", table)
 	tw.Flush()
 	return buf.String()
 }