Add basic tests for cloud shell

go.mod

@@ -18,6 +18,8 @@ require (
 )
 
 require (
+	github.com/onsi/ginkgo v1.11.0
+	github.com/onsi/gomega v1.8.1
 	github.com/operator-framework/operator-sdk v0.17.0
 	github.com/spf13/pflag v1.0.5
 	k8s.io/api v0.17.4

test/e2e/cmd/workspaces_test.go

@@ -0,0 +1,102 @@
+package cmd
+
+import (
+	"fmt"
+	"path/filepath"
+	"testing"
+
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	"github.com/che-incubator/che-workspace-operator/test/e2e/pkg/metadata"
+	_ "github.com/che-incubator/che-workspace-operator/test/e2e/pkg/tests"
+	workspaces "github.com/che-incubator/che-workspace-operator/test/e2e/pkg/workspaces"
+	"github.com/onsi/ginkgo"
+	"github.com/onsi/ginkgo/reporters"
+	"github.com/onsi/gomega"
+)
+
+//Create Constant file
+const (
+	testResultsDirectory = "/tmp/artifacts"
+	jUnitOutputFilename  = "junit-workspaces-operator.xml"
+)
+
+//SynchronizedBeforeSuite blocks is executed before run all test suites
+var _ = ginkgo.SynchronizedBeforeSuite(func() []byte {
+	//!TODO: Try to create a specific function to call all <ginkgo suite> configuration.
+	fmt.Println("Starting to setup objects before run ginkgo suite")
+	metadata.Namespace.Name = "che-workspace-controller"
+
+	workspaces := workspaces.NewWorkspaceClient()
+
+	ns := newNamespace()
+	ns, err := workspaces.Kube().CoreV1().Namespaces().Create(ns)
+
+	if err != nil {
+		fmt.Println("Failed to create namespace")
+	}
+
+	if err := workspaces.CreatePluginRegistryDeployment(); err != nil {
+		_ = fmt.Errorf("Failed to create deployment for plugin registry")
+	}
+
+	if err := workspaces.CreatePluginRegistryService(); err != nil {
+		_ = fmt.Errorf("Failed to create plugin registry service %s", err)
+	}
+
+	if err := workspaces.CreateOpenshiftRoute(); err != nil {
+		_ = fmt.Errorf("Failed to create route in cluster %s", err)
+	}
+
+	if err := workspaces.CreateAllOperatorRoles(); err != nil {
+		_ = fmt.Errorf("Failed to create roles in clusters %s", err)
+	}
+
+	if err := workspaces.CreateOperatorClusterRole(); err != nil {
+		_ = fmt.Errorf("Failed to create roles in clusters %s", err)
+	}
+
+	if err := workspaces.CustomResourceDefinitions(); err != nil {
+		_ = fmt.Errorf("Failed to add custom resources definitions to cluster %s", err)
+	}
+
+	if err := workspaces.DeployWorkspacesController(); err != nil {
+		_ = fmt.Errorf("Failed to deploy workspace controller %s", err)
+	}
+
+	return nil
+}, func(data []byte) {})
+
+var _ = ginkgo.SynchronizedAfterSuite(func() {
+	workspaces := workspaces.NewWorkspaceClient()
+
+	if err := workspaces.Kube().CoreV1().Namespaces().Delete(metadata.Namespace.Name, &metav1.DeleteOptions{}); err != nil {
+		_ = fmt.Errorf("Failed to deploy workspace controller %s", err)
+	}
+}, func() {})
+
+func TestHarnessCodeReadyWorkspaces(t *testing.T) {
+	gomega.RegisterFailHandler(ginkgo.Fail)
+
+	fmt.Println("Creating ginkgo reporter for Test Harness: Junit and Debug Detail reporter")
+	var r []ginkgo.Reporter
+	r = append(r, reporters.NewJUnitReporter(filepath.Join(testResultsDirectory, jUnitOutputFilename)))
+
+	fmt.Println("Running Workspace Controller e2e tests...")
+	ginkgo.RunSpecsWithDefaultAndCustomReporters(t, "Workspaces Controller Operator Tests", r)
+
+}
+
+func newNamespace() (ns *corev1.Namespace) {
+	return &corev1.Namespace{
+
+		TypeMeta: metav1.TypeMeta{
+			Kind:       "Namespace",
+			APIVersion: corev1.SchemeGroupVersion.Version,
+		},
+		ObjectMeta: metav1.ObjectMeta{
+			Name: metadata.Namespace.Name,
+		},
+	}
+}

test/e2e/pkg/metadata/metadata.go

@@ -0,0 +1,7 @@
+package metadata
+
+type OperatorNamespace struct {
+	Name string
+}
+
+var Namespace = OperatorNamespace{}

test/e2e/pkg/tests/cloud_shell_tests.go

@@ -0,0 +1,22 @@
+package tests
+
+import (
+	"fmt"
+	"github.com/che-incubator/che-workspace-operator/test/e2e/pkg/workspaces"
+	"github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+var client workspaces.CodeReady
+
+var _ = ginkgo.Describe("[Create Cloud Shell Workspace]", func() {
+	ginkgo.It("Add cloud shell to cluster", func() {
+		label := "che.workspace_name=cloud-shell"
+		workspace := workspaces.NewWorkspaceClient()
+		_ = workspace.AddCloudShellSample()
+		deploy , err := client.PodDeployWaitUtil(label)
+		if !deploy {
+			fmt.Println("Cloud Shell not deployed")
+		}
+		Expect(err).NotTo(HaveOccurred())
+	})
+})

test/e2e/pkg/workspaces/client.go

@@ -0,0 +1,24 @@
+package workspaces
+
+import (
+	"k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/rest"
+	"sigs.k8s.io/controller-runtime/pkg/client/config"
+)
+
+type CodeReady struct {
+	rest *rest.Config
+}
+
+// NewCodeReady creates C, a workspaces used to expose common testing functions.
+func NewWorkspaceClient() *CodeReady {
+	h := &CodeReady{}
+	return h
+}
+
+// Kube returns the clientset for Kubernetes upstream.
+func (c *CodeReady) Kube() kubernetes.Interface {
+	cfg, _ := config.GetConfig()
+	client, _ := kubernetes.NewForConfig(cfg)
+	return client
+}

test/e2e/pkg/workspaces/deserialize.go

@@ -0,0 +1,48 @@
+package workspaces
+
+import (
+	"fmt"
+	"io/ioutil"
+
+	appsv1 "k8s.io/api/apps/v1"
+	corev1 "k8s.io/api/core/v1"
+	"k8s.io/client-go/kubernetes/scheme"
+)
+
+func deserializePluginRegistryDeployment() (pluginRegistry *appsv1.Deployment, err error) {
+	if err != nil {
+		fmt.Println("Failed to locate operator deployment yaml, %s", err)
+	}
+	file, err := ioutil.ReadFile("deploy/registry/local/deployment.yaml")
+	if err != nil {
+		fmt.Println("Failed to locate operator deployment yaml, %s", err)
+	}
+	deployment := string(file)
+	decode := scheme.Codecs.UniversalDeserializer().Decode
+	object, _, err := decode([]byte(deployment), nil, nil)
+	if err != nil {
+		fmt.Println("Failed to deserialize yaml %s", err)
+		return nil, err
+	}
+	pluginRegistry = object.(*appsv1.Deployment)
+	return pluginRegistry, nil
+}
+
+func deserializePluginRegistryService() (pluginRegistry *corev1.Service, err error) {
+	if err != nil {
+		fmt.Println("Failed to locate operator deployment yaml, %s", err)
+	}
+	file, err := ioutil.ReadFile("deploy/registry/local/service.yaml")
+	if err != nil {
+		fmt.Println("Failed to locate operator deployment yaml, %s", err)
+	}
+	deployment := string(file)
+	decode := scheme.Codecs.UniversalDeserializer().Decode
+	object, _, err := decode([]byte(deployment), nil, nil)
+	if err != nil {
+		fmt.Println("Failed to deserialize yaml %s", err)
+		return nil, err
+	}
+	pluginRegistry = object.(*corev1.Service)
+	return pluginRegistry, nil
+}

test/e2e/pkg/workspaces/oc.go

@@ -0,0 +1,76 @@
+package workspaces
+
+import (
+	"fmt"
+	"github.com/che-incubator/che-workspace-operator/test/e2e/pkg/metadata"
+	"os/exec"
+	"strings"
+)
+
+func (w *CodeReady) DeployWorkspacesController() (err error) {
+	label := "app=che-workspace-controller"
+	cmd := exec.Command("oc", "apply", "--namespace", metadata.Namespace.Name, "-f", "deploy/os")
+	output, err := cmd.CombinedOutput()
+	fmt.Println(string(output))
+	if err != nil && !strings.Contains(string(output), "AlreadyExists") {
+		fmt.Println(err)
+		return err
+	}
+
+	deploy , err := w.PodDeployWaitUtil(label)
+	if !deploy {
+		fmt.Println("Che Workspaces Controller not deployed")
+		return err
+	}
+	return err
+}
+
+func (w *CodeReady) CreateAllOperatorRoles() (err error) {
+	cmd := exec.Command("oc", "apply", "--namespace", metadata.Namespace.Name, "-f", "deploy")
+	output, err := cmd.CombinedOutput()
+	fmt.Println(string(output))
+	if err != nil && !strings.Contains(string(output), "AlreadyExists") {
+		fmt.Println(err)
+	}
+	return err
+}
+
+func (w *CodeReady) CreateOpenshiftRoute() (err error) {
+	cmd := exec.Command("oc", "apply", "--namespace", metadata.Namespace.Name, "-f", "deploy/registry/local/os")
+	output, err := cmd.CombinedOutput()
+	fmt.Println(string(output))
+	if err != nil && !strings.Contains(string(output), "AlreadyExists") {
+		fmt.Println(err)
+	}
+	return err
+}
+
+func (w *CodeReady) CustomResourceDefinitions() (err error) {
+	cmd := exec.Command("oc", "apply", "--namespace", metadata.Namespace.Name, "-f", "deploy/crds")
+	output, err := cmd.CombinedOutput()
+	if err != nil && !strings.Contains(string(output), "AlreadyExists") {
+		fmt.Println(err)
+	}
+	return err
+}
+
+func (w *CodeReady) CreateOperatorClusterRole() (err error) {
+	cmd := exec.Command("oc", "apply", "--namespace", metadata.Namespace.Name, "-f", "deploy/role.yaml")
+	output, err := cmd.CombinedOutput()
+	if err != nil && !strings.Contains(string(output), "AlreadyExists") {
+		fmt.Println(err)
+	}
+	return err
+}
+
+func (w *CodeReady) AddCloudShellSample() (err error) {
+	const namespace = "che-workspace-controller"
+	cmd := exec.Command("oc", "apply", "--namespace", namespace, "-f", "samples/cloud-shell.yaml")
+	output, err := cmd.CombinedOutput()
+	fmt.Println(string(output))
+	if err != nil && !strings.Contains(string(output), "AlreadyExists") {
+		fmt.Println(err)
+	}
+	return err
+}
+

test/e2e/pkg/workspaces/util.go

@@ -0,0 +1,89 @@
+package workspaces
+
+import (
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/che-incubator/che-workspace-operator/test/e2e/pkg/metadata"
+	v1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/wait"
+)
+
+func (w *CodeReady) PodDeployWaitUtil(label string) (deployed bool, err error) {
+	timeout := time.After(15 * time.Minute)
+	tick := time.Tick(1 * time.Second)
+
+	for {
+		select {
+		case <-timeout:
+			return false, errors.New("timed out")
+		case <-tick:
+			desc := w.WaitForPodBySelectorRunning(metadata.Namespace.Name, label, 180)
+			if desc != nil {
+			} else {
+				return true, nil
+			}
+		}
+	}
+}
+
+// return a condition function that indicates whether the given pod is
+// currently running
+func (w *CodeReady) isPodRunning(podName, namespace string) wait.ConditionFunc {
+	return func() (bool, error) {
+		pod, _ := w.Kube().CoreV1().Pods(namespace).Get(podName, metav1.GetOptions{})
+		age := time.Since(pod.GetCreationTimestamp().Time).Seconds()
+
+		switch pod.Status.Phase {
+		case v1.PodRunning:
+			fmt.Println("Pod started after", age, "seconds")
+			return true, nil
+		case v1.PodFailed, v1.PodSucceeded:
+			return false, nil
+		}
+		return false, nil
+	}
+}
+
+// Poll up to timeout seconds for pod to enter running state.
+// Returns an error if the pod never enters the running state.
+func (w *CodeReady) waitForPodRunning(namespace, podName string, timeout time.Duration) error {
+	return wait.PollImmediate(time.Second, timeout, w.isPodRunning(podName, namespace))
+}
+
+// Returns the list of currently scheduled or running pods in `namespace` with the given selector
+func (w *CodeReady) ListPods(namespace, selector string) (*v1.PodList, error) {
+	listOptions := metav1.ListOptions{LabelSelector: selector}
+	podList, err := w.Kube().CoreV1().Pods(namespace).List(listOptions)
+
+	if err != nil {
+		return nil, err
+	}
+	return podList, nil
+}
+
+// Wait up to timeout seconds for all pods in 'namespace' with given 'selector' to enter running state.
+// Returns an error if no pods are found or not all discovered pods enter running state.
+func (w *CodeReady) WaitForPodBySelectorRunning(namespace, selector string, timeout int) error {
+	podList, err := w.ListPods(namespace, selector)
+
+	if err != nil {
+		return err
+	}
+	if len(podList.Items) == 0 {
+		fmt.Println("Pod not created yet with selector " + selector + " in namespace " + namespace)
+
+		return fmt.Errorf("Pod not created yet in %s with label %s", namespace, selector)
+	}
+
+	for _, pod := range podList.Items {
+		fmt.Println("Pod " + pod.Name + " created in namespace " + namespace + "...Checking startup data.")
+		if err := w.waitForPodRunning(namespace, pod.Name, time.Duration(timeout)*time.Second); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}