diff --git a/Makefile b/Makefile
index 1aadd065f..316e62264 100644
--- a/Makefile
+++ b/Makefile
@@ -1,6 +1,6 @@
 REPO?=quay.io/coreos/prometheus-operator
 TAG?=$(shell git rev-parse --short HEAD)
-NAMESPACE?=prometheus-operator-e2e-tests-$(shell LC_CTYPE=C tr -dc a-z0-9 < /dev/urandom | head -c 13 ; echo '')
+NAMESPACE?=po-e2e-$(shell LC_CTYPE=C tr -dc a-z0-9 < /dev/urandom | head -c 13 ; echo '')
 
 PROMU := $(GOPATH)/bin/promu
 PREFIX ?= $(shell pwd)
diff --git a/scripts/jenkins/Dockerfile b/scripts/jenkins/Dockerfile
index 23076f028..c4791ca87 100644
--- a/scripts/jenkins/Dockerfile
+++ b/scripts/jenkins/Dockerfile
@@ -1,4 +1,4 @@
-FROM golang:1.7.5-wheezy
+FROM golang:1.8.1-stretch
 
 ENV TERRAFORM_VERSION 0.8.7
 ENV KOPS_VERSION 1.5.1
@@ -10,7 +10,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     ca-certificates \
     wget \
     unzip \
-    python python-pip jq \
+    python python-pip jq python-setuptools \
     && rm -rf /var/lib/apt/lists/*
 
 RUN curl https://get.docker.com/builds/Linux/x86_64/docker-${DOCKER_VERSION}.tgz | tar -xvz && \
diff --git a/test/e2e/alertmanager_test.go b/test/e2e/alertmanager_test.go
index 663580ccf..e30507bd5 100644
--- a/test/e2e/alertmanager_test.go
+++ b/test/e2e/alertmanager_test.go
@@ -28,85 +28,101 @@ import (
 )
 
 func TestAlertmanagerCreateDeleteCluster(t *testing.T) {
+	ctx := testFramework.NewTestCtx(t)
+	defer ctx.CleanUp(t)
+	ctx.BasicSetup(t, framework.KubeClient)
+
 	name := "test"
 
 	defer func() {
-		if err := framework.DeleteAlertmanagerAndWaitUntilGone(name); err != nil {
+		if err := framework.DeleteAlertmanagerAndWaitUntilGone(ctx.Id, name); err != nil {
 			t.Fatal(err)
 		}
 	}()
 
-	if err := framework.CreateAlertmanagerAndWaitUntilReady(framework.MakeBasicAlertmanager(name, 3)); err != nil {
+	if err := framework.CreateAlertmanagerAndWaitUntilReady(ctx.Id, framework.MakeBasicAlertmanager(name, 3)); err != nil {
 		t.Fatal(err)
 	}
 }
 
 func TestAlertmanagerScaling(t *testing.T) {
+	ctx := testFramework.NewTestCtx(t)
+	defer ctx.CleanUp(t)
+	ctx.BasicSetup(t, framework.KubeClient)
+
 	name := "test"
 
 	defer func() {
-		if err := framework.DeleteAlertmanagerAndWaitUntilGone(name); err != nil {
+		if err := framework.DeleteAlertmanagerAndWaitUntilGone(ctx.Id, name); err != nil {
 			t.Fatal(err)
 		}
 	}()
 
-	if err := framework.CreateAlertmanagerAndWaitUntilReady(framework.MakeBasicAlertmanager(name, 3)); err != nil {
+	if err := framework.CreateAlertmanagerAndWaitUntilReady(ctx.Id, framework.MakeBasicAlertmanager(name, 3)); err != nil {
 		t.Fatal(err)
 	}
 
-	if err := framework.UpdateAlertmanagerAndWaitUntilReady(framework.MakeBasicAlertmanager(name, 5)); err != nil {
+	if err := framework.UpdateAlertmanagerAndWaitUntilReady(ctx.Id, framework.MakeBasicAlertmanager(name, 5)); err != nil {
 		t.Fatal(err)
 	}
 
-	if err := framework.UpdateAlertmanagerAndWaitUntilReady(framework.MakeBasicAlertmanager(name, 3)); err != nil {
+	if err := framework.UpdateAlertmanagerAndWaitUntilReady(ctx.Id, framework.MakeBasicAlertmanager(name, 3)); err != nil {
 		t.Fatal(err)
 	}
 }
 
 func TestAlertmanagerVersionMigration(t *testing.T) {
+	ctx := testFramework.NewTestCtx(t)
+	defer ctx.CleanUp(t)
+	ctx.BasicSetup(t, framework.KubeClient)
+
 	name := "test"
 
 	defer func() {
-		if err := framework.DeleteAlertmanagerAndWaitUntilGone(name); err != nil {
+		if err := framework.DeleteAlertmanagerAndWaitUntilGone(ctx.Id, name); err != nil {
 			t.Fatal(err)
 		}
 	}()
 
 	am := framework.MakeBasicAlertmanager(name, 3)
 	am.Spec.Version = "v0.6.0"
-	if err := framework.CreateAlertmanagerAndWaitUntilReady(am); err != nil {
+	if err := framework.CreateAlertmanagerAndWaitUntilReady(ctx.Id, am); err != nil {
 		t.Fatal(err)
 	}
 
 	am.Spec.Version = "v0.6.1"
-	if err := framework.UpdateAlertmanagerAndWaitUntilReady(am); err != nil {
+	if err := framework.UpdateAlertmanagerAndWaitUntilReady(ctx.Id, am); err != nil {
 		t.Fatal(err)
 	}
 
 	am.Spec.Version = "v0.6.0"
-	if err := framework.UpdateAlertmanagerAndWaitUntilReady(am); err != nil {
+	if err := framework.UpdateAlertmanagerAndWaitUntilReady(ctx.Id, am); err != nil {
 		t.Fatal(err)
 	}
 }
 
 func TestExposingAlertmanagerWithNodePort(t *testing.T) {
+	ctx := testFramework.NewTestCtx(t)
+	defer ctx.CleanUp(t)
+	ctx.BasicSetup(t, framework.KubeClient)
+
 	alertmanager := framework.MakeBasicAlertmanager("test-alertmanager", 1)
 	alertmanagerService := framework.MakeAlertmanagerNodePortService(alertmanager.Name, "nodeport-service", 30903)
 
 	defer func() {
-		if err := framework.DeleteAlertmanagerAndWaitUntilGone(alertmanager.Name); err != nil {
+		if err := framework.DeleteAlertmanagerAndWaitUntilGone(ctx.Id, alertmanager.Name); err != nil {
 			t.Fatal(err)
 		}
-		if err := testFramework.DeleteService(framework.KubeClient, framework.Namespace.Name, alertmanagerService.Name); err != nil {
+		if err := testFramework.DeleteService(framework.KubeClient, ctx.Id, alertmanagerService.Name); err != nil {
 			t.Fatal(err)
 		}
 	}()
 
-	if err := framework.CreateAlertmanagerAndWaitUntilReady(alertmanager); err != nil {
+	if err := framework.CreateAlertmanagerAndWaitUntilReady(ctx.Id, alertmanager); err != nil {
 		t.Fatal(err)
 	}
 
-	if err := testFramework.CreateServiceAndWaitUntilReady(framework.KubeClient, framework.Namespace.Name, alertmanagerService); err != nil {
+	if err := testFramework.CreateServiceAndWaitUntilReady(framework.KubeClient, ctx.Id, alertmanagerService); err != nil {
 		t.Fatal(err)
 	}
 
@@ -119,27 +135,31 @@ func TestExposingAlertmanagerWithNodePort(t *testing.T) {
 }
 
 func TestExposingAlertmanagerWithKubernetesAPI(t *testing.T) {
+	ctx := testFramework.NewTestCtx(t)
+	defer ctx.CleanUp(t)
+	ctx.BasicSetup(t, framework.KubeClient)
+
 	alertmanager := framework.MakeBasicAlertmanager("test-alertmanager", 1)
 	alertmanagerService := framework.MakeAlertmanagerService(alertmanager.Name, "alertmanager-service", v1.ServiceTypeClusterIP)
 
 	defer func() {
-		if err := framework.DeleteAlertmanagerAndWaitUntilGone(alertmanager.Name); err != nil {
+		if err := framework.DeleteAlertmanagerAndWaitUntilGone(ctx.Id, alertmanager.Name); err != nil {
 			t.Fatal(err)
 		}
-		if err := testFramework.DeleteService(framework.KubeClient, framework.Namespace.Name, alertmanagerService.Name); err != nil {
+		if err := testFramework.DeleteService(framework.KubeClient, ctx.Id, alertmanagerService.Name); err != nil {
 			t.Fatal(err)
 		}
 	}()
 
-	if err := framework.CreateAlertmanagerAndWaitUntilReady(alertmanager); err != nil {
+	if err := framework.CreateAlertmanagerAndWaitUntilReady(ctx.Id, alertmanager); err != nil {
 		t.Fatal(err)
 	}
 
-	if err := testFramework.CreateServiceAndWaitUntilReady(framework.KubeClient, framework.Namespace.Name, alertmanagerService); err != nil {
+	if err := testFramework.CreateServiceAndWaitUntilReady(framework.KubeClient, ctx.Id, alertmanagerService); err != nil {
 		t.Fatal(err)
 	}
 
-	proxyGet := framework.KubeClient.CoreV1().Services(framework.Namespace.Name).ProxyGet
+	proxyGet := framework.KubeClient.CoreV1().Services(ctx.Id).ProxyGet
 	request := proxyGet("", alertmanagerService.Name, "web", "/", make(map[string]string))
 	_, err := request.DoRaw()
 	if err != nil {
@@ -148,42 +168,46 @@ func TestExposingAlertmanagerWithKubernetesAPI(t *testing.T) {
 }
 
 func TestExposingAlertmanagerWithIngress(t *testing.T) {
+	ctx := testFramework.NewTestCtx(t)
+	defer ctx.CleanUp(t)
+	ctx.BasicSetup(t, framework.KubeClient)
+
 	alertmanager := framework.MakeBasicAlertmanager("main", 1)
 	alertmanagerService := framework.MakeAlertmanagerService(alertmanager.Name, "test-group", v1.ServiceTypeClusterIP)
 	ingress := testFramework.MakeBasicIngress(alertmanagerService.Name, 9093)
 
 	defer func() {
-		if err := framework.DeleteAlertmanagerAndWaitUntilGone(alertmanager.Name); err != nil {
+		if err := framework.DeleteAlertmanagerAndWaitUntilGone(ctx.Id, alertmanager.Name); err != nil {
 			t.Fatal(err)
 		}
-		if err := testFramework.DeleteService(framework.KubeClient, framework.Namespace.Name, alertmanagerService.Name); err != nil {
+		if err := testFramework.DeleteService(framework.KubeClient, ctx.Id, alertmanagerService.Name); err != nil {
 			t.Fatal(err)
 		}
-		if err := framework.KubeClient.Extensions().Ingresses(framework.Namespace.Name).Delete(ingress.Name, nil); err != nil {
+		if err := framework.KubeClient.Extensions().Ingresses(ctx.Id).Delete(ingress.Name, nil); err != nil {
 			t.Fatal(err)
 		}
-		if err := testFramework.DeleteNginxIngressControllerIncDefaultBackend(framework.KubeClient, framework.Namespace.Name); err != nil {
+		if err := testFramework.DeleteNginxIngressControllerIncDefaultBackend(framework.KubeClient, ctx.Id); err != nil {
 			t.Fatal(err)
 		}
 	}()
 
-	if err := testFramework.SetupNginxIngressControllerIncDefaultBackend(framework.KubeClient, framework.Namespace.Name); err != nil {
+	if err := testFramework.SetupNginxIngressControllerIncDefaultBackend(framework.KubeClient, ctx.Id); err != nil {
 		t.Fatal(err)
 	}
 
-	if err := framework.CreateAlertmanagerAndWaitUntilReady(alertmanager); err != nil {
+	if err := framework.CreateAlertmanagerAndWaitUntilReady(ctx.Id, alertmanager); err != nil {
 		t.Fatal(err)
 	}
 
-	if err := testFramework.CreateServiceAndWaitUntilReady(framework.KubeClient, framework.Namespace.Name, alertmanagerService); err != nil {
+	if err := testFramework.CreateServiceAndWaitUntilReady(framework.KubeClient, ctx.Id, alertmanagerService); err != nil {
 		t.Fatal(err)
 	}
 
-	if err := testFramework.CreateIngress(framework.KubeClient, framework.Namespace.Name, ingress); err != nil {
+	if err := testFramework.CreateIngress(framework.KubeClient, ctx.Id, ingress); err != nil {
 		t.Fatal(err)
 	}
 
-	ip, err := testFramework.GetIngressIP(framework.KubeClient, framework.Namespace.Name, ingress.Name)
+	ip, err := testFramework.GetIngressIP(framework.KubeClient, ctx.Id, ingress.Name)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -195,6 +219,10 @@ func TestExposingAlertmanagerWithIngress(t *testing.T) {
 }
 
 func TestMeshInitialization(t *testing.T) {
+	ctx := testFramework.NewTestCtx(t)
+	defer ctx.CleanUp(t)
+	ctx.BasicSetup(t, framework.KubeClient)
+
 	var amountAlertmanagers int32 = 3
 	alertmanager := &v1alpha1.Alertmanager{
 		ObjectMeta: v1.ObjectMeta{
@@ -209,31 +237,35 @@ func TestMeshInitialization(t *testing.T) {
 	alertmanagerService := framework.MakeAlertmanagerService(alertmanager.Name, "alertmanager-service", v1.ServiceTypeClusterIP)
 
 	defer func() {
-		if err := framework.DeleteAlertmanagerAndWaitUntilGone(alertmanager.Name); err != nil {
+		if err := framework.DeleteAlertmanagerAndWaitUntilGone(ctx.Id, alertmanager.Name); err != nil {
 			t.Fatal(err)
 		}
-		if err := testFramework.DeleteService(framework.KubeClient, framework.Namespace.Name, alertmanagerService.Name); err != nil {
+		if err := testFramework.DeleteService(framework.KubeClient, ctx.Id, alertmanagerService.Name); err != nil {
 			t.Fatal(err)
 		}
 	}()
 
-	if err := framework.CreateAlertmanagerAndWaitUntilReady(alertmanager); err != nil {
+	if err := framework.CreateAlertmanagerAndWaitUntilReady(ctx.Id, alertmanager); err != nil {
 		t.Fatal(err)
 	}
 
-	if err := testFramework.CreateServiceAndWaitUntilReady(framework.KubeClient, framework.Namespace.Name, alertmanagerService); err != nil {
+	if err := testFramework.CreateServiceAndWaitUntilReady(framework.KubeClient, ctx.Id, alertmanagerService); err != nil {
 		t.Fatal(err)
 	}
 
 	for i := 0; i < int(amountAlertmanagers); i++ {
 		name := "alertmanager-" + alertmanager.Name + "-" + strconv.Itoa(i)
-		if err := framework.WaitForAlertmanagerInitializedMesh(name, int(amountAlertmanagers)); err != nil {
+		if err := framework.WaitForAlertmanagerInitializedMesh(ctx.Id, name, int(amountAlertmanagers)); err != nil {
 			t.Fatal(err)
 		}
 	}
 }
 
 func TestAlertmanagerReloadConfig(t *testing.T) {
+	ctx := testFramework.NewTestCtx(t)
+	defer ctx.CleanUp(t)
+	ctx.BasicSetup(t, framework.KubeClient)
+
 	alertmanager := framework.MakeBasicAlertmanager("reload-config", 1)
 
 	firstConfig := `
@@ -275,30 +307,30 @@ receivers:
 	}
 
 	defer func() {
-		if err := framework.DeleteAlertmanagerAndWaitUntilGone(alertmanager.Name); err != nil {
+		if err := framework.DeleteAlertmanagerAndWaitUntilGone(ctx.Id, alertmanager.Name); err != nil {
 			t.Fatal(err)
 		}
 	}()
 
-	if err := framework.CreateAlertmanagerAndWaitUntilReady(alertmanager); err != nil {
+	if err := framework.CreateAlertmanagerAndWaitUntilReady(ctx.Id, alertmanager); err != nil {
 		t.Fatal(err)
 	}
 
-	if _, err := framework.KubeClient.CoreV1().Secrets(framework.Namespace.Name).Update(cfg); err != nil {
+	if _, err := framework.KubeClient.CoreV1().Secrets(ctx.Id).Update(cfg); err != nil {
 		t.Fatal(err)
 	}
 
-	if err := framework.WaitForSpecificAlertmanagerConfig(alertmanager.Name, firstConfig); err != nil {
+	if err := framework.WaitForSpecificAlertmanagerConfig(ctx.Id, alertmanager.Name, firstConfig); err != nil {
 		t.Fatal(err)
 	}
 
 	cfg.Data["alertmanager.yaml"] = []byte(secondConfig)
 
-	if _, err := framework.KubeClient.CoreV1().Secrets(framework.Namespace.Name).Update(cfg); err != nil {
+	if _, err := framework.KubeClient.CoreV1().Secrets(ctx.Id).Update(cfg); err != nil {
 		t.Fatal(err)
 	}
 
-	if err := framework.WaitForSpecificAlertmanagerConfig(alertmanager.Name, secondConfig); err != nil {
+	if err := framework.WaitForSpecificAlertmanagerConfig(ctx.Id, alertmanager.Name, secondConfig); err != nil {
 		t.Fatal(err)
 	}
 }
diff --git a/test/e2e/framework/alertmanager.go b/test/e2e/framework/alertmanager.go
index a8939add0..44b0ed4ef 100644
--- a/test/e2e/framework/alertmanager.go
+++ b/test/e2e/framework/alertmanager.go
@@ -17,7 +17,6 @@ package framework
 import (
 	"encoding/json"
 	"fmt"
-	"log"
 	"os"
 	"time"
 
@@ -113,26 +112,25 @@ func (f *Framework) AlertmanagerConfigSecret(name string) (*v1.Secret, error) {
 	return s, nil
 }
 
-func (f *Framework) CreateAlertmanagerAndWaitUntilReady(a *v1alpha1.Alertmanager) error {
-	log.Printf("Creating Alertmanager (%s/%s)", f.Namespace.Name, a.Name)
+func (f *Framework) CreateAlertmanagerAndWaitUntilReady(ns string, a *v1alpha1.Alertmanager) error {
 	amConfigSecretName := fmt.Sprintf("alertmanager-%s", a.Name)
 	s, err := f.AlertmanagerConfigSecret(amConfigSecretName)
 	if err != nil {
 		return errors.Wrap(err, fmt.Sprintf("making alertmanager config secret %v failed", amConfigSecretName))
 	}
-	_, err = f.KubeClient.CoreV1().Secrets(f.Namespace.Name).Create(s)
+	_, err = f.KubeClient.CoreV1().Secrets(ns).Create(s)
 	if err != nil {
 		return errors.Wrap(err, fmt.Sprintf("creating alertmanager config secret %v failed", s.Name))
 	}
 
-	_, err = f.MonClient.Alertmanagers(f.Namespace.Name).Create(a)
+	_, err = f.MonClient.Alertmanagers(ns).Create(a)
 	if err != nil {
 		return errors.Wrap(err, fmt.Sprintf("creating alertmanager %v failed", a.Name))
 	}
 
 	err = WaitForPodsReady(
 		f.KubeClient,
-		f.Namespace.Name,
+		ns,
 		f.DefaultTimeout,
 		int(*a.Spec.Replicas),
 		alertmanager.ListOptions(a.Name),
@@ -143,16 +141,15 @@ func (f *Framework) CreateAlertmanagerAndWaitUntilReady(a *v1alpha1.Alertmanager
 	return nil
 }
 
-func (f *Framework) UpdateAlertmanagerAndWaitUntilReady(a *v1alpha1.Alertmanager) error {
-	log.Printf("Updating Alertmanager (%s/%s)", f.Namespace.Name, a.Name)
-	_, err := f.MonClient.Alertmanagers(f.Namespace.Name).Update(a)
+func (f *Framework) UpdateAlertmanagerAndWaitUntilReady(ns string, a *v1alpha1.Alertmanager) error {
+	_, err := f.MonClient.Alertmanagers(ns).Update(a)
 	if err != nil {
 		return err
 	}
 
 	err = WaitForPodsReady(
 		f.KubeClient,
-		f.Namespace.Name,
+		ns,
 		f.DefaultTimeout,
 		int(*a.Spec.Replicas),
 		alertmanager.ListOptions(a.Name),
@@ -164,20 +161,19 @@ func (f *Framework) UpdateAlertmanagerAndWaitUntilReady(a *v1alpha1.Alertmanager
 	return nil
 }
 
-func (f *Framework) DeleteAlertmanagerAndWaitUntilGone(name string) error {
-	log.Printf("Deleting Alertmanager (%s/%s)", f.Namespace.Name, name)
-	_, err := f.MonClient.Alertmanagers(f.Namespace.Name).Get(name)
+func (f *Framework) DeleteAlertmanagerAndWaitUntilGone(ns, name string) error {
+	_, err := f.MonClient.Alertmanagers(ns).Get(name)
 	if err != nil {
 		return errors.Wrap(err, fmt.Sprintf("requesting Alertmanager tpr %v failed", name))
 	}
 
-	if err := f.MonClient.Alertmanagers(f.Namespace.Name).Delete(name, nil); err != nil {
+	if err := f.MonClient.Alertmanagers(ns).Delete(name, nil); err != nil {
 		return errors.Wrap(err, fmt.Sprintf("deleting Alertmanager tpr %v failed", name))
 	}
 
 	if err := WaitForPodsReady(
 		f.KubeClient,
-		f.Namespace.Name,
+		ns,
 		f.DefaultTimeout,
 		0,
 		alertmanager.ListOptions(name),
@@ -185,16 +181,16 @@ func (f *Framework) DeleteAlertmanagerAndWaitUntilGone(name string) error {
 		return errors.Wrap(err, fmt.Sprintf("waiting for Alertmanager tpr (%s) to vanish timed out", name))
 	}
 
-	return f.KubeClient.CoreV1().Secrets(f.Namespace.Name).Delete(fmt.Sprintf("alertmanager-%s", name), nil)
+	return f.KubeClient.CoreV1().Secrets(ns).Delete(fmt.Sprintf("alertmanager-%s", name), nil)
 }
 
 func amImage(version string) string {
 	return fmt.Sprintf("quay.io/prometheus/alertmanager:%s", version)
 }
 
-func (f *Framework) WaitForAlertmanagerInitializedMesh(name string, amountPeers int) error {
+func (f *Framework) WaitForAlertmanagerInitializedMesh(ns, name string, amountPeers int) error {
 	return wait.Poll(time.Second, time.Second*20, func() (bool, error) {
-		amStatus, err := f.GetAlertmanagerConfig(name)
+		amStatus, err := f.GetAlertmanagerConfig(ns, name)
 		if err != nil {
 			return false, err
 		}
@@ -206,9 +202,9 @@ func (f *Framework) WaitForAlertmanagerInitializedMesh(name string, amountPeers
 	})
 }
 
-func (f *Framework) GetAlertmanagerConfig(n string) (alertmanagerStatus, error) {
+func (f *Framework) GetAlertmanagerConfig(ns, n string) (alertmanagerStatus, error) {
 	var amStatus alertmanagerStatus
-	request := ProxyGetPod(f.KubeClient, f.Namespace.Name, n, "9093", "/api/v1/status")
+	request := ProxyGetPod(f.KubeClient, ns, n, "9093", "/api/v1/status")
 	resp, err := request.DoRaw()
 	if err != nil {
 		return amStatus, err
@@ -221,9 +217,9 @@ func (f *Framework) GetAlertmanagerConfig(n string) (alertmanagerStatus, error)
 	return amStatus, nil
 }
 
-func (f *Framework) WaitForSpecificAlertmanagerConfig(amName string, expectedConfig string) error {
+func (f *Framework) WaitForSpecificAlertmanagerConfig(ns, amName string, expectedConfig string) error {
 	return wait.Poll(time.Second, time.Minute*5, func() (bool, error) {
-		config, err := f.GetAlertmanagerConfig("alertmanager-" + amName + "-0")
+		config, err := f.GetAlertmanagerConfig(ns, "alertmanager-"+amName+"-0")
 		if err != nil {
 			return false, err
 		}
diff --git a/test/e2e/framework/context.go b/test/e2e/framework/context.go
new file mode 100644
index 000000000..21d42360c
--- /dev/null
+++ b/test/e2e/framework/context.go
@@ -0,0 +1,53 @@
+package framework
+
+import (
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"golang.org/x/sync/errgroup"
+	"k8s.io/client-go/kubernetes"
+)
+
+type TestCtx struct {
+	Id         string
+	cleanUpFns []finalizerFn
+}
+
+type finalizerFn func() error
+
+func NewTestCtx(t *testing.T) TestCtx {
+	prefix := strings.TrimPrefix(strings.ToLower(t.Name()), "test")
+
+	id := prefix + "-" + strconv.FormatInt(time.Now().Unix(), 10)
+	return TestCtx{
+		Id: id,
+	}
+}
+
+func (ctx *TestCtx) BasicSetup(t *testing.T, kubeClient kubernetes.Interface) {
+	if _, err := CreateNamespace(kubeClient, ctx.Id); err != nil {
+		t.Fatal(err)
+	}
+
+	ctx.cleanUpFns = append(ctx.cleanUpFns, func() error {
+		if err := DeleteNamespace(kubeClient, ctx.Id); err != nil {
+			return err
+		}
+		return nil
+	})
+}
+
+func (ctx *TestCtx) CleanUp(t *testing.T) {
+	var eg errgroup.Group
+
+	// TODO: Should be a stack not a list
+	for _, f := range ctx.cleanUpFns {
+		eg.Go(f)
+	}
+
+	if err := eg.Wait(); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/test/e2e/framework/framework.go b/test/e2e/framework/framework.go
index 34d9980db..5c653c92b 100644
--- a/test/e2e/framework/framework.go
+++ b/test/e2e/framework/framework.go
@@ -26,6 +26,7 @@ import (
 
 	"github.com/coreos/prometheus-operator/pkg/client/monitoring/v1alpha1"
 	"github.com/coreos/prometheus-operator/pkg/k8sutil"
+	"github.com/pkg/errors"
 )
 
 type Framework struct {
@@ -61,11 +62,7 @@ func New(ns, kubeconfig, opImage, ip string) (*Framework, error) {
 		return nil, err
 	}
 
-	namespace, err := cli.Core().Namespaces().Create(&v1.Namespace{
-		ObjectMeta: v1.ObjectMeta{
-			Name: ns,
-		},
-	})
+	namespace, err := CreateNamespace(cli, ns)
 	if err != nil {
 		return nil, err
 	}
@@ -114,7 +111,7 @@ func (f *Framework) setupPrometheusOperator(opImage string) error {
 	opts := v1.ListOptions{LabelSelector: fields.SelectorFromSet(fields.Set(deploy.Spec.Template.ObjectMeta.Labels)).String()}
 	err = WaitForPodsReady(f.KubeClient, f.Namespace.Name, f.DefaultTimeout, 1, opts)
 	if err != nil {
-		return err
+		return errors.Wrap(err, "failed to wait for prometheus operator to become ready")
 	}
 
 	pl, err := f.KubeClient.Core().Pods(f.Namespace.Name).List(opts)
@@ -149,8 +146,7 @@ func (f *Framework) Teardown() error {
 	if err := f.KubeClient.Extensions().Deployments(f.Namespace.Name).Delete("prometheus-operator", nil); err != nil {
 		return err
 	}
-
-	if err := f.KubeClient.Core().Namespaces().Delete(f.Namespace.Name, nil); err != nil {
+	if err := DeleteNamespace(f.KubeClient, f.Namespace.Name); err != nil {
 		return err
 	}
 
diff --git a/test/e2e/framework/namespace.go b/test/e2e/framework/namespace.go
new file mode 100644
index 000000000..d5c8e835e
--- /dev/null
+++ b/test/e2e/framework/namespace.go
@@ -0,0 +1,26 @@
+package framework
+
+import (
+	"fmt"
+
+	"k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/pkg/api/v1"
+
+	"github.com/pkg/errors"
+)
+
+func CreateNamespace(kubeClient kubernetes.Interface, name string) (*v1.Namespace, error) {
+	namespace, err := kubeClient.Core().Namespaces().Create(&v1.Namespace{
+		ObjectMeta: v1.ObjectMeta{
+			Name: name,
+		},
+	})
+	if err != nil {
+		return nil, errors.Wrap(err, fmt.Sprintf("failed to create namespace with name %v", name))
+	}
+	return namespace, nil
+}
+
+func DeleteNamespace(kubeClient kubernetes.Interface, name string) error {
+	return kubeClient.Core().Namespaces().Delete(name, nil)
+}
diff --git a/test/e2e/framework/prometheus.go b/test/e2e/framework/prometheus.go
index d8215f23f..6ce496bce 100644
--- a/test/e2e/framework/prometheus.go
+++ b/test/e2e/framework/prometheus.go
@@ -17,7 +17,6 @@ package framework
 import (
 	"encoding/json"
 	"fmt"
-	"log"
 	"net/http"
 	"time"
 
@@ -32,11 +31,11 @@ import (
 	"github.com/pkg/errors"
 )
 
-func (f *Framework) MakeBasicPrometheus(name, group string, replicas int32) *v1alpha1.Prometheus {
+func (f *Framework) MakeBasicPrometheus(ns, name, group string, replicas int32) *v1alpha1.Prometheus {
 	return &v1alpha1.Prometheus{
 		ObjectMeta: v1.ObjectMeta{
 			Name:      name,
-			Namespace: f.Namespace.Name,
+			Namespace: ns,
 		},
 		Spec: v1alpha1.PrometheusSpec{
 			Replicas: &replicas,
@@ -59,11 +58,11 @@ func (f *Framework) MakeBasicPrometheus(name, group string, replicas int32) *v1a
 	}
 }
 
-func (f *Framework) AddAlertingToPrometheus(p *v1alpha1.Prometheus, name string) {
+func (f *Framework) AddAlertingToPrometheus(p *v1alpha1.Prometheus, ns, name string) {
 	p.Spec.Alerting = v1alpha1.AlertingSpec{
 		Alertmanagers: []v1alpha1.AlertmanagerEndpoints{
 			v1alpha1.AlertmanagerEndpoints{
-				Namespace: f.Namespace.Name,
+				Namespace: ns,
 				Name:      fmt.Sprintf("alertmanager-%s", name),
 				Port:      intstr.FromString("web"),
 			},
@@ -126,28 +125,26 @@ func (f *Framework) MakePrometheusService(name, group string, serviceType v1.Ser
 	return service
 }
 
-func (f *Framework) CreatePrometheusAndWaitUntilReady(p *v1alpha1.Prometheus) error {
-	log.Printf("Creating Prometheus (%s/%s)", f.Namespace.Name, p.Name)
-	_, err := f.MonClient.Prometheuses(f.Namespace.Name).Create(p)
+func (f *Framework) CreatePrometheusAndWaitUntilReady(ns string, p *v1alpha1.Prometheus) error {
+	_, err := f.MonClient.Prometheuses(ns).Create(p)
 	if err != nil {
 		return err
 	}
 
 	if err := f.WaitForPrometheusReady(p, time.Minute); err != nil {
-		return fmt.Errorf("failed to create %d Prometheus instances (%s): %v", p.Spec.Replicas, p.Name, err)
+		return fmt.Errorf("failed to create %d Prometheus instances (%v): %v", p.Spec.Replicas, p.Name, err)
 	}
 
 	return nil
 }
 
-func (f *Framework) UpdatePrometheusAndWaitUntilReady(p *v1alpha1.Prometheus) error {
-	log.Printf("Updating Prometheus (%s/%s)", f.Namespace.Name, p.Name)
-	_, err := f.MonClient.Prometheuses(f.Namespace.Name).Update(p)
+func (f *Framework) UpdatePrometheusAndWaitUntilReady(ns string, p *v1alpha1.Prometheus) error {
+	_, err := f.MonClient.Prometheuses(ns).Update(p)
 	if err != nil {
 		return err
 	}
 	if err := f.WaitForPrometheusReady(p, time.Minute); err != nil {
-		return fmt.Errorf("failed to update %d Prometheus instances (%s): %v", p.Spec.Replicas, p.Name, err)
+		return fmt.Errorf("failed to update %d Prometheus instances (%v): %v", p.Spec.Replicas, p.Name, err)
 	}
 
 	return nil
@@ -157,26 +154,25 @@ func (f *Framework) WaitForPrometheusReady(p *v1alpha1.Prometheus, timeout time.
 	return wait.Poll(2*time.Second, timeout, func() (bool, error) {
 		st, _, err := prometheus.PrometheusStatus(f.KubeClient, p)
 		if err != nil {
-			return false, err
+			return false, nil
 		}
 		return st.UpdatedReplicas == *p.Spec.Replicas, nil
 	})
 }
 
-func (f *Framework) DeletePrometheusAndWaitUntilGone(name string) error {
-	log.Printf("Deleting Prometheus (%s/%s)", f.Namespace.Name, name)
-	_, err := f.MonClient.Prometheuses(f.Namespace.Name).Get(name)
+func (f *Framework) DeletePrometheusAndWaitUntilGone(ns, name string) error {
+	_, err := f.MonClient.Prometheuses(ns).Get(name)
 	if err != nil {
 		return errors.Wrap(err, fmt.Sprintf("requesting Prometheus tpr %v failed", name))
 	}
 
-	if err := f.MonClient.Prometheuses(f.Namespace.Name).Delete(name, nil); err != nil {
+	if err := f.MonClient.Prometheuses(ns).Delete(name, nil); err != nil {
 		return errors.Wrap(err, fmt.Sprintf("deleting Prometheus tpr %v failed", name))
 	}
 
 	if err := WaitForPodsReady(
 		f.KubeClient,
-		f.Namespace.Name,
+		ns,
 		f.DefaultTimeout,
 		0,
 		prometheus.ListOptions(name),
@@ -187,13 +183,13 @@ func (f *Framework) DeletePrometheusAndWaitUntilGone(name string) error {
 	return nil
 }
 
-func (f *Framework) WaitForPrometheusRunImageAndReady(p *v1alpha1.Prometheus) error {
-	if err := WaitForPodsRunImage(f.KubeClient, f.Namespace.Name, int(*p.Spec.Replicas), promImage(p.Spec.Version), prometheus.ListOptions(p.Name)); err != nil {
+func (f *Framework) WaitForPrometheusRunImageAndReady(ns string, p *v1alpha1.Prometheus) error {
+	if err := WaitForPodsRunImage(f.KubeClient, ns, int(*p.Spec.Replicas), promImage(p.Spec.Version), prometheus.ListOptions(p.Name)); err != nil {
 		return err
 	}
 	return WaitForPodsReady(
 		f.KubeClient,
-		f.Namespace.Name,
+		ns,
 		f.DefaultTimeout,
 		int(*p.Spec.Replicas),
 		prometheus.ListOptions(p.Name),
diff --git a/test/e2e/prometheus_test.go b/test/e2e/prometheus_test.go
index 2ec3212fa..728dae6e6 100644
--- a/test/e2e/prometheus_test.go
+++ b/test/e2e/prometheus_test.go
@@ -36,93 +36,106 @@ import (
 )
 
 func TestPrometheusCreateDeleteCluster(t *testing.T) {
+	ctx := testFramework.NewTestCtx(t)
+	defer ctx.CleanUp(t)
+	ctx.BasicSetup(t, framework.KubeClient)
+
 	name := "test"
 
-	if err := framework.CreatePrometheusAndWaitUntilReady(framework.MakeBasicPrometheus(name, name, 1)); err != nil {
+	prometheusTPR := framework.MakeBasicPrometheus(ctx.Id, name, name, 1)
+	prometheusTPR.Namespace = ctx.Id
+
+	if err := framework.CreatePrometheusAndWaitUntilReady(ctx.Id, prometheusTPR); err != nil {
 		t.Fatal(err)
 	}
 
-	if err := framework.DeletePrometheusAndWaitUntilGone(name); err != nil {
+	if err := framework.DeletePrometheusAndWaitUntilGone(ctx.Id, name); err != nil {
 		t.Fatal(err)
 	}
 }
 
 func TestPrometheusScaleUpDownCluster(t *testing.T) {
+	ctx := testFramework.NewTestCtx(t)
+	defer ctx.CleanUp(t)
+	ctx.BasicSetup(t, framework.KubeClient)
+
 	name := "test"
 
-	defer func() {
-		if err := framework.DeletePrometheusAndWaitUntilGone(name); err != nil {
-			t.Fatal(err)
-		}
-	}()
-
-	if err := framework.CreatePrometheusAndWaitUntilReady(framework.MakeBasicPrometheus(name, name, 1)); err != nil {
+	if err := framework.CreatePrometheusAndWaitUntilReady(ctx.Id, framework.MakeBasicPrometheus(ctx.Id, name, name, 1)); err != nil {
 		t.Fatal(err)
 	}
 
-	if err := framework.UpdatePrometheusAndWaitUntilReady(framework.MakeBasicPrometheus(name, name, 3)); err != nil {
+	if err := framework.UpdatePrometheusAndWaitUntilReady(ctx.Id, framework.MakeBasicPrometheus(ctx.Id, name, name, 3)); err != nil {
 		t.Fatal(err)
 	}
 
-	if err := framework.UpdatePrometheusAndWaitUntilReady(framework.MakeBasicPrometheus(name, name, 2)); err != nil {
+	if err := framework.UpdatePrometheusAndWaitUntilReady(ctx.Id, framework.MakeBasicPrometheus(ctx.Id, name, name, 2)); err != nil {
 		t.Fatal(err)
 	}
 }
 
 func TestPrometheusVersionMigration(t *testing.T) {
+	ctx := testFramework.NewTestCtx(t)
+	defer ctx.CleanUp(t)
+	ctx.BasicSetup(t, framework.KubeClient)
+
 	name := "test"
 
 	defer func() {
-		if err := framework.DeletePrometheusAndWaitUntilGone(name); err != nil {
+		if err := framework.DeletePrometheusAndWaitUntilGone(ctx.Id, name); err != nil {
 			t.Fatal(err)
 		}
 	}()
 
-	p := framework.MakeBasicPrometheus(name, name, 1)
+	p := framework.MakeBasicPrometheus(ctx.Id, name, name, 1)
 
 	p.Spec.Version = "v1.5.1"
-	if err := framework.CreatePrometheusAndWaitUntilReady(p); err != nil {
+	if err := framework.CreatePrometheusAndWaitUntilReady(ctx.Id, p); err != nil {
 		t.Fatal(err)
 	}
 
 	p.Spec.Version = "v1.6.1"
-	if err := framework.UpdatePrometheusAndWaitUntilReady(p); err != nil {
+	if err := framework.UpdatePrometheusAndWaitUntilReady(ctx.Id, p); err != nil {
 		t.Fatal(err)
 	}
-	if err := framework.WaitForPrometheusRunImageAndReady(p); err != nil {
+	if err := framework.WaitForPrometheusRunImageAndReady(ctx.Id, p); err != nil {
 		t.Fatal(err)
 	}
 
 	p.Spec.Version = "v1.5.1"
-	if err := framework.UpdatePrometheusAndWaitUntilReady(p); err != nil {
+	if err := framework.UpdatePrometheusAndWaitUntilReady(ctx.Id, p); err != nil {
 		t.Fatal(err)
 	}
-	if err := framework.WaitForPrometheusRunImageAndReady(p); err != nil {
+	if err := framework.WaitForPrometheusRunImageAndReady(ctx.Id, p); err != nil {
 		t.Fatal(err)
 	}
 }
 
 func TestPrometheusResourceUpdate(t *testing.T) {
+	ctx := testFramework.NewTestCtx(t)
+	defer ctx.CleanUp(t)
+	ctx.BasicSetup(t, framework.KubeClient)
+
 	name := "test"
 
 	defer func() {
-		if err := framework.DeletePrometheusAndWaitUntilGone(name); err != nil {
+		if err := framework.DeletePrometheusAndWaitUntilGone(ctx.Id, name); err != nil {
 			t.Fatal(err)
 		}
 	}()
 
-	p := framework.MakeBasicPrometheus(name, name, 1)
+	p := framework.MakeBasicPrometheus(ctx.Id, name, name, 1)
 
 	p.Spec.Resources = v1.ResourceRequirements{
 		Requests: v1.ResourceList{
 			v1.ResourceMemory: resource.MustParse("100Mi"),
 		},
 	}
-	if err := framework.CreatePrometheusAndWaitUntilReady(p); err != nil {
+	if err := framework.CreatePrometheusAndWaitUntilReady(ctx.Id, p); err != nil {
 		t.Fatal(err)
 	}
 
-	pods, err := framework.KubeClient.Core().Pods(framework.Namespace.Name).List(prometheus.ListOptions(name))
+	pods, err := framework.KubeClient.Core().Pods(ctx.Id).List(prometheus.ListOptions(name))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -137,11 +150,11 @@ func TestPrometheusResourceUpdate(t *testing.T) {
 			v1.ResourceMemory: resource.MustParse("200Mi"),
 		},
 	}
-	if err := framework.UpdatePrometheusAndWaitUntilReady(p); err != nil {
+	if err := framework.UpdatePrometheusAndWaitUntilReady(ctx.Id, p); err != nil {
 		t.Fatal(err)
 	}
 
-	pods, err = framework.KubeClient.Core().Pods(framework.Namespace.Name).List(prometheus.ListOptions(name))
+	pods, err = framework.KubeClient.Core().Pods(ctx.Id).List(prometheus.ListOptions(name))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -153,12 +166,16 @@ func TestPrometheusResourceUpdate(t *testing.T) {
 }
 
 func TestPrometheusReloadConfig(t *testing.T) {
+	ctx := testFramework.NewTestCtx(t)
+	defer ctx.CleanUp(t)
+	ctx.BasicSetup(t, framework.KubeClient)
+
 	name := "test"
 	replicas := int32(1)
 	p := &v1alpha1.Prometheus{
 		ObjectMeta: v1.ObjectMeta{
 			Name:      name,
-			Namespace: framework.Namespace.Name,
+			Namespace: ctx.Id,
 		},
 		Spec: v1alpha1.PrometheusSpec{
 			Replicas: &replicas,
@@ -194,27 +211,27 @@ scrape_configs:
 	svc := framework.MakeBasicPrometheusNodePortService(name, "reloadconfig-group", 30900)
 
 	defer func() {
-		if err := framework.DeletePrometheusAndWaitUntilGone(name); err != nil {
+		if err := framework.DeletePrometheusAndWaitUntilGone(ctx.Id, name); err != nil {
 			t.Fatal(err)
 		}
-		if err := testFramework.DeleteService(framework.KubeClient, framework.Namespace.Name, svc.Name); err != nil {
+		if err := testFramework.DeleteService(framework.KubeClient, ctx.Id, svc.Name); err != nil {
 			t.Fatal(err)
 		}
 	}()
 
 	// TODO(fabxc): tests are all running in the same namespace and not reliable cleaned
 	// up from all resources.
-	framework.KubeClient.CoreV1().Secrets(framework.Namespace.Name).Delete(cfg.Name, nil)
+	framework.KubeClient.CoreV1().Secrets(ctx.Id).Delete(cfg.Name, nil)
 
-	if _, err := framework.KubeClient.CoreV1().Secrets(framework.Namespace.Name).Create(cfg); err != nil {
+	if _, err := framework.KubeClient.CoreV1().Secrets(ctx.Id).Create(cfg); err != nil {
 		t.Fatal(err)
 	}
 
-	if err := framework.CreatePrometheusAndWaitUntilReady(p); err != nil {
+	if err := framework.CreatePrometheusAndWaitUntilReady(ctx.Id, p); err != nil {
 		t.Fatal(err)
 	}
 
-	if err := testFramework.CreateServiceAndWaitUntilReady(framework.KubeClient, framework.Namespace.Name, svc); err != nil {
+	if err := testFramework.CreateServiceAndWaitUntilReady(framework.KubeClient, ctx.Id, svc); err != nil {
 		t.Fatal(err)
 	}
 
@@ -235,7 +252,7 @@ scrape_configs:
 `
 
 	cfg.Data["prometheus.yaml"] = []byte(secondConfig)
-	if _, err := framework.KubeClient.CoreV1().Secrets(framework.Namespace.Name).Update(cfg); err != nil {
+	if _, err := framework.KubeClient.CoreV1().Secrets(ctx.Id).Update(cfg); err != nil {
 		t.Fatal(err)
 	}
 
@@ -245,6 +262,10 @@ scrape_configs:
 }
 
 func TestPrometheusReloadRules(t *testing.T) {
+	ctx := testFramework.NewTestCtx(t)
+	defer ctx.CleanUp(t)
+	ctx.BasicSetup(t, framework.KubeClient)
+
 	name := "test"
 
 	ruleFileConfigMap := &v1.ConfigMap{
@@ -259,35 +280,35 @@ func TestPrometheusReloadRules(t *testing.T) {
 		},
 	}
 
-	_, err := framework.KubeClient.CoreV1().ConfigMaps(framework.Namespace.Name).Create(ruleFileConfigMap)
+	_, err := framework.KubeClient.CoreV1().ConfigMaps(ctx.Id).Create(ruleFileConfigMap)
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	defer func() {
-		if err := framework.DeletePrometheusAndWaitUntilGone(name); err != nil {
+		if err := framework.DeletePrometheusAndWaitUntilGone(ctx.Id, name); err != nil {
 			t.Fatal(err)
 		}
 
-		err = framework.KubeClient.CoreV1().ConfigMaps(framework.Namespace.Name).Delete(ruleFileConfigMap.Name, nil)
+		err = framework.KubeClient.CoreV1().ConfigMaps(ctx.Id).Delete(ruleFileConfigMap.Name, nil)
 		if err != nil {
 			t.Fatal(err)
 		}
 	}()
 
-	if err := framework.CreatePrometheusAndWaitUntilReady(framework.MakeBasicPrometheus(name, name, 1)); err != nil {
+	if err := framework.CreatePrometheusAndWaitUntilReady(ctx.Id, framework.MakeBasicPrometheus(ctx.Id, name, name, 1)); err != nil {
 		t.Fatal(err)
 	}
 
 	ruleFileConfigMap.Data["test.rules"] = "# comment to trigger a configmap reload"
-	_, err = framework.KubeClient.CoreV1().ConfigMaps(framework.Namespace.Name).Update(ruleFileConfigMap)
+	_, err = framework.KubeClient.CoreV1().ConfigMaps(ctx.Id).Update(ruleFileConfigMap)
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	// remounting a ConfigMap can take some time
 	err = wait.Poll(time.Second, time.Minute*5, func() (bool, error) {
-		logs, err := testFramework.GetLogs(framework.KubeClient, framework.Namespace.Name, fmt.Sprintf("prometheus-%s-0", name), "prometheus-config-reloader")
+		logs, err := testFramework.GetLogs(framework.KubeClient, ctx.Id, fmt.Sprintf("prometheus-%s-0", name), "prometheus-config-reloader")
 		if err != nil {
 			return false, err
 		}
@@ -304,53 +325,61 @@ func TestPrometheusReloadRules(t *testing.T) {
 }
 
 func TestPrometheusDiscovery(t *testing.T) {
+	ctx := testFramework.NewTestCtx(t)
+	defer ctx.CleanUp(t)
+	ctx.BasicSetup(t, framework.KubeClient)
+
 	prometheusName := "test"
 	group := "servicediscovery-test"
 	svc := framework.MakeBasicPrometheusNodePortService(prometheusName, group, 30900)
 
 	defer func() {
-		if err := framework.DeletePrometheusAndWaitUntilGone(prometheusName); err != nil {
+		if err := framework.DeletePrometheusAndWaitUntilGone(ctx.Id, prometheusName); err != nil {
 			t.Fatal(err)
 		}
-		if err := framework.MonClient.ServiceMonitors(framework.Namespace.Name).Delete(group, nil); err != nil {
+		if err := framework.MonClient.ServiceMonitors(ctx.Id).Delete(group, nil); err != nil {
 			t.Fatal(err)
 		}
-		if err := testFramework.DeleteService(framework.KubeClient, framework.Namespace.Name, svc.Name); err != nil {
+		if err := testFramework.DeleteService(framework.KubeClient, ctx.Id, svc.Name); err != nil {
 			t.Fatal(err)
 		}
 	}()
 
 	log.Print("Creating Prometheus ServiceMonitor")
 	s := framework.MakeBasicServiceMonitor(group)
-	if _, err := framework.MonClient.ServiceMonitors(framework.Namespace.Name).Create(s); err != nil {
+	if _, err := framework.MonClient.ServiceMonitors(ctx.Id).Create(s); err != nil {
 		t.Fatal("Creating ServiceMonitor failed: ", err)
 	}
 
-	p := framework.MakeBasicPrometheus(prometheusName, group, 1)
+	p := framework.MakeBasicPrometheus(ctx.Id, prometheusName, group, 1)
 	p.Spec.Version = "v1.5.0"
-	if err := framework.CreatePrometheusAndWaitUntilReady(p); err != nil {
+	if err := framework.CreatePrometheusAndWaitUntilReady(ctx.Id, p); err != nil {
 		t.Fatal(err)
 	}
 
 	log.Print("Creating Prometheus Service")
-	if err := testFramework.CreateServiceAndWaitUntilReady(framework.KubeClient, framework.Namespace.Name, svc); err != nil {
+	if err := testFramework.CreateServiceAndWaitUntilReady(framework.KubeClient, ctx.Id, svc); err != nil {
 		t.Fatal(err)
 	}
 
 	log.Print("Validating Prometheus config Secret was created")
-	_, err := framework.KubeClient.CoreV1().Secrets(framework.Namespace.Name).Get(fmt.Sprintf("prometheus-%s", prometheusName))
+	_, err := framework.KubeClient.CoreV1().Secrets(ctx.Id).Get(fmt.Sprintf("prometheus-%s", prometheusName))
 	if err != nil {
 		t.Fatal("Generated Secret could not be retrieved: ", err)
 	}
 
 	log.Print("Validating Prometheus Targets were properly discovered")
-	err = wait.Poll(time.Second, 18*time.Minute, isDiscoveryWorking(prometheusName))
+	err = wait.Poll(time.Second, 18*time.Minute, isDiscoveryWorking(ctx.Id, prometheusName))
 	if err != nil {
 		t.Fatal(err)
 	}
 }
 
 func TestPrometheusAlertmanagerDiscovery(t *testing.T) {
+	ctx := testFramework.NewTestCtx(t)
+	defer ctx.CleanUp(t)
+	ctx.BasicSetup(t, framework.KubeClient)
+
 	prometheusName := "test"
 	alertmanagerName := "test"
 	group := "servicediscovery-test"
@@ -358,81 +387,85 @@ func TestPrometheusAlertmanagerDiscovery(t *testing.T) {
 	amsvc := framework.MakeAlertmanagerNodePortService(alertmanagerName, group, 30903)
 
 	defer func() {
-		if err := framework.DeleteAlertmanagerAndWaitUntilGone(alertmanagerName); err != nil {
+		if err := framework.DeleteAlertmanagerAndWaitUntilGone(ctx.Id, alertmanagerName); err != nil {
 			t.Fatal(err)
 		}
-		if err := testFramework.DeleteService(framework.KubeClient, framework.Namespace.Name, amsvc.Name); err != nil {
+		if err := testFramework.DeleteService(framework.KubeClient, ctx.Id, amsvc.Name); err != nil {
 			t.Fatal(err)
 		}
-		if err := framework.DeletePrometheusAndWaitUntilGone(prometheusName); err != nil {
+		if err := framework.DeletePrometheusAndWaitUntilGone(ctx.Id, prometheusName); err != nil {
 			t.Fatal(err)
 		}
-		if err := framework.MonClient.ServiceMonitors(framework.Namespace.Name).Delete(group, nil); err != nil {
+		if err := framework.MonClient.ServiceMonitors(ctx.Id).Delete(group, nil); err != nil {
 			t.Fatal(err)
 		}
-		if err := testFramework.DeleteService(framework.KubeClient, framework.Namespace.Name, svc.Name); err != nil {
+		if err := testFramework.DeleteService(framework.KubeClient, ctx.Id, svc.Name); err != nil {
 			t.Fatal(err)
 		}
 	}()
 
-	p := framework.MakeBasicPrometheus(prometheusName, group, 1)
-	framework.AddAlertingToPrometheus(p, alertmanagerName)
+	p := framework.MakeBasicPrometheus(ctx.Id, prometheusName, group, 1)
+	framework.AddAlertingToPrometheus(p, ctx.Id, alertmanagerName)
 	p.Spec.Version = "v1.5.0"
-	if err := framework.CreatePrometheusAndWaitUntilReady(p); err != nil {
+	if err := framework.CreatePrometheusAndWaitUntilReady(ctx.Id, p); err != nil {
 		t.Fatal(err)
 	}
 
 	log.Print("Creating Prometheus Service")
-	if err := testFramework.CreateServiceAndWaitUntilReady(framework.KubeClient, framework.Namespace.Name, svc); err != nil {
+	if err := testFramework.CreateServiceAndWaitUntilReady(framework.KubeClient, ctx.Id, svc); err != nil {
 		t.Fatal(err)
 	}
 
 	log.Print("Creating Prometheus ServiceMonitor")
 	s := framework.MakeBasicServiceMonitor(group)
-	if _, err := framework.MonClient.ServiceMonitors(framework.Namespace.Name).Create(s); err != nil {
-		t.Fatalf("Creating ServiceMonitor failed: ", err)
+	if _, err := framework.MonClient.ServiceMonitors(ctx.Id).Create(s); err != nil {
+		t.Fatalf("Creating ServiceMonitor failed: %v", err)
 	}
 
 	log.Print("Validating Prometheus config Secret was created")
-	_, err := framework.KubeClient.CoreV1().Secrets(framework.Namespace.Name).Get(fmt.Sprintf("prometheus-%s", prometheusName))
+	_, err := framework.KubeClient.CoreV1().Secrets(ctx.Id).Get(fmt.Sprintf("prometheus-%s", prometheusName))
 	if err != nil {
-		t.Fatalf("Generated Secret could not be retrieved: ", err)
+		t.Fatalf("Generated Secret could not be retrieved: %v", err)
 	}
 
-	if err := framework.CreateAlertmanagerAndWaitUntilReady(framework.MakeBasicAlertmanager(alertmanagerName, 3)); err != nil {
+	if err := framework.CreateAlertmanagerAndWaitUntilReady(ctx.Id, framework.MakeBasicAlertmanager(alertmanagerName, 3)); err != nil {
 		t.Fatal(err)
 	}
 
 	log.Print("Creating Alertmanager Service")
-	if err := testFramework.CreateServiceAndWaitUntilReady(framework.KubeClient, framework.Namespace.Name, amsvc); err != nil {
+	if err := testFramework.CreateServiceAndWaitUntilReady(framework.KubeClient, ctx.Id, amsvc); err != nil {
 		t.Fatal(err)
 	}
 
 	log.Print("Validating Prometheus properly discovered alertmanagers")
-	err = wait.Poll(time.Second, 18*time.Minute, isAlertmanagerDiscoveryWorking(alertmanagerName))
+	err = wait.Poll(time.Second, 18*time.Minute, isAlertmanagerDiscoveryWorking(ctx.Id, alertmanagerName))
 	if err != nil {
 		t.Fatal(err)
 	}
 }
 
 func TestExposingPrometheusWithNodePort(t *testing.T) {
-	basicPrometheus := framework.MakeBasicPrometheus("test", "test", 1)
+	ctx := testFramework.NewTestCtx(t)
+	defer ctx.CleanUp(t)
+	ctx.BasicSetup(t, framework.KubeClient)
+
+	basicPrometheus := framework.MakeBasicPrometheus(ctx.Id, "test", "test", 1)
 	service := framework.MakeBasicPrometheusNodePortService(basicPrometheus.Name, "nodeport-service", 30900)
 
 	defer func() {
-		if err := framework.DeletePrometheusAndWaitUntilGone(basicPrometheus.Name); err != nil {
+		if err := framework.DeletePrometheusAndWaitUntilGone(ctx.Id, basicPrometheus.Name); err != nil {
 			t.Fatal(err)
 		}
-		if err := testFramework.DeleteService(framework.KubeClient, framework.Namespace.Name, service.Name); err != nil {
+		if err := testFramework.DeleteService(framework.KubeClient, ctx.Id, service.Name); err != nil {
 			t.Fatal(err)
 		}
 	}()
 
-	if err := framework.CreatePrometheusAndWaitUntilReady(basicPrometheus); err != nil {
+	if err := framework.CreatePrometheusAndWaitUntilReady(ctx.Id, basicPrometheus); err != nil {
 		t.Fatal("Creating prometheus failed: ", err)
 	}
 
-	if err := testFramework.CreateServiceAndWaitUntilReady(framework.KubeClient, framework.Namespace.Name, service); err != nil {
+	if err := testFramework.CreateServiceAndWaitUntilReady(framework.KubeClient, ctx.Id, service); err != nil {
 		t.Fatal("Creating prometheus service failed: ", err)
 	}
 
@@ -445,27 +478,31 @@ func TestExposingPrometheusWithNodePort(t *testing.T) {
 }
 
 func TestExposingPrometheusWithKubernetesAPI(t *testing.T) {
-	basicPrometheus := framework.MakeBasicPrometheus("basic-prometheus", "test-group", 1)
+	ctx := testFramework.NewTestCtx(t)
+	defer ctx.CleanUp(t)
+	ctx.BasicSetup(t, framework.KubeClient)
+
+	basicPrometheus := framework.MakeBasicPrometheus(ctx.Id, "basic-prometheus", "test-group", 1)
 	service := framework.MakePrometheusService(basicPrometheus.Name, "test-group", v1.ServiceTypeClusterIP)
 
 	defer func() {
-		if err := framework.DeletePrometheusAndWaitUntilGone(basicPrometheus.Name); err != nil {
+		if err := framework.DeletePrometheusAndWaitUntilGone(ctx.Id, basicPrometheus.Name); err != nil {
 			t.Fatal(err)
 		}
-		if err := testFramework.DeleteService(framework.KubeClient, framework.Namespace.Name, service.Name); err != nil {
+		if err := testFramework.DeleteService(framework.KubeClient, ctx.Id, service.Name); err != nil {
 			t.Fatal(err)
 		}
 	}()
 
-	if err := framework.CreatePrometheusAndWaitUntilReady(basicPrometheus); err != nil {
+	if err := framework.CreatePrometheusAndWaitUntilReady(ctx.Id, basicPrometheus); err != nil {
 		t.Fatal("Creating prometheus failed: ", err)
 	}
 
-	if err := testFramework.CreateServiceAndWaitUntilReady(framework.KubeClient, framework.Namespace.Name, service); err != nil {
+	if err := testFramework.CreateServiceAndWaitUntilReady(framework.KubeClient, ctx.Id, service); err != nil {
 		t.Fatal("Creating prometheus service failed: ", err)
 	}
 
-	ProxyGet := framework.KubeClient.CoreV1().Services(framework.Namespace.Name).ProxyGet
+	ProxyGet := framework.KubeClient.CoreV1().Services(ctx.Id).ProxyGet
 	request := ProxyGet("", service.Name, "web", "/metrics", make(map[string]string))
 	_, err := request.DoRaw()
 	if err != nil {
@@ -474,45 +511,49 @@ func TestExposingPrometheusWithKubernetesAPI(t *testing.T) {
 }
 
 func TestExposingPrometheusWithIngress(t *testing.T) {
-	prometheus := framework.MakeBasicPrometheus("main", "test-group", 1)
+	ctx := testFramework.NewTestCtx(t)
+	defer ctx.CleanUp(t)
+	ctx.BasicSetup(t, framework.KubeClient)
+
+	prometheus := framework.MakeBasicPrometheus(ctx.Id, "main", "test-group", 1)
 	prometheusService := framework.MakePrometheusService(prometheus.Name, "test-group", v1.ServiceTypeClusterIP)
 	ingress := testFramework.MakeBasicIngress(prometheusService.Name, 9090)
 
 	defer func() {
-		if err := framework.DeletePrometheusAndWaitUntilGone(prometheus.Name); err != nil {
+		if err := framework.DeletePrometheusAndWaitUntilGone(ctx.Id, prometheus.Name); err != nil {
 			t.Fatal(err)
 		}
-		if err := testFramework.DeleteService(framework.KubeClient, framework.Namespace.Name, prometheusService.Name); err != nil {
+		if err := testFramework.DeleteService(framework.KubeClient, ctx.Id, prometheusService.Name); err != nil {
 			t.Fatal(err)
 		}
-		if err := framework.KubeClient.Extensions().Ingresses(framework.Namespace.Name).Delete(ingress.Name, nil); err != nil {
+		if err := framework.KubeClient.Extensions().Ingresses(ctx.Id).Delete(ingress.Name, nil); err != nil {
 			t.Fatal(err)
 		}
-		if err := testFramework.DeleteNginxIngressControllerIncDefaultBackend(framework.KubeClient, framework.Namespace.Name); err != nil {
+		if err := testFramework.DeleteNginxIngressControllerIncDefaultBackend(framework.KubeClient, ctx.Id); err != nil {
 			t.Fatal(err)
 		}
 	}()
 
-	err := testFramework.SetupNginxIngressControllerIncDefaultBackend(framework.KubeClient, framework.Namespace.Name)
+	err := testFramework.SetupNginxIngressControllerIncDefaultBackend(framework.KubeClient, ctx.Id)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	err = framework.CreatePrometheusAndWaitUntilReady(prometheus)
+	err = framework.CreatePrometheusAndWaitUntilReady(ctx.Id, prometheus)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	if err := testFramework.CreateServiceAndWaitUntilReady(framework.KubeClient, framework.Namespace.Name, prometheusService); err != nil {
+	if err := testFramework.CreateServiceAndWaitUntilReady(framework.KubeClient, ctx.Id, prometheusService); err != nil {
 		t.Fatal(err)
 	}
 
-	err = testFramework.CreateIngress(framework.KubeClient, framework.Namespace.Name, ingress)
+	err = testFramework.CreateIngress(framework.KubeClient, ctx.Id, ingress)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	ip, err := testFramework.GetIngressIP(framework.KubeClient, framework.Namespace.Name, ingress.Name)
+	ip, err := testFramework.GetIngressIP(framework.KubeClient, ctx.Id, ingress.Name)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -522,9 +563,9 @@ func TestExposingPrometheusWithIngress(t *testing.T) {
 		t.Fatal(err)
 	}
 }
-func isDiscoveryWorking(prometheusName string) func() (bool, error) {
+func isDiscoveryWorking(ns, prometheusName string) func() (bool, error) {
 	return func() (bool, error) {
-		pods, err := framework.KubeClient.CoreV1().Pods(framework.Namespace.Name).List(prometheus.ListOptions(prometheusName))
+		pods, err := framework.KubeClient.CoreV1().Pods(ns).List(prometheus.ListOptions(prometheusName))
 		if err != nil {
 			return false, err
 		}
@@ -590,9 +631,9 @@ func basicQueryWorking() (bool, error) {
 	return true, nil
 }
 
-func isAlertmanagerDiscoveryWorking(alertmanagerName string) func() (bool, error) {
+func isAlertmanagerDiscoveryWorking(ns, alertmanagerName string) func() (bool, error) {
 	return func() (bool, error) {
-		pods, err := framework.KubeClient.CoreV1().Pods(framework.Namespace.Name).List(alertmanager.ListOptions(alertmanagerName))
+		pods, err := framework.KubeClient.CoreV1().Pods(ns).List(alertmanager.ListOptions(alertmanagerName))
 		if err != nil {
 			return false, err
 		}