use random namespace when flag is empty

build/Makefile

@@ -245,7 +245,7 @@ test-e2e:
 	$(MAKE) test-e2e-failure
 
 test-e2e-integration: FEATURE_GATES ?= $(ALPHA_FEATURE_GATES)
-test-e2e-integration: GAMESERVERS_NAMESPACE ?= "default"
+test-e2e-integration: GAMESERVERS_NAMESPACE ?= ""
 test-e2e-integration: $(ensure-build-image)
 	echo "Starting e2e integration test!"
 	$(GO_TEST) $(ARGS) $(agones_package)/test/e2e $(GO_E2E_TEST_ARGS) \
@@ -295,7 +295,6 @@ install: ALLOCATOR_SERVICE_TYPE := "LoadBalancer"
 install: CRD_CLEANUP := true
 install: LOG_LEVEL := "debug"
 install: FEATURE_GATES ?= $(ALPHA_FEATURE_GATES)
-install: GAMESERVERS_NAMESPACES ?= {"default"}
 install: $(ensure-build-image) install-custom-pull-secret
 	$(DOCKER_RUN) \
 		helm upgrade --install --wait --namespace=agones-system\
@@ -307,7 +306,6 @@ install: $(ensure-build-image) install-custom-pull-secret
 		--set agones.controller.logLevel=$(LOG_LEVEL) \
 		--set agones.crds.cleanupOnDelete=$(CRD_CLEANUP) \
 		--set agones.featureGates=$(FEATURE_GATES) \
-		--set gameservers.namespaces=$(GAMESERVERS_NAMESPACES) \
 		agones $(mount_path)/install/helm/agones/
 
 uninstall: $(ensure-build-image)

test/e2e/allocator_test.go

@@ -61,8 +61,17 @@ func TestAllocator(t *testing.T) {
 	tlsCA := refreshAllocatorTLSCerts(t, ip)
 
 	namespace := fmt.Sprintf("allocator-%s", uuid.NewUUID())
-	framework.CreateNamespace(t, namespace)
-	defer framework.DeleteNamespace(t, namespace)
+
+	err := framework.CreateNamespace(namespace)
+	if !assert.Nil(t, err) {
+		return
+	}
+
+	defer func() {
+		if derr := framework.DeleteNamespace(namespace); derr != nil {
+			t.Error(derr)
+		}
+	}()
 
 	clientSecretName := fmt.Sprintf("allocator-client-%s", uuid.NewUUID())
 	genClientSecret(t, namespace, clientSecretName)
@@ -119,11 +128,26 @@ func TestAllocatorCrossNamespace(t *testing.T) {
 
 	// Create namespaces A and B
 	namespaceA := fmt.Sprintf("allocator-a-%s", uuid.NewUUID())
-	framework.CreateNamespace(t, namespaceA)
-	defer framework.DeleteNamespace(t, namespaceA)
+	err := framework.CreateNamespace(namespaceA)
+	if !assert.Nil(t, err) {
+		return
+	}
+	defer func() {
+		if derr := framework.DeleteNamespace(namespaceA); derr != nil {
+			t.Error(derr)
+		}
+	}()
+
 	namespaceB := fmt.Sprintf("allocator-b-%s", uuid.NewUUID())
-	framework.CreateNamespace(t, namespaceB)
-	defer framework.DeleteNamespace(t, namespaceB)
+	err = framework.CreateNamespace(namespaceB)
+	if !assert.Nil(t, err) {
+		return
+	}
+	defer func() {
+		if derr := framework.DeleteNamespace(namespaceB); derr != nil {
+			t.Error(derr)
+		}
+	}()
 
 	// Create client secret A, B is receiver of the request and does not need client secret
 	clientSecretNameA := fmt.Sprintf("allocator-client-%s", uuid.NewUUID())

test/e2e/framework/framework.go

@@ -495,20 +495,19 @@ func GetAllocation(f *agonesv1.Fleet) *allocationv1.GameServerAllocation {
 }
 
 // CreateNamespace creates a namespace in the test cluster
-func (f *Framework) CreateNamespace(t *testing.T, namespace string) {
-	t.Helper()
-
+func (f *Framework) CreateNamespace(namespace string) error {
 	kubeCore := f.KubeClient.CoreV1()
 	ns := &corev1.Namespace{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:   namespace,
 			Labels: map[string]string{"owner": "e2e-test"},
 		},
 	}
+
 	if _, err := kubeCore.Namespaces().Create(ns); err != nil {
-		t.Fatalf("creating namespace %s failed: %s", namespace, err)
+		return errors.Errorf("creating namespace %s failed: %s", namespace, err.Error())
 	}
-	t.Logf("Namespace %s is created", namespace)
+	logrus.Infof("Namespace %s is created", namespace)
 
 	saName := "agones-sdk"
 	if _, err := kubeCore.ServiceAccounts(namespace).Create(&corev1.ServiceAccount{
@@ -518,9 +517,9 @@ func (f *Framework) CreateNamespace(t *testing.T, namespace string) {
 			Labels:    map[string]string{"app": "agones"},
 		},
 	}); err != nil {
-		t.Fatalf("creating ServiceAccount %s in namespace %s failed: %s", saName, namespace, err)
+		return errors.Errorf("creating ServiceAccount %s in namespace %s failed: %s", saName, namespace, err.Error())
 	}
-	t.Logf("ServiceAccount %s/%s is created", namespace, saName)
+	logrus.Infof("ServiceAccount %s/%s is created", namespace, saName)
 
 	rb := &rbacv1.RoleBinding{
 		ObjectMeta: metav1.ObjectMeta{
@@ -542,21 +541,21 @@ func (f *Framework) CreateNamespace(t *testing.T, namespace string) {
 		},
 	}
 	if _, err := f.KubeClient.RbacV1().RoleBindings(namespace).Create(rb); err != nil {
-		t.Fatalf("creating RoleBinding for service account %q in namespace %q failed: %s", saName, namespace, err)
+		return errors.Errorf("creating RoleBinding for service account %q in namespace %q failed: %s", saName, namespace, err)
 	}
-	t.Logf("RoleBinding %s/%s is created", namespace, rb.Name)
+	logrus.Infof("RoleBinding %s/%s is created", namespace, rb.Name)
+
+	return nil
 }
 
 // DeleteNamespace deletes a namespace from the test cluster
-func (f *Framework) DeleteNamespace(t *testing.T, namespace string) {
-	t.Helper()
-
+func (f *Framework) DeleteNamespace(namespace string) error {
 	kubeCore := f.KubeClient.CoreV1()
 
 	// Remove finalizers
 	pods, err := kubeCore.Pods(namespace).List(metav1.ListOptions{})
 	if err != nil {
-		t.Fatalf("listing pods in namespace %s failed: %s", namespace, err)
+		return errors.Errorf("listing pods in namespace %s failed: %s", namespace, err)
 	}
 	for i := range pods.Items {
 		pod := &pods.Items[i]
@@ -568,15 +567,16 @@ func (f *Framework) DeleteNamespace(t *testing.T, namespace string) {
 			}}
 			payloadBytes, _ := json.Marshal(payload)
 			if _, err := kubeCore.Pods(namespace).Patch(pod.Name, types.JSONPatchType, payloadBytes); err != nil {
-				t.Errorf("updating pod %s failed: %s", pod.GetName(), err)
+				return errors.Errorf("updating pod %s failed: %s", pod.GetName(), err)
 			}
 		}
 	}
 
 	if err := kubeCore.Namespaces().Delete(namespace, &metav1.DeleteOptions{}); err != nil {
-		t.Fatalf("deleting namespace %s failed: %s", namespace, err)
+		return errors.Errorf("deleting namespace %s failed: %s", namespace, err)
 	}
-	t.Logf("Namespace %s is deleted", namespace)
+	logrus.Infof("Namespace %s is deleted", namespace)
+	return nil
 }
 
 type patchRemoveNoValue struct {

test/e2e/gameserverallocation_test.go

@@ -77,8 +77,15 @@ func TestMultiClusterAllocationOnLocalCluster(t *testing.T) {
 			t.Parallel()
 
 			namespace := fmt.Sprintf("gsa-multicluster-local-%s", uuid.NewUUID())
-			framework.CreateNamespace(t, namespace)
-			defer framework.DeleteNamespace(t, namespace)
+			err := framework.CreateNamespace(namespace)
+			if !assert.Nil(t, err) {
+				return
+			}
+			defer func() {
+				if derr := framework.DeleteNamespace(namespace); derr != nil {
+					t.Error(derr)
+				}
+			}()
 
 			fleets := framework.AgonesClient.AgonesV1().Fleets(namespace)
 			fleet := defaultFleet(namespace)

test/e2e/main_test.go

@@ -16,7 +16,9 @@ package e2e
 
 import (
 	"os"
+	"strconv"
 	"testing"
+	"time"
 
 	e2eframework "agones.dev/agones/test/e2e/framework"
 	"github.com/sirupsen/logrus"
@@ -47,19 +49,38 @@ func TestMain(m *testing.M) {
 		os.Exit(1)
 	}
 
-	// run cleanup before tests, to ensure no resources from previous runs exist.
-	err = framework.CleanUp(framework.Namespace)
-	if err != nil {
-		log.WithError(err).Error("failed to cleanup resources")
-	}
+	if framework.Namespace == "" {
+		// use a random namespace
+		framework.Namespace = strconv.Itoa(int(time.Now().Unix()))
+		log.Infof("Randomly generated namespace: %s", framework.Namespace)
+
+		if err := framework.CreateNamespace(framework.Namespace); err != nil {
+			log.WithError(err).Error("failed to create a random namespace")
+			os.Exit(1)
+		}
 
-	defer func() {
+		defer func() {
+			if derr := framework.DeleteNamespace(framework.Namespace); derr != nil {
+				log.Error(derr)
+			}
+			os.Exit(exitCode)
+		}()
+	} else {
+		// use an already existing namespace
+		// run cleanup before tests to ensure no resources from previous runs exist
 		err = framework.CleanUp(framework.Namespace)
 		if err != nil {
 			log.WithError(err).Error("failed to cleanup resources")
 		}
-		os.Exit(exitCode)
-	}()
+
+		defer func() {
+			err = framework.CleanUp(framework.Namespace)
+			if err != nil {
+				log.WithError(err).Error("failed to cleanup resources")
+			}
+			os.Exit(exitCode)
+		}()
+	}
 
 	exitCode = m.Run()
 }