test(e2e): add test for bundle image

WIP: this is currently using a local custom image.

Author: Jeff Peeler

test/e2e/installplan_e2e_test.go

@@ -18,6 +18,7 @@ import (
 	k8serrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/util/wait"
 	"k8s.io/apimachinery/pkg/watch"
 	"k8s.io/kubernetes/pkg/apis/rbac"
@@ -106,6 +107,22 @@ func fetchInstallPlanWithNamespace(t *testing.T, c versioned.Interface, name str
 	return fetchedInstallPlan, err
 }
 
+// do not return an error if the installplan has not been created yet
+func waitForInstallPlan(t *testing.T, c versioned.Interface, name string, namespace string, checkPhase checkInstallPlanFunc) (*v1alpha1.InstallPlan, error) {
+	var fetchedInstallPlan *v1alpha1.InstallPlan
+	var err error
+
+	err = wait.Poll(pollInterval, pollDuration, func() (bool, error) {
+		fetchedInstallPlan, err = c.OperatorsV1alpha1().InstallPlans(namespace).Get(name, metav1.GetOptions{})
+		if err != nil && !k8serrors.IsNotFound(err) {
+			return false, err
+		}
+
+		return checkPhase(fetchedInstallPlan), nil
+	})
+	return fetchedInstallPlan, err
+}
+
 func newNginxInstallStrategy(name string, permissions []v1alpha1.StrategyDeploymentPermissions, clusterPermissions []v1alpha1.StrategyDeploymentPermissions) v1alpha1.NamedInstallStrategy {
 	// Create an nginx details deployment
 	details := v1alpha1.StrategyDetailsDeployment{
@@ -2552,3 +2569,135 @@ func TestInstallPlanCRDValidation(t *testing.T) {
 
 	require.Equal(t, v1alpha1.InstallPlanPhaseComplete, fetchedInstallPlan.Status.Phase)
 }
+
+func TestInstallPlanFromBundleImage(t *testing.T) {
+	defer cleaner.NotifyTestComplete(t, true)
+	c := newKubeClient(t)
+	crc := newCRClient(t)
+	catalogSourceName := genName("mock-kiali-")
+
+	// expect to execute in the same namespace OLM is operating in
+	testNamespace := strings.TrimSuffix(testNamespace, "-operator")
+
+	// add RBAC for e2e namespace
+	rbacRole := &rbacv1.Role{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "olm-e2e-configmap-access",
+			Namespace: testNamespace,
+		},
+		Rules: []rbacv1.PolicyRule{
+			{
+				APIGroups: []string{
+					"",
+				},
+				Verbs: []string{
+					"create", "get", "update",
+				},
+				Resources: []string{
+					"configmaps",
+				},
+			},
+		},
+	}
+	_, err := c.KubernetesInterface().RbacV1().Roles(testNamespace).Create(rbacRole)
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, c.KubernetesInterface().RbacV1().Roles(testNamespace).Delete(rbacRole.GetName(), &metav1.DeleteOptions{}))
+	}()
+
+	rbacBinding := &rbacv1.RoleBinding{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "olm-e2e-configmap-access-binding",
+			Namespace: testNamespace,
+		},
+		Subjects: []rbacv1.Subject{
+			{
+				Kind:      "ServiceAccount",
+				APIGroup:  "",
+				Name:      "default",
+				Namespace: testNamespace,
+			},
+		},
+		RoleRef: rbacv1.RoleRef{
+			APIGroup: "rbac.authorization.k8s.io",
+			Kind:     "Role",
+			Name:     rbacRole.GetName(),
+		},
+	}
+	_, err = c.KubernetesInterface().RbacV1().RoleBindings(testNamespace).Create(rbacBinding)
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, c.KubernetesInterface().RbacV1().RoleBindings(testNamespace).Delete(rbacBinding.GetName(), &metav1.DeleteOptions{}))
+	}()
+
+	grpcCatalogSource := &v1alpha1.CatalogSource{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      catalogSourceName,
+			Namespace: testNamespace,
+			UID:       types.UID("catalog-uid"),
+			Labels:    map[string]string{"olm.catalogSource": "kaili-catalog"},
+		},
+		Spec: v1alpha1.CatalogSourceSpec{
+			Image:      "quay.io/jpeeler/registry-image:latest",
+			SourceType: v1alpha1.SourceTypeGrpc,
+		},
+	}
+	_, err = crc.OperatorsV1alpha1().CatalogSources(testNamespace).Create(grpcCatalogSource)
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, crc.OperatorsV1alpha1().CatalogSources(testNamespace).Delete(grpcCatalogSource.GetName(), &metav1.DeleteOptions{}))
+	}()
+
+	// wait for catalog source to be ready
+	_, err = fetchCatalogSource(t, crc, catalogSourceName, testNamespace, catalogSourceRegistryPodSynced)
+	require.NoError(t, err)
+
+	// generate subscription
+	subscriptionName := genName("sub-kiali-")
+	cleanupSubscription := createSubscriptionForCatalog(t, crc, testNamespace, subscriptionName, catalogSourceName, "kiali", stableChannel, "", v1alpha1.ApprovalAutomatic)
+	defer cleanupSubscription()
+
+	subscription, err := fetchSubscription(t, crc, testNamespace, subscriptionName, subscriptionHasInstallPlanChecker)
+	require.NoError(t, err)
+	require.NotNil(t, subscription)
+	installPlanName := subscription.Status.InstallPlanRef.Name
+
+	// get InstallPlan
+	fetchedInstallPlan, err := waitForInstallPlan(t, crc, installPlanName, testNamespace, buildInstallPlanPhaseCheckFunc(v1alpha1.InstallPlanPhaseFailed, v1alpha1.InstallPlanPhaseComplete))
+	require.NoError(t, err)
+	require.NotEqual(t, v1alpha1.InstallPlanPhaseFailed, fetchedInstallPlan.Status.Phase, "InstallPlan failed")
+
+	// verify steps
+	operatorName := "kiali-operator"
+	expectedSteps := map[registry.ResourceKey]struct{}{
+		registry.ResourceKey{Name: operatorName, Kind: "ClusterServiceVersion"}:                                  {},
+		registry.ResourceKey{Name: "kialis.kiali.io", Kind: "CustomResourceDefinition"}:                          {},
+		registry.ResourceKey{Name: "monitoringdashboards.monitoring.kiali.io", Kind: "CustomResourceDefinition"}: {},
+		registry.ResourceKey{Name: operatorName, Kind: "ServiceAccount"}:                                         {},
+		registry.ResourceKey{Name: operatorName, Kind: "ClusterRole"}:                                            {},
+		registry.ResourceKey{Name: operatorName, Kind: "ClusterRoleBinding"}:                                     {},
+	}
+
+	require.Equal(t, len(expectedSteps), len(fetchedInstallPlan.Status.Plan), "number of expected steps does not match installed: %v", fetchedInstallPlan.Status.Plan)
+
+	for _, step := range fetchedInstallPlan.Status.Plan {
+		key := registry.ResourceKey{
+			Name: step.Resource.Name,
+			Kind: step.Resource.Kind,
+		}
+		for expected := range expectedSteps {
+			if strings.HasPrefix(key.Name, expected.Name) && key.Kind == expected.Kind {
+				delete(expectedSteps, expected)
+			} else {
+				t.Logf("%v, %v: %v && %v", key, expected, strings.HasPrefix(key.Name, expected.Name), key.Kind == expected.Kind)
+			}
+		}
+	}
+	require.Equal(t, 0, len(expectedSteps), "Actual resource steps do not match expected: %#v", expectedSteps)
+
+	// check CSV installed successfully
+	csvName := "kiali-operator.v1.4.2"
+	_, err = fetchCSV(t, crc, csvName, testNamespace, csvSucceededChecker)
+	require.NoError(t, err)
+	require.NoError(t, crc.OperatorsV1alpha1().ClusterServiceVersions(testNamespace).Delete(csvName, &metav1.DeleteOptions{}))
+}