969 lines
26 KiB
Go
969 lines
26 KiB
Go
package common
|
|
|
|
import (
|
|
"encoding/json"
|
|
"testing"
|
|
"time"
|
|
|
|
"fiskerinc.com/modules/grpc/kafka_grpc"
|
|
"fiskerinc.com/modules/utils/elptr"
|
|
)
|
|
|
|
func TestDepotRouteHMIPayload(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
payload *kafka_grpc.GRPC_DepotPayload
|
|
expectedResult *ConsumerPayload
|
|
expectedError error
|
|
}{
|
|
{
|
|
name: "Valid payload with 'init' handler",
|
|
payload: &kafka_grpc.GRPC_DepotPayload{
|
|
Handler: "init",
|
|
Data: &kafka_grpc.GRPC_DepotPayload_HmiSession{
|
|
HmiSession: &kafka_grpc.HMISessionData{
|
|
SessionId: "123456",
|
|
Vin: "ABC123",
|
|
Salt: "salt123",
|
|
},
|
|
},
|
|
},
|
|
expectedResult: &ConsumerPayload{
|
|
Handler: "init",
|
|
Data: func() []byte {
|
|
data, _ := json.Marshal(&HMISessionData{
|
|
SessionID: "123456",
|
|
VIN: "ABC123",
|
|
Salt: "salt123",
|
|
})
|
|
return data
|
|
}(),
|
|
},
|
|
expectedError: nil,
|
|
},
|
|
// Add more test cases as needed
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
result, err := DepotRouteHMIPayload(test.payload)
|
|
|
|
if err != test.expectedError {
|
|
t.Errorf("Expected error: %v, got: %v", test.expectedError, err)
|
|
}
|
|
|
|
if result.Handler != test.expectedResult.Handler {
|
|
t.Errorf("Handler mismatch. Expected: %s, got: %s", test.expectedResult.Handler, result.Handler)
|
|
}
|
|
|
|
if string(result.Data) != string(test.expectedResult.Data) {
|
|
t.Errorf("Data mismatch. Expected: %s, got: %s", test.expectedResult.Data, result.Data)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDepotRouteTRexPayloadMessage(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
payload *kafka_grpc.GRPC_DepotPayload
|
|
expectedResult *ConsumerPayload
|
|
expectedError error
|
|
}{
|
|
{
|
|
name: "Valid payload with 'init' handler",
|
|
payload: &kafka_grpc.GRPC_DepotPayload{
|
|
Handler: "init",
|
|
Data: &kafka_grpc.GRPC_DepotPayload_InitPayload{
|
|
InitPayload: &kafka_grpc.InitPayload{
|
|
Data: map[string]string{
|
|
"key1": "value1",
|
|
"key2": "value2",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expectedResult: &ConsumerPayload{
|
|
Handler: "init",
|
|
Data: func() []byte {
|
|
data, _ := json.Marshal(map[string]string{
|
|
"key1": "value1",
|
|
"key2": "value2",
|
|
})
|
|
return data
|
|
}(),
|
|
},
|
|
expectedError: nil,
|
|
},
|
|
{
|
|
name: "Payload with nil data",
|
|
payload: &kafka_grpc.GRPC_DepotPayload{
|
|
Handler: "init",
|
|
Data: nil,
|
|
},
|
|
expectedResult: &ConsumerPayload{
|
|
Handler: "init",
|
|
Data: nil,
|
|
},
|
|
expectedError: nil,
|
|
},
|
|
|
|
{
|
|
name: "Invalid handlerl handler",
|
|
payload: &kafka_grpc.GRPC_DepotPayload{
|
|
Handler: "fake_handler",
|
|
Data: nil,
|
|
},
|
|
expectedResult: &ConsumerPayload{
|
|
Handler: "fake_handler",
|
|
Data: nil,
|
|
},
|
|
expectedError: nil,
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
result, err := DepotRouteTRexPayload(test.payload)
|
|
|
|
if err != test.expectedError {
|
|
t.Errorf("Expected error: %v, got: %v", test.expectedError, err)
|
|
}
|
|
|
|
if result.Handler != test.expectedResult.Handler {
|
|
t.Errorf("Handler mismatch. Expected: %s, got: %s", test.expectedResult.Handler, result.Handler)
|
|
}
|
|
|
|
if string(result.Data) != string(test.expectedResult.Data) {
|
|
t.Errorf("Data mismatch. Expected: %s, got: %s", test.expectedResult.Data, result.Data)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestAttendantRouteMobilePayload(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
payload *kafka_grpc.GRPC_AttendantPayload
|
|
expectedResult *ConsumerPayload
|
|
expectedError error
|
|
}{
|
|
{
|
|
name: "Valid payload with 'update_approve' handler",
|
|
payload: &kafka_grpc.GRPC_AttendantPayload{
|
|
Handler: "update_approve",
|
|
Data: &kafka_grpc.GRPC_AttendantPayload_UpdateApprove{
|
|
UpdateApprove: &kafka_grpc.UpdateData{
|
|
Id: 123,
|
|
},
|
|
},
|
|
},
|
|
expectedResult: &ConsumerPayload{
|
|
Handler: "update_approve",
|
|
Data: func() []byte {
|
|
data, _ := json.Marshal(map[string]int{"id": 123})
|
|
return data
|
|
}(),
|
|
},
|
|
expectedError: nil,
|
|
},
|
|
{
|
|
name: "Valid payload with 'updates_get' handler",
|
|
payload: &kafka_grpc.GRPC_AttendantPayload{
|
|
Handler: "updates_get",
|
|
Data: &kafka_grpc.GRPC_AttendantPayload_UpdateGet{
|
|
UpdateGet: &kafka_grpc.VehicleData{
|
|
Vin: "ABC123",
|
|
},
|
|
},
|
|
},
|
|
expectedResult: &ConsumerPayload{
|
|
Handler: "updates_get",
|
|
Data: func() []byte {
|
|
data, _ := json.Marshal(map[string]string{"vin": "ABC123"})
|
|
return data
|
|
}(),
|
|
},
|
|
expectedError: nil,
|
|
},
|
|
{
|
|
name: "Payload with nil data",
|
|
payload: &kafka_grpc.GRPC_AttendantPayload{
|
|
Handler: "update_approve",
|
|
Data: nil,
|
|
},
|
|
expectedResult: &ConsumerPayload{
|
|
Handler: "update_approve",
|
|
Data: nil,
|
|
},
|
|
expectedError: nil,
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
result, err := AttendantRouteMobilePayload(test.payload)
|
|
|
|
if err != test.expectedError {
|
|
t.Errorf("Expected error: %v, got: %v", test.expectedError, err)
|
|
}
|
|
|
|
if result.Handler != test.expectedResult.Handler {
|
|
t.Errorf("Handler mismatch. Expected: %s, got: %s", test.expectedResult.Handler, result.Handler)
|
|
}
|
|
|
|
if string(result.Data) != string(test.expectedResult.Data) {
|
|
t.Errorf("Data mismatch. Expected: %s, got: %s", test.expectedResult.Data, result.Data)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestUpdateManifestToGRPC(t *testing.T) {
|
|
pub1 := "9a1a6949d7f8a511df6e2e2771e444dbd6de97e7d98bdecbb5adc4b8965ce3bef353f523dbea123d7882dc043d415cda02810bad1b6f1b8c6202234a424b7d5b"
|
|
pub2 := "407f59557fb64ae98bc30b5370fab138f4827e14784d79bcf707dbe35ba2b85d"
|
|
priv1 := "9a1a6949d7f8a511df6e2e2771e444dbd6de97e7d98bdecbb5adc4b8965ce3bef353f523dbea123d7882dc043d415cda02810bad1b6f1b8c6202234a424b7d5c"
|
|
var pub1B BinaryHex = []byte(pub1)
|
|
var pub2B BinaryHex = []byte(pub2)
|
|
var priv1B BinaryHex = []byte(priv1)
|
|
date := time.Date(2022, 5, 27, 12, 49, 0, 0, time.UTC)
|
|
unixMillis := date.UnixMilli()
|
|
toDate := time.Unix(0, unixMillis*int64(time.Millisecond))
|
|
flag := true
|
|
expectedUpdate := &UpdateManifest{
|
|
ID: 1,
|
|
ECUs: []*UpdateManifestECU{
|
|
{
|
|
ID: 3,
|
|
Mode: "v",
|
|
ECCKeys: &ECCKeys{
|
|
ECU: "ecu",
|
|
Env: "env",
|
|
PubKey1: &pub1B,
|
|
PrivKey1: &priv1B,
|
|
PubKey2: &pub2B,
|
|
},
|
|
Files: []*UpdateManifestFile{
|
|
{
|
|
FileID: "file_id_value",
|
|
UpdateManifestECUID: 123456789,
|
|
Filename: "filename_value",
|
|
URL: "url_value",
|
|
FileSize: 1024, // Example file size
|
|
Checksum: "checksum_value",
|
|
FileType: "type_value",
|
|
FileOrder: 1, // Example order
|
|
WriteRegion: MemoryRegion{
|
|
Offset: 1024, // Example offset
|
|
Length: 2048, // Example length
|
|
},
|
|
EraseRegion: &MemoryRegion{
|
|
Offset: 4096, // Example offset
|
|
Length: 8192, // Example length
|
|
},
|
|
FileKey: &FileKeyResponse{
|
|
FileID: "file_key_file_id_value",
|
|
Key: "file_key_key_value",
|
|
Auth: "file_key_auth_value",
|
|
Nonce: "file_key_nonce_value",
|
|
Error: "file_key_error_value",
|
|
},
|
|
Parsed: &flag, // Example parsed file value
|
|
Signature: "signature_value",
|
|
CompatibleTrims: []CompatibleTrim{
|
|
EXTREME,
|
|
SPORT,
|
|
},
|
|
CompatibleDriveSides: []CompatibleDriveSide{
|
|
LEFT_HAND_DRIVE,
|
|
RIGHT_HAND_DRIVE,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
expectedUpdate.CreatedAt = &toDate
|
|
expectedUpdate.ECUs[0].CreatedAt = &toDate
|
|
expectedUpdate.ECUs[0].UpdatedAt = &toDate
|
|
expectedUpdate.ECUs[0].Files[0].CreatedAt = &date
|
|
expectedUpdate.ECUs[0].Files[0].UpdatedAt = &date
|
|
|
|
b, _ := json.Marshal(expectedUpdate)
|
|
msg := MessageRawJSON{
|
|
Handler: "send_manifest",
|
|
Data: b,
|
|
}
|
|
|
|
grpcRep := UpdateManifestToGRPC(msg)
|
|
|
|
if grpcRep == nil {
|
|
t.Errorf("Expected not nil reponse from UpdateManifestToGRPC but got: nil")
|
|
}
|
|
|
|
if grpcRep.GetHandler() != msg.Handler {
|
|
t.Errorf("Expected handler should equal to %v but got %v:", msg.Handler, grpcRep.Handler)
|
|
}
|
|
|
|
reveseGRPC := GRPCToUpdateManifest(grpcRep)
|
|
|
|
grpcP, _ := json.Marshal(reveseGRPC)
|
|
|
|
if string(grpcP) != string(b) {
|
|
t.Errorf("Expected data should equal to %v but got %v:", string(b), string(grpcP))
|
|
}
|
|
|
|
}
|
|
func TestAttendantSendManifest(t *testing.T) {
|
|
pub1 := "9a1a6949d7f8a511df6e2e2771e444dbd6de97e7d98bdecbb5adc4b8965ce3bef353f523dbea123d7882dc043d415cda02810bad1b6f1b8c6202234a424b7d5b"
|
|
pub2 := "407f59557fb64ae98bc30b5370fab138f4827e14784d79bcf707dbe35ba2b85d"
|
|
priv1 := "9a1a6949d7f8a511df6e2e2771e444dbd6de97e7d98bdecbb5adc4b8965ce3bef353f523dbea123d7882dc043d415cda02810bad1b6f1b8c6202234a424b7d5c"
|
|
var pub1B BinaryHex = []byte(pub1)
|
|
var pub2B BinaryHex = []byte(pub2)
|
|
var priv1B BinaryHex = []byte(priv1)
|
|
date := time.Date(2022, 5, 27, 12, 49, 0, 0, time.UTC)
|
|
dateString := "2022-05-27T12:49:00Z"
|
|
unixMillis := date.UnixMilli()
|
|
toDate := time.Unix(0, unixMillis*int64(time.Millisecond))
|
|
flag := true
|
|
expectedUpdate := &UpdateManifest{
|
|
ID: 1,
|
|
ECUs: []*UpdateManifestECU{
|
|
{
|
|
ID: 3,
|
|
Mode: "v",
|
|
ECCKeys: &ECCKeys{
|
|
ECU: "ecu",
|
|
Env: "env",
|
|
PubKey1: &pub1B,
|
|
PrivKey1: &priv1B,
|
|
PubKey2: &pub2B,
|
|
},
|
|
Files: []*UpdateManifestFile{
|
|
{
|
|
FileID: "file_id_value",
|
|
UpdateManifestECUID: 123456789,
|
|
Filename: "filename_value",
|
|
URL: "url_value",
|
|
FileSize: 1024, // Example file size
|
|
Checksum: "checksum_value",
|
|
FileType: "type_value",
|
|
FileOrder: 1, // Example order
|
|
WriteRegion: MemoryRegion{
|
|
Offset: 1024, // Example offset
|
|
Length: 2048, // Example length
|
|
},
|
|
EraseRegion: &MemoryRegion{
|
|
Offset: 4096, // Example offset
|
|
Length: 8192, // Example length
|
|
},
|
|
FileKey: &FileKeyResponse{
|
|
FileID: "file_key_file_id_value",
|
|
Key: "file_key_key_value",
|
|
Auth: "file_key_auth_value",
|
|
Nonce: "file_key_nonce_value",
|
|
Error: "file_key_error_value",
|
|
},
|
|
Parsed: &flag, // Example parsed file value
|
|
Signature: "signature_value",
|
|
CompatibleTrims: []CompatibleTrim{
|
|
EXTREME,
|
|
SPORT,
|
|
},
|
|
CompatibleDriveSides: []CompatibleDriveSide{
|
|
LEFT_HAND_DRIVE,
|
|
RIGHT_HAND_DRIVE,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
expectedUpdate.CreatedAt = &toDate
|
|
expectedUpdate.ECUs[0].CreatedAt = &toDate
|
|
expectedUpdate.ECUs[0].UpdatedAt = &toDate
|
|
expectedUpdate.ECUs[0].Files[0].CreatedAt = &date
|
|
expectedUpdate.ECUs[0].Files[0].UpdatedAt = &date
|
|
|
|
tests := []struct {
|
|
name string
|
|
payload *kafka_grpc.GRPC_AttendantPayload
|
|
expectedResult *ConsumerPayload
|
|
expectedError error
|
|
}{
|
|
{
|
|
name: "Valid payload with 'send_manifest' handler",
|
|
payload: &kafka_grpc.GRPC_AttendantPayload{
|
|
Handler: "send_manifest",
|
|
Data: &kafka_grpc.GRPC_AttendantPayload_UpdateManifest{
|
|
UpdateManifest: &kafka_grpc.UpdateManifest{
|
|
Id: 1,
|
|
EcuUpdates: []*kafka_grpc.UpdateManifestECU{
|
|
{
|
|
Created: &unixMillis,
|
|
Updated: &unixMillis,
|
|
Id: 3,
|
|
Mode: "v",
|
|
EccKeys: &kafka_grpc.ECCKey{
|
|
Ecu: "ecu",
|
|
Env: "env",
|
|
PubKeyLevel_1: &kafka_grpc.BineryHex{
|
|
Data: []byte(pub1),
|
|
},
|
|
Level_1: &kafka_grpc.BineryHex{
|
|
Data: []byte(priv1),
|
|
},
|
|
PubKeyLevel_2: &kafka_grpc.BineryHex{
|
|
Data: []byte(pub2),
|
|
},
|
|
},
|
|
Files: []*kafka_grpc.UpdateManifestFile{
|
|
{
|
|
FileId: "file_id_value",
|
|
ManifestEcuId: 123456789,
|
|
Filename: "filename_value",
|
|
Url: "url_value",
|
|
FileSize: 1024, // Example file size
|
|
Checksum: "checksum_value",
|
|
Type: "type_value",
|
|
Order: 1, // Example order
|
|
WriteRegion: &kafka_grpc.MemoryRegion{
|
|
Offset: 1024, // Example offset
|
|
Length: 2048, // Example length
|
|
},
|
|
EraseRegion: &kafka_grpc.MemoryRegion{
|
|
Offset: 4096, // Example offset
|
|
Length: 8192, // Example length
|
|
},
|
|
FileKey: &kafka_grpc.FileKeyResponse{
|
|
FileId: "file_key_file_id_value",
|
|
Key: "file_key_key_value",
|
|
Auth: "file_key_auth_value",
|
|
Nonce: "file_key_nonce_value",
|
|
Error: "file_key_error_value",
|
|
},
|
|
Updated: &dateString,
|
|
Created: &dateString,
|
|
ParsedFile: &flag, // Example parsed file value
|
|
Signature: "signature_value",
|
|
CompatibleTrims: []string{
|
|
string(EXTREME),
|
|
string(SPORT),
|
|
},
|
|
CompatibleDriveSides: []string{
|
|
string(LEFT_HAND_DRIVE),
|
|
string(RIGHT_HAND_DRIVE),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Created: &unixMillis,
|
|
},
|
|
},
|
|
},
|
|
expectedResult: &ConsumerPayload{
|
|
Handler: "send_manifest",
|
|
Data: func() []byte {
|
|
data, _ := json.Marshal(expectedUpdate)
|
|
return data
|
|
}(),
|
|
},
|
|
expectedError: nil,
|
|
},
|
|
{
|
|
name: "Payload with nil data",
|
|
payload: &kafka_grpc.GRPC_AttendantPayload{
|
|
Handler: "send_manifest",
|
|
Data: nil,
|
|
},
|
|
expectedResult: &ConsumerPayload{
|
|
Handler: "send_manifest",
|
|
Data: nil,
|
|
},
|
|
expectedError: nil,
|
|
},
|
|
// Add more test cases as needed
|
|
}
|
|
|
|
// Set date
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
result, err := AttendantRouteServicePayload(test.payload)
|
|
|
|
if err != test.expectedError {
|
|
t.Errorf("Expected error: %v, got: %v", test.expectedError, err)
|
|
}
|
|
|
|
if result.Handler != test.expectedResult.Handler {
|
|
t.Errorf("Handler mismatch. Expected: %s, got: %s", test.expectedResult.Handler, result.Handler)
|
|
}
|
|
|
|
if string(result.Data) != string(test.expectedResult.Data) {
|
|
t.Errorf("Data mismatch. Expected: %s, <<><><<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n<<<<<got: %s", test.expectedResult.Data, result.Data)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestAttendantOrderUpdated(t *testing.T) {
|
|
date := time.Date(2022, 5, 27, 12, 49, 0, 0, time.UTC)
|
|
unixMillis := date.UnixMilli()
|
|
toDate := time.Unix(0, unixMillis*int64(time.Millisecond))
|
|
tests := []struct {
|
|
name string
|
|
payload *kafka_grpc.GRPC_AttendantPayload
|
|
expectedResult *ConsumerPayload
|
|
expectedError error
|
|
}{
|
|
{
|
|
name: "Valid payload with 'order_updated' handler",
|
|
payload: &kafka_grpc.GRPC_AttendantPayload{
|
|
Handler: "order_updated",
|
|
Data: &kafka_grpc.GRPC_AttendantPayload_Order{
|
|
Order: &kafka_grpc.Order{
|
|
OrderNo: 123,
|
|
MsgIdentifier: "msg123",
|
|
SpecId: 456,
|
|
VehicleSpecification: &kafka_grpc.VehicleSpecification{
|
|
DestCon: "DestinationCountry",
|
|
FOrderId: "FleetOrderIndicator",
|
|
MfPlant: "ManufacturingPlant",
|
|
ModelType: "ModelType",
|
|
ModelYear: 2022,
|
|
ModelId: 1,
|
|
OrderId: "OrderIndicator",
|
|
ProductId: "ProductionPhaseIndicator",
|
|
Sn: "SequenceNumber",
|
|
VehicleId: "VehicleIndicator",
|
|
Model: "VehicleModel",
|
|
VinPre: "VinPrefix",
|
|
Version: 1,
|
|
Date: unixMillis,
|
|
Feature: []*kafka_grpc.FeatureCodes{
|
|
{
|
|
FamilyCode: "family1",
|
|
FeatureCode: "feature1",
|
|
},
|
|
{
|
|
FamilyCode: "family2",
|
|
FeatureCode: "feature2",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expectedResult: &ConsumerPayload{
|
|
Handler: "order_updated",
|
|
Data: func() []byte {
|
|
order := &VehicleOrder{
|
|
OrderNumber: 123,
|
|
MessageIdentifier: "msg123",
|
|
SpecID: 456,
|
|
VehicleSpecification: VehicleSpecification{
|
|
DestinationCountry: "DestinationCountry",
|
|
FleetOrderIndicator: "FleetOrderIndicator",
|
|
ManufacturingPlant: "ManufacturingPlant",
|
|
ModelType: "ModelType",
|
|
ModelYear: 2022,
|
|
ModelYearIndicator: 1,
|
|
OrderIndicator: "OrderIndicator",
|
|
ProductionPhaseIndicator: "ProductionPhaseIndicator",
|
|
SequenceNumber: "SequenceNumber",
|
|
VehicleIndicator: "VehicleIndicator",
|
|
VehicleModel: "VehicleModel",
|
|
VinPrefix: "VinPrefix",
|
|
VersionDuringModelYear: 1,
|
|
ExpectedReferenceDate: ExpectedReferenceDate{toDate},
|
|
VehicleFeatures: []FeatureCodes{
|
|
{
|
|
FamilyCode: "family1",
|
|
FeatureCode: "feature1",
|
|
},
|
|
{
|
|
FamilyCode: "family2",
|
|
FeatureCode: "feature2",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
data, _ := json.Marshal(order)
|
|
return data
|
|
}(),
|
|
},
|
|
expectedError: nil,
|
|
},
|
|
{
|
|
name: "Payload with nil data",
|
|
payload: &kafka_grpc.GRPC_AttendantPayload{
|
|
Handler: "order_updated",
|
|
Data: nil,
|
|
},
|
|
expectedResult: &ConsumerPayload{
|
|
Handler: "order_updated",
|
|
Data: nil,
|
|
},
|
|
expectedError: nil,
|
|
},
|
|
// Add more test cases as needed
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
result, err := AttendantRouteServicePayload(test.payload)
|
|
|
|
if err != test.expectedError {
|
|
t.Errorf("Expected error: %v, got: %v", test.expectedError, err)
|
|
}
|
|
|
|
if result.Handler != test.expectedResult.Handler {
|
|
t.Errorf("Handler mismatch. Expected: %s, got: %s", test.expectedResult.Handler, result.Handler)
|
|
}
|
|
|
|
if string(result.Data) != string(test.expectedResult.Data) {
|
|
t.Errorf("Data mismatch. Expected: %s, got: %s", test.expectedResult.Data, result.Data)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestValetRouteTRexCMDChangedPayload(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
payload *kafka_grpc.GRPC_ValetPayload
|
|
expectedResult *ConsumerPayload
|
|
expectedError error
|
|
}{
|
|
{
|
|
name: "Valid payload with 'charging_command' handler",
|
|
payload: &kafka_grpc.GRPC_ValetPayload{
|
|
Handler: "charging_command",
|
|
Data: &kafka_grpc.GRPC_ValetPayload_ChCMD{
|
|
ChCMD: &kafka_grpc.ChargingCommand{
|
|
Action: "start_charging",
|
|
},
|
|
},
|
|
},
|
|
expectedResult: &ConsumerPayload{
|
|
Handler: "charging_command",
|
|
Data: func() []byte {
|
|
data, _ := json.Marshal(&kafka_grpc.ChargingCommand{
|
|
Action: "start_charging",
|
|
})
|
|
return data
|
|
}(),
|
|
},
|
|
expectedError: nil,
|
|
},
|
|
{
|
|
name: "Payload with nil data",
|
|
payload: &kafka_grpc.GRPC_ValetPayload{
|
|
Handler: "charging_command",
|
|
Data: nil,
|
|
},
|
|
expectedResult: &ConsumerPayload{
|
|
Handler: "charging_command",
|
|
Data: nil,
|
|
},
|
|
expectedError: nil,
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
result, err := ValetRouteTRexPayload(test.payload)
|
|
|
|
if err != test.expectedError {
|
|
t.Errorf("Expected error: %v, got: %v", test.expectedError, err)
|
|
}
|
|
|
|
if result.Handler != test.expectedResult.Handler {
|
|
t.Errorf("Handler mismatch. Expected: %s, got: %s", test.expectedResult.Handler, result.Handler)
|
|
}
|
|
|
|
if string(result.Data) != string(test.expectedResult.Data) {
|
|
t.Errorf("Data mismatch. Expected: %s, got: %s", test.expectedResult.Data, result.Data)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestValetRouteTRexDepartureSchedulePayload(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
payload *kafka_grpc.GRPC_ValetPayload
|
|
expectedResult *ConsumerPayload
|
|
expectedError error
|
|
}{
|
|
{
|
|
name: "Valid payload with 'departure_schedule' handler",
|
|
payload: &kafka_grpc.GRPC_ValetPayload{
|
|
Handler: "departure_schedule",
|
|
Data: &kafka_grpc.GRPC_ValetPayload_DepartureSchedule{
|
|
DepartureSchedule: &kafka_grpc.DepartureSchedule{
|
|
NextDayDeparture: nil,
|
|
DepartureDays: []*kafka_grpc.DepartureDay{
|
|
{
|
|
DayOfWeek: "Monday",
|
|
Time: "08:00",
|
|
},
|
|
{
|
|
DayOfWeek: "Wednesday",
|
|
Time: "10:00",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expectedResult: &ConsumerPayload{
|
|
Handler: "departure_schedule",
|
|
Data: func() []byte {
|
|
data, _ := json.Marshal(&DepartureSchedule{
|
|
NextDayDeparture: nil,
|
|
DepartureDays: []DepartureDay{
|
|
{
|
|
DayOfWeek: "Monday",
|
|
Time: "08:00",
|
|
},
|
|
{
|
|
DayOfWeek: "Wednesday",
|
|
Time: "10:00",
|
|
},
|
|
},
|
|
})
|
|
return data
|
|
}(),
|
|
},
|
|
expectedError: nil,
|
|
},
|
|
{
|
|
name: "Payload with nil data",
|
|
payload: &kafka_grpc.GRPC_ValetPayload{
|
|
Handler: "departure_schedule",
|
|
Data: nil,
|
|
},
|
|
expectedResult: &ConsumerPayload{
|
|
Handler: "departure_schedule",
|
|
Data: nil,
|
|
},
|
|
expectedError: nil,
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
result, err := ValetRouteTRexPayload(test.payload)
|
|
|
|
if err != test.expectedError {
|
|
t.Errorf("Expected error: %v, got: %v", test.expectedError, err)
|
|
}
|
|
|
|
if result.Handler != test.expectedResult.Handler {
|
|
t.Errorf("Handler mismatch. Expected: %s, got: %s", test.expectedResult.Handler, result.Handler)
|
|
}
|
|
|
|
if string(result.Data) != string(test.expectedResult.Data) {
|
|
t.Errorf("Data mismatch. Expected: %s, got: %s", test.expectedResult.Data, result.Data)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// Unit tests for CarStateToGRPC function
|
|
func TestCarStateToGRPC(t *testing.T) {
|
|
// Test case 1: Valid input
|
|
ecu := CarECU{
|
|
VIN: "123456",
|
|
ECU: "ECU1",
|
|
Version: "v1",
|
|
Epoch_usec: time.Now().Unix(),
|
|
}
|
|
carState := CarStateUpdate{
|
|
ECUs: map[string]CarECU{"ecu1": ecu},
|
|
}
|
|
data, err := json.Marshal(carState)
|
|
if err != nil {
|
|
t.Fatalf("Failed to marshal test data: %v", err)
|
|
}
|
|
input1 := MessageRawJSON{
|
|
Handler: "car_state_updated",
|
|
Data: data,
|
|
}
|
|
expected := &kafka_grpc.GRPC_AttendantPayload{
|
|
Handler: "car_state_updated",
|
|
Data: &kafka_grpc.GRPC_AttendantPayload_CarUpdateStatus{
|
|
CarUpdateStatus: &kafka_grpc.CarUpdateStatus{
|
|
Ecus: map[string]*kafka_grpc.CarECU{
|
|
"ecu1": {
|
|
Vin: ecu.VIN,
|
|
Ecu: ecu.ECU,
|
|
SwVersion: ecu.Version,
|
|
EpochUsec: ecu.Epoch_usec,
|
|
// Add other fields here as needed
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
output := CarStateToGRPC(input1)
|
|
expectedJSON, _ := json.Marshal(expected)
|
|
actualJSON, _ := json.Marshal(output)
|
|
if string(expectedJSON) != string(actualJSON) {
|
|
t.Errorf("Test case 1 failed: expected handler %+v, got %+v", expected.Data, output.Data)
|
|
}
|
|
}
|
|
|
|
// func TestGRPCToECCKeys(t *testing.T) {
|
|
|
|
// var pub1, pub2, priv1, priv2 []byte
|
|
// pub1 = []byte(`9a1a6949d7f8a511df6e2e2771e444dbd6de97e7d98bdecbb5adc4b8965ce3bef353f523dbea123d7882dc043d415cda02810bad1b6f1b8c6202234a424b7d5b`)
|
|
// pub2 = []byte(`9a1a6949d7f8a511df6e2e2771e444dbd6de97e7d98bdecbb5adc4b8965ce3bef353f523dbea123d7882dc043d415cda02810bad1b6f1b8c6202234a424b7d5c`)
|
|
// priv1 = []byte(`407f59557fb64ae98bc30b5370fab138f4827e14784d79bcf707dbe35ba2b85b`)
|
|
// priv2 = []byte(`407f59557fb64ae98bc30b5370fab138f4827e14784d79bcf707dbe35ba2b85c`)
|
|
|
|
// var pub11, pub22, priv11, priv22 BinaryHex
|
|
// pub11 = []byte(`9a1a6949d7f8a511df6e2e2771e444dbd6de97e7d98bdecbb5adc4b8965ce3bef353f523dbea123d7882dc043d415cda02810bad1b6f1b8c6202234a424b7d5b`)
|
|
// pub22 = []byte(`9a1a6949d7f8a511df6e2e2771e444dbd6de97e7d98bdecbb5adc4b8965ce3bef353f523dbea123d7882dc043d415cda02810bad1b6f1b8c6202234a424b7d5c`)
|
|
// priv11 = []byte(`407f59557fb64ae98bc30b5370fab138f4827e14784d79bcf707dbe35ba2b85b`)
|
|
// priv22 = []byte(`407f59557fb64ae98bc30b5370fab138f4827e14784d79bcf707dbe35ba2b85c`)
|
|
|
|
// testCases := []struct {
|
|
// name string
|
|
// payload *kafka_grpc.GRPC_AttendantPayload
|
|
// expected []ECCKeys
|
|
// }{
|
|
// {
|
|
// name: "NilPayload",
|
|
// payload: &kafka_grpc.GRPC_AttendantPayload{
|
|
// Handler: "test",
|
|
// },
|
|
// expected: nil,
|
|
// },
|
|
// {
|
|
// name: "WithPayload",
|
|
// payload: &kafka_grpc.GRPC_AttendantPayload{
|
|
// Handler: "test",
|
|
// Data: &kafka_grpc.GRPC_AttendantPayload_Keys{
|
|
// Keys: &kafka_grpc.ECCKeys{
|
|
// EccKeys: []*kafka_grpc.ECCKey{
|
|
// {
|
|
// Ecu: "ecu",
|
|
// Env: "env",
|
|
// PubKeyLevel_1: &pub1,
|
|
// PubKeyLevel_2: &pub2,
|
|
// Level_1: &priv1,
|
|
// Level_2: &priv2,
|
|
// },
|
|
// },
|
|
// },
|
|
// },
|
|
// },
|
|
// expected: []ECCKeys{
|
|
// {
|
|
// ECU: "ecu",
|
|
// Env: "env",
|
|
// PubKey1: &pub11,
|
|
// PubKey2: &pub22,
|
|
// PrivKey1: &priv11,
|
|
// PrivKey2: &priv22,
|
|
// },
|
|
// },
|
|
// },
|
|
// }
|
|
|
|
// for _, tc := range testCases {
|
|
// t.Run(tc.name, func(t *testing.T) {
|
|
// result := GRPCToECCKeys(tc.payload)
|
|
|
|
// // Compare the result with expected value
|
|
// if !equal(result, tc.expected) {
|
|
// t.Errorf("Test case %s failed. Expected: %v, got: %v", tc.name, tc.expected, result)
|
|
// }
|
|
// })
|
|
// }
|
|
// }
|
|
|
|
// Helper function to check equality of slices of ECCKeys
|
|
// func equal(a, b []ECCKeys) bool {
|
|
// if len(a) != len(b) {
|
|
// return false
|
|
// }
|
|
// for i := range a {
|
|
// if a[i] != b[i] {
|
|
// return false
|
|
// }
|
|
// }
|
|
// return true
|
|
// }
|
|
|
|
func TestRemoteCMD(t *testing.T) {
|
|
|
|
input := []struct {
|
|
name string
|
|
cmd *RemoteCommandRequest
|
|
}{
|
|
{
|
|
name: "With valid data",
|
|
cmd: &RemoteCommandRequest{
|
|
VIN: "1F15K3R45N1234567",
|
|
RemoteCommandSource: RemoteCommandSource{
|
|
Command: "temp_cabin",
|
|
Data: elptr.ElPtr("20"),
|
|
Start: elptr.ElPtr(time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)),
|
|
End: elptr.ElPtr(time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "With end date null",
|
|
cmd: &RemoteCommandRequest{
|
|
VIN: "1F15K3R45N1234567",
|
|
RemoteCommandSource: RemoteCommandSource{
|
|
Command: "temp_cabin",
|
|
Data: elptr.ElPtr("20"),
|
|
Start: elptr.ElPtr(time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)),
|
|
End: nil,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "With all values with zero",
|
|
cmd: &RemoteCommandRequest{},
|
|
},
|
|
{
|
|
name: "With null data",
|
|
cmd: nil,
|
|
},
|
|
{
|
|
name: "With zero cmd values",
|
|
cmd: &RemoteCommandRequest{
|
|
RemoteCommandSource: RemoteCommandSource{},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, in := range input {
|
|
t.Run(in.name, func(t *testing.T) {
|
|
b := toBinaryArray(in.cmd)
|
|
|
|
rawMsg := MessageRawJSON{
|
|
Handler: "remote_command",
|
|
Data: b,
|
|
}
|
|
protoCmd := RemoteCMDToGRPC(rawMsg)
|
|
|
|
resCMD := GRPCToRemotCMD(protoCmd)
|
|
protoCmdInBinary := toBinaryArray(resCMD)
|
|
|
|
if string(b) != string(protoCmdInBinary) {
|
|
t.Errorf("Expected %v, got %v", string(b), string(protoCmdInBinary))
|
|
}
|
|
})
|
|
}
|
|
|
|
}
|