Add --watch-namespace to operator-sdk test local sub-command

This patch resolves mergeconflicts in cherry-pick ea8caeb
and recent refactoring in operator-sdk/pkg/test
operator-framework#2037

Add --watch-namespace flag to `operator-sdk test local <test-dir> --up-local` command

`--deploy-namespace` flag specifies namespace where namespaced resources are deployed for testing

`--watch-namespace` flag specifies the namespace which operator watches during testing. That is the value
of `WATCH_NAMESPACE` envvar

**the behavior of `--watch-namespace` flags is as follows**

when not set
    `WATCH_NAMESPACE` is set to deploy namespace.
    which means when `--watch-namespace` is not set, watch-namespace == deploy-namespace
    operator watched deploy-namespace during testing

`--watch-namespace=foo`
    `WATCH_NAMESPACES=foo` operator watches namespace `foo` during testing

`--watch-namespace=""`
    `WATCH_NAMESPACES=""` operator watches all namespaces during testing

Update tests

Signed-off-by: Nikhil Thomas <[email protected]>
(cherry picked from commit ea8caeb)
Signed-off-by: Nikhil Thomas <[email protected]>

Author: nikhil-thomas

CHANGELOG.md

@@ -3,8 +3,13 @@
 ### Added
 - Support for vars in top level ansible watches. ([#2147](https://github.com/operator-framework/operator-sdk/pull/2147))
 
+- Added `--watch-namespace` flag as `operator-sdk test local <test-dir> --up-local` command. ([#2149](https://github.com/operator-framework/operator-sdk/pull/2149))
+
 ### Changed
+
 - Upgrade minimal Ansible version in the init projects from `2.4` to `2.6`. ([#2107](https://github.com/operator-framework/operator-sdk/pull/2107))
+- **Breaking Change:** Renamed `--namespace` flag as `--watch-namespace` in `operator-sdk up local` command. ([#2149](https://github.com/operator-framework/operator-sdk/pull/2149))
+- **Breaking Change:** Renamed `--namespace` flag as `--deploy-namespace` in `operator-sdk test local <test-dir> --up-local` command. ([#2149](https://github.com/operator-framework/operator-sdk/pull/2149))
 
 ### Deprecated
 

cmd/operator-sdk/test/local.go

@@ -48,6 +48,7 @@ type testLocalConfig struct {
 	goTestFlags        string
 	moleculeTestFlags  string
 	deployNamespace    string
+	watchNamespace     string
 	upLocal            bool
 	noSetup            bool
 	debug              bool
@@ -69,6 +70,7 @@ func newTestLocalCmd() *cobra.Command {
 	testCmd.Flags().StringVar(&tlConfig.goTestFlags, "go-test-flags", "", "Additional flags to pass to go test")
 	testCmd.Flags().StringVar(&tlConfig.moleculeTestFlags, "molecule-test-flags", "", "Additional flags to pass to molecule test")
 	testCmd.Flags().StringVar(&tlConfig.deployNamespace, "deploy-namespace", "", "If non-empty, single namespace to run tests in (deploys namespaced resources here)")
+	testCmd.Flags().StringVar(&tlConfig.watchNamespace, "watch-namespace", "", "The namespace where the operator watches for changes (with --up-local, if not set, watches deployNamespace")
 	testCmd.Flags().BoolVar(&tlConfig.upLocal, "up-local", false, "Enable running operator locally with go run instead of as an image in the cluster")
 	testCmd.Flags().BoolVar(&tlConfig.noSetup, "no-setup", false, "Disable test resource creation")
 	testCmd.Flags().BoolVar(&tlConfig.debug, "debug", false, "Enable debug-level logging")
@@ -103,7 +105,7 @@ func testLocalAnsibleFunc(cmd *cobra.Command, args []string) error {
 	}
 
 	dc := exec.Command("molecule", testArgs...)
-	dc.Env = append(os.Environ(), fmt.Sprintf("%v=%v", test.TestNamespaceEnv, tlConfig.deployNamespace))
+	dc.Env = append(os.Environ(), fmt.Sprintf("%v=%v", test.TestDeployNamespaceEnv, tlConfig.deployNamespace))
 	dc.Dir = projutil.MustGetwd()
 	return projutil.ExecCmd(dc)
 }
@@ -209,14 +211,21 @@ func testLocalGoFunc(cmd *cobra.Command, args []string) error {
 	if tlConfig.deployNamespace != "" || tlConfig.noSetup {
 		testArgs = append(testArgs, "-"+test.SingleNamespaceFlag, "-parallel=1")
 	}
-	env := append(os.Environ(), fmt.Sprintf("%v=%v", test.TestNamespaceEnv, tlConfig.deployNamespace))
+	env := append(os.Environ(), fmt.Sprintf("%v=%v", test.TestDeployNamespaceEnv, tlConfig.deployNamespace))
 	if tlConfig.upLocal {
 		env = append(env, fmt.Sprintf("%s=%s", k8sutil.ForceRunModeEnv, k8sutil.LocalRunMode))
 		testArgs = append(testArgs, "-"+test.LocalOperatorFlag)
 		if tlConfig.localOperatorFlags != "" {
 			testArgs = append(testArgs, "-"+test.LocalOperatorArgs, tlConfig.localOperatorFlags)
 		}
 	}
+	// if watch-namespace is not explicitly set
+	// then set test.WatchDeployNamespaceFlag
+	// so that watchNamespace == deployNamespace in --up-local mode
+	if tlConfig.upLocal && !cmd.Flags().Changed("watch-namespace") {
+		testArgs = append(testArgs, "-"+test.WatchDeployNamespaceFlag)
+	}
+	env = append(env, fmt.Sprintf("%v=%v", test.TestWatchNamespaceEnv, tlConfig.watchNamespace))
 	opts := projutil.GoTestOptions{
 		GoCmdOptions: projutil.GoCmdOptions{
 			PackagePath: args[0] + "/...",

doc/cli/operator-sdk_test_local.md

@@ -14,17 +14,18 @@ operator-sdk test local <path to tests directory> [flags]
 
 ```
       --debug                         Enable debug-level logging
+      --deploy-namespace string       If non-empty, single namespace to run tests in (deploys namespaced resources here)
       --global-manifest string        Path to manifest for Global resources (e.g. CRD manifests)
       --go-test-flags string          Additional flags to pass to go test
   -h, --help                          help for local
       --image string                  Use a different operator image from the one specified in the namespaced manifest
       --kubeconfig string             Kubeconfig path
       --local-operator-flags string   The flags that the operator needs (while using --up-local). Example: "--flag1 value1 --flag2=value2"
       --molecule-test-flags string    Additional flags to pass to molecule test
-      --namespace string              If non-empty, single namespace to run tests in
       --namespaced-manifest string    Path to manifest for per-test, namespaced resources (e.g. RBAC and Operator manifest)
       --no-setup                      Disable test resource creation
       --up-local                      Enable running operator locally with go run instead of as an image in the cluster
+      --watch-namespace string        The namespace where the operator watches for changes (with --up-local, if not set, watches deployNamespace
 ```
 
 ### SEE ALSO

doc/cli/operator-sdk_up_local.md

@@ -16,12 +16,12 @@ operator-sdk up local [flags]
 ### Options
 
 ```
-      --enable-delve            Start the operator using the delve debugger
-      --go-ldflags string       Set Go linker options
-  -h, --help                    help for local
-      --kubeconfig string       The file path to kubernetes configuration file; defaults to location specified by $KUBECONFIG with a fallback to $HOME/.kube/config if not set
-      --namespace string        The namespace where the operator watches for changes.
-      --operator-flags string   The flags that the operator needs. Example: "--flag1 value1 --flag2=value2"
+      --enable-delve             Start the operator using the delve debugger
+      --go-ldflags string        Set Go linker options
+  -h, --help                     help for local
+      --kubeconfig string        The file path to kubernetes configuration file; defaults to location specified by $KUBECONFIG with a fallback to $HOME/.kube/config if not set
+      --operator-flags string    The flags that the operator needs. Example: "--flag1 value1 --flag2=value2"
+      --watch-namespace string   The namespace where the operator watches for changes.
 ```
 
 ### SEE ALSO

doc/sdk-cli-reference.md

@@ -460,7 +460,8 @@ Runs the tests locally
 * `--kubeconfig` string - location of kubeconfig for Kubernetes cluster (default "~/.kube/config")
 * `--global-manifest` string - path to manifest for global resources (default "deploy/crd.yaml)
 * `--namespaced-manifest` string - path to manifest for per-test, namespaced resources (default: combines deploy/service_account.yaml, deploy/rbac.yaml, and deploy/operator.yaml)
-* `--namespace` string - if non-empty, single namespace to run tests in (e.g. "operator-test") (default: "")
+* `--deploy-namespace` string - if non-empty, single namespace to run tests in (e.g. "operator-test") (default: "default")
+* `--watch-namespace` string - if set, namespace which operator watches while testing with `--up-local`.  if set to "", operator watches AllNamespaces. if not set while testing with `--up-local` operator watches deploy-namespace
 * `--go-test-flags` string - Additional flags to pass to go test
 * `--molecule-test-flags` string - Additional flags to pass to molecule test
 * `--up-local` - enable running operator locally with go run instead of as an image in the cluster
@@ -500,7 +501,7 @@ the operator-sdk binary itself as the operator.
 * `--enable-delve` bool - starts the operator locally and enables the delve debugger listening on port 2345
 * `--go-ldflags` string - Set Go linker options
 * `--kubeconfig` string - The file path to Kubernetes configuration file; defaults to $HOME/.kube/config
-* `--namespace` string - The namespace where the operator watches for changes. (default "default")
+* `--watch-namespace` string - The namespace where the operator watches for changes. (default "default"). set to `""` to watch All-Namepsaces
 * `--operator-flags` string - Flags that the local operator may need.
 * `-h, --help` - help for local
 

doc/test-framework/writing-e2e-tests.md

@@ -239,11 +239,11 @@ $ operator-sdk test local ./test/e2e --image quay.io/example/my-operator:v0.0.2
 
 ### Namespace Flag
 
-If you wish to run all the tests in 1 namespace (which also forces `-parallel=1`), you can use the `--namespace` flag:
+If you wish to run all the tests in 1 namespace (which also forces `-parallel=1`), you can use the `--deploy-namespace` flag:
 
 ```shell
 $ kubectl create namespace operator-test
-$ operator-sdk test local ./test/e2e --namespace operator-test
+$ operator-sdk test local ./test/e2e --deploy-namespace operator-test
 ```
 
 ### Up-Local Flag
@@ -252,11 +252,11 @@ To run the operator itself locally during the tests instead of starting a deploy
 `--up-local` flag. This mode will still create global resources, but by default will not create any in-cluster namespaced
 resources unless the user specifies one through the `--namespaced-manifest` flag.
 
-**NOTE**: The `--up-local` flag requires the `--namespace` flag and the command will NOT create the namespace. Then, be sure that you are specifying a valid namespace.
+**NOTE**: The `--up-local` flag requires the `--deploy-namespace` flag and the command will NOT create the namespace. Then, be sure that you are specifying a valid namespace.
 
 ```shell
 $ kubectl create namespace operator-test
-$ operator-sdk test local ./test/e2e --namespace operator-test --up-local
+$ operator-sdk test local ./test/e2e --deploy-namespace operator-test --up-local
 ```
 
 ### No-Setup Flag
@@ -269,7 +269,7 @@ $ kubectl create -f deploy/service_account.yaml --namespace operator-test
 $ kubectl create -f deploy/role.yaml --namespace operator-test
 $ kubectl create -f deploy/role_binding.yaml --namespace operator-test
 $ kubectl create -f deploy/operator.yaml --namespace operator-test
-$ operator-sdk test local ./test/e2e --namespace operator-test --no-setup
+$ operator-sdk test local ./test/e2e --deploy-namespace operator-test --no-setup
 ```
 
 For more documentation on the `operator-sdk test local` command, see the [SDK CLI Reference][sdk-cli-ref] doc.

doc/user-guide.md

@@ -303,7 +303,7 @@ export OPERATOR_NAME=memcached-operator
 Run the operator locally with the default Kubernetes config file present at `$HOME/.kube/config`:
 
 ```sh
-$ operator-sdk up local --namespace=default
+$ operator-sdk up local --watch-namespace=default
 2018/09/30 23:10:11 Go Version: go1.10.2
 2018/09/30 23:10:11 Go OS/Arch: darwin/amd64
 2018/09/30 23:10:11 operator-sdk Version: 0.0.6+git

hack/tests/e2e-ansible-molecule.sh

@@ -52,7 +52,7 @@ pushd memcached-operator
 # The following code is the default used (Not valid for MacOSX)
 sed -i 's|\(FROM quay.io/operator-framework/ansible-operator\)\(:.*\)\?|\1:dev|g' build/Dockerfile
 OPERATORDIR="$(pwd)"
-TEST_CLUSTER_PORT=24443 operator-sdk test local --namespace default
+TEST_CLUSTER_PORT=24443 operator-sdk test local --deploy-namespace default
 
 remove_prereqs
 
@@ -65,6 +65,6 @@ pushd "${ROOTDIR}/test/ansible-inventory"
 # sed -i "" 's|\(FROM quay.io/operator-framework/ansible-operator\)\(:.*\)\?|\1:dev|g' build/Dockerfile
 # The following code is the default used (Not valid for MacOSX)
 sed -i 's|\(FROM quay.io/operator-framework/ansible-operator\)\(:.*\)\?|\1:dev|g' build/Dockerfile
-TEST_CLUSTER_PORT=24443 operator-sdk test local --namespace default
+TEST_CLUSTER_PORT=24443 operator-sdk test local --deploy-namespace default
 
 popd

hack/tests/subcommand.sh

@@ -16,32 +16,37 @@ operator-sdk test local ./test/e2e --global-manifest deploy/crds/cache.example.c
 
 # we use the test-memcached namespace for all future tests, so we only need to set this trap once
 kubectl create namespace test-memcached
-trap_add 'kubectl delete namespace test-memcached || true' EXIT
-operator-sdk test local ./test/e2e --namespace=test-memcached
+trap_add 'kubectl delete --ignore-not-found namespace test-memcached' EXIT
+operator-sdk test local ./test/e2e --deploy-namespace=test-memcached
 kubectl delete namespace test-memcached
 
 # test operator in up local mode
 kubectl create namespace test-memcached
-operator-sdk test local ./test/e2e --up-local --namespace=test-memcached
+operator-sdk test local ./test/e2e --up-local --deploy-namespace=test-memcached
+kubectl delete namespace test-memcached
+
+# test operator in up local mode with --watch-namespace flag
+kubectl create namespace test-memcached
+operator-sdk test local ./test/e2e --up-local --deploy-namespace=test-memcached --watch-namespace=""
 kubectl delete namespace test-memcached
 
 # test operator in up local mode with kubeconfig
 kubectl create namespace test-memcached
-operator-sdk test local ./test/e2e --up-local --namespace=test-memcached --kubeconfig $KUBECONFIG
+operator-sdk test local ./test/e2e --up-local --deploy-namespace=test-memcached --kubeconfig $KUBECONFIG
 kubectl delete namespace test-memcached
 
 # test operator in no-setup mode
 kubectl create namespace test-memcached
 kubectl create -f deploy/crds/cache.example.com_memcacheds_crd.yaml
 # this runs after the popd at the end, so it needs the path from the project root
-trap_add 'kubectl delete -f test/test-framework/deploy/crds/cache.example.com_memcacheds_crd.yaml' EXIT
+trap_add 'kubectl delete --ignore-not-found -f test/test-framework/deploy/crds/cache.example.com_memcacheds_crd.yaml' EXIT
 kubectl create -f deploy/crds/cache.example.com_memcachedrs_crd.yaml
 # this runs after the popd at the end, so it needs the path from the project root
-trap_add 'kubectl delete -f test/test-framework/deploy/crds/cache.example.com_memcachedrs_crd.yaml' EXIT
+trap_add 'kubectl delete --ignore-not-found -f test/test-framework/deploy/crds/cache.example.com_memcachedrs_crd.yaml' EXIT
 kubectl create -f deploy/service_account.yaml --namespace test-memcached
 kubectl create -f deploy/role.yaml --namespace test-memcached
 kubectl create -f deploy/role_binding.yaml --namespace test-memcached
 kubectl create -f deploy/operator.yaml --namespace test-memcached
-operator-sdk test local ./test/e2e --namespace=test-memcached --no-setup
+operator-sdk test local ./test/e2e --deploy-namespace=test-memcached --no-setup
 kubectl delete namespace test-memcached
 popd

pkg/test/context.go

@@ -66,7 +66,7 @@ func (f *Framework) newTestCtx(t *testing.T) *TestCtx {
 
 	var namespace string
 	if f.singleNamespaceMode {
-		namespace = f.Namespace
+		namespace = f.DeployNamespace
 	}
 	return &TestCtx{
 		id:                id,

pkg/test/e2eutil/wait_util.go

@@ -52,7 +52,7 @@ func waitForDeployment(t *testing.T, kubeclient kubernetes.Interface, namespace,
 		deployment, err := kubeclient.AppsV1().Deployments(namespace).Get(name, metav1.GetOptions{})
 		if err != nil {
 			if apierrors.IsNotFound(err) {
-				t.Logf("Waiting for availability of %s deployment\n", name)
+				t.Logf("Waiting for availability of %s/%s deployment\n", namespace, name)
 				return false, nil
 			}
 			return false, err

pkg/test/framework.go

@@ -60,7 +60,8 @@ type Framework struct {
 	KubeClient        kubernetes.Interface
 	Scheme            *runtime.Scheme
 	NamespacedManPath *string
-	Namespace         string
+	DeployNamespace   string
+	WatchNamespace    string
 	LocalOperator     bool
 
 	projectRoot         string
@@ -74,26 +75,29 @@ type Framework struct {
 }
 
 type frameworkOpts struct {
-	projectRoot         string
-	kubeconfigPath      string
-	globalManPath       string
-	namespacedManPath   string
-	localOperator       bool
-	singleNamespaceMode bool
-	isLocalOperator     bool
-	localOperatorArgs   string
+	projectRoot          string
+	kubeconfigPath       string
+	globalManPath        string
+	namespacedManPath    string
+	localOperator        bool
+	singleNamespaceMode  bool
+	watchDeployNamespace bool
+	isLocalOperator      bool
+	localOperatorArgs    string
 }
 
 const (
-	ProjRootFlag          = "root"
-	KubeConfigFlag        = "kubeconfig"
-	NamespacedManPathFlag = "namespacedMan"
-	GlobalManPathFlag     = "globalMan"
-	SingleNamespaceFlag   = "singleNamespace"
-	LocalOperatorFlag     = "localOperator"
-	LocalOperatorArgs     = "localOperatorArgs"
-
-	TestNamespaceEnv = "TEST_NAMESPACE"
+	ProjRootFlag             = "root"
+	KubeConfigFlag           = "kubeconfig"
+	NamespacedManPathFlag    = "namespacedMan"
+	GlobalManPathFlag        = "globalMan"
+	SingleNamespaceFlag      = "singleNamespace"
+	WatchDeployNamespaceFlag = "watchDeployNamespace"
+	LocalOperatorFlag        = "localOperator"
+	LocalOperatorArgs        = "localOperatorArgs"
+
+	TestDeployNamespaceEnv = "TEST_DEPLOY_NAMESPACE"
+	TestWatchNamespaceEnv  = "TEST_WATCH_NAMESPACE"
 )
 
 func (opts *frameworkOpts) addToFlagSet(flagset *flag.FlagSet) {
@@ -103,6 +107,7 @@ func (opts *frameworkOpts) addToFlagSet(flagset *flag.FlagSet) {
 	flagset.StringVar(&opts.kubeconfigPath, KubeConfigFlag, "", "path to kubeconfig")
 	flagset.StringVar(&opts.globalManPath, GlobalManPathFlag, "", "path to operator manifest")
 	flagset.BoolVar(&opts.singleNamespaceMode, SingleNamespaceFlag, false, "enable single namespace mode")
+	flagset.BoolVar(&opts.watchDeployNamespace, WatchDeployNamespaceFlag, false, "set watch namespace to deploy namespace")
 	flagset.StringVar(&opts.localOperatorArgs, LocalOperatorArgs, "", "flags that the operator needs (while using --up-local). example: \"--flag1 value1 --flag2=value2\"")
 }
 
@@ -112,14 +117,19 @@ func newFramework(opts *frameworkOpts) (*Framework, error) {
 		return nil, fmt.Errorf("failed to build the kubeconfig: %v", err)
 	}
 
-	namespace := kcNamespace
+	deployNamespace := kcNamespace
 	if opts.singleNamespaceMode {
-		testNamespace := os.Getenv(TestNamespaceEnv)
-		if testNamespace != "" {
-			namespace = testNamespace
+		testDeployNamespace := os.Getenv(TestDeployNamespaceEnv)
+		if testDeployNamespace != "" {
+			deployNamespace = testDeployNamespace
 		}
 	}
 
+	watchNamespace := os.Getenv(TestWatchNamespaceEnv)
+	if watchNamespace == "" && opts.watchDeployNamespace {
+		watchNamespace = deployNamespace
+	}
+
 	kubeclient, err := kubernetes.NewForConfig(kubeconfig)
 	if err != nil {
 		return nil, fmt.Errorf("failed to build the kubeclient: %v", err)
@@ -147,7 +157,8 @@ func newFramework(opts *frameworkOpts) (*Framework, error) {
 		KubeClient:        kubeclient,
 		Scheme:            scheme,
 		NamespacedManPath: &opts.namespacedManPath,
-		Namespace:         namespace,
+		DeployNamespace:   deployNamespace,
+		WatchNamespace:    watchNamespace,
 		LocalOperator:     opts.isLocalOperator,
 
 		projectRoot:         opts.projectRoot,
@@ -190,7 +201,7 @@ func (f *Framework) addToScheme(addToScheme addToSchemeFunc, obj runtime.Object)
 	}
 	err = wait.PollImmediate(time.Second, time.Second*10, func() (done bool, err error) {
 		if f.singleNamespaceMode {
-			err = dynClient.List(goctx.TODO(), obj, dynclient.InNamespace(f.Namespace))
+			err = dynClient.List(goctx.TODO(), obj, dynclient.InNamespace(f.DeployNamespace))
 		} else {
 			err = dynClient.List(goctx.TODO(), obj, dynclient.InNamespace("default"))
 		}
@@ -284,6 +295,6 @@ func (f *Framework) setupLocalCommand() (*exec.Cmd, error) {
 		// be populated by NewDefaultClientConfigLoadingRules()
 		localCmd.Env = append(os.Environ(), fmt.Sprintf("%v=%v", k8sutil.KubeConfigEnvVar, clientcmd.NewDefaultClientConfigLoadingRules().Precedence[0]))
 	}
-	localCmd.Env = append(localCmd.Env, fmt.Sprintf("%v=%v", k8sutil.WatchNamespaceEnvVar, f.Namespace))
+	localCmd.Env = append(localCmd.Env, fmt.Sprintf("%v=%v", k8sutil.WatchNamespaceEnvVar, f.WatchNamespace))
 	return localCmd, nil
 }

test/ansible-memcached/molecule.yml

@@ -29,7 +29,7 @@ provisioner:
   inventory:
     group_vars:
       all:
-        namespace: ${TEST_NAMESPACE:-osdk-test}
+        namespace: ${TEST_DEPLOY_NAMESPACE:-osdk-test}
   env:
     K8S_AUTH_KUBECONFIG: /tmp/molecule/kind-test-local/kubeconfig
     KUBECONFIG: /tmp/molecule/kind-test-local/kubeconfig

test/e2e/_incluster-test-code/memcached_test.go

@@ -217,7 +217,7 @@ func MemcachedLocal(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	cmd := exec.Command("operator-sdk", "up", "local", "--namespace="+namespace)
+	cmd := exec.Command("operator-sdk", "up", "local", "--watch-namespace="+namespace)
 	stderr, err := os.Create("stderr.txt")
 	if err != nil {
 		t.Fatalf("Failed to create stderr.txt: %v", err)