Update tests to work on OpenShift

test/e2e/all_in_one_test.go

@@ -113,22 +113,26 @@ func allInOneWithUIConfigTest(t *testing.T, f *framework.Framework, ctx *framewo
 		return err
 	}
 
-	err = WaitForIngress(t, f.KubeClient, namespace, "all-in-one-with-ui-config-query", retryInterval, timeout)
+	err = e2eutil.WaitForDeployment(t, f.KubeClient, namespace, "all-in-one-with-ui-config", 1, retryInterval, timeout)
 	if err != nil {
 		return err
 	}
 
-	i, err := f.KubeClient.ExtensionsV1beta1().Ingresses(namespace).Get("all-in-one-with-ui-config-query", metav1.GetOptions{})
+	queryPod, err := GetPod(namespace, "all-in-one-with-ui-config", "jaegertracing/all-in-one", f.KubeClient)
 	if err != nil {
 		return err
 	}
 
-	if len(i.Status.LoadBalancer.Ingress) != 1 {
-		return fmt.Errorf("Wrong number of ingresses. Expected 1, was %v", len(i.Status.LoadBalancer.Ingress))
+	portForward, closeChan, err := CreatePortForward(namespace, queryPod.Name, []string{"16686"}, f.KubeConfig)
+	if err != nil {
+		return err
 	}
+	defer portForward.Close()
+	defer close(closeChan)
+
+
 
-	address := i.Status.LoadBalancer.Ingress[0].IP
-	url := fmt.Sprintf("http://%s%s/search", address, basePath)
+	url := fmt.Sprintf("http://localhost:16686/%s/search", basePath)
 	c := http.Client{Timeout: time.Second}
 
 	req, err := http.NewRequest(http.MethodGet, url, nil)

test/e2e/daemonset.go

@@ -32,32 +32,17 @@ func DaemonSet(t *testing.T) {
 }
 
 func daemonsetTest(t *testing.T, f *framework.Framework, ctx *framework.TestCtx) error {
+	// TODO restore this after fix of https://github.com/jaegertracing/jaeger-operator/issues/322
+	if isOpenShift(t, f) {
+		t.Skipf("Test %s is not currently supported on OpenShift because of issue 322\n", t.Name())
+	}
 	cleanupOptions := &framework.CleanupOptions{TestContext: ctx, Timeout: timeout, RetryInterval: retryInterval}
 	namespace, err := ctx.GetNamespace()
 	if err != nil {
 		return fmt.Errorf("could not get namespace: %v", err)
 	}
 
-	j := &v1.Jaeger{
-		TypeMeta: metav1.TypeMeta{
-			Kind:       "Jaeger",
-			APIVersion: "jaegertracing.io/v1",
-		},
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      "agent-as-daemonset",
-			Namespace: namespace,
-		},
-		Spec: v1.JaegerSpec{
-			Strategy: "allInOne",
-			AllInOne: v1.JaegerAllInOneSpec{},
-			Agent: v1.JaegerAgentSpec{
-				Strategy: "DaemonSet",
-				Options: v1.NewOptions(map[string]interface{}{
-					"log-level": "debug",
-				}),
-			},
-		},
-	}
+	j := getJaegerDefinition(namespace, "agent-as-daemonset")
 
 	log.Infof("passing %v", j)
 	err = f.Client.Create(goctx.TODO(), j, cleanupOptions)
@@ -71,6 +56,65 @@ func daemonsetTest(t *testing.T, f *framework.Framework, ctx *framework.TestCtx)
 	}
 
 	selector := map[string]string{"app": "vertx-create-span"}
+	dep := getVertxDeployment(namespace, selector)
+	err = f.Client.Create(goctx.TODO(), dep, cleanupOptions)
+	if err != nil {
+		return err
+	}
+
+	err = e2eutil.WaitForDeployment(t, f.KubeClient, namespace, "vertx-create-span", 1, retryInterval, 3 * timeout)
+	if err != nil {
+		fmt.Println("Failed waiting for vertx deployment")
+		return err
+	}
+
+	queryPod, err := GetPod(namespace, "agent-as-daemonset", "jaegertracing/all-in-one", f.KubeClient)
+	if err != nil {
+		fmt.Println("Failed waiting for pod agent-as-daemonset")
+		return err
+	}
+
+	portForw, closeChan, err := CreatePortForward(namespace, queryPod.Name, []string{"16686"}, f.KubeConfig)
+	if err != nil {
+		fmt.Println("Failed waiting for port forward")
+		return err
+	}
+	defer portForw.Close()
+	defer close(closeChan)
+
+	url := "http://localhost:16686/api/traces?service=order"
+	c := http.Client{Timeout: time.Second}
+
+	req, err := http.NewRequest(http.MethodGet, url, nil)
+	if err != nil {
+		fmt.Println("Failed waiting for get on " + url)
+		return err
+	}
+
+	return wait.Poll(retryInterval, timeout, func() (done bool, err error) {
+		res, err := c.Do(req)
+		if err != nil {
+			return false, err
+		}
+
+		body, err := ioutil.ReadAll(res.Body)
+		if err != nil {
+			return false, err
+		}
+
+		resp := &resp{}
+		err = json.Unmarshal(body, &resp)
+		if err != nil {
+			return false, err
+		}
+
+		return len(resp.Data) > 0, nil
+	})
+}
+
+
+
+func getVertxDeployment(namespace string, selector map[string]string) *appsv1.Deployment {
 	dep := &appsv1.Deployment{
 		TypeMeta: metav1.TypeMeta{
 			APIVersion: "apps/v1",
@@ -130,56 +174,29 @@ func daemonsetTest(t *testing.T, f *framework.Framework, ctx *framework.TestCtx)
 			},
 		},
 	}
-	err = f.Client.Create(goctx.TODO(), dep, cleanupOptions)
-	if err != nil {
-		return err
-	}
-
-	err = e2eutil.WaitForDeployment(t, f.KubeClient, namespace, "vertx-create-span", 1, retryInterval, timeout)
-	if err != nil {
-		return err
-	}
-
-	err = WaitForIngress(t, f.KubeClient, namespace, "agent-as-daemonset-query", retryInterval, timeout)
-	if err != nil {
-		return err
-	}
-
-	i, err := f.KubeClient.ExtensionsV1beta1().Ingresses(namespace).Get("agent-as-daemonset-query", metav1.GetOptions{})
-	if err != nil {
-		return err
-	}
-
-	if len(i.Status.LoadBalancer.Ingress) != 1 {
-		return fmt.Errorf("Wrong number of ingresses. Expected 1, was %v", len(i.Status.LoadBalancer.Ingress))
-	}
-
-	address := i.Status.LoadBalancer.Ingress[0].IP
-	url := fmt.Sprintf("http://%s/api/traces?service=order", address)
-	c := http.Client{Timeout: time.Second}
+	return dep
+}
 
-	req, err := http.NewRequest(http.MethodGet, url, nil)
-	if err != nil {
-		return err
+func getJaegerDefinition(namespace string, name string) *v1.Jaeger {
+	j := &v1.Jaeger{
+		TypeMeta: metav1.TypeMeta{
+			Kind:       "Jaeger",
+			APIVersion: "jaegertracing.io/v1",
+		},
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      name,
+			Namespace: namespace,
+		},
+		Spec: v1.JaegerSpec{
+			Strategy: "allInOne",
+			AllInOne: v1.JaegerAllInOneSpec{},
+			Agent: v1.JaegerAgentSpec{
+				Strategy: "DaemonSet",
+				Options: v1.NewOptions(map[string]interface{}{
+					"log-level": "debug",
+				}),
+			},
+		},
 	}
-
-	return wait.Poll(retryInterval, timeout, func() (done bool, err error) {
-		res, err := c.Do(req)
-		if err != nil {
-			return false, err
-		}
-
-		body, err := ioutil.ReadAll(res.Body)
-		if err != nil {
-			return false, err
-		}
-
-		resp := &resp{}
-		err = json.Unmarshal(body, &resp)
-		if err != nil {
-			return false, err
-		}
-
-		return len(resp.Data) > 0, nil
-	})
+	return j
 }

test/e2e/daemonset_with_ingress.go

@@ -0,0 +1,111 @@
+package e2e
+
+import (
+	goctx "context"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"testing"
+	"time"
+
+	framework "github.com/operator-framework/operator-sdk/pkg/test"
+	"github.com/operator-framework/operator-sdk/pkg/test/e2eutil"
+	log "github.com/sirupsen/logrus"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/wait"
+)
+
+// DaemonSet runs a test with the agent as DaemonSet, but uses ingress to access it rather than portforwarding
+func DaemonSetWithIngress(t *testing.T) {
+	ctx := prepare(t)
+	defer ctx.Cleanup()
+
+	if err := daemonsetTestWithIngress(t, framework.Global, ctx); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func daemonsetTestWithIngress(t *testing.T, f *framework.Framework, ctx *framework.TestCtx) error {
+	// This does not currently work on OpenShift as it creates a route, and the kubeclient call
+	// in WaitForIngress doesn't find that.  We either need to figure out how to get kubeclient
+	// to find routes (at the command line "kubectl get route.route.openshift.io" works) or use
+	// the openshift client to find it.
+	if isOpenShift(t, f) {
+		t.Skipf("Test %s is not currently supported on OpenShift\n", t.Name())
+	}
+
+	cleanupOptions := &framework.CleanupOptions{TestContext: ctx, Timeout: timeout, RetryInterval: retryInterval}
+	namespace, err := ctx.GetNamespace()
+	if err != nil {
+		return fmt.Errorf("could not get namespace: %v", err)
+	}
+
+	j := getJaegerDefinition(namespace, "agent-as-daemonset")
+
+	log.Infof("passing %v", j)
+	err = f.Client.Create(goctx.TODO(), j, cleanupOptions)
+	if err != nil {
+		return err
+	}
+
+	err = WaitForDaemonSet(t, f.KubeClient, namespace, "agent-as-daemonset-agent-daemonset", retryInterval, timeout)
+	if err != nil {
+		return err
+	}
+
+	selector := map[string]string{"app": "vertx-create-span"}
+	dep := getVertxDeployment(namespace, selector)
+	err = f.Client.Create(goctx.TODO(), dep, cleanupOptions)
+	if err != nil {
+		return err
+	}
+
+	err = e2eutil.WaitForDeployment(t, f.KubeClient, namespace, "vertx-create-span", 1, retryInterval, 3 * timeout)
+	if err != nil {
+		return err
+	}
+
+	err = WaitForIngress(t, f.KubeClient, namespace, "agent-as-daemonset-query", retryInterval, timeout)
+	if err != nil {
+		return err
+	}
+
+	i, err := f.KubeClient.ExtensionsV1beta1().Ingresses(namespace).Get("agent-as-daemonset-query", metav1.GetOptions{})
+	if err != nil {
+		return err
+	}
+
+	if len(i.Status.LoadBalancer.Ingress) != 1 {
+		return fmt.Errorf("Wrong number of ingresses. Expected 1, was %v", len(i.Status.LoadBalancer.Ingress))
+	}
+
+	address := i.Status.LoadBalancer.Ingress[0].IP
+	url := fmt.Sprintf("http://%s/api/traces?service=order", address)
+	c := http.Client{Timeout: time.Second}
+
+	req, err := http.NewRequest(http.MethodGet, url, nil)
+	if err != nil {
+		return err
+	}
+
+	return wait.Poll(retryInterval, timeout, func() (done bool, err error) {
+		res, err := c.Do(req)
+		if err != nil {
+			return false, err
+		}
+
+		body, err := ioutil.ReadAll(res.Body)
+		if err != nil {
+			return false, err
+		}
+
+		resp := &resp{}
+		err = json.Unmarshal(body, &resp)
+		if err != nil {
+			return false, err
+		}
+
+		return len(resp.Data) > 0, nil
+	})
+}

test/e2e/sidecar.go

@@ -124,22 +124,19 @@ func sidecarTest(t *testing.T, f *framework.Framework, ctx *framework.TestCtx) e
 		return err
 	}
 
-	err = WaitForIngress(t, f.KubeClient, namespace, "agent-as-sidecar-query", retryInterval, timeout)
+	queryPod, err := GetPod(namespace, "agent-as-sidecar", "jaegertracing/all-in-one", f.KubeClient)
 	if err != nil {
 		return err
 	}
 
-	i, err := f.KubeClient.ExtensionsV1beta1().Ingresses(namespace).Get("agent-as-sidecar-query", metav1.GetOptions{})
+	portForward, closeChan, err := CreatePortForward(namespace, queryPod.Name, []string{"16686"}, f.KubeConfig)
 	if err != nil {
 		return err
 	}
+	defer portForward.Close()
+	defer close(closeChan)
 
-	if len(i.Status.LoadBalancer.Ingress) != 1 {
-		return fmt.Errorf("Wrong number of ingresses. Expected 1, was %v", len(i.Status.LoadBalancer.Ingress))
-	}
-
-	address := i.Status.LoadBalancer.Ingress[0].IP
-	url := fmt.Sprintf("http://%s/api/traces?service=order", address)
+	url := "http://localhost:16686/api/traces?service=order"
 	c := http.Client{Timeout: time.Second}
 
 	req, err := http.NewRequest(http.MethodGet, url, nil)

test/e2e/suite_smoke_test.go

@@ -24,6 +24,7 @@ func TestSmoke(t *testing.T) {
 	t.Run("smoke", func(t *testing.T) {
 		t.Run("my-jaeger", JaegerAllInOne)
 		t.Run("daemonset", DaemonSet)
+		t.Run("daemonset-with-ingress", DaemonSetWithIngress)
 		t.Run("sidecar", Sidecar)
 	})
 }