feat: add labels flag as optional

Author: Felipe Amaral

README.md

@@ -223,7 +223,7 @@ Otherwise there's `Makefile`
 ```sh
 $ make
 make
-all                            Cean, build and pack
+all                            Clean, build and pack
 help                           Prints list of tasks
 build                          Build binary
 generate                       Go generate

cmd/kubent/main.go

@@ -156,7 +156,7 @@ func main() {
 		log.Fatal().Err(err).Str("name", "Rego").Msg("Failed to filter results")
 	}
 
-	err = outputResults(results, config.Output, config.OutputFile)
+	err = outputResults(results, config.Output, config.OutputFile, *config.OptionalFlags)
 	if err != nil {
 		log.Fatal().Err(err).Msgf("Failed to output results")
 	}
@@ -180,14 +180,14 @@ func configureGlobalLogging() {
 	log.Logger = log.Output(zerolog.ConsoleWriter{Out: os.Stderr})
 }
 
-func outputResults(results []judge.Result, outputType string, outputFile string) error {
+func outputResults(results []judge.Result, outputType string, outputFile string, optionalFlags config.OptionalFlags) error {
 	printer, err := printer.NewPrinter(outputType, outputFile)
 	if err != nil {
 		return fmt.Errorf("failed to create printer: %v", err)
 	}
 	defer printer.Close()
 
-	err = printer.Print(results)
+	err = printer.Print(results, optionalFlags)
 	if err != nil {
 		return fmt.Errorf("failed to print results: %v", err)
 	}

cmd/kubent/main_test.go

@@ -272,23 +272,24 @@ func Test_outputResults(t *testing.T) {
 		ApiVersion: "1.2.3", RuleSet: "rs", ReplaceWith: "rep", Since: testVersion}}
 
 	type args struct {
-		results    []judge.Result
-		outputType string
-		outputFile string
+		results       []judge.Result
+		outputType    string
+		outputFile    string
+		optionalFlags config.OptionalFlags
 	}
 	tests := []struct {
 		name    string
 		args    args
 		wantErr bool
 	}{
-		{"good", args{testResults, "text", "-"}, false},
-		{"bad-new-printer-type", args{testResults, "unknown", "-"}, true},
-		{"bad-new-printer-file", args{testResults, "text", "/unlikely/to/exist/dir"}, true},
+		{"good", args{testResults, "text", "-", config.OptionalFlags{Labels: false}}, false},
+		{"bad-new-printer-type", args{testResults, "unknown", "-", config.OptionalFlags{Labels: false}}, true},
+		{"bad-new-printer-file", args{testResults, "text", "/unlikely/to/exist/dir", config.OptionalFlags{Labels: false}}, true},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if err := outputResults(tt.args.results, tt.args.outputType, tt.args.outputFile); (err != nil) != tt.wantErr {
+			if err := outputResults(tt.args.results, tt.args.outputType, tt.args.outputFile, tt.args.optionalFlags); (err != nil) != tt.wantErr {
 				t.Errorf("unexpected error - got: %v, wantErr: %v", err, tt.wantErr)
 			}
 		})

fixtures/expected-json-output.json

@@ -6,6 +6,7 @@
 		"ApiVersion": "apps/v1beta1",
 		"RuleSet": "Deprecated APIs removed in 1.16",
 		"ReplaceWith": "apps/v1",
-		"Since": "1.9.0"
+		"Since": "1.9.0",
+		"Labels": {}
 	}
 ]

pkg/collector/file_test.go

@@ -52,7 +52,7 @@ func TestFileCollectorGet(t *testing.T) {
 				t.Errorf("Expected to get %d, got %d", len(tc.expected), len(manifests))
 			}
 
-			for i, _ := range manifests {
+			for i := range manifests {
 				if manifests[i]["kind"] != tc.expected[i] {
 					t.Errorf("Expected to get %s, instead got: %s", tc.expected[i], manifests[i]["kind"])
 				}

pkg/config/config.go

@@ -10,13 +10,18 @@ import (
 	"unicode"
 
 	"github.com/doitintl/kube-no-trouble/pkg/judge"
-	"github.com/doitintl/kube-no-trouble/pkg/printer"
 	"k8s.io/client-go/tools/clientcmd"
 
 	"github.com/rs/zerolog"
 	flag "github.com/spf13/pflag"
 )
 
+const (
+	JSON = "json"
+	TEXT = "text"
+	CSV  = "csv"
+)
+
 type Config struct {
 	AdditionalKinds       []string
 	AdditionalAnnotations []string
@@ -31,12 +36,18 @@ type Config struct {
 	OutputFile            string
 	TargetVersion         *judge.Version
 	KubentVersion         bool
+	OptionalFlags         *OptionalFlags
+}
+
+type OptionalFlags struct {
+	Labels bool
 }
 
 func NewFromFlags() (*Config, error) {
 	config := Config{
 		LogLevel:      ZeroLogLevel(zerolog.InfoLevel),
 		TargetVersion: &judge.Version{},
+		OptionalFlags: &OptionalFlags{},
 	}
 
 	flag.StringSliceVarP(&config.AdditionalKinds, "additional-kind", "a", []string{}, "additional kinds of resources to report in Kind.version.group.com format")
@@ -52,11 +63,12 @@ func NewFromFlags() (*Config, error) {
 	flag.StringVarP(&config.OutputFile, "output-file", "O", "-", "output file, use - for stdout")
 	flag.VarP(&config.LogLevel, "log-level", "l", "set log level (trace, debug, info, warn, error, fatal, panic, disabled)")
 	flag.VarP(config.TargetVersion, "target-version", "t", "target K8s version in SemVer format (autodetected by default)")
+	flag.BoolVar(&config.OptionalFlags.Labels, "labels", false, "print resource labels")
 
 	flag.Parse()
 
-	if _, err := printer.ParsePrinter(config.Output); err != nil {
-		return nil, fmt.Errorf("failed to validate argument output: %w", err)
+	if !isValidOutputFormat(config.Output) {
+		return nil, fmt.Errorf("failed to validate argument output: %s", config.Output)
 	}
 
 	if err := validateOutputFile(config.OutputFile); err != nil {
@@ -77,6 +89,17 @@ func NewFromFlags() (*Config, error) {
 	return &config, nil
 }
 
+// Previuosly this was handled by a printer.go ParsePrinter function
+// but we need to avoid cycle imports in order to inject the additional flags
+func isValidOutputFormat(format string) bool {
+	switch format {
+	case JSON, TEXT, CSV:
+		return true
+	default:
+		return false
+	}
+}
+
 // validateAdditionalResources check that all resources are provided in full form
 // resource.version.group.com. E.g. managedcertificate.v1beta1.networking.gke.io
 func validateAdditionalResources(resources []string) error {

pkg/config/config_test.go

@@ -72,9 +72,9 @@ func TestValidateAdditionalResources(t *testing.T) {
 
 func TestValidateAdditionalResourcesFail(t *testing.T) {
 	testCases := [][]string{
-		[]string{"abcdef"},
-		[]string{""},
-		[]string{"test.v1.com"},
+		{"abcdef"},
+		{""},
+		{"test.v1.com"},
 	}
 
 	for _, tc := range testCases {

pkg/judge/judge.go

@@ -8,6 +8,7 @@ type Result struct {
 	RuleSet     string
 	ReplaceWith string
 	Since       *Version
+	Labels      map[string]interface{}
 }
 
 type Judge interface {

pkg/judge/rego.go

@@ -63,6 +63,12 @@ func (j *RegoJudge) Eval(input []map[string]interface{}) ([]Result, error) {
 					m["Namespace"] = "<undefined>"
 				}
 
+				var labels map[string]interface{}
+				if v, ok := m["Labels"].(map[string]interface{}); ok {
+					labels = v
+				} else {
+					labels = make(map[string]interface{})
+				}
 				results = append(results, Result{
 					Name:        m["Name"].(string),
 					Namespace:   m["Namespace"].(string),
@@ -71,6 +77,7 @@ func (j *RegoJudge) Eval(input []map[string]interface{}) ([]Result, error) {
 					ReplaceWith: m["ReplaceWith"].(string),
 					RuleSet:     m["RuleSet"].(string),
 					Since:       since,
+					Labels:      labels,
 				})
 			}
 		}

pkg/judge/rego_test.go

@@ -90,7 +90,7 @@ func TestEvalRules(t *testing.T) {
 				t.Errorf("expected %d findings, instead got: %d", len(tc.expected), len(results))
 			}
 
-			for i, _ := range results {
+			for i := range results {
 				if results[i].Kind != tc.expected[i] {
 					t.Errorf("expected to get %s finding, instead got: %s", tc.expected[i], results[i].Kind)
 				}