Update tests to work on OpenShift

test/e2e/all_in_one_test.go

@@ -2,6 +2,7 @@ package e2e
 
 import (
 	goctx "context"
+	"encoding/json"
 	"fmt"
 	"io/ioutil"
 	"net/http"
@@ -28,6 +29,10 @@ func JaegerAllInOne(t *testing.T) {
 		t.Fatal(err)
 	}
 
+	if err := allInOneWithIngressTest(t, framework.Global, ctx); err != nil {
+		t.Fatal(err)
+	}
+
 	if err := allInOneWithUIConfigTest(t, framework.Global, ctx); err != nil {
 		t.Fatal(err)
 	}
@@ -69,6 +74,97 @@ func allInOneTest(t *testing.T, f *framework.Framework, ctx *framework.TestCtx)
 	return e2eutil.WaitForDeployment(t, f.KubeClient, namespace, "my-jaeger", 1, retryInterval, timeout)
 }
 
+func allInOneWithIngressTest(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 the route.
+	if isOpenShift(t, f) {
+		t.Skipf("Test %s is not currently supported on OpenShift\n", t.Name())
+	}
+	namespace, err := ctx.GetNamespace()
+	if err != nil {
+		return fmt.Errorf("could not get namespace: %v", err)
+	}
+
+	ingressEnagled := true
+	// create jaeger custom resource
+	exampleJaeger := &v1.Jaeger{
+		TypeMeta: metav1.TypeMeta{
+			Kind:       "Jaeger",
+			APIVersion: "jaegertracing.io/v1",
+		},
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "my-jaeger-with-ingress",
+			Namespace: namespace,
+		},
+		Spec: v1.JaegerSpec{
+			Strategy: "allInOne",
+			AllInOne: v1.JaegerAllInOneSpec{
+				Options: v1.NewOptions(map[string]interface{}{
+					"log-level":         "debug",
+					"memory.max-traces": 10000,
+				}),
+			},
+			Ingress: v1.JaegerIngressSpec {
+				Enabled: &ingressEnagled,
+				Security:v1.IngressSecurityNoneExplicit,
+			},
+		},
+	}
+
+	log.Infof("passing %v", exampleJaeger)
+	err = f.Client.Create(goctx.TODO(), exampleJaeger, &framework.CleanupOptions{TestContext: ctx, Timeout: timeout, RetryInterval: retryInterval})
+	if err != nil {
+		return err
+	}
+
+	ingress, err := WaitForIngress(t, f.KubeClient, namespace, "my-jaeger-with-ingress-query", retryInterval, timeout)
+	if err != nil {
+		return err
+	}
+
+	if len(ingress.Status.LoadBalancer.Ingress) != 1 {
+		return fmt.Errorf("Wrong number of ingresses. Expected 1, was %v", len(ingress.Status.LoadBalancer.Ingress))
+	}
+
+	address := ingress.Status.LoadBalancer.Ingress[0].IP
+	url := fmt.Sprintf("http://%s/api/services", address)
+	c := http.Client{Timeout: time.Second}
+	req, err := http.NewRequest(http.MethodGet, url, nil)
+	if err != nil {
+		return err
+	}
+
+	// Hit this url once to make Jaeger itself create a trace, then it will show up in services
+	c.Do(req)
+
+	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 := &services{}
+		err = json.Unmarshal(body, &resp)
+		if err != nil {
+			return false, nil
+		}
+
+		for _, v := range resp.Data {
+			if v == "jaeger-query" {
+				return true, nil
+			}
+		}
+		return false, nil
+	})
+}
+
 func allInOneWithUIConfigTest(t *testing.T, f *framework.Framework, ctx *framework.TestCtx) error {
 	cleanupOptions := &framework.CleanupOptions{TestContext: ctx, Timeout: timeout, RetryInterval: retryInterval}
 	namespace, err := ctx.GetNamespace()
@@ -113,22 +209,24 @@ 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 := jaegerAgentAsDaemonsetDefinition(namespace, "agent-as-daemonset")
 
 	log.Infof("passing %v", j)
 	err = f.Client.Create(goctx.TODO(), j, cleanupOptions)
@@ -71,6 +56,63 @@ 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 +172,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 jaegerAgentAsDaemonsetDefinition(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/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)