fix: add invalid files to yaml/json output

bl/evaluation/evaluator.go

@@ -50,7 +50,7 @@ func (e *Evaluator) CreateEvaluation(cliId string, cliVersion string, k8sVersion
 	return createEvaluationResponse, err
 }
 
-func (e *Evaluator) UpdateFailedYamlValidation(invalidFiles []*validation.InvalidFile, evaluationId int, stopEvaluation bool) error {
+func (e *Evaluator) UpdateFailedYamlValidation(invalidFiles []*validation.InvalidYamlFile, evaluationId int, stopEvaluation bool) error {
 	invalidFilesPaths := []*string{}
 	for _, file := range invalidFiles {
 		invalidFilesPaths = append(invalidFilesPaths, &file.Path)
@@ -63,7 +63,7 @@ func (e *Evaluator) UpdateFailedYamlValidation(invalidFiles []*validation.Invali
 	return err
 }
 
-func (e *Evaluator) UpdateFailedK8sValidation(invalidFiles []*validation.InvalidFile, evaluationId int, stopEvaluation bool) error {
+func (e *Evaluator) UpdateFailedK8sValidation(invalidFiles []*validation.InvalidK8sFile, evaluationId int, stopEvaluation bool) error {
 	invalidFilesPaths := []*string{}
 	for _, file := range invalidFiles {
 		invalidFilesPaths = append(invalidFilesPaths, &file.Path)

bl/evaluation/printer.go

@@ -13,24 +13,26 @@ import (
 )
 
 type Printer interface {
-	PrintWarnings(warnings []printer.Warning)
+	PrintWarnings(invalidYamlWarnings []printer.Warning, invalidK8sWarnings []printer.Warning, failedEvaluationWarnings []printer.Warning)
 	PrintSummaryTable(summary printer.Summary)
 	PrintEvaluationSummary(summary printer.EvaluationSummary, k8sVersion string)
 }
 
 type FormattedOutput struct {
-	Results           *EvaluationResults
+	Evaluationresults *EvaluationResults
 	EvaluationSummary printer.EvaluationSummary
+	InvalidYamlFiles  []*validation.InvalidYamlFile
+	InvalidK8sFiles   []*validation.InvalidK8sFile
 }
 
-func PrintResults(results *EvaluationResults, invalidFiles []*validation.InvalidFile, evaluationSummary printer.EvaluationSummary, loginURL string, outputFormat string, printer Printer, k8sVersion string) error {
+func PrintResults(results *EvaluationResults, invalidYamlFiles []*validation.InvalidYamlFile, invalidK8sFiles []*validation.InvalidK8sFile, evaluationSummary printer.EvaluationSummary, loginURL string, outputFormat string, printer Printer, k8sVersion string) error {
 	switch {
 	case outputFormat == "json":
-		return jsonOutput(&FormattedOutput{Results: results, EvaluationSummary: evaluationSummary})
+		return jsonOutput(&FormattedOutput{Evaluationresults: results, EvaluationSummary: evaluationSummary, InvalidYamlFiles: invalidYamlFiles, InvalidK8sFiles: invalidK8sFiles})
 	case outputFormat == "yaml":
-		return yamlOutput(&FormattedOutput{Results: results, EvaluationSummary: evaluationSummary})
+		return yamlOutput(&FormattedOutput{Evaluationresults: results, EvaluationSummary: evaluationSummary, InvalidYamlFiles: invalidYamlFiles, InvalidK8sFiles: invalidK8sFiles})
 	default:
-		return textOutput(results, invalidFiles, evaluationSummary, loginURL, printer, k8sVersion)
+		return textOutput(results, invalidYamlFiles, invalidK8sFiles, evaluationSummary, loginURL, printer, k8sVersion)
 	}
 }
 
@@ -56,19 +58,19 @@ func yamlOutput(formattedOutput *FormattedOutput) error {
 	return nil
 }
 
-func textOutput(results *EvaluationResults, invalidFiles []*validation.InvalidFile, evaluationSummary printer.EvaluationSummary, url string, printer Printer, k8sVersion string) error {
+func textOutput(results *EvaluationResults, invalidYamlFiles []*validation.InvalidYamlFile, invalidK8sFiles []*validation.InvalidK8sFile, evaluationSummary printer.EvaluationSummary, url string, printer Printer, k8sVersion string) error {
 	pwd, err := os.Getwd()
 	if err != nil {
 		return err
 	}
 
-	warnings, err := parseToPrinterWarnings(results, invalidFiles, pwd, k8sVersion)
+	invalidYamlWarnings, invalidK8sWarnings, failedEvaluationWarnings, err := parseToPrinterWarnings(results, invalidYamlFiles, invalidK8sFiles, pwd, k8sVersion)
 	if err != nil {
 		fmt.Println(err)
 		return err
 	}
 
-	printer.PrintWarnings(warnings)
+	printer.PrintWarnings(invalidYamlWarnings, invalidK8sWarnings, failedEvaluationWarnings)
 
 	summary := parseEvaluationResultsToSummary(results, evaluationSummary, url)
 
@@ -79,16 +81,29 @@ func textOutput(results *EvaluationResults, invalidFiles []*validation.InvalidFi
 	return nil
 }
 
-func parseToPrinterWarnings(results *EvaluationResults, invalidFiles []*validation.InvalidFile, pwd string, k8sVersion string) ([]printer.Warning, error) {
-	var warnings = []printer.Warning{}
+func parseToPrinterWarnings(results *EvaluationResults, invalidYamlFiles []*validation.InvalidYamlFile, invalidK8sFiles []*validation.InvalidK8sFile, pwd string, k8sVersion string) ([]printer.Warning, []printer.Warning, []printer.Warning, error) {
+	var invalidYamlWarnings = []printer.Warning{}
+	var invalidK8sWarnings = []printer.Warning{}
+	var failedEvaluationWarnings = []printer.Warning{}
 
-	for _, invalidFile := range invalidFiles {
-		warnings = append(warnings, printer.Warning{
+	for _, invalidFile := range invalidYamlFiles {
+		invalidYamlWarnings = append(invalidYamlWarnings, printer.Warning{
+			Title:   fmt.Sprintf(">>  File: %s\n", invalidFile.Path),
+			Details: []printer.WarningInfo{},
+			ValidationInfo: printer.ValidationInfo{
+				IsValid:          false,
+				ValidationErrors: invalidFile.ValidationErrors,
+				K8sVersion:       k8sVersion,
+			},
+		})
+	}
+
+	for _, invalidFile := range invalidK8sFiles {
+		invalidK8sWarnings = append(invalidK8sWarnings, printer.Warning{
 			Title:   fmt.Sprintf(">>  File: %s\n", invalidFile.Path),
 			Details: []printer.WarningInfo{},
 			ValidationInfo: printer.ValidationInfo{
 				IsValid:          false,
-				ValidationStatus: invalidFile.ValidationStatus,
 				ValidationErrors: invalidFile.ValidationErrors,
 				K8sVersion:       k8sVersion,
 			},
@@ -110,7 +125,7 @@ func parseToPrinterWarnings(results *EvaluationResults, invalidFiles []*validati
 
 			relativePath, _ := filepath.Rel(pwd, fileName)
 
-			warnings = append(warnings, printer.Warning{
+			failedEvaluationWarnings = append(failedEvaluationWarnings, printer.Warning{
 				Title:   fmt.Sprintf(">>  File: %s\n", relativePath),
 				Details: warningDetails,
 				ValidationInfo: printer.ValidationInfo{
@@ -122,7 +137,7 @@ func parseToPrinterWarnings(results *EvaluationResults, invalidFiles []*validati
 		}
 	}
 
-	return warnings, nil
+	return invalidYamlWarnings, invalidK8sWarnings, failedEvaluationWarnings, nil
 }
 
 type OutputTitle int

bl/evaluation/printer_test.go

@@ -14,8 +14,8 @@ type mockPrinter struct {
 	mock.Mock
 }
 
-func (m *mockPrinter) PrintWarnings(warnings []printer.Warning) {
-	m.Called(warnings)
+func (m *mockPrinter) PrintWarnings(invalidYamlWarnings []printer.Warning, invalidK8sWarnings []printer.Warning, failedEvaluationWarnings []printer.Warning) {
+	m.Called(invalidYamlWarnings, invalidK8sWarnings, failedEvaluationWarnings)
 }
 
 func (c *mockPrinter) PrintSummaryTable(summary printer.Summary) {
@@ -28,7 +28,8 @@ func (c *mockPrinter) PrintEvaluationSummary(summary printer.EvaluationSummary,
 
 type printResultsTestCaseArgs struct {
 	results           *EvaluationResults
-	invalidFiles      []*validation.InvalidFile
+	invalidYamlFiles  []*validation.InvalidYamlFile
+	invalidK8sFiles   []*validation.InvalidK8sFile
 	evaluationSummary printer.EvaluationSummary
 	loginURL          string
 	outputFormat      string
@@ -49,12 +50,12 @@ func TestPrintResults(t *testing.T) {
 	}
 	for _, tt := range tests {
 		mockedPrinter := &mockPrinter{}
-		mockedPrinter.On("PrintWarnings", mock.Anything)
+		mockedPrinter.On("PrintWarnings", mock.Anything, mock.Anything, mock.Anything)
 		mockedPrinter.On("PrintSummaryTable", mock.Anything)
 		mockedPrinter.On("PrintEvaluationSummary", mock.Anything, mock.Anything)
 
 		t.Run(tt.name, func(t *testing.T) {
-			_ = PrintResults(tt.args.results, tt.args.invalidFiles, tt.args.evaluationSummary, tt.args.loginURL, tt.args.outputFormat, mockedPrinter, "1.18.0")
+			_ = PrintResults(tt.args.results, tt.args.invalidYamlFiles, tt.args.invalidK8sFiles, tt.args.evaluationSummary, tt.args.loginURL, tt.args.outputFormat, mockedPrinter, "1.18.0")
 
 			if tt.args.outputFormat == "json" {
 				mockedPrinter.AssertNotCalled(t, "PrintWarnings")
@@ -63,8 +64,8 @@ func TestPrintResults(t *testing.T) {
 
 			} else {
 				pwd, _ := os.Getwd()
-				warnings, _ := parseToPrinterWarnings(tt.args.results, tt.args.invalidFiles, pwd, "1.18.0")
-				mockedPrinter.AssertCalled(t, "PrintWarnings", warnings)
+				invalidYamlWarnings, invalidK8sWarnings, failedEvaluationWarnings, _ := parseToPrinterWarnings(tt.args.results, tt.args.invalidYamlFiles, tt.args.invalidK8sFiles, pwd, "1.18.0")
+				mockedPrinter.AssertCalled(t, "PrintWarnings", invalidYamlWarnings, invalidK8sWarnings, failedEvaluationWarnings)
 			}
 		})
 	}
@@ -88,11 +89,12 @@ func print_resultst(outputFormat string) *printResultsTestCase {
 					TotalPassedCount: 0,
 				},
 			},
-			invalidFiles:      []*validation.InvalidFile{},
+			invalidYamlFiles:  []*validation.InvalidYamlFile{},
+			invalidK8sFiles:   []*validation.InvalidK8sFile{},
 			evaluationSummary: printer.EvaluationSummary{},
 			loginURL:          "login/url",
-			outputFormat: outputFormat,
+			outputFormat:      outputFormat,
 		},
 		expected: nil,
 	}
-}
\ No newline at end of file
+}

bl/files/files.go

@@ -23,9 +23,9 @@ func ToAbsolutePath(path string) (string, error) {
 	return "", fmt.Errorf("failed parsing absolute path %s", path)
 }
 
-func ExtractFilesConfigurations(paths []string, concurrency int) (chan *extractor.FileConfigurations, chan *validation.InvalidFile) {
+func ExtractFilesConfigurations(paths []string, concurrency int) (chan *extractor.FileConfigurations, chan *validation.InvalidYamlFile) {
 	filesConfigurationsChan := make(chan *extractor.FileConfigurations, concurrency)
-	invalidFilesChan := make(chan *validation.InvalidFile, concurrency)
+	invalidFilesChan := make(chan *validation.InvalidYamlFile, concurrency)
 
 	go func() {
 		defer func() {
@@ -37,19 +37,19 @@ func ExtractFilesConfigurations(paths []string, concurrency int) (chan *extracto
 
 			absolutePath, err := ToAbsolutePath(path)
 			if err != nil {
-				invalidFilesChan <- &validation.InvalidFile{Path: path, ValidationStatus: validation.InvalidYamlFile, ValidationErrors: []error{err}}
+				invalidFilesChan <- &validation.InvalidYamlFile{Path: path, ValidationErrors: []error{err}}
 				continue
 			}
 
 			content, err := extractor.ReadFileContent(absolutePath)
 			if err != nil {
-				invalidFilesChan <- &validation.InvalidFile{Path: absolutePath, ValidationStatus: validation.InvalidYamlFile, ValidationErrors: []error{err}}
+				invalidFilesChan <- &validation.InvalidYamlFile{Path: absolutePath, ValidationErrors: []error{err}}
 				continue
 			}
 
 			configurations, err := extractor.ParseYaml(content)
 			if err != nil {
-				invalidFilesChan <- &validation.InvalidFile{Path: absolutePath, ValidationStatus: validation.InvalidYamlFile, ValidationErrors: []error{err}}
+				invalidFilesChan <- &validation.InvalidYamlFile{Path: absolutePath, ValidationErrors: []error{err}}
 				continue
 			}
 

bl/validation/k8sValidator.go

@@ -21,30 +21,21 @@ func New() *K8sValidator {
 	return &K8sValidator{}
 }
 
-type ValidationStatus int
-
-const (
-	InvalidYamlFile ValidationStatus = iota + 1
-	InvalidK8sFile
-)
-
-func (validationStatus ValidationStatus) String() string {
-	return [...]string{"InvalidYamlFile", "InvalidK8sFile"}[validationStatus]
-}
-
 type InvalidFile struct {
 	Path             string
-	ValidationStatus ValidationStatus
 	ValidationErrors []error
 }
+type InvalidYamlFile InvalidFile
+
+type InvalidK8sFile InvalidFile
 
 func (val *K8sValidator) InitClient(k8sVersion string) {
 	val.validationClient = newKubconformValidator(k8sVersion)
 }
 
-func (val *K8sValidator) ValidateResources(filesConfigurationsChan chan *extractor.FileConfigurations, concurrency int) (chan *extractor.FileConfigurations, chan *InvalidFile) {
+func (val *K8sValidator) ValidateResources(filesConfigurationsChan chan *extractor.FileConfigurations, concurrency int) (chan *extractor.FileConfigurations, chan *InvalidK8sFile) {
 	validK8sFilesConfigurationsChan := make(chan *extractor.FileConfigurations, concurrency)
-	invalidK8sFilesChan := make(chan *InvalidFile, concurrency)
+	invalidK8sFilesChan := make(chan *InvalidK8sFile, concurrency)
 
 	go func() {
 		defer func() {
@@ -56,9 +47,8 @@ func (val *K8sValidator) ValidateResources(filesConfigurationsChan chan *extract
 
 			isValid, validationErrors, err := val.validateResource(fileConfigurations.FileName)
 			if err != nil {
-				invalidK8sFilesChan <- &InvalidFile{
+				invalidK8sFilesChan <- &InvalidK8sFile{
 					Path:             fileConfigurations.FileName,
-					ValidationStatus: InvalidK8sFile,
 					ValidationErrors: []error{err},
 				}
 				continue
@@ -66,9 +56,8 @@ func (val *K8sValidator) ValidateResources(filesConfigurationsChan chan *extract
 			if isValid {
 				validK8sFilesConfigurationsChan <- fileConfigurations
 			} else {
-				invalidK8sFilesChan <- &InvalidFile{
+				invalidK8sFilesChan <- &InvalidK8sFile{
 					Path:             fileConfigurations.FileName,
-					ValidationStatus: InvalidK8sFile,
 					ValidationErrors: validationErrors,
 				}
 			}

cmd/test/main.go

@@ -19,8 +19,8 @@ import (
 type Evaluator interface {
 	Evaluate(filesConfigurationsChan []*extractor.FileConfigurations, evaluationId int) (*evaluation.EvaluationResults, error)
 	CreateEvaluation(cliId string, cliVersion string, k8sVersion string) (*cliClient.CreateEvaluationResponse, error)
-	UpdateFailedYamlValidation(invalidFiles []*validation.InvalidFile, evaluationId int, stopEvaluation bool) error
-	UpdateFailedK8sValidation(invalidFiles []*validation.InvalidFile, evaluationId int, stopEvaluation bool) error
+	UpdateFailedYamlValidation(invalidFiles []*validation.InvalidYamlFile, evaluationId int, stopEvaluation bool) error
+	UpdateFailedK8sValidation(invalidFiles []*validation.InvalidK8sFile, evaluationId int, stopEvaluation bool) error
 }
 
 type Messager interface {
@@ -28,7 +28,7 @@ type Messager interface {
 }
 
 type K8sValidator interface {
-	ValidateResources(filesConfigurations chan *extractor.FileConfigurations, concurrency int) (chan *extractor.FileConfigurations, chan *validation.InvalidFile)
+	ValidateResources(filesConfigurations chan *extractor.FileConfigurations, concurrency int) (chan *extractor.FileConfigurations, chan *validation.InvalidK8sFile)
 	InitClient(k8sVersion string)
 }
 
@@ -38,7 +38,7 @@ type TestCommandFlags struct {
 }
 
 type EvaluationPrinter interface {
-	PrintWarnings(warnings []printer.Warning)
+	PrintWarnings(invalidYamlWarnings []printer.Warning, invalidK8sWarnings []printer.Warning, failedEvaluationWarnings []printer.Warning)
 	PrintSummaryTable(summary printer.Summary)
 	PrintMessage(messageText string, messageColor string)
 	PrintEvaluationSummary(evaluationSummary printer.EvaluationSummary, k8sVersion string)
@@ -133,7 +133,7 @@ func test(ctx *TestCommandContext, paths []string, flags TestCommandFlags) error
 	ctx.K8sValidator.InitClient(createEvaluationResponse.K8sVersion)
 	validK8sFilesConfigurationsChan, invalidK8sFilesChan := ctx.K8sValidator.ValidateResources(validYamlFilesConfigurationsChan, concurrency)
 
-	invalidYamlFiles := aggregateInvalidFiles(invalidYamlFilesChan)
+	invalidYamlFiles := aggregateInvalidYamlFiles(invalidYamlFilesChan)
 
 	invalidYamlFilesLen := len(invalidYamlFiles)
 
@@ -144,7 +144,7 @@ func test(ctx *TestCommandContext, paths []string, flags TestCommandFlags) error
 		return err
 	}
 
-	invalidK8sFiles := aggregateInvalidFiles(invalidK8sFilesChan)
+	invalidK8sFiles := aggregateInvalidK8sFiles(invalidK8sFilesChan)
 
 	invalidK8sFilesLen := len(invalidK8sFiles)
 	stopEvaluation = invalidYamlFilesLen+invalidK8sFilesLen == filesPathsLen
@@ -186,16 +186,14 @@ func test(ctx *TestCommandContext, paths []string, flags TestCommandFlags) error
 		PassedPolicyCheckCount:    passedPolicyCheckCount,
 	}
 
-	invalidFiles := append(invalidYamlFiles, invalidK8sFiles...)
-
-	err = evaluation.PrintResults(results, invalidFiles, evaluationSummary, fmt.Sprintf("https://app.datree.io/login?cliId=%s", ctx.LocalConfig.CliId), flags.Output, ctx.Printer, createEvaluationResponse.K8sVersion)
+	err = evaluation.PrintResults(results, invalidYamlFiles, invalidK8sFiles, evaluationSummary, fmt.Sprintf("https://app.datree.io/login?cliId=%s", ctx.LocalConfig.CliId), flags.Output, ctx.Printer, createEvaluationResponse.K8sVersion)
 
 	var invocationFailedErr error = nil
 
 	if err != nil {
 		fmt.Println(err.Error())
 		invocationFailedErr = err
-	} else if len(invalidFiles) > 0 || results.Summary.TotalFailedRules > 0 {
+	} else if len(invalidYamlFiles) > 0 || len(invalidK8sFiles) > 0 || results.Summary.TotalFailedRules > 0 {
 		invocationFailedErr = fmt.Errorf("Evaluation failed")
 	}
 

cmd/test/main_test.go

@@ -28,13 +28,13 @@ func (m *mockEvaluator) CreateEvaluation(cliId string, cliVersion string, k8sVer
 	return args.Get(0).(*cliClient.CreateEvaluationResponse), args.Error(1)
 }
 
-func (m *mockEvaluator) UpdateFailedYamlValidation(invalidFiles []*validation.InvalidFile, evaluationId int, stopEvaluation bool) error {
-	args := m.Called(invalidFiles, evaluationId, stopEvaluation)
+func (m *mockEvaluator) UpdateFailedYamlValidation(invalidYamlFiles []*validation.InvalidYamlFile, evaluationId int, stopEvaluation bool) error {
+	args := m.Called(invalidYamlFiles, evaluationId, stopEvaluation)
 	return args.Error(0)
 }
 
-func (m *mockEvaluator) UpdateFailedK8sValidation(invalidFiles []*validation.InvalidFile, evaluationId int, stopEvaluation bool) error {
-	args := m.Called(invalidFiles, evaluationId, stopEvaluation)
+func (m *mockEvaluator) UpdateFailedK8sValidation(invalidK8sFiles []*validation.InvalidK8sFile, evaluationId int, stopEvaluation bool) error {
+	args := m.Called(invalidK8sFiles, evaluationId, stopEvaluation)
 	return args.Error(0)
 }
 
@@ -62,9 +62,9 @@ type K8sValidatorMock struct {
 	mock.Mock
 }
 
-func (kv *K8sValidatorMock) ValidateResources(filesConfigurationsChan chan *extractor.FileConfigurations, concurrency int) (chan *extractor.FileConfigurations, chan *validation.InvalidFile) {
+func (kv *K8sValidatorMock) ValidateResources(filesConfigurationsChan chan *extractor.FileConfigurations, concurrency int) (chan *extractor.FileConfigurations, chan *validation.InvalidK8sFile) {
 	args := kv.Called(filesConfigurationsChan, concurrency)
-	return args.Get(0).(chan *extractor.FileConfigurations), args.Get(1).(chan *validation.InvalidFile)
+	return args.Get(0).(chan *extractor.FileConfigurations), args.Get(1).(chan *validation.InvalidK8sFile)
 }
 
 func (kv *K8sValidatorMock) InitClient(k8sVersion string) {
@@ -74,8 +74,8 @@ type PrinterMock struct {
 	mock.Mock
 }
 
-func (p *PrinterMock) PrintWarnings(warnings []printer.Warning) {
-	p.Called(warnings)
+func (p *PrinterMock) PrintWarnings(invalidYamlWarnings []printer.Warning, invalidK8sWarnings []printer.Warning, failedEvaluationWarnings []printer.Warning) {
+	p.Called(invalidYamlWarnings, invalidK8sWarnings, failedEvaluationWarnings)
 }
 
 func (p *PrinterMock) PrintSummaryTable(summary printer.Summary) {
@@ -125,13 +125,13 @@ func TestTestCommand(t *testing.T) {
 	filesConfigurationsChan := newFilesConfigurationsChan(path)
 	filesConfigurations := newFilesConfigurations(path)
 
-	invalidFilesChan := newInvalidFilesChan()
+	invelidK8sFilesChan := newInvalidK8sFilesChan()
 
-	k8sValidatorMock.On("ValidateResources", mock.Anything, mock.Anything).Return(filesConfigurationsChan, invalidFilesChan, newErrorsChan())
+	k8sValidatorMock.On("ValidateResources", mock.Anything, mock.Anything).Return(filesConfigurationsChan, invelidK8sFilesChan, newErrorsChan())
 	k8sValidatorMock.On("InitClient", mock.Anything).Return()
 
 	printerMock := &PrinterMock{}
-	printerMock.On("PrintWarnings", mock.Anything)
+	printerMock.On("PrintWarnings", mock.Anything, mock.Anything, mock.Anything)
 	printerMock.On("PrintSummaryTable", mock.Anything)
 	printerMock.On("PrintMessage", mock.Anything, mock.Anything)
 	printerMock.On("PrintEvaluationSummary", mock.Anything, mock.Anything)
@@ -193,10 +193,10 @@ func newFilesConfigurations(path string) []*extractor.FileConfigurations {
 	return filesConfigurations
 }
 
-func newInvalidFilesChan() chan *validation.InvalidFile {
-	invalidFilesChan := make(chan *validation.InvalidFile, 1)
+func newInvalidK8sFilesChan() chan *validation.InvalidK8sFile {
+	invalidFilesChan := make(chan *validation.InvalidK8sFile, 1)
 
-	invalidFile := &validation.InvalidFile{
+	invalidFile := &validation.InvalidK8sFile{
 		Path:             "invalid/path",
 		ValidationErrors: []error{},
 	}

cmd/test/testCommandHelper.go

@@ -15,8 +15,15 @@ func createSpinner(text string, color string) *spinner.Spinner {
 	return s
 }
 
-func aggregateInvalidFiles(invalidFilesChan chan *validation.InvalidFile) []*validation.InvalidFile {
-	var invalidFiles []*validation.InvalidFile
+func aggregateInvalidK8sFiles(invalidFilesChan chan *validation.InvalidK8sFile) []*validation.InvalidK8sFile {
+	var invalidFiles []*validation.InvalidK8sFile
+	for invalidFile := range invalidFilesChan {
+		invalidFiles = append(invalidFiles, invalidFile)
+	}
+	return invalidFiles
+}
+func aggregateInvalidYamlFiles(invalidFilesChan chan *validation.InvalidYamlFile) []*validation.InvalidYamlFile {
+	var invalidFiles []*validation.InvalidYamlFile
 	for invalidFile := range invalidFilesChan {
 		invalidFiles = append(invalidFiles, invalidFile)
 	}

pkg/printer/printer.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/datreeio/datree/bl/validation"
 	"github.com/fatih/color"
 	"github.com/olekukonko/tablewriter"
 )
@@ -28,7 +27,6 @@ type WarningInfo struct {
 
 type ValidationInfo struct {
 	IsValid          bool
-	ValidationStatus validation.ValidationStatus
 	ValidationErrors []error
 	K8sVersion       string
 }
@@ -38,40 +36,47 @@ type Warning struct {
 	ValidationInfo ValidationInfo
 }
 
-func (p *Printer) PrintWarnings(warnings []Warning) {
-	for _, warning := range warnings {
+func (p *Printer) PrintWarnings(invalidYamlWarnings []Warning, invalidK8sWarnings []Warning, failedEvaluationWarnings []Warning) {
+	for _, warning := range invalidYamlWarnings {
 		p.printInColor(warning.Title, p.theme.Colors.Yellow)
 		fmt.Println()
 
-		if !warning.ValidationInfo.IsValid {
-			if warning.ValidationInfo.ValidationStatus == validation.InvalidYamlFile {
-				p.printInColor("[X] YAML validation\n", p.theme.Colors.White)
-				fmt.Println()
-				for _, validationError := range warning.ValidationInfo.ValidationErrors {
-					validationError := p.theme.Colors.Red.Sprint(validationError.Error())
-					fmt.Printf("%v %v\n", p.theme.Emoji.Error, validationError)
-				}
-				fmt.Println()
+		p.printInColor("[X] YAML validation\n", p.theme.Colors.White)
+		fmt.Println()
+		for _, validationError := range warning.ValidationInfo.ValidationErrors {
+			validationError := p.theme.Colors.Red.Sprint(validationError.Error())
+			fmt.Printf("%v %v\n", p.theme.Emoji.Error, validationError)
+		}
+		fmt.Println()
 
-				p.printInColor("[?] Kubernetes schema validation\n", p.theme.Colors.White)
-				p.printInColor("[?] Policy check didn’t run for this file\n", p.theme.Colors.White)
+		p.printInColor("[?] Kubernetes schema validation\n", p.theme.Colors.White)
+		p.printInColor("[?] Policy check didn’t run for this file\n", p.theme.Colors.White)
 
-				fmt.Println()
+		fmt.Println()
+	}
 
-			} else if warning.ValidationInfo.ValidationStatus == validation.InvalidK8sFile {
-				p.printInColor("[V] YAML validation\n", p.theme.Colors.Green)
-				p.printInColor("[X] Kubernetes schema validation\n", p.theme.Colors.White)
-				fmt.Println()
+	for _, warning := range invalidK8sWarnings {
+		p.printInColor(warning.Title, p.theme.Colors.Yellow)
+		fmt.Println()
 
-				for _, validationError := range warning.ValidationInfo.ValidationErrors {
-					validationError := p.theme.Colors.Red.Sprint(validationError.Error())
-					fmt.Printf("%v %v\n", p.theme.Emoji.Error, validationError)
-				}
-				fmt.Println()
-				p.printInColor("[?] Policy check didn’t run for this file\n", p.theme.Colors.White)
-				fmt.Println()
-			}
-		} else {
+		p.printInColor("[V] YAML validation\n", p.theme.Colors.Green)
+		p.printInColor("[X] Kubernetes schema validation\n", p.theme.Colors.White)
+		fmt.Println()
+
+		for _, validationError := range warning.ValidationInfo.ValidationErrors {
+			validationError := p.theme.Colors.Red.Sprint(validationError.Error())
+			fmt.Printf("%v %v\n", p.theme.Emoji.Error, validationError)
+		}
+		fmt.Println()
+		p.printInColor("[?] Policy check didn’t run for this file\n", p.theme.Colors.White)
+
+		fmt.Println()
+	}
+	for _, warning := range failedEvaluationWarnings {
+		p.printInColor(warning.Title, p.theme.Colors.Yellow)
+		fmt.Println()
+
+		if warning.ValidationInfo.IsValid {
 			p.printInColor("[V] YAML validation\n", p.theme.Colors.Green)
 			p.printInColor("[V] Kubernetes schema validation\n", p.theme.Colors.Green)