github.com/angryronald/go-kit@v0.0.0-20240505173814-ff2bd9c79dbf/cast/object.transformer_test.go

package cast

import (
	"fmt"
	"reflect"
	"testing"

	"github.com/google/uuid"
	"github.com/stretchr/testify/assert"
)

func TestTransformObject(t *testing.T) {
	// Define sample input and output structs
	type SourceStruct struct {
		Field1 string `json:"field1"`
		Field2 int    `json:"field2"`
	}

	type ResultStruct struct {
		Field1 string `json:"field1"`
		Field2 int    `json:"field2"`
	}

	// Create a sample source object
	source := SourceStruct{
		Field1: "value1",
		Field2: 42,
	}

	// Create a result object with the same structure
	var result ResultStruct

	// Test TransformObject function
	err := TransformObject(source, &result)
	if err != nil {
		t.Errorf("TransformObject returned an error: %v", err)
	}

	// Check if the result matches the expected output
	expectedResult := ResultStruct{
		Field1: "value1",
		Field2: 42,
	}

	if !reflect.DeepEqual(result, expectedResult) {
		t.Errorf("TransformObject result doesn't match the expected result.")
	}
}

func TestFromBytes(t *testing.T) {
	// Define a sample JSON
	jsonData := []byte(`{"Field1": "value1", "Field2": 42}`)

	// Create a result struct
	var result struct {
		Field1 string `json:"Field1"`
		Field2 int    `json:"Field2"`
	}

	// Test FromBytes function
	err := FromBytes(jsonData, &result)
	if err != nil {
		t.Errorf("FromBytes returned an error: %v", err)
	}

	// Check if the result matches the expected output
	expectedResult := struct {
		Field1 string `json:"Field1"`
		Field2 int    `json:"Field2"`
	}{
		Field1: "value1",
		Field2: 42,
	}

	if !reflect.DeepEqual(result, expectedResult) {
		t.Errorf("FromBytes result doesn't match the expected result.")
	}
}

func TestToBytes(t *testing.T) {
	// Define a sample struct
	data := struct {
		Field1 string `json:"Field1"`
		Field2 int    `json:"Field2"`
	}{
		Field1: "value1",
		Field2: 42,
	}

	// Test ToBytes function
	jsonData, err := ToBytes(data)
	if err != nil {
		t.Errorf("ToBytes returned an error: %v", err)
	}

	// Check if the JSON data matches the expected JSON
	expectedJSON := []byte(`{"Field1":"value1","Field2":42}`)

	if !reflect.DeepEqual(jsonData, expectedJSON) {
		t.Errorf("ToBytes result doesn't match the expected JSON data.")
	}
}

func TestInterfacePointerArrayToInterfaceArray(t *testing.T) {
	var a interface{} = 1
	var b interface{} = "hello"
	var c interface{} = 3.14

	// Create a sample input slice of pointers to interfaces
	input := []*interface{}{&a, &b, &c}

	// Call the function to be tested
	output := InterfacePointerArrayToInterfaceArray(input)

	// Expected output (converted to []interface{})
	expected := []interface{}{
		1,
		"hello",
		3.14,
	}

	// Compare the actual and expected output
	if !reflect.DeepEqual(output, expected) {
		t.Errorf("Expected %v, but got %v", expected, output)
	}
}

func TestStructPointerArrayToInterfaceArray(t *testing.T) {
	// Create a sample input slice of pointers to interfaces
	type AStruct struct {
		val interface{}
	}
	var input []*AStruct
	var a interface{} = 1
	var b interface{} = "hello"
	var c interface{} = 3.14
	input = append(input, &AStruct{val: a})
	input = append(input, &AStruct{val: b})
	input = append(input, &AStruct{val: c})

	// Call the function to be tested
	output := StructPointerArrayToInterfaceArray(input)

	// Expected output (converted to []interface{})
	expected := []interface{}{
		AStruct{val: a},
		AStruct{val: b},
		AStruct{val: c},
	}

	// Compare the actual and expected output
	if !reflect.DeepEqual(output, expected) {
		t.Errorf("Expected %v, but got %v", expected, output)
	}
}

func TestStructPointerArrayToInterfacePointerArray(t *testing.T) {
	// Create a sample input slice of pointers to interfaces
	type AStruct struct {
		val interface{}
	}
	var input []*AStruct
	var a interface{} = 1
	var b interface{} = "hello"
	var c interface{} = 3.14
	ap := &AStruct{val: a}
	bp := &AStruct{val: b}
	cp := &AStruct{val: c}
	input = append(input, ap)
	input = append(input, bp)
	input = append(input, cp)

	// Call the function to be tested
	output := StructPointerArrayToInterfacePointerArray(input)

	// Expected output (converted to []interface{})
	expected := []interface{}{
		ap,
		bp,
		cp,
	}

	// Compare the actual and expected output
	if !reflect.DeepEqual(output, expected) {
		t.Errorf("Expected %v, but got %v", expected, output)
	}
}

func TestInterfaceArrayToPointerArray(t *testing.T) {
	// Define a slice of structs
	type Person struct {
		Name string
		Age  int
	}

	people := []Person{
		{"Alice", 30},
		{"Bob", 25},
	}

	// Convert []Person to []*Person using the function
	pointerArray := InterfaceArrayToPointerArray(people)

	// Assert that the result is of the correct type ([]*Person)
	assert.NotNil(t, pointerArray)
	assert.Equal(t, reflect.SliceOf(reflect.PtrTo(reflect.TypeOf(Person{}))), reflect.TypeOf(pointerArray))

	// Access the converted data
	peoplePointer := pointerArray.([]*Person)

	// Check the contents of the converted data
	assert.Len(t, peoplePointer, len(people))
	assert.Equal(t, "Alice", peoplePointer[0].Name)
	assert.Equal(t, 30, peoplePointer[0].Age)
	assert.Equal(t, "Bob", peoplePointer[1].Name)
	assert.Equal(t, 25, peoplePointer[1].Age)
}

func TestStructToPointer(t *testing.T) {
	// Create an instance of the Person struct
	type Person struct {
		Name string
		Age  int
	}
	person := Person{Name: "Alice", Age: 30}

	// Convert the Person object to a pointer
	ptrPerson := ToPointerObject(person)

	// Assert that the result is a pointer to Person
	if reflect.TypeOf(ptrPerson).Elem() != reflect.TypeOf(Person{}) {
		t.Errorf("Expected a pointer to Person, but got %T", ptrPerson)
	}

	// Access the converted data
	convertedPerson, ok := ptrPerson.(*Person)
	if !ok {
		t.Errorf("Failed to assert the type to *Person")
	}

	// Check the field values
	if convertedPerson.Name != person.Name || convertedPerson.Age != person.Age {
		t.Errorf("Field values do not match: %+v", convertedPerson)
	}
}

func TestStructToPointerWithOtherStruct(t *testing.T) {
	// Test with a different struct type
	otherStruct := struct {
		Name string
		Age  int
	}{Name: "Bob", Age: 25}

	ptrStruct := ToPointerObject(otherStruct)

	// Assert that the result is a pointer to the correct struct type
	if reflect.TypeOf(ptrStruct).Elem() != reflect.TypeOf(otherStruct) {
		t.Errorf("Expected a pointer to %T, but got %T", otherStruct, ptrStruct)
	}

	// Check the field values
	if !reflect.DeepEqual(ptrStruct, &otherStruct) {
		t.Errorf("Field values do not match: %+v", ptrStruct)
	}
}

func TestStructToPointerWithNonStruct(t *testing.T) {
	// Test with a non-struct type (int)
	i := 42
	ptr := ToPointerObject(i)

	// Assert that the result is nil because it's not a struct
	if reflect.TypeOf(ptr).Elem() != reflect.TypeOf(&i).Elem() {
		t.Errorf("Expected a pointer object, but got %+v", ptr)
	}
}

func TestObjectToStructPointerSlice(t *testing.T) {
	type SampleStruct struct {
		Name string
		Age  int
	}

	// Create an instance of a struct.
	obj := &SampleStruct{
		Name: "Alice",
		Age:  30,
	}

	// Call the function to create a slice of struct pointers.
	pointerSlice := ObjectToStructPointerSlice(obj)

	// Assert that the result is a slice.
	if reflect.TypeOf(pointerSlice).Kind() != reflect.Slice {
		t.Errorf("Expected result to be a slice, got %v", reflect.TypeOf(pointerSlice).Kind())
	}

	// Convert the interface back to a slice of struct pointers.
	result := pointerSlice.([]*SampleStruct)

	// Assert that the result slice has one element.
	if len(result) != 1 {
		t.Errorf("Expected result slice to have 1 element, got %d", len(result))
	}

	// Access the first element in the result slice.
	firstElement := result[0]

	// Assert that the values match.
	expectedName := "Alice"
	expectedAge := 30

	if firstElement.Name != expectedName {
		t.Errorf("Expected Name: %s, got Name: %s", expectedName, firstElement.Name)
	}

	if firstElement.Age != expectedAge {
		t.Errorf("Expected Age: %d, got Age: %d", expectedAge, firstElement.Age)
	}
}

func TestToString(t *testing.T) {
	// Test cases for different data types.
	sampleUUID := uuid.New()
	type StringInEnum string
	const thisIsString StringInEnum = "this is string value"
	testCases := []struct {
		input    interface{}
		expected string
		err      error
	}{
		// Valid cases
		{"Hello, World!", "Hello, World!", nil},
		{42, "42", nil},
		{int64(12345), "12345", nil},
		{3.14159, "3.141590", nil},
		{sampleUUID, sampleUUID.String(), nil},
		// Unsupported data type
		{thisIsString, "this is string value", nil},
	}

	for _, tc := range testCases {
		t.Run(fmt.Sprintf("%v", tc.input), func(t *testing.T) {
			result, err := ToString(tc.input)

			if err == nil && tc.err != nil {
				t.Errorf("Expected error: %v, but got no error", tc.err)
			} else if err != nil && tc.err == nil {
				t.Errorf("Expected no error, but got error: %v", err)
			} else if err != nil && tc.err != nil && err.Error() != tc.err.Error() {
				t.Errorf("Expected error: %v, but got error: %v", tc.err, err)
			}

			if result != tc.expected {
				t.Errorf("Expected result: %v, but got: %v", tc.expected, result)
			}
		})
	}
}

// func TestConvertSliceOfPointersToArrayOfInterfaces(t *testing.T) {
// 	type Person struct {
// 		Name string
// 		Age  int
// 	}

// 	// Create a slice of struct pointers.
// 	pointerSlice := []*Person{
// 		{Name: "Alice", Age: 30},
// 		{Name: "Bob", Age: 25},
// 	}

// 	// Convert the slice of pointers to a slice of interfaces.
// 	interfaceSlice := ConvertSliceOfPointersToArrayOfInterfaces(pointerSlice)

// 	// Check if the result is a slice of interfaces.
// 	if reflect.TypeOf(interfaceSlice).Kind() != reflect.Slice {
// 		t.Errorf("Expected result to be a slice, but got %v", reflect.TypeOf(interfaceSlice))
// 	}

// 	// Check the length of the result.
// 	if len(interfaceSlice.([]interface{})) != len(pointerSlice) {
// 		t.Errorf("Expected result length to be %d, but got %d", len(pointerSlice), len(interfaceSlice.([]interface{})))
// 	}

// 	// Check the types of elements in the result.
// 	for _, elem := range interfaceSlice.([]interface{}) {
// 		if reflect.TypeOf(elem).Kind() != reflect.Ptr {
// 			t.Errorf("Expected element type to be a pointer, but got %v", reflect.TypeOf(elem))
// 		}
// 		if reflect.TypeOf(elem).Elem() != reflect.TypeOf(&Person{}) {
// 			t.Errorf("Expected element type to be *Person, but got %v", reflect.TypeOf(elem).Elem())
// 		}
// 	}

// 	// Check the values of elements in the result.
// 	for i, elem := range interfaceSlice.([]interface{}) {
// 		personPointer := elem.(*Person) // Assert back to the struct pointer type
// 		expectedPerson := pointerSlice[i]

// 		if personPointer.Name != expectedPerson.Name || personPointer.Age != expectedPerson.Age {
// 			t.Errorf("Expected element at index %d to have values %v, but got %v", i, expectedPerson, personPointer)
// 		}
// 	}
// }