Merge pull request kubernetes#74508 from danielqsj/uapps

Fix golint failures for e2e/upgrades/...

Author: k8s-ci-robot

hack/.golint_failures

@@ -673,9 +673,6 @@ test/e2e/storage/testsuites
 test/e2e/storage/utils
 test/e2e/storage/vsphere
 test/e2e/ui
-test/e2e/upgrades
-test/e2e/upgrades/apps
-test/e2e/upgrades/storage
 test/e2e/windows
 test/e2e_kubeadm
 test/e2e_node

test/e2e/lifecycle/cluster_upgrade.go

@@ -66,7 +66,7 @@ var gpuUpgradeTests = []upgrades.Test{
 }
 
 var statefulsetUpgradeTests = []upgrades.Test{
-	&upgrades.MySqlUpgradeTest{},
+	&upgrades.MySQLUpgradeTest{},
 	&upgrades.EtcdUpgradeTest{},
 	&upgrades.CassandraUpgradeTest{},
 }

test/e2e/upgrades/apparmor.go

@@ -22,8 +22,8 @@ import (
 	"k8s.io/kubernetes/test/e2e/common"
 	"k8s.io/kubernetes/test/e2e/framework"
 
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
+	"github.com/onsi/ginkgo"
+	"github.com/onsi/gomega"
 	"github.com/onsi/gomega/gstruct"
 )
 
@@ -32,8 +32,10 @@ type AppArmorUpgradeTest struct {
 	pod *api.Pod
 }
 
+// Name returns the tracking name of the test.
 func (AppArmorUpgradeTest) Name() string { return "apparmor-upgrade" }
 
+// Skip returns true when this test can be skipped.
 func (AppArmorUpgradeTest) Skip(upgCtx UpgradeContext) bool {
 	supportedImages := make(map[string]bool)
 	for _, d := range common.AppArmorDistros {
@@ -50,11 +52,11 @@ func (AppArmorUpgradeTest) Skip(upgCtx UpgradeContext) bool {
 
 // Setup creates a secret and then verifies that a pod can consume it.
 func (t *AppArmorUpgradeTest) Setup(f *framework.Framework) {
-	By("Loading AppArmor profiles to nodes")
+	ginkgo.By("Loading AppArmor profiles to nodes")
 	common.LoadAppArmorProfiles(f)
 
 	// Create the initial test pod.
-	By("Creating a long-running AppArmor enabled pod.")
+	ginkgo.By("Creating a long-running AppArmor enabled pod.")
 	t.pod = common.CreateAppArmorTestPod(f, false, false)
 
 	// Verify initial state.
@@ -76,32 +78,32 @@ func (t *AppArmorUpgradeTest) Test(f *framework.Framework, done <-chan struct{},
 // Teardown cleans up any remaining resources.
 func (t *AppArmorUpgradeTest) Teardown(f *framework.Framework) {
 	// rely on the namespace deletion to clean up everything
-	By("Logging container failures")
+	ginkgo.By("Logging container failures")
 	framework.LogFailedContainers(f.ClientSet, f.Namespace.Name, framework.Logf)
 }
 
 func (t *AppArmorUpgradeTest) verifyPodStillUp(f *framework.Framework) {
-	By("Verifying an AppArmor profile is continuously enforced for a pod")
+	ginkgo.By("Verifying an AppArmor profile is continuously enforced for a pod")
 	pod, err := f.PodClient().Get(t.pod.Name, metav1.GetOptions{})
 	framework.ExpectNoError(err, "Should be able to get pod")
-	Expect(pod.Status.Phase).To(Equal(api.PodRunning), "Pod should stay running")
-	Expect(pod.Status.ContainerStatuses[0].State.Running).NotTo(BeNil(), "Container should be running")
-	Expect(pod.Status.ContainerStatuses[0].RestartCount).To(BeZero(), "Container should not need to be restarted")
+	gomega.Expect(pod.Status.Phase).To(gomega.Equal(api.PodRunning), "Pod should stay running")
+	gomega.Expect(pod.Status.ContainerStatuses[0].State.Running).NotTo(gomega.BeNil(), "Container should be running")
+	gomega.Expect(pod.Status.ContainerStatuses[0].RestartCount).To(gomega.BeZero(), "Container should not need to be restarted")
 }
 
 func (t *AppArmorUpgradeTest) verifyNewPodSucceeds(f *framework.Framework) {
-	By("Verifying an AppArmor profile is enforced for a new pod")
+	ginkgo.By("Verifying an AppArmor profile is enforced for a new pod")
 	common.CreateAppArmorTestPod(f, false, true)
 }
 
 func (t *AppArmorUpgradeTest) verifyNodesAppArmorEnabled(f *framework.Framework) {
-	By("Verifying nodes are AppArmor enabled")
+	ginkgo.By("Verifying nodes are AppArmor enabled")
 	nodes, err := f.ClientSet.CoreV1().Nodes().List(metav1.ListOptions{})
 	framework.ExpectNoError(err, "Failed to list nodes")
 	for _, node := range nodes.Items {
-		Expect(node.Status.Conditions).To(gstruct.MatchElements(conditionType, gstruct.IgnoreExtras, gstruct.Elements{
+		gomega.Expect(node.Status.Conditions).To(gstruct.MatchElements(conditionType, gstruct.IgnoreExtras, gstruct.Elements{
 			"Ready": gstruct.MatchFields(gstruct.IgnoreExtras, gstruct.Fields{
-				"Message": ContainSubstring("AppArmor enabled"),
+				"Message": gomega.ContainSubstring("AppArmor enabled"),
 			}),
 		}))
 	}

test/e2e/upgrades/apps/daemonsets.go

@@ -17,7 +17,7 @@ limitations under the License.
 package upgrades
 
 import (
-	. "github.com/onsi/ginkgo"
+	"github.com/onsi/ginkgo"
 
 	apps "k8s.io/api/apps/v1"
 	v1 "k8s.io/api/core/v1"
@@ -35,6 +35,7 @@ type DaemonSetUpgradeTest struct {
 	daemonSet *apps.DaemonSet
 }
 
+// Name returns the tracking name of the test.
 func (DaemonSetUpgradeTest) Name() string { return "[sig-apps] daemonset-upgrade" }
 
 // Setup creates a DaemonSet and verifies that it's running
@@ -74,29 +75,29 @@ func (t *DaemonSetUpgradeTest) Setup(f *framework.Framework) {
 		},
 	}
 
-	By("Creating a DaemonSet")
+	ginkgo.By("Creating a DaemonSet")
 	var err error
 	if t.daemonSet, err = f.ClientSet.AppsV1().DaemonSets(ns.Name).Create(t.daemonSet); err != nil {
 		framework.Failf("unable to create test DaemonSet %s: %v", t.daemonSet.Name, err)
 	}
 
-	By("Waiting for DaemonSet pods to become ready")
+	ginkgo.By("Waiting for DaemonSet pods to become ready")
 	err = wait.Poll(framework.Poll, framework.PodStartTimeout, func() (bool, error) {
 		return checkRunningOnAllNodes(f, t.daemonSet.Namespace, t.daemonSet.Labels)
 	})
 	framework.ExpectNoError(err)
 
-	By("Validating the DaemonSet after creation")
+	ginkgo.By("Validating the DaemonSet after creation")
 	t.validateRunningDaemonSet(f)
 }
 
 // Test waits until the upgrade has completed and then verifies that the DaemonSet
 // is still running
 func (t *DaemonSetUpgradeTest) Test(f *framework.Framework, done <-chan struct{}, upgrade upgrades.UpgradeType) {
-	By("Waiting for upgradet to complete before re-validating DaemonSet")
+	ginkgo.By("Waiting for upgradet to complete before re-validating DaemonSet")
 	<-done
 
-	By("validating the DaemonSet is still running after upgrade")
+	ginkgo.By("validating the DaemonSet is still running after upgrade")
 	t.validateRunningDaemonSet(f)
 }
 
@@ -106,15 +107,15 @@ func (t *DaemonSetUpgradeTest) Teardown(f *framework.Framework) {
 }
 
 func (t *DaemonSetUpgradeTest) validateRunningDaemonSet(f *framework.Framework) {
-	By("confirming the DaemonSet pods are running on all expected nodes")
+	ginkgo.By("confirming the DaemonSet pods are running on all expected nodes")
 	res, err := checkRunningOnAllNodes(f, t.daemonSet.Namespace, t.daemonSet.Labels)
 	framework.ExpectNoError(err)
 	if !res {
 		framework.Failf("expected DaemonSet pod to be running on all nodes, it was not")
 	}
 
 	// DaemonSet resource itself should be good
-	By("confirming the DaemonSet resource is in a good state")
+	ginkgo.By("confirming the DaemonSet resource is in a good state")
 	res, err = checkDaemonStatus(f, t.daemonSet.Namespace, t.daemonSet.Name)
 	framework.ExpectNoError(err)
 	if !res {

test/e2e/upgrades/apps/deployments.go

@@ -26,8 +26,8 @@ import (
 	"k8s.io/kubernetes/test/e2e/framework"
 	"k8s.io/kubernetes/test/e2e/upgrades"
 
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
+	"github.com/onsi/ginkgo"
+	"github.com/onsi/gomega"
 	imageutils "k8s.io/kubernetes/test/utils/image"
 )
 
@@ -46,6 +46,7 @@ type DeploymentUpgradeTest struct {
 	newRSUID         types.UID
 }
 
+// Name returns the tracking name of the test.
 func (DeploymentUpgradeTest) Name() string { return "[sig-apps] deployment-upgrade" }
 
 // Setup creates a deployment and makes sure it has a new and an old replicaset running.
@@ -57,15 +58,15 @@ func (t *DeploymentUpgradeTest) Setup(f *framework.Framework) {
 	deploymentClient := c.AppsV1().Deployments(ns)
 	rsClient := c.AppsV1().ReplicaSets(ns)
 
-	By(fmt.Sprintf("Creating a deployment %q with 1 replica in namespace %q", deploymentName, ns))
+	ginkgo.By(fmt.Sprintf("Creating a deployment %q with 1 replica in namespace %q", deploymentName, ns))
 	d := framework.NewDeployment(deploymentName, int32(1), map[string]string{"test": "upgrade"}, "nginx", nginxImage, apps.RollingUpdateDeploymentStrategyType)
 	deployment, err := deploymentClient.Create(d)
 	framework.ExpectNoError(err)
 
-	By(fmt.Sprintf("Waiting deployment %q to complete", deploymentName))
+	ginkgo.By(fmt.Sprintf("Waiting deployment %q to complete", deploymentName))
 	framework.ExpectNoError(framework.WaitForDeploymentComplete(c, deployment))
 
-	By(fmt.Sprintf("Getting replicaset revision 1 of deployment %q", deploymentName))
+	ginkgo.By(fmt.Sprintf("Getting replicaset revision 1 of deployment %q", deploymentName))
 	rsSelector, err := metav1.LabelSelectorAsSelector(d.Spec.Selector)
 	framework.ExpectNoError(err)
 	rsList, err := rsClient.List(metav1.ListOptions{LabelSelector: rsSelector.String()})
@@ -76,28 +77,28 @@ func (t *DeploymentUpgradeTest) Setup(f *framework.Framework) {
 	}
 	t.oldRSUID = rss[0].UID
 
-	By(fmt.Sprintf("Waiting for revision of the deployment %q to become 1", deploymentName))
+	ginkgo.By(fmt.Sprintf("Waiting for revision of the deployment %q to become 1", deploymentName))
 	framework.ExpectNoError(framework.WaitForDeploymentRevision(c, deployment, "1"))
 
 	// Trigger a new rollout so that we have some history.
-	By(fmt.Sprintf("Triggering a new rollout for deployment %q", deploymentName))
+	ginkgo.By(fmt.Sprintf("Triggering a new rollout for deployment %q", deploymentName))
 	deployment, err = framework.UpdateDeploymentWithRetries(c, ns, deploymentName, func(update *apps.Deployment) {
 		update.Spec.Template.Spec.Containers[0].Name = "updated-name"
 	})
 	framework.ExpectNoError(err)
 
-	By(fmt.Sprintf("Waiting deployment %q to complete", deploymentName))
+	ginkgo.By(fmt.Sprintf("Waiting deployment %q to complete", deploymentName))
 	framework.ExpectNoError(framework.WaitForDeploymentComplete(c, deployment))
 
-	By(fmt.Sprintf("Getting replicasets revision 1 and 2 of deployment %q", deploymentName))
+	ginkgo.By(fmt.Sprintf("Getting replicasets revision 1 and 2 of deployment %q", deploymentName))
 	rsList, err = rsClient.List(metav1.ListOptions{LabelSelector: rsSelector.String()})
 	framework.ExpectNoError(err)
 	rss = rsList.Items
 	if len(rss) != 2 {
 		framework.ExpectNoError(fmt.Errorf("expected 2 replicaset, got %d", len(rss)))
 	}
 
-	By(fmt.Sprintf("Checking replicaset of deployment %q that is created before rollout survives the rollout", deploymentName))
+	ginkgo.By(fmt.Sprintf("Checking replicaset of deployment %q that is created before rollout survives the rollout", deploymentName))
 	switch t.oldRSUID {
 	case rss[0].UID:
 		t.newRSUID = rss[1].UID
@@ -107,7 +108,7 @@ func (t *DeploymentUpgradeTest) Setup(f *framework.Framework) {
 		framework.ExpectNoError(fmt.Errorf("old replicaset with UID %q does not survive rollout", t.oldRSUID))
 	}
 
-	By(fmt.Sprintf("Waiting for revision of the deployment %q to become 2", deploymentName))
+	ginkgo.By(fmt.Sprintf("Waiting for revision of the deployment %q to become 2", deploymentName))
 	framework.ExpectNoError(framework.WaitForDeploymentRevision(c, deployment, "2"))
 
 	t.oldDeploymentUID = deployment.UID
@@ -116,7 +117,7 @@ func (t *DeploymentUpgradeTest) Setup(f *framework.Framework) {
 // Test checks whether the replicasets for a deployment are the same after an upgrade.
 func (t *DeploymentUpgradeTest) Test(f *framework.Framework, done <-chan struct{}, upgrade upgrades.UpgradeType) {
 	// Block until upgrade is done
-	By(fmt.Sprintf("Waiting for upgrade to finish before checking replicasets for deployment %q", deploymentName))
+	ginkgo.By(fmt.Sprintf("Waiting for upgrade to finish before checking replicasets for deployment %q", deploymentName))
 	<-done
 
 	c := f.ClientSet
@@ -127,10 +128,10 @@ func (t *DeploymentUpgradeTest) Test(f *framework.Framework, done <-chan struct{
 	deployment, err := deploymentClient.Get(deploymentName, metav1.GetOptions{})
 	framework.ExpectNoError(err)
 
-	By(fmt.Sprintf("Checking UID to verify deployment %q survives upgrade", deploymentName))
-	Expect(deployment.UID).To(Equal(t.oldDeploymentUID))
+	ginkgo.By(fmt.Sprintf("Checking UID to verify deployment %q survives upgrade", deploymentName))
+	gomega.Expect(deployment.UID).To(gomega.Equal(t.oldDeploymentUID))
 
-	By(fmt.Sprintf("Verifying deployment %q does not create new replicasets", deploymentName))
+	ginkgo.By(fmt.Sprintf("Verifying deployment %q does not create new replicasets", deploymentName))
 	rsSelector, err := metav1.LabelSelectorAsSelector(deployment.Spec.Selector)
 	framework.ExpectNoError(err)
 	rsList, err := rsClient.List(metav1.ListOptions{LabelSelector: rsSelector.String()})
@@ -142,27 +143,27 @@ func (t *DeploymentUpgradeTest) Test(f *framework.Framework, done <-chan struct{
 
 	switch t.oldRSUID {
 	case rss[0].UID:
-		Expect(rss[1].UID).To(Equal(t.newRSUID))
+		gomega.Expect(rss[1].UID).To(gomega.Equal(t.newRSUID))
 	case rss[1].UID:
-		Expect(rss[0].UID).To(Equal(t.newRSUID))
+		gomega.Expect(rss[0].UID).To(gomega.Equal(t.newRSUID))
 	default:
 		framework.ExpectNoError(fmt.Errorf("new replicasets are created during upgrade of deployment %q", deploymentName))
 	}
 
-	By(fmt.Sprintf("Verifying revision of the deployment %q is still 2", deploymentName))
-	Expect(deployment.Annotations[deploymentutil.RevisionAnnotation]).To(Equal("2"))
+	ginkgo.By(fmt.Sprintf("Verifying revision of the deployment %q is still 2", deploymentName))
+	gomega.Expect(deployment.Annotations[deploymentutil.RevisionAnnotation]).To(gomega.Equal("2"))
 
-	By(fmt.Sprintf("Waiting for deployment %q to complete adoption", deploymentName))
+	ginkgo.By(fmt.Sprintf("Waiting for deployment %q to complete adoption", deploymentName))
 	framework.ExpectNoError(framework.WaitForDeploymentComplete(c, deployment))
 
 	// Verify the upgraded deployment is active by scaling up the deployment by 1
-	By(fmt.Sprintf("Scaling up replicaset of deployment %q by 1", deploymentName))
+	ginkgo.By(fmt.Sprintf("Scaling up replicaset of deployment %q by 1", deploymentName))
 	_, err = framework.UpdateDeploymentWithRetries(c, ns, deploymentName, func(deployment *apps.Deployment) {
 		*deployment.Spec.Replicas = *deployment.Spec.Replicas + 1
 	})
 	framework.ExpectNoError(err)
 
-	By(fmt.Sprintf("Waiting for deployment %q to complete after scaling", deploymentName))
+	ginkgo.By(fmt.Sprintf("Waiting for deployment %q to complete after scaling", deploymentName))
 	framework.ExpectNoError(framework.WaitForDeploymentComplete(c, deployment))
 }
 

test/e2e/upgrades/apps/job.go

@@ -22,8 +22,8 @@ import (
 	"k8s.io/kubernetes/test/e2e/framework"
 	"k8s.io/kubernetes/test/e2e/upgrades"
 
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
+	"github.com/onsi/ginkgo"
+	"github.com/onsi/gomega"
 )
 
 // JobUpgradeTest is a test harness for batch Jobs.
@@ -32,30 +32,31 @@ type JobUpgradeTest struct {
 	namespace string
 }
 
+// Name returns the tracking name of the test.
 func (JobUpgradeTest) Name() string { return "[sig-apps] job-upgrade" }
 
 // Setup starts a Job with a parallelism of 2 and 2 completions running.
 func (t *JobUpgradeTest) Setup(f *framework.Framework) {
 	t.namespace = f.Namespace.Name
 
-	By("Creating a job")
+	ginkgo.By("Creating a job")
 	t.job = framework.NewTestJob("notTerminate", "foo", v1.RestartPolicyOnFailure, 2, 2, nil, 6)
 	job, err := framework.CreateJob(f.ClientSet, t.namespace, t.job)
 	t.job = job
-	Expect(err).NotTo(HaveOccurred())
+	gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
-	By("Ensuring active pods == parallelism")
+	ginkgo.By("Ensuring active pods == parallelism")
 	err = framework.WaitForAllJobPodsRunning(f.ClientSet, t.namespace, job.Name, 2)
-	Expect(err).NotTo(HaveOccurred())
+	gomega.Expect(err).NotTo(gomega.HaveOccurred())
 }
 
 // Test verifies that the Jobs Pods are running after the an upgrade
 func (t *JobUpgradeTest) Test(f *framework.Framework, done <-chan struct{}, upgrade upgrades.UpgradeType) {
 	<-done
-	By("Ensuring active pods == parallelism")
+	ginkgo.By("Ensuring active pods == parallelism")
 	running, err := framework.CheckForAllJobPodsRunning(f.ClientSet, t.namespace, t.job.Name, 2)
-	Expect(err).NotTo(HaveOccurred())
-	Expect(running).To(BeTrue())
+	gomega.Expect(err).NotTo(gomega.HaveOccurred())
+	gomega.Expect(running).To(gomega.BeTrue())
 }
 
 // Teardown cleans up any remaining resources.