feat: add convertion function for proper handling of byte arrays to base64 strings

Author: Benjosh95

core/utils/utils.go

@@ -1,5 +1,10 @@
 package utils
 
+import (
+	"encoding/base64"
+	"encoding/json"
+)
+
 // Ptr Returns the pointer to any type T
 func Ptr[T any](v T) *T {
 	return &v
@@ -13,3 +18,50 @@ func Contains[T comparable](slice []T, element T) bool {
 	}
 	return false
 }
+
+// ConvertForYAML converts a struct to a map with byte arrays converted to base64 strings
+// for proper YAML marshaling. This handles the case where []byte fields need to be
+// displayed as base64 strings in YAML output instead of byte arrays.
+func ConvertForYAML(obj interface{}) (map[string]interface{}, error) {
+	if obj == nil {
+		return nil, nil
+	}
+
+	// Marshal to JSON first to get the correct structure
+	jsonData, err := json.Marshal(obj)
+	if err != nil {
+		return nil, err
+	}
+
+	var result map[string]interface{}
+	if err := json.Unmarshal(jsonData, &result); err != nil {
+		return nil, err
+	}
+
+	// Convert byte arrays to base64 strings
+	convertByteArraysToBase64(result)
+
+	return result, nil
+}
+
+// convertByteArraysToBase64 recursively converts []byte values to base64 strings
+func convertByteArraysToBase64(data interface{}) {
+	switch v := data.(type) {
+	case map[string]interface{}:
+		for key, value := range v {
+			if byteArray, ok := value.([]byte); ok {
+				v[key] = base64.StdEncoding.EncodeToString(byteArray)
+			} else {
+				convertByteArraysToBase64(value)
+			}
+		}
+	case []interface{}:
+		for i, value := range v {
+			if byteArray, ok := value.([]byte); ok {
+				v[i] = base64.StdEncoding.EncodeToString(byteArray)
+			} else {
+				convertByteArraysToBase64(value)
+			}
+		}
+	}
+}

core/utils/utils_test.go

@@ -1,6 +1,7 @@
 package utils
 
 import (
+	"encoding/base64"
 	"testing"
 )
 
@@ -37,3 +38,122 @@ func TestContainsInt(t *testing.T) {
 		t.Fatalf("Should not be contained")
 	}
 }
+
+// Test struct for YAML conversion testing
+type TestServer struct {
+	Name     string  `json:"name"`
+	UserData *[]byte `json:"userData,omitempty"`
+	Data     []byte  `json:"data,omitempty"`
+}
+
+func TestConvertForYAML(t *testing.T) {
+	// Test with nil input
+	result, err := ConvertForYAML(nil)
+	if err != nil {
+		t.Fatalf("Expected no error for nil input, got: %v", err)
+	}
+	if result != nil {
+		t.Fatalf("Expected nil result for nil input, got: %v", result)
+	}
+
+	// Test with server containing byte arrays
+	userData := []byte("hello world")
+	data := []byte("test data")
+
+	server := TestServer{
+		Name:     "test-server",
+		UserData: &userData,
+		Data:     data,
+	}
+
+	result1, err := ConvertForYAML(server)
+	if err != nil {
+		t.Fatalf("Expected no error, got: %v", err)
+	}
+
+	// Check that UserData is converted to base64
+	if userDataStr, ok := result1["userData"].(string); !ok {
+		t.Fatalf("Expected userData to be a string, got: %T", result1["userData"])
+	} else {
+		expected := base64.StdEncoding.EncodeToString(userData)
+		if userDataStr != expected {
+			t.Fatalf("Expected userData to be %s, got: %s", expected, userDataStr)
+		}
+	}
+
+	// Check that Data is converted to base64
+	if dataStr, ok := result1["data"].(string); !ok {
+		t.Fatalf("Expected data to be a string, got: %T", result1["data"])
+	} else {
+		expected := base64.StdEncoding.EncodeToString(data)
+		if dataStr != expected {
+			t.Fatalf("Expected data to be %s, got: %s", expected, dataStr)
+		}
+	}
+
+	// Check that other fields remain unchanged
+	if result1["name"] != "test-server" {
+		t.Fatalf("Expected name to be 'test-server', got: %v", result1["name"])
+	}
+}
+
+func TestConvertForYAMLWithNilPointer(t *testing.T) {
+	// Test with nil pointer to byte array
+	server := TestServer{
+		Name:     "test-server",
+		UserData: nil, // nil pointer
+		Data:     []byte("test"),
+	}
+
+	result2, err := ConvertForYAML(server)
+	if err != nil {
+		t.Fatalf("Expected no error, got: %v", err)
+	}
+
+	// Check that nil pointer is handled correctly
+	if result2["userData"] != nil {
+		t.Fatalf("Expected userData to be nil, got: %v", result2["userData"])
+	}
+
+	// Check that non-nil byte array is still converted
+	if dataStr, ok := result2["data"].(string); !ok {
+		t.Fatalf("Expected data to be a string, got: %T", result2["data"])
+	} else {
+		expected := base64.StdEncoding.EncodeToString([]byte("test"))
+		if dataStr != expected {
+			t.Fatalf("Expected data to be %s, got: %s", expected, dataStr)
+		}
+	}
+}
+
+func TestConvertForYAMLWithEmptyByteArray(t *testing.T) {
+	// Test with empty byte array
+	emptyData := []byte{}
+
+	server := TestServer{
+		Name: "test-server",
+		Data: emptyData,
+	}
+
+	result3, err := ConvertForYAML(server)
+	if err != nil {
+		t.Fatalf("Expected no error, got: %v", err)
+	}
+
+	// Check that empty byte array is converted to empty base64 string
+	// Note: empty byte arrays might be omitted from JSON, so we check if it exists
+	if dataStr, exists := result3["data"]; !exists {
+		// Empty byte array was omitted from JSON, which is expected behavior
+		t.Logf("Empty byte array was omitted from JSON output, which is expected")
+	} else if dataStr, ok := dataStr.(string); !ok {
+		t.Fatalf("Expected data to be a string, got: %T", result3["data"])
+	} else {
+		expected := base64.StdEncoding.EncodeToString(emptyData)
+		if dataStr != expected {
+			t.Fatalf("Expected data to be %s, got: %s", expected, dataStr)
+		}
+		if dataStr != "" {
+			t.Fatalf("Expected empty byte array to be converted to empty string, got: %s", dataStr)
+		}
+	}
+}