feat: Add labels flag and output

README.md

@@ -215,7 +215,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.Labels)
 	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, labels bool) 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, labels)
 	if err != nil {
 		return fmt.Errorf("failed to print results: %v", err)
 	}

cmd/kubent/main_test.go

@@ -288,7 +288,7 @@ func Test_outputResults(t *testing.T) {
 
 	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, false); (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

@@ -31,6 +31,7 @@ type Config struct {
 	OutputFile            string
 	TargetVersion         *judge.Version
 	KubentVersion         bool
+	Labels                bool
 }
 
 func NewFromFlags() (*Config, error) {
@@ -52,6 +53,7 @@ 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.Labels, "labels", false, "print resource labels")
 
 	flag.Parse()
 

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)
 				}

pkg/printer/csv.go

@@ -29,7 +29,7 @@ func (c *csvPrinter) Close() error {
 }
 
 // Print will print results in CSV format
-func (c *csvPrinter) Print(results []judge.Result) error {
+func (c *csvPrinter) Print(results []judge.Result, labels bool) error {
 
 	sort.Slice(results, func(i, j int) bool {
 		return results[i].Name < results[j].Name
@@ -46,26 +46,50 @@ func (c *csvPrinter) Print(results []judge.Result) error {
 
 	w := csv.NewWriter(c.commonPrinter.outputFile)
 
-	w.Write([]string{
-		"api_version",
-		"kind",
-		"namespace",
-		"name",
-		"replace_with",
-		"since",
-		"rule_set",
-	})
-
-	for _, r := range results {
+	if labels {
+		w.Write([]string{
+			"api_version",
+			"kind",
+			"namespace",
+			"name",
+			"replace_with",
+			"since",
+			"rule_set",
+			"labels",
+		})
+		for _, r := range results {
+			w.Write([]string{
+				r.ApiVersion,
+				r.Kind,
+				r.Namespace,
+				r.Name,
+				r.ReplaceWith,
+				r.Since.String(),
+				r.RuleSet,
+				mapToCommaSeparatedString(r.Labels),
+			})
+		}
+	} else {
 		w.Write([]string{
-			r.ApiVersion,
-			r.Kind,
-			r.Namespace,
-			r.Name,
-			r.ReplaceWith,
-			r.Since.String(),
-			r.RuleSet,
+			"api_version",
+			"kind",
+			"namespace",
+			"name",
+			"replace_with",
+			"since",
+			"rule_set",
 		})
+		for _, r := range results {
+			w.Write([]string{
+				r.ApiVersion,
+				r.Kind,
+				r.Namespace,
+				r.Name,
+				r.ReplaceWith,
+				r.Since.String(),
+				r.RuleSet,
+			})
+		}
 	}
 
 	w.Flush()

pkg/printer/csv_test.go

@@ -51,9 +51,51 @@ func TestCSVPrinterPrint(t *testing.T) {
 	}
 
 	version, _ := judge.NewVersion("1.2.3")
-	results := []judge.Result{{"Name", "Namespace", "Kind", "1.2.3", "Test", "4.5.6", version}}
+	results := []judge.Result{{
+		Name:        "Name",
+		Namespace:   "Namespace",
+		Kind:        "Kind",
+		ApiVersion:  "1.2.3",
+		RuleSet:     "Test",
+		ReplaceWith: "4.5.6",
+		Since:       version,
+		Labels:      map[string]interface{}{"app": "php-apache-app"},
+	}}
 
-	if err := tp.Print(results); err != nil {
+	if err := tp.Print(results, true); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	fi, _ := tmpFile.Stat()
+	if fi.Size() == 0 {
+		t.Fatalf("expected non-zero size output file: %v", err)
+	}
+}
+
+func TestCSVPrinterPrintNoLabels(t *testing.T) {
+	tmpFile, err := ioutil.TempFile(os.TempDir(), tempFilePrefix)
+	if err != nil {
+		t.Fatalf(tempFileCreateFailureMessage, err)
+	}
+	defer os.Remove(tmpFile.Name())
+
+	tp := &csvPrinter{
+		commonPrinter: &commonPrinter{tmpFile},
+	}
+
+	version, _ := judge.NewVersion("1.2.3")
+	results := []judge.Result{{
+		Name:        "Name",
+		Namespace:   "Namespace",
+		Kind:        "Kind",
+		ApiVersion:  "1.2.3",
+		RuleSet:     "Test",
+		ReplaceWith: "4.5.6",
+		Since:       version,
+		Labels:      map[string]interface{}{},
+	}}
+
+	if err := tp.Print(results, false); err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
 

pkg/printer/json.go

@@ -29,7 +29,7 @@ func (c *jsonPrinter) Close() error {
 }
 
 // Print will print results in text format
-func (c *jsonPrinter) Print(results []judge.Result) error {
+func (c *jsonPrinter) Print(results []judge.Result, labels bool) error {
 	writer := bufio.NewWriter(c.commonPrinter.outputFile)
 	defer writer.Flush()
 

pkg/printer/json_test.go

@@ -53,9 +53,60 @@ func Test_jsonPrinter_Print(t *testing.T) {
 	}
 
 	version, _ := judge.NewVersion("1.2.3")
-	results := []judge.Result{{"Name", "Namespace", "Kind", "1.2.3", "Test", "4.5.6", version}}
+	results := []judge.Result{{
+		Name:        "Name",
+		Namespace:   "Namespace",
+		Kind:        "Kind",
+		ApiVersion:  "1.2.3",
+		RuleSet:     "Test",
+		ReplaceWith: "4.5.6",
+		Since:       version,
+		Labels:      map[string]interface{}{"label1": "value1", "label2": "value2"},
+	}}
 
-	if err := c.Print(results); err != nil {
+	if err := c.Print(results, true); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	tmpFile.Seek(0, 0)
+
+	var readResults []judge.Result
+	readBytes, err := ioutil.ReadAll(tmpFile)
+	if err != nil {
+		t.Fatalf("unexpected error reading back the file: %v", err)
+	}
+	if err := json.Unmarshal(readBytes, &readResults); err != nil {
+		t.Fatalf("unexpected error unmarshalling the previously written file: %v", err)
+	}
+	if !reflect.DeepEqual(readResults, results) {
+		t.Fatalf("written and read result do not seem to be equal")
+	}
+}
+
+func Test_jsonPrinter_PrintNoLabel(t *testing.T) {
+	tmpFile, err := ioutil.TempFile(os.TempDir(), tempFilePrefix)
+	if err != nil {
+		t.Fatalf(tempFileCreateFailureMessage, err)
+	}
+	defer os.Remove(tmpFile.Name())
+
+	c := &jsonPrinter{
+		commonPrinter: &commonPrinter{tmpFile},
+	}
+
+	version, _ := judge.NewVersion("1.2.3")
+	results := []judge.Result{{
+		Name:        "Name",
+		Namespace:   "Namespace",
+		Kind:        "Kind",
+		ApiVersion:  "1.2.3",
+		RuleSet:     "Test",
+		ReplaceWith: "4.5.6",
+		Since:       version,
+		Labels:      map[string]interface{}{},
+	}}
+
+	if err := c.Print(results, false); err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
 

pkg/printer/printer.go

@@ -14,7 +14,7 @@ var printers = map[string]func(string) (Printer, error){
 }
 
 type Printer interface {
-	Print([]judge.Result) error
+	Print([]judge.Result, bool) error
 	Close() error
 }
 

pkg/printer/printer_helper.go

@@ -0,0 +1,17 @@
+package printer
+
+import (
+	"fmt"
+	"strings"
+)
+
+func mapToCommaSeparatedString(m map[string]interface{}) string {
+	var sb strings.Builder
+	for k, v := range m {
+		if sb.Len() > 0 {
+			sb.WriteString(", ")
+		}
+		sb.WriteString(fmt.Sprintf("%s:%v", k, v))
+	}
+	return sb.String()
+}

pkg/printer/printer_helper_test.go

@@ -0,0 +1,36 @@
+package printer
+
+import (
+	"testing"
+)
+
+func TestMapToCommaSeparatedString(t *testing.T) {
+	tests := []struct {
+		input    map[string]interface{}
+		expected string
+	}{
+		{
+			input:    map[string]interface{}{},
+			expected: "",
+		},
+		{
+			input:    map[string]interface{}{"key1": "value1"},
+			expected: "key1:value1",
+		},
+		{
+			input:    map[string]interface{}{"key1": "value1", "key2": "value2"},
+			expected: "key1:value1, key2:value2",
+		},
+		{
+			input:    map[string]interface{}{"key1": 123, "key2": true, "key3": 45.67},
+			expected: "key1:123, key2:true, key3:45.67",
+		},
+	}
+
+	for _, test := range tests {
+		result := mapToCommaSeparatedString(test.input)
+		if result != test.expected {
+			t.Errorf("For input %v, expected %s but got %s", test.input, test.expected, result)
+		}
+	}
+}