feat: output report to file

Author: xBlaz3kx

cmd/validate.go

@@ -38,6 +38,9 @@ var ocpp21Schemas embed.FS
 
 var additionalOcppSchemasFolder = ""
 
+// supportedOutputFormats lists allowed output file formats for the CLI report writer.
+var supportedOutputFormats = map[string]bool{".json": true, ".csv": true, ".txt": true}
+
 // registerSchemas registers all schemas from the embedded filesystem for a specific OCPP version.
 func registerSchemas(logger *zap.Logger, embeddedDir embed.FS, version ocpp.Version, registry schema_registry.SchemaRegistry) error {
 	logger.Debug("Registering OCPP schemas", zap.String("version", version.String()))
@@ -175,16 +178,43 @@ var validate = &cobra.Command{
 			message = args[0]
 		}
 
+		output := viper.GetString("output")
+
+		// Validate provided output extension if present
+		if output != "" {
+			ext := strings.ToLower(filepath.Ext(output))
+			if !supportedOutputFormats[ext] {
+				return errors.Errorf("unsupported output format '%s', supported: .json, .csv, .txt", ext)
+			}
+		}
+
+		validationOpts := []validation.Option{}
+		if output != "" {
+			validationOpts = append(validationOpts, validation.WithOutput(output))
+		}
+
 		switch {
 		case file == "" && message == "":
 			return errors.New("no message provided to validate, please provide a message as a command line argument or use the --file flag to read from a file")
 		case message != "":
 			// The message is expected to be a JSON string in the format:
 			// '[2, "uniqueId", "BootNotification", {"chargePointVendor": "TestVendor", "chargePointModel": "TestModel"}]'
-			return service.ValidateMessage(message, version)
+			if output == "" {
+				return service.ValidateMessage(message, version)
+			}
+
+			// Validate and write report
+			r, err := service.ValidateMessageWithReport(message, version)
+			if err != nil {
+				return err
+			}
+
+			return validation.WriteReport(output, r)
+
 		case file != "":
+			// Use the options pattern to write output using registered strategies
 			// Read the messages from the file
-			return service.ValidateFile(file, version)
+			return service.ValidateFile(file, version, validationOpts...)
 		}
 
 		return nil
@@ -196,7 +226,9 @@ func init() {
 	validate.Flags().StringVarP(&additionalOcppSchemasFolder, "schemas", "a", "", "Path to additional OCPP schemas folder")
 	validate.Flags().StringP("response-type", "r", "", "Response type to validate against (e.g. 'BootNotificationResponse'). Currently needed if you want to validate a single response message. ")
 	validate.Flags().StringP("file", "f", "", "Path to a file containing the OCPP message to validate. If this flag is set, the message will be read from the file instead of the command line argument.")
+	validate.Flags().StringP("output", "o", "", "Path to write validation report. Supports .json, .csv and .txt extensions.")
 
 	_ = viper.BindPFlag("response-type", validate.Flags().Lookup("response-type"))
 	_ = viper.BindPFlag("file", validate.Flags().Lookup("file"))
+	_ = viper.BindPFlag("output", validate.Flags().Lookup("output"))
 }

internal/validation/csv_strategy.go

@@ -0,0 +1,46 @@
+package validation
+
+import (
+	"encoding/csv"
+	"os"
+	"strings"
+
+	"github.com/ChargePi/chargeflow/pkg/report"
+)
+
+// csvStrategy implements OutputStrategy for CSV output.
+type csvStrategy struct{}
+
+func (csvStrategy) Write(path string, r *report.Report) error {
+	f, err := os.Create(path)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	w := csv.NewWriter(f)
+	defer w.Flush()
+
+	// Header
+	if err = w.Write([]string{"message_id", "type", "errors"}); err != nil {
+		return err
+	}
+
+	// Invalid messages
+	for msgID, rr := range r.InvalidMessages {
+		for typ, errs := range rr {
+			if err = w.Write([]string{msgID, typ, strings.Join(errs, " | ")}); err != nil {
+				return err
+			}
+		}
+	}
+
+	// Non parsable messages
+	for msgID, errs := range r.NonParsableMessages {
+		if err = w.Write([]string{msgID, "non_parsable", strings.Join(errs, " | ")}); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

internal/validation/csv_strategy_test.go

@@ -0,0 +1,41 @@
+package validation
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/ChargePi/chargeflow/pkg/report"
+)
+
+func TestCSVStrategy_Write(t *testing.T) {
+	dir, err := os.MkdirTemp("", "csv-strat-test")
+	require.NoError(t, err)
+	defer os.RemoveAll(dir)
+
+	path := filepath.Join(dir, "out.csv")
+
+	r := &report.Report{
+		InvalidMessages: map[string]map[string][]string{
+			"m1": {
+				"request": []string{"e1", "e2"},
+			},
+		},
+		NonParsableMessages: map[string][]string{"p1": {"pe1"}},
+		Statistics:          report.Statistics{},
+	}
+
+	s := csvStrategy{}
+	require.NoError(t, s.Write(path, r))
+
+	b, err := os.ReadFile(path)
+	require.NoError(t, err)
+
+	content := string(b)
+	require.Truef(t, strings.Contains(content, "message_id,type,errors") || strings.Contains(content, "message_id, type, errors"), "csv header missing, got: %s", content)
+	require.Contains(t, content, "m1", "expected m1 in csv")
+	require.Contains(t, content, "non_parsable", "expected non_parsable in csv")
+}

internal/validation/json_strategy.go

@@ -0,0 +1,32 @@
+package validation
+
+import (
+	"encoding/json"
+	"os"
+
+	"github.com/ChargePi/chargeflow/pkg/report"
+)
+
+// jsonStrategy implements OutputStrategy for JSON output.
+type jsonStrategy struct{}
+
+func (jsonStrategy) Write(path string, r *report.Report) error {
+	out := struct {
+		Report     *report.Report    `json:"report"`
+		Statistics report.Statistics `json:"statistics"`
+	}{
+		Report:     r,
+		Statistics: r.Statistics,
+	}
+
+	b, err := json.MarshalIndent(out, "", "  ")
+	if err != nil {
+		return err
+	}
+
+	if err = os.WriteFile(path, b, 0644); err != nil {
+		return err
+	}
+
+	return nil
+}

internal/validation/json_strategy_test.go

@@ -0,0 +1,41 @@
+package validation
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/ChargePi/chargeflow/pkg/report"
+)
+
+func TestJSONStrategy_Write(t *testing.T) {
+	dir, err := os.MkdirTemp("", "json-strat-test")
+	require.NoError(t, err)
+	defer os.RemoveAll(dir)
+
+	path := filepath.Join(dir, "out.json")
+
+	r := &report.Report{
+		InvalidMessages: map[string]map[string][]string{
+			"msg1": {"request": {"req-err"}},
+		},
+		NonParsableMessages: map[string][]string{"line1": {"parse-err"}},
+		Statistics:          report.Statistics{ValidRequests: 1, InvalidRequests: 1, ValidResponses: 0, InvalidResponses: 0, UnparsableMessages: 1},
+	}
+
+	s := jsonStrategy{}
+	require.NoError(t, s.Write(path, r))
+
+	b, err := os.ReadFile(path)
+	require.NoError(t, err)
+
+	// Unmarshal into a generic map to ensure fields exist
+	var out map[string]interface{}
+	require.NoError(t, json.Unmarshal(b, &out))
+
+	require.Contains(t, out, "report")
+	require.Contains(t, out, "statistics")
+}

internal/validation/opts.go

@@ -0,0 +1,13 @@
+package validation
+
+// Option is a functional option for ValidateFile.
+type Option func(*options)
+
+type options struct {
+	output string
+}
+
+// WithOutput sets the output path for the validation report.
+func WithOutput(path string) Option {
+	return func(o *options) { o.output = path }
+}

internal/validation/output_strategy.go

@@ -0,0 +1,40 @@
+package validation
+
+import (
+	"path/filepath"
+	"strings"
+
+	"github.com/pkg/errors"
+
+	"github.com/ChargePi/chargeflow/pkg/report"
+)
+
+// OutputStrategy defines how to write a validation report.
+type OutputStrategy interface {
+	Write(path string, r *report.Report) error
+}
+
+// outputStrategyFactory returns an OutputStrategy based on the file extension.
+func outputStrategyFactory(path string) (OutputStrategy, error) {
+	ext := strings.ToLower(filepath.Ext(path))
+	switch ext {
+	case ".json":
+		return jsonStrategy{}, nil
+	case ".csv":
+		return csvStrategy{}, nil
+	case ".txt":
+		return txtStrategy{}, nil
+	default:
+		return nil, errors.Errorf("unsupported output extension: %s", ext)
+	}
+}
+
+// WriteReport is a convenience exported helper that writes the report using the
+// appropriate OutputStrategy based on the provided path extension.
+func WriteReport(path string, r *report.Report) error {
+	strat, err := outputStrategyFactory(path)
+	if err != nil {
+		return err
+	}
+	return strat.Write(path, r)
+}

internal/validation/output_strategy_test.go

@@ -0,0 +1,43 @@
+package validation
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestOutputStrategyFactory(t *testing.T) {
+	tests := []struct {
+		name    string
+		path    string
+		wantErr bool
+	}{
+		{"json", "a.json", false},
+		{"csv", "b.csv", false},
+		{"txt", "c.txt", false},
+		{"bad", "d.unknown", true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			strat, err := outputStrategyFactory(tt.path)
+			if tt.wantErr {
+				require.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+
+			// ensure strategy concrete type via extension
+			ext := filepath.Ext(tt.path)
+			switch ext {
+			case ".json":
+				require.IsType(t, jsonStrategy{}, strat)
+			case ".csv":
+				require.IsType(t, csvStrategy{}, strat)
+			case ".txt":
+				require.IsType(t, txtStrategy{}, strat)
+			}
+		})
+	}
+}