Skip to content

Commit 7f3f460

Browse files
Benjosh95Benjosh95
committed
refactor utils tests to table tests
1 parent 4502061 commit 7f3f460

File tree

1 file changed

+102
-108
lines changed

1 file changed

+102
-108
lines changed

‎core/utils/utils_test.go‎

Lines changed: 102 additions & 108 deletions
Original file line numberDiff line numberDiff line change
@@ -47,113 +47,107 @@ type TestServer struct {
4747
}
4848

4949
func TestConvertByteArraysToBase64(t *testing.T) {
50-
// Test with nil input
51-
result, err := ConvertByteArraysToBase64(nil)
52-
if err != nil {
53-
t.Fatalf("Expected no error for nil input, got: %v", err)
54-
}
55-
if result != nil {
56-
t.Fatalf("Expected nil result for nil input, got: %v", result)
57-
}
58-
59-
// Test with server containing byte arrays
60-
userData := []byte("hello world")
61-
data := []byte("test data")
62-
63-
server := TestServer{
64-
Name: "test-server",
65-
UserData: &userData,
66-
Data: data,
67-
}
68-
69-
result1, err := ConvertByteArraysToBase64(server)
70-
if err != nil {
71-
t.Fatalf("Expected no error, got: %v", err)
72-
}
73-
74-
// Check that UserData is converted to base64
75-
if userDataStr, ok := result1["userData"].(string); !ok {
76-
t.Fatalf("Expected userData to be a string, got: %T", result1["userData"])
77-
} else {
78-
expected := base64.StdEncoding.EncodeToString(userData)
79-
if userDataStr != expected {
80-
t.Fatalf("Expected userData to be %s, got: %s", expected, userDataStr)
81-
}
82-
}
83-
84-
// Check that Data is converted to base64
85-
if dataStr, ok := result1["data"].(string); !ok {
86-
t.Fatalf("Expected data to be a string, got: %T", result1["data"])
87-
} else {
88-
expected := base64.StdEncoding.EncodeToString(data)
89-
if dataStr != expected {
90-
t.Fatalf("Expected data to be %s, got: %s", expected, dataStr)
91-
}
92-
}
93-
94-
// Check that other fields remain unchanged
95-
if result1["name"] != "test-server" {
96-
t.Fatalf("Expected name to be 'test-server', got: %v", result1["name"])
97-
}
98-
}
99-
100-
func TestConvertByteArraysToBase64WithNilPointer(t *testing.T) {
101-
// Test with nil pointer to byte array
102-
server := TestServer{
103-
Name: "test-server",
104-
UserData: nil, // nil pointer
105-
Data: []byte("test"),
106-
}
107-
108-
result2, err := ConvertByteArraysToBase64(server)
109-
if err != nil {
110-
t.Fatalf("Expected no error, got: %v", err)
111-
}
112-
113-
// Check that nil pointer is handled correctly
114-
if result2["userData"] != nil {
115-
t.Fatalf("Expected userData to be nil, got: %v", result2["userData"])
116-
}
117-
118-
// Check that non-nil byte array is still converted
119-
if dataStr, ok := result2["data"].(string); !ok {
120-
t.Fatalf("Expected data to be a string, got: %T", result2["data"])
121-
} else {
122-
expected := base64.StdEncoding.EncodeToString([]byte("test"))
123-
if dataStr != expected {
124-
t.Fatalf("Expected data to be %s, got: %s", expected, dataStr)
125-
}
126-
}
127-
}
128-
129-
func TestConvertByteArraysToBase64WithEmptyByteArray(t *testing.T) {
130-
// Test with empty byte array
131-
emptyData := []byte{}
132-
133-
server := TestServer{
134-
Name: "test-server",
135-
Data: emptyData,
136-
}
137-
138-
result3, err := ConvertByteArraysToBase64(server)
139-
if err != nil {
140-
t.Fatalf("Expected no error, got: %v", err)
141-
}
142-
143-
// Check that empty byte array is converted to empty base64 string
144-
// Note: empty byte arrays might be omitted from JSON, so we check if it exists
145-
if dataStr, exists := result3["data"]; !exists {
146-
// Empty byte array was omitted from JSON, which is expected behavior
147-
t.Logf("Empty byte array was omitted from JSON output, which is expected")
148-
} else if dataStr, ok := dataStr.(string); !ok {
149-
t.Fatalf("Expected data to be a string, got: %T", result3["data"])
150-
} else {
151-
expected := base64.StdEncoding.EncodeToString(emptyData)
152-
if dataStr != expected {
153-
t.Fatalf("Expected data to be %s, got: %s", expected, dataStr)
154-
}
155-
if dataStr != "" {
156-
t.Fatalf("Expected empty byte array to be converted to empty string, got: %s", dataStr)
157-
}
50+
tests := []struct {
51+
name string
52+
input interface{}
53+
expectedFields map[string]interface{}
54+
expectError bool
55+
}{
56+
{
57+
name: "nil input",
58+
input: nil,
59+
expectError: false,
60+
},
61+
{
62+
name: "normal case with byte arrays",
63+
input: TestServer{
64+
Name: "test-server",
65+
UserData: func() *[]byte { b := []byte("hello world"); return &b }(),
66+
Data: []byte("test data"),
67+
},
68+
expectedFields: map[string]interface{}{
69+
"name": "test-server",
70+
"userData": base64.StdEncoding.EncodeToString([]byte("hello world")),
71+
"data": base64.StdEncoding.EncodeToString([]byte("test data")),
72+
},
73+
expectError: false,
74+
},
75+
{
76+
name: "nil pointer case",
77+
input: TestServer{
78+
Name: "test-server",
79+
UserData: nil,
80+
Data: []byte("test"),
81+
},
82+
expectedFields: map[string]interface{}{
83+
"name": "test-server",
84+
"data": base64.StdEncoding.EncodeToString([]byte("test")),
85+
},
86+
expectError: false,
87+
},
88+
{
89+
name: "empty byte array case",
90+
input: TestServer{
91+
Name: "test-server",
92+
Data: []byte{},
93+
},
94+
expectedFields: map[string]interface{}{
95+
"name": "test-server",
96+
// Note: empty byte arrays are omitted from JSON output
97+
},
98+
expectError: false,
99+
},
100+
}
101+
102+
for _, tt := range tests {
103+
t.Run(tt.name, func(t *testing.T) {
104+
result, err := ConvertByteArraysToBase64(tt.input)
105+
106+
if tt.expectError {
107+
if err == nil {
108+
t.Fatalf("Expected error but got none")
109+
}
110+
return
111+
}
112+
113+
if err != nil {
114+
t.Fatalf("Expected no error, got: %v", err)
115+
}
116+
117+
// Special case for nil input
118+
if tt.input == nil {
119+
if result != nil {
120+
t.Fatalf("Expected nil result for nil input, got: %v", result)
121+
}
122+
return
123+
}
124+
125+
// Check expected fields
126+
for fieldName, expectedValue := range tt.expectedFields {
127+
if actualValue, exists := result[fieldName]; !exists {
128+
// For empty byte arrays, the field might be omitted from JSON
129+
if fieldName == "data" && expectedValue == nil {
130+
t.Logf("Empty byte array was omitted from JSON output, which is expected")
131+
continue
132+
}
133+
t.Fatalf("Expected field %s to exist, but it doesn't", fieldName)
134+
} else {
135+
if actualValue != expectedValue {
136+
t.Fatalf("Expected field %s to be %v, got %v", fieldName, expectedValue, actualValue)
137+
}
138+
}
139+
}
140+
141+
// Check that no unexpected fields exist (except for omitted empty byte arrays)
142+
for fieldName, actualValue := range result {
143+
if _, expected := tt.expectedFields[fieldName]; !expected {
144+
// Allow data field to exist even if not in expectedFields (for empty byte array case)
145+
if fieldName == "data" && tt.name == "empty byte array case" {
146+
continue
147+
}
148+
t.Fatalf("Unexpected field %s with value %v", fieldName, actualValue)
149+
}
150+
}
151+
})
158152
}
159153
}

0 commit comments

Comments
 (0)