rework tests

Signed-off-by: Matias Charriere <matias@giantswarm.io>

Author: mcharriere

cmd/template/policyexception/runner.go

@@ -11,8 +11,10 @@ import (
 	"github.com/spf13/cobra"
 	"sigs.k8s.io/yaml"
 
+	polexdraftv1alpha1 "github.com/giantswarm/exception-recommender/api/v1alpha1"
 	"github.com/giantswarm/kubectl-gs/v2/pkg/commonconfig"
 	template "github.com/giantswarm/kubectl-gs/v2/pkg/template/policyexception"
+	runtimeclient "sigs.k8s.io/controller-runtime/pkg/client"
 )
 
 type runner struct {
@@ -30,26 +32,27 @@ func (r *runner) Run(cmd *cobra.Command, args []string) error {
 	if err != nil {
 		return microerror.Mask(err)
 	}
-	err = r.run(ctx, cmd, args)
+
+	client, err := r.commonConfig.GetClient(r.logger)
+	if err != nil {
+		return microerror.Mask(err)
+	}
+
+	err = r.run(ctx, client.CtrlClient(), args)
 	if err != nil {
 		return microerror.Mask(err)
 	}
 
 	return nil
 }
 
-func (r *runner) run(ctx context.Context, cmd *cobra.Command, args []string) error {
+func (r *runner) run(ctx context.Context, client runtimeclient.Client, args []string) error {
 	var err error
 
 	config := template.Config{
 		Name: r.flag.Draft,
 	}
 
-	client, err := r.commonConfig.GetClient(r.logger)
-	if err != nil {
-		return microerror.Mask(err)
-	}
-
 	var outputWriter io.Writer
 	{
 		if r.flag.Output == "" {
@@ -65,11 +68,14 @@ func (r *runner) run(ctx context.Context, cmd *cobra.Command, args []string) err
 		}
 	}
 
-	policyexceptionCR, err := template.NewPolicyExceptionCR(config, client.CtrlClient())
+	polexdraft := polexdraftv1alpha1.PolicyExceptionDraft{}
+	err = client.Get(ctx, runtimeclient.ObjectKey{Namespace: "policy-exceptions", Name: config.Name}, &polexdraft)
 	if err != nil {
 		return microerror.Mask(err)
 	}
 
+	policyexceptionCR := template.NewPolicyExceptionCR(polexdraft)
+
 	policyexceptionCRYaml, err := yaml.Marshal(policyexceptionCR)
 	if err != nil {
 		return microerror.Mask(err)

cmd/template/policyexception/runner_test.go

@@ -2,52 +2,64 @@ package policyexception
 
 import (
 	"bytes"
+	"context"
 	goflag "flag"
 	"testing"
 
+	"github.com/giantswarm/micrologger"
 	"github.com/google/go-cmp/cmp"
 	"github.com/pkg/errors"
 
+	//nolint:staticcheck
+
 	"github.com/giantswarm/kubectl-gs/v2/test/goldenfile"
+	"github.com/giantswarm/kubectl-gs/v2/test/kubeclient"
 )
 
 var update = goflag.Bool("update", false, "update .golden reference test files")
 
-// TestRunner_Run uses golden files.
+// Test_run uses golden files.
 //
-// go test ./cmd/template/organization -run TestRunner_Run -update
-func TestRunner_Run(t *testing.T) {
+// go test ./cmd/template/policyexception -run Test_run -update
+func Test_run(t *testing.T) {
 	testCases := []struct {
 		name               string
-		flag               *flag
+		flags              *flag
+		args               []string
+		clusterName        string
 		expectedGoldenFile string
 		errorMatcher       func(error) bool
 	}{
 		{
-			name:         "",
-			flag:         &flag{},
-			errorMatcher: IsInvalidFlag,
-		},
-		{
-			name: "",
-			flag: &flag{
-				Draft:  "example",
-				Output: "",
+			name: "template polex",
+			flags: &flag{
+				Draft: "test-app",
 			},
-			expectedGoldenFile: "run_with_name.golden",
+			args:               nil,
+			expectedGoldenFile: "run_template_polex.golden",
 		},
 	}
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
+			ctx := context.Background()
+
 			out := new(bytes.Buffer)
+			// tc.flags.print = genericclioptions.NewPrintFlags("").WithDefaultOutput(output.TypeDefault)
 
-			r := &runner{
-				flag:   tc.flag,
+			logger, err := micrologger.New(micrologger.Config{})
+			if err != nil {
+				t.Fatalf("failed to create logger: %s", err.Error())
+			}
+
+			runner := &runner{
+				flag:   tc.flags,
+				logger: logger,
 				stdout: out,
 			}
 
-			err := r.Run(nil, nil)
+			k8sClient := kubeclient.FakeK8sClient()
+			err = runner.run(ctx, k8sClient.CtrlClient(), tc.args)
 			if tc.errorMatcher != nil {
 				if !tc.errorMatcher(err) {
 					t.Fatalf("error not matching expected matcher, got: %s", errors.Cause(err))
@@ -62,11 +74,11 @@ func TestRunner_Run(t *testing.T) {
 			{
 				gf := goldenfile.New("testdata", tc.expectedGoldenFile)
 				if *update {
-					expectedResult = out.Bytes()
-					err = gf.Update(expectedResult)
+					err = gf.Update(out.Bytes())
 					if err != nil {
 						t.Fatalf("unexpected error: %s", err.Error())
 					}
+					expectedResult = out.Bytes()
 				} else {
 					expectedResult, err = gf.Read()
 					if err != nil {
@@ -77,7 +89,7 @@ func TestRunner_Run(t *testing.T) {
 
 			diff := cmp.Diff(string(expectedResult), out.String())
 			if diff != "" {
-				t.Fatalf("value not expected, got:\n %s", diff)
+				t.Fatalf("no difference from golden file %s expected, got:\n %s", tc.expectedGoldenFile, diff)
 			}
 		})
 	}

cmd/template/policyexception/testdata/run_template_polex.golden

@@ -0,0 +1,15 @@
+apiVersion: policy.giantswarm.io/v1alpha1
+kind: PolicyExceptionDraft
+metadata:
+  name: test-app
+  namespace: policy-exceptions
+spec:
+  policies:
+  - restrict-policy
+  targets:
+  - kind: Deployment
+    names:
+    - test-app*
+    namespaces:
+    - test-app
+

cmd/template/policyexception/testdata/run_with_name.golden

@@ -1,41 +1,28 @@
 package policyexception
 
 import (
-	"context"
-
-	"github.com/giantswarm/microerror"
-
 	polexdraftv1alpha1 "github.com/giantswarm/exception-recommender/api/v1alpha1"
 	polexv1alpha1 "github.com/giantswarm/kyverno-policy-operator/api/v1alpha1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	runtimeclient "sigs.k8s.io/controller-runtime/pkg/client"
 )
 
 type Config struct {
 	Name string
 }
 
-func NewPolicyExceptionCR(config Config, client runtimeclient.Client) (*polexv1alpha1.PolicyException, error) {
-	ctx := context.Background()
-
-	polexdraft := &polexdraftv1alpha1.PolicyExceptionDraft{}
-	err := client.Get(ctx, runtimeclient.ObjectKey{Namespace: "policy-exceptions", Name: config.Name}, polexdraft)
-	if err != nil {
-		return nil, microerror.Mask(err)
-	}
-
+func NewPolicyExceptionCR(polexdraft polexdraftv1alpha1.PolicyExceptionDraft) *polexv1alpha1.PolicyException {
 	polexCR := &polexv1alpha1.PolicyException{
 		TypeMeta: metav1.TypeMeta{
 			Kind:       "PolicyException",
 			APIVersion: "policy.giantswarm.io/v1alpha1",
 		},
 		ObjectMeta: metav1.ObjectMeta{
-			Name: config.Name,
+			Name: polexdraft.GetName(),
 		},
 		Spec: policyExceptionSpecDeepCopy(polexdraft.Spec),
 	}
 
-	return polexCR, nil
+	return polexCR
 }
 
 func policyExceptionSpecDeepCopy(draft polexdraftv1alpha1.PolicyExceptionDraftSpec) polexv1alpha1.PolicyExceptionSpec {