Merge branch 'rewrite.operatorsource.test' of github.com:pratikjagrut/devconsole-operator into rewrite.operatorsource.test

Signed-off-by: Pratik Jagrut <pjagrut@redhat.com>

Author: Pratik Jagrut

test/operatorsource/basic_test.go

@@ -18,16 +18,15 @@ var (
 )
 
 func Test_OperatorSource(t *testing.T) {
-
-	pod, err := Client.GetPodByLabel(label, namespace)
+	pods, err := Client.GetPodByLabel(label, namespace)
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer CleanUp(t, pod)
+	defer CleanUp(t, &pods.Items[0])
 	retryInterval := time.Second * 10
 	timeout := time.Second * 120
 
-	err = Client.WaitForOperatorDeployment(t, pod.Name, namespace, retryInterval, timeout)
+	err = Client.WaitForOperatorDeployment(t, pods.Items[0].Name, namespace, retryInterval, timeout)
 	if err != nil {
 		t.Fatal(err)
 	} else {
@@ -42,23 +41,17 @@ func Subscription(t *testing.T) {
 	if suberr != nil {
 		t.Fatal(suberr)
 	}
-	fmt.Printf("Subscription Name: %s\nCatalog Source: %s\n", subscription.Name, subscription.Spec.CatalogSource)
 	require.Equal(t, subName, subscription.Name)
 	require.Equal(t, "installed-custom-openshift-operators", subscription.Spec.CatalogSource)
 }
 
 func InstallPlan(t *testing.T) {
 	// 2) Find the name of the install plan
 	installPlanName := subscription.Status.Install.Name
-	fmt.Printf("Install Plan Name: %s\n", installPlanName)
 	installPlan, err := Client.GetInstallPlan(installPlanName, namespace)
 	if err != nil {
 		t.Fatal(err)
 	}
-	fmt.Printf("CSV: %v\n", installPlan.Spec.ClusterServiceVersionNames[0])
-	fmt.Printf("Install Plan Approval: %v\n", installPlan.Spec.Approval)
-	fmt.Printf("Install Plan Approved: %v\n", installPlan.Spec.Approved)
-
 	require.Equal(t, "devconsole-operator.v0.1.0", installPlan.Spec.ClusterServiceVersionNames[0])
 	require.Equal(t, "Automatic", string(installPlan.Spec.Approval))
 	if !installPlan.Spec.Approved {
@@ -68,11 +61,11 @@ func InstallPlan(t *testing.T) {
 
 func OperatorPod(t *testing.T) {
 	// 3) Check operator pod status, fail status != Running
-	pod, err := Client.GetPodByLabel(label, namespace)
+	pods, err := Client.GetPodByLabel(label, namespace)
 	if err != nil {
 		t.Fatal(err)
 	}
-	fmt.Printf("Pod Name: %v\nPod status: %v\n", pod.Name, pod.Status.Phase)
+	pod := pods.Items[0]
 	require.Equal(t, pod.Status.Phase, corev1.PodRunning)
 }
 

test/operatorsource/helpers.go

@@ -56,7 +56,7 @@ func NewTestClient() *TestClient {
 }
 
 // GetPodByLabel is a function that takes label and namespace and returns the pod and error
-func (tc *TestClient) GetPodByLabel(label string, namespace string) (*corev1.Pod, error) {
+func (tc *TestClient) GetPodByLabel(label string, namespace string) (*corev1.PodList, error) {
 
 	pods, err := tc.K8sClient.CoreV1().Pods(namespace).List(metav1.ListOptions{LabelSelector: label})
 	if err != nil {
@@ -65,7 +65,7 @@ func (tc *TestClient) GetPodByLabel(label string, namespace string) (*corev1.Pod
 	if len(pods.Items) == 0 {
 		return nil, nil
 	}
-	return &pods.Items[0], nil
+	return pods, nil
 }
 
 //GetSubscription returns subscription struct
@@ -92,45 +92,25 @@ func (tc *TestClient) GetInstallPlan(installPlanName, namespace string) (*apis_v
 func (tc *TestClient) Delete(resource, name, namespace string) error {
 	switch resource {
 	case "subscription", "sub":
-		err := tc.OperatorClient.Subscriptions(namespace).Delete(name, &metav1.DeleteOptions{})
-		if err != nil {
-			return err
-		}
-		return nil
+		return tc.OperatorClient.Subscriptions(namespace).Delete(name, &metav1.DeleteOptions{})
 	case "installplan":
-		err := tc.OperatorClient.InstallPlans(namespace).Delete(name, &metav1.DeleteOptions{})
-		if err != nil {
-			return err
-		}
-		return nil
-	case "catalogsource", "catsrc":
-		err := tc.OperatorClient.CatalogSources(namespace).Delete(name, &metav1.DeleteOptions{})
-		if err != nil {
-			return err
-		}
-		return nil
+		return tc.OperatorClient.InstallPlans(namespace).Delete(name, &metav1.DeleteOptions{})
+	case "catalogsource", "catsrc", "csc":
+		return tc.OperatorClient.CatalogSources(namespace).Delete(name, &metav1.DeleteOptions{})
 	case "clusterserviceversion", "csv":
-		err := tc.OperatorClient.ClusterServiceVersions(namespace).Delete(name, &metav1.DeleteOptions{})
-		if err != nil {
-			return err
-		}
-		return nil
+		return tc.OperatorClient.ClusterServiceVersions(namespace).Delete(name, &metav1.DeleteOptions{})
 	case "pod":
-		err := tc.K8sClient.CoreV1().Pods(namespace).Delete(name, &metav1.DeleteOptions{})
-		if err != nil {
-			return err
-		}
-		return nil
+		return tc.K8sClient.CoreV1().Pods(namespace).Delete(name, &metav1.DeleteOptions{})
 	default:
 		option := fmt.Sprintf("Invalid resource: %s", resource)
 		return errors.New(option)
 
 	}
 }
 
-//WaitForOperatorDeployment takes pod struct and wait till pods gets in runnig state
+//WaitForOperatorDeployment takes pod name and wait till pod gets in runnig state
 func (tc *TestClient) WaitForOperatorDeployment(t *testing.T, name, namespace string, retryInterval, timeout time.Duration) error {
-	err := wait.Poll(retryInterval, timeout, func() (bool, error) {
+	return wait.Poll(retryInterval, timeout, func() (bool, error) {
 		pod, err := tc.K8sClient.CoreV1().Pods(namespace).Get(name, metav1.GetOptions{})
 		if err != nil {
 			return false, err
@@ -141,11 +121,7 @@ func (tc *TestClient) WaitForOperatorDeployment(t *testing.T, name, namespace st
 		if pod.Status.Phase == corev1.PodRunning {
 			return true, nil
 		}
-		t.Logf("Pod %s Status: %s", pod.Name, pod.Status.Phase)
+		t.Logf("Waiting for pod %s to get running, Current Status: %s\n", pod.Name, pod.Status.Phase)
 		return false, nil
 	})
-	if err != nil {
-		return err
-	}
-	return nil
 }