github.com/angryronald/go-kit@v0.0.0-20240505173814-ff2bd9c79dbf/generic/repository/generic.utils_test.go

package repository

import (
	reflect "reflect"
	"testing"

	"github.com/google/uuid"

	"github.com/angryronald/go-kit/cast"
)

func TestIsValidOperations(t *testing.T) {
	// Test case where conditions match and relational operations are 1 less
	conditionalOps := []ConditionalOperation{"=", ">", "<"}
	relationalOps := []RelationalOperation{"AND", "OR"}
	params := map[string]interface{}{"field1": 1, "field2": 2, "field3": 3}
	if !IsValidOperations(conditionalOps, relationalOps, params) {
		t.Errorf("Expected IsValidOperations to return true, but got false")
	}

	// Test case where conditions do not match
	conditionalOps = []ConditionalOperation{"=", ">", "<"}
	relationalOps = []RelationalOperation{"AND", "OR"}
	params = map[string]interface{}{"field1": 1, "field2": 2}
	if IsValidOperations(conditionalOps, relationalOps, params) {
		t.Errorf("Expected IsValidOperations to return false, but got true")
	}
}

func TestToSnakeCase(t *testing.T) {
	// Test with camel case string
	input := "camelCaseString"
	expected := "camel_case_string"
	result := ToSnakeCase(input)
	if result != expected {
		t.Errorf("Expected ToSnakeCase(%s) to return %s, but got %s", input, expected, result)
	}

	// Test with already snake case string
	input = "snake_case_string"
	expected = "snake_case_string"
	result = ToSnakeCase(input)
	if result != expected {
		t.Errorf("Expected ToSnakeCase(%s) to return %s, but got %s", input, expected, result)
	}
}

func TestGetTableName(t *testing.T) {
	// Test with a struct named User
	type User struct{}
	expected := "users"
	result := GetTableName(&User{})
	if result != expected {
		t.Errorf("Expected GetTableName(User{}) to return %s, but got %s", expected, result)
	}

	// Test with a struct named UserProfile
	type UserProfile struct{}
	expected = "user_profiles"
	result = GetTableName(&UserProfile{})
	if result != expected {
		t.Errorf("Expected GetTableName(UserProfile{}) to return %s, but got %s", expected, result)
	}

	type OTPModel struct{}
	expected = "otp_models"
	result = GetTableName(&OTPModel{})
	if result != expected {
		t.Errorf("Expected GetTableName(OTPModel{}) to return %s, but got %s", expected, result)
	}
}

func TestIsMapStringInterface(t *testing.T) {
	tests := []struct {
		name   string
		input  interface{}
		expect bool
	}{
		{
			name:   "Valid map[string]interface{}",
			input:  map[string]interface{}{"key": "value"},
			expect: true,
		},
		{
			name:   "Invalid non-map input",
			input:  "not a map",
			expect: false,
		},
		{
			name:   "Invalid map with non-string key",
			input:  map[int]interface{}{1: "value"},
			expect: false,
		},
		{
			name:   "Invalid map with non-interface value",
			input:  map[string]int{"key": 42},
			expect: false,
		},
		{
			name:   "Valid empty map",
			input:  map[string]interface{}{},
			expect: true,
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			result := IsMapStringInterface(test.input)
			if result != test.expect {
				t.Errorf("Expected %v, but got %v for input %+v", test.expect, result, test.input)
			}
		})
	}
}

func TestGetStructPropertyAsString(t *testing.T) {
	// Create an instance of the Person struct with a UUID field
	type Person struct {
		ID    uuid.UUID
		Name  string
		Age   int
		Email string
	}

	person := Person{
		ID:    uuid.New(),
		Name:  "Alice",
		Age:   30,
		Email: "alice@example.com",
	}

	// Test getting a string property (Name)
	name, err := GetStructPropertyAsString(&person, "NAME")
	if err != nil {
		t.Errorf("Error getting property 'Name': %v", err)
	}
	if name != "Alice" {
		t.Errorf("Expected 'Name' to be 'Alice', but got '%s'", name)
	}

	// Test getting an integer property (Age)
	age, err := GetStructPropertyAsString(&person, "AGE")
	if err != nil {
		t.Errorf("Error getting property 'Age': %v", err)
	}
	if age != "30" {
		t.Errorf("Expected 'Age' to be '30', but got '%s'", age)
	}

	// Test getting a UUID property (ID)
	id, err := GetStructPropertyAsString(&person, "ID")
	if err != nil {
		t.Errorf("Error getting property 'ID': %v", err)
	}
	// The actual UUID value is generated dynamically, so we can't predict the exact value.
	// We'll just check that it's a non-empty string.
	if id == "" {
		t.Errorf("Expected a non-empty UUID string for 'ID', but got an empty string")
	}

	// Test getting a non-existent property
	_, err = GetStructPropertyAsString(&person, "NonExistent")
	if err == nil {
		t.Errorf("Expected an error for getting a non-existent property")
	}

	// Test getting a property from a nil pointer (should return an error)
	var nilPointer *Person
	_, err = GetStructPropertyAsString(nilPointer, "NAME")
	if err == nil {
		t.Errorf("Expected an error for getting a property from a nil pointer")
	}
}

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

	tests := []struct {
		name string
		src  interface{}
	}{
		{
			name: "Copy Person Struct",
			src:  &Person{Name: "John", Age: 30, Address: "123 Main St"},
		},
		{
			name: "Copy Empty Struct",
			src:  &struct{}{},
		},
		{
			name: "Copy Struct with Different Field Types",
			src: &struct {
				Name  string
				Age   int
				Score float64
			}{Name: "Alice", Age: 25, Score: 98.5},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			dest, err := CopyObject(tt.src)
			if err != nil {
				t.Errorf("Error copying object: %v", err)
			}

			// Check if the source and destination objects have the same type.
			if reflect.TypeOf(tt.src) != reflect.TypeOf(dest) {
				t.Errorf("Expected source and destination types to be the same, but got different types.")
			}

			// Check if the source and destination objects have the same field values.
			srcValue := reflect.ValueOf(tt.src).Elem()
			destValue := reflect.ValueOf(dest).Elem()

			for i := 0; i < srcValue.NumField(); i++ {
				srcField := srcValue.Field(i)
				destField := destValue.Field(i)

				if !reflect.DeepEqual(srcField.Interface(), destField.Interface()) {
					t.Errorf("Field %s mismatch between source and destination: expected %v, got %v",
						srcValue.Type().Field(i).Name, srcField.Interface(), destField.Interface())
				}
			}
		})
	}
}

func TestCopySliceOfPointers(t *testing.T) {
	// Define a sample struct type.
	type SampleStruct struct {
		ID   int
		Name string
	}

	// Create a sample slice of struct pointers.
	sourceSlice := []*SampleStruct{
		&SampleStruct{1, "Alice"},
		&SampleStruct{2, "Bob"},
		&SampleStruct{3, "Charlie"},
	}

	// Call the function to copy the slice.
	result, err := CopySliceOfPointers(sourceSlice)

	// Check for errors.
	if err != nil {
		t.Errorf("CopySliceOfPointers returned an error: %v", err)
	}

	// Check the type of the result.
	resultValue := reflect.ValueOf(result)
	if resultValue.Kind() != reflect.Slice {
		t.Errorf("Result is not a slice")
	}

	// Check the length of the result slice.
	if resultValue.Len() != len(sourceSlice) {
		t.Errorf("Result slice has unexpected length")
	}

	// Check the type and content of each element in the result slice.
	for i := 0; i < resultValue.Len(); i++ {
		resultElem := resultValue.Index(i)
		sourceElem := reflect.ValueOf(sourceSlice[i])

		// Check that the element is a pointer to a struct.
		if resultElem.Kind() != reflect.Ptr || resultElem.Elem().Kind() != reflect.Struct {
			t.Errorf("Element at index %d is not a struct pointer", i)
		}

		// Check that the element has the same type as the source element.
		if resultElem.Elem().Type() != sourceElem.Elem().Type() {
			t.Errorf("Element at index %d has a different type from the source", i)
		}

		// Check that the element's field values match the source element.
		if !reflect.DeepEqual(resultElem.Elem().Interface(), sourceElem.Elem().Interface()) {
			t.Errorf("Element at index %d does not match the source", i)
		}
	}
}

func TestCopySliceOfPointersWithIdentitySeparated(t *testing.T) {
	type PersonStruct struct {
		ID   int
		Name string
	}

	// Sample data
	sourceSlice := []*PersonStruct{
		{ID: 1, Name: "One"},
		{ID: 2, Name: "Two"},
		{ID: 3, Name: "Three"},
	}

	// Call the function
	result, err := CopySliceOfPointersWithIdentitySeparated(sourceSlice, cast.StructPointerArrayToInterfacePointerArray(sourceSlice))
	if err != nil {
		t.Fatalf("Unexpected error: %v", err)
	}

	// Check if the result is a slice
	resultValue := reflect.ValueOf(result)
	if resultValue.Kind() != reflect.Slice {
		t.Errorf("Expected result to be a slice, got %v", resultValue.Kind())
	}

	// Check if the length of the result is the same as the sourceSlice
	if resultValue.Len() != len(sourceSlice) {
		t.Errorf("Expected result length %d, got %d", len(sourceSlice), resultValue.Len())
	}

	// Check if the elements in the result have the same identity as the sourceSlice
	for i := 0; i < resultValue.Len(); i++ {
		resultElement := resultValue.Index(i).Interface().(*PersonStruct)
		sourceElement := sourceSlice[i]

		// Compare fields or use a custom equality check based on your requirements
		if !reflect.DeepEqual(resultElement, sourceElement) {
			t.Errorf("Expected element %v, got %v", sourceElement, resultElement)
		}
	}
}

func TestAreAllNumbers(t *testing.T) {
	tests := []struct {
		name     string
		input    []interface{}
		expected bool
	}{
		{"AllNumbers", []interface{}{1, 2, 3, 4}, true},
		{"MixedTypes", []interface{}{1, 2, "hello", 4}, false},
		{"EmptySlice", []interface{}{}, true}, // Empty slice is considered valid
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := AreAllNumbers(tt.input)
			if got != tt.expected {
				t.Errorf("AreAllNumbers(%v) = %v; want %v", tt.input, got, tt.expected)
			}
		})
	}
}

func TestStringJoin(t *testing.T) {
	tests := []struct {
		name          string
		inputArr      []interface{}
		encapsulation string
		expected      string
	}{
		{"JoinStrings", []interface{}{"hello", "world"}, "'", "'hello','world'"},
		{"JoinNumbers", []interface{}{1, 2, 3}, "", "1,2,3"},
		{"JoinMixedTypes", []interface{}{"hello", 2, "world"}, "\"", "\"hello\",\"2\",\"world\""},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := StringJoin(tt.inputArr, tt.encapsulation)
			if got != tt.expected {
				t.Errorf("StringJoin(%v, %q) = %q; want %q", tt.inputArr, tt.encapsulation, got, tt.expected)
			}
		})
	}
}

func TestUpdatePropertyValue(t *testing.T) {
	// Define a struct for testing
	type TestStruct struct {
		ID   int
		Name string
	}

	// Create an instance of TestStruct
	obj := &TestStruct{ID: 1, Name: "John"}

	// Define the property name and the new value
	propertyName := "ID"
	newValue := 2

	// Call the function to update the property
	err := UpdatePropertyValue(obj, propertyName, newValue)
	if err != nil {
		t.Errorf("UpdateIDProperty returned an error: %v", err)
	}

	// Check if the ID property was updated correctly
	if obj.ID != newValue {
		t.Errorf("ID property was not updated to the expected value. Expected: %d, Got: %d", newValue, obj.ID)
	}

	// Check if the Name property remains unchanged
	expectedName := "John"
	if obj.Name != expectedName {
		t.Errorf("Name property was unexpectedly changed. Expected: %s, Got: %s", expectedName, obj.Name)
	}

	// Test with an invalid property name
	invalidPropertyName := "Age"
	invalidValue := 30
	err = UpdatePropertyValue(obj, invalidPropertyName, invalidValue)
	if err == nil {
		t.Errorf("UpdateIDProperty did not return an error for an invalid property name")
	} else {
		// expectedErrorMessage := fmt.Sprintf("struct does not have an '%s' field", invalidPropertyName)
		if err.Error() != ErrPropertyNotFound.Error() {
			t.Errorf("UpdateIDProperty returned an unexpected error message. Expected: %s, Got: %s", ErrPropertyNotFound.Error(), err.Error())
		}
	}

	// Test with a newValue of a different type
	invalidNewValue := "Invalid"
	err = UpdatePropertyValue(obj, propertyName, invalidNewValue)
	if err == nil {
		t.Errorf("UpdateIDProperty did not return an error for an invalid newValue type")
	} else {
		// expectedErrorMessage := fmt.Sprintf("newValue must have the same type as the '%s' field", propertyName)
		if err.Error() != ErrPropertyTypeNotMatch.Error() {
			t.Errorf("UpdateIDProperty returned an unexpected error message. Expected: %s, Got: %s", ErrPropertyTypeNotMatch.Error(), err.Error())
		}
	}
}

func TestAreAllUUIDs(t *testing.T) {
	tests := []struct {
		name     string
		input    []interface{}
		expected bool
	}{
		{"AllUUIDs", []interface{}{uuid.New(), uuid.New(), uuid.New(), uuid.New()}, true},
		{"MixedTypes", []interface{}{1, 2, "hello", uuid.New()}, false},
		{"EmptySlice", []interface{}{}, true}, // Empty slice is considered valid
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := AreAllUUIDs(tt.input)
			if got != tt.expected {
				t.Errorf("AreAllUUIDs(%v) = %v; want %v", tt.input, got, tt.expected)
			}
		})
	}
}