chore: additional unit tests (#7)

xBlaz3kx · web-flow · commit 6e2e14e39bc4 · 2025-06-14T00:48:51.000+02:00
* chore: added validate command test cases (wip)

* fix: test name

* chore: additional message tests

* chore: add result test cases

* chore: add parser tests

* chore: fix format
diff --git a/cmd/validate_test.go b/cmd/validate_test.go
@@ -1,6 +1,7 @@
 package cmd
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
 	"testing"
@@ -17,6 +18,9 @@ import (
 	"github.com/ChargePi/chargeflow/pkg/ocpp"
 )
 
+var validOcppRequest = "[2, \"1234567890\", \"Authorize\", {\"idTag\": \"1234567890\"}]"
+var validOcppResponse = "[3, \"1234567890\", {\"idTagInfo\": {\"status\": \"Accepted\"}}]"
+
 func Test_registerAdditionalSchemas(t *testing.T) {
 	logger := zap.L()
 	registry = schema_registry.NewInMemorySchemaRegistry(logger)
@@ -80,40 +84,57 @@ func Test_registerAdditionalSchemas(t *testing.T) {
 	}
 }
 
-func Test_registerSchemas(t *testing.T) {
-
-}
-
 func Test_Validate(t *testing.T) {
+	l, _ := zap.NewProduction()
+	zap.ReplaceGlobals(l)
+
 	tests := []struct {
 		name        string
 		args        []string
 		flags       map[string]string
 		expectedErr error
 	}{
 		{
-			name: "Defaults",
+			name:  "OCPP 1.6 Request",
+			args:  []string{validOcppRequest},
+			flags: map[string]string{},
+		},
+		{
+			name: "OCPP 1.6 Response",
+			args: []string{validOcppResponse},
+			flags: map[string]string{
+				"response-type": "Authorize",
+			},
 		},
 		{
-			name: "Invalid OCPP message",
+			name:  "Invalid OCPP message",
+			args:  []string{"{\"invalid\": \"message\"}"},
+			flags: map[string]string{},
 		},
 		{
 			name: "Invalid OCPP version",
+			args: []string{validOcppRequest},
+			flags: map[string]string{
+				"ocpp-version": "invalid_version",
+			},
+		},
+		{
+			name:  "Provided response without response-type",
+			args:  []string{validOcppResponse},
+			flags: map[string]string{},
 		},
 	}
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			r := require.New(t)
-
 			// Setup: Set command arguments and flags
-			validate.SetArgs(test.args)
-
+			args := test.args
 			for flag, value := range test.flags {
-				err := validate.Flags().Set(flag, value)
-				r.NoError(err)
+				args = append(args, fmt.Sprintf("--%s=%s", flag, value))
 			}
 
+			validate.SetArgs(args)
+
 			// Execute the command
 			err := validate.Execute()
 			if test.expectedErr != nil {
diff --git a/pkg/ocpp/message.go b/pkg/ocpp/message.go
@@ -1,9 +1,5 @@
 package ocpp
 
-import (
-	"fmt"
-)
-
 // MessageType identifies the type of message exchanged between two OCPP endpoints.
 type MessageType int
 
@@ -124,7 +120,7 @@ func FormatErrorType(version Version) ErrorCode {
 	case V20:
 		return FormatViolationV2
 	default:
-		panic(fmt.Sprintf("invalid dialect"))
+		panic("invalid dialect")
 	}
 }
 
@@ -135,7 +131,7 @@ func OccurrenceConstraintErrorType(version Version) ErrorCode {
 	case V20:
 		return OccurrenceConstraintViolationV2
 	default:
-		panic(fmt.Sprintf("invalid dialect"))
+		panic("invalid dialect")
 	}
 }
 
diff --git a/pkg/ocpp/message_test.go b/pkg/ocpp/message_test.go
@@ -0,0 +1,153 @@
+package ocpp
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFormatErrorType(t *testing.T) {
+	tests := []struct {
+		name     string
+		version  Version
+		expected ErrorCode
+	}{
+		{
+			name:     "OCPP 1.6",
+			version:  V16,
+			expected: FormatViolationV16,
+		},
+		{
+			name:     "OCPP 2.0",
+			version:  V20,
+			expected: FormatViolationV2,
+		},
+		{
+			name:    "Invalid Version",
+			version: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if tt.name == "Invalid Version" {
+				assert.Panics(t, func() {
+					_ = FormatErrorType(tt.version)
+				})
+			} else {
+				result := FormatErrorType(tt.version)
+				assert.Equal(t, result, tt.expected)
+			}
+		})
+	}
+}
+
+func TestOccurrenceConstraintErrorType(t *testing.T) {
+	tests := []struct {
+		name     string
+		version  Version
+		expected ErrorCode
+	}{
+		{
+			name:     "OCPP 1.6",
+			version:  V16,
+			expected: OccurrenceConstraintViolationV16,
+		},
+		{
+			name:     "OCPP 2.0",
+			version:  V20,
+			expected: OccurrenceConstraintViolationV2,
+		},
+		{
+			name: "Invalid Version",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if tt.name == "Invalid Version" {
+				assert.Panics(t, func() {
+					_ = OccurrenceConstraintErrorType(tt.version)
+				})
+			} else {
+				result := OccurrenceConstraintErrorType(tt.version)
+				assert.Equal(t, result, tt.expected)
+			}
+		})
+	}
+}
+
+func TestIsErrorCodeValid(t *testing.T) {
+	tests := []struct {
+		name     string
+		code     ErrorCode
+		expected bool
+	}{
+		{
+			name:     "Not implemented",
+			code:     NotImplemented,
+			expected: true,
+		},
+		{
+			name:     "Not supported",
+			code:     NotSupported,
+			expected: true,
+		},
+		{
+			name:     "Internal error",
+			code:     InternalError,
+			expected: true,
+		},
+		{
+			name:     "Format violation",
+			code:     FormatViolationV16,
+			expected: true,
+		}, {
+			name:     "Format violation",
+			code:     FormatViolationV2,
+			expected: true,
+		},
+		{
+			name:     "Security error",
+			code:     SecurityError,
+			expected: true,
+		},
+		{
+			name:     "Property constraint violation",
+			code:     PropertyConstraintViolation,
+			expected: true,
+		},
+		{
+			name:     "Occurrence constraint violation",
+			code:     OccurrenceConstraintViolationV16,
+			expected: true,
+		},
+		{
+			name:     "Occurrence constraint violation",
+			code:     OccurrenceConstraintViolationV2,
+			expected: true,
+		},
+		{
+			name:     "Type constraint violation",
+			code:     TypeConstraintViolation,
+			expected: true,
+		},
+		{
+			name:     "Generic error",
+			code:     GenericError,
+			expected: true,
+		},
+		{
+			name:     "Unknown error",
+			code:     "UnknownError",
+			expected: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := IsErrorCodeValid(tt.code)
+			assert.Equal(t, result, tt.expected)
+		})
+	}
+}
diff --git a/pkg/parser/parser.go b/pkg/parser/parser.go
@@ -3,6 +3,7 @@ package parser
 import (
 	"encoding/json"
 	"fmt"
+
 	"github.com/spf13/viper"
 
 	"github.com/pkg/errors"
diff --git a/pkg/parser/parser_test.go b/pkg/parser/parser_test.go
@@ -1,6 +1,9 @@
 package parser
 
 import (
+	"github.com/ChargePi/chargeflow/pkg/ocpp"
+	"github.com/pkg/errors"
+	"go.uber.org/zap"
 	"testing"
 
 	"github.com/stretchr/testify/suite"
@@ -11,7 +14,83 @@ type parserTestSuite struct {
 }
 
 func (s *parserTestSuite) TestParseMessage() {
+	logger, _ := zap.NewDevelopment()
+	tests := []struct {
+		name            string
+		data            string
+		expectedMessage ocpp.Message
+		expectedResult  *Result
+		expectedError   error
+	}{
+		{
+			name: "Valid Request",
+			data: `[2,"1234", "BootNotification", {"chargePointVendor": "TestVendor", "chargePointModel": "TestModel"}]`,
+			expectedMessage: &ocpp.Call{
+				MessageTypeId: ocpp.CALL,
+				UniqueId:      "1234",
+				Payload:       map[string]interface{}{"chargePointVendor": "TestVendor", "chargePointModel": "TestModel"},
+				Action:        "BootNotification",
+			},
+			expectedResult: NewResult(),
+			expectedError:  nil,
+		},
+		{
+			name: "Valid Response",
+			data: `[3,"1234", {"status": "Accepted"}]`,
+			expectedMessage: &ocpp.CallResult{
+				MessageTypeId: ocpp.CALL_RESULT,
+				UniqueId:      "1234",
+				Payload:       map[string]interface{}{"status": "Accepted"},
+				Action:        "",
+			},
+			expectedResult: NewResult(),
+			expectedError:  nil,
+		},
+		{
+			name: "Valid Error",
+			data: `[4,"1234", "GenericError", "An error occurred"]`,
+			expectedMessage: &ocpp.CallError{
+				MessageTypeId:    ocpp.CALL_ERROR,
+				UniqueId:         "1234",
+				ErrorCode:        "GenericError",
+				ErrorDescription: "An error occurred",
+			},
+			expectedResult: NewResult(),
+			expectedError:  nil,
+		},
+		{
+			name:            "Invalid Message",
+			data:            `[5,"1234", "InvalidMessage"]`,
+			expectedMessage: nil,
+			expectedResult: &Result{
+				errors: []string{"Unknown message type: 5"},
+			},
+			expectedError: errors.New("Unknown message type: 5"),
+		},
+		{
+			name:            "Invalid JSON",
+			data:            `{"invalid": "json"}`,
+			expectedMessage: nil,
+			expectedResult: &Result{
+				errors: []string{"cannot parse message"},
+			},
+			expectedError: errors.New("cannot parse message"),
+		},
+	}
 
+	for _, tt := range tests {
+		s.Run(tt.name, func() {
+			parser := NewParser(logger)
+			message, result, err := parser.ParseMessage(tt.data)
+			if tt.expectedError != nil {
+				s.ErrorContains(err, tt.expectedError.Error())
+			} else {
+				s.NoError(err)
+			}
+			s.Equal(tt.expectedMessage, message)
+			s.Equal(tt.expectedResult, result)
+		})
+	}
 }
 
 func TestParser(t *testing.T) {
diff --git a/pkg/parser/result_test.go b/pkg/parser/result_test.go
diff --git a/pkg/validator/result_test.go b/pkg/validator/result_test.go

Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,5 @@`
`1`	`1`	`package ocpp`
`2`	`2`
`3`		`-import (`
`4`		`- "fmt"`
`5`		`-)`
`6`		`-`
`7`	`3`	`// MessageType identifies the type of message exchanged between two OCPP endpoints.`
`8`	`4`	`type MessageType int`
`9`	`5`
`@@ -124,7 +120,7 @@ func FormatErrorType(version Version) ErrorCode {`
`124`	`120`	`case V20:`
`125`	`121`	`return FormatViolationV2`
`126`	`122`	`default:`
`127`		`- panic(fmt.Sprintf("invalid dialect"))`
	`123`	`+ panic("invalid dialect")`
`128`	`124`	`}`
`129`	`125`	`}`
`130`	`126`
`@@ -135,7 +131,7 @@ func OccurrenceConstraintErrorType(version Version) ErrorCode {`
`135`	`131`	`case V20:`
`136`	`132`	`return OccurrenceConstraintViolationV2`
`137`	`133`	`default:`
`138`		`- panic(fmt.Sprintf("invalid dialect"))`
	`134`	`+ panic("invalid dialect")`
`139`	`135`	`}`
`140`	`136`	`}`
`141`	`137`