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

package memcached

import (
	"reflect"
	"strings"
	"testing"

	"github.com/stretchr/testify/assert"

	"github.com/angryronald/go-kit/generic/repository"
)

func TestCheckRelationalOperation(t *testing.T) {
	tests := []struct {
		prev      bool
		current   bool
		operation repository.RelationalOperation
		expected  bool
		expectErr error
	}{
		{true, true, repository.AND, true, nil},
		{true, false, repository.AND, false, nil},
		{true, true, repository.OR, true, nil},
		{false, false, repository.OR, false, nil},
		{true, true, repository.RelationalOperation("!"), false, repository.ErrNotImplement},
	}

	for _, test := range tests {
		result, err := checkRelationalOperation(test.prev, test.current, test.operation)

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

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

func TestCheckConditionalOperation(t *testing.T) {
	tests := []struct {
		expected       interface{}
		actual         interface{}
		operation      repository.ConditionalOperation
		expectedResult bool
		expectErr      error
	}{
		{"hello", "world", repository.EQUAL_WITH, false, nil},
		{42, 43, repository.GREATER_THAN, true, nil},
		{"prefix%", "prefixsum", repository.LIKE, true, nil},
		{"%suffix", "thereisasuffix", repository.LIKE, true, nil},
		{"%substring%", "thisissubstringinthemiddle", repository.LIKE, true, nil},
		{"%substring", "thisissub", repository.LIKE, false, nil},
		{"abc", nil, repository.IS, false, repository.ErrNotImplement},
		{"abc", nil, repository.IS_NOT, false, repository.ErrNotImplement},
		{"abc", nil, repository.IN, false, repository.ErrNotImplement},
	}

	for _, test := range tests {
		result, err := checkConditionalOperation(test.expected, test.actual, test.operation)

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

		if result != test.expectedResult {
			t.Errorf("Expected result %v, but got %v", test.expectedResult, result)
		}
	}
}

func TestExtractObjectAndCheckConditions(t *testing.T) {
	type TestStruct struct {
		Field1 string
		Field2 int
	}

	params := map[string]interface{}{
		"FIELD1": "hello",
		"Field2": 42,
	}

	tests := []struct {
		object         interface{}
		conditionalOps []repository.ConditionalOperation
		relationalOps  []repository.RelationalOperation
		expectedResult bool
		expectErr      bool
	}{
		{TestStruct{"hello", 43}, []repository.ConditionalOperation{repository.EQUAL_WITH, repository.GREATER_THAN}, []repository.RelationalOperation{repository.AND}, true, false},
		{TestStruct{"world", 23}, []repository.ConditionalOperation{repository.EQUAL_WITH, repository.GREATER_THAN}, []repository.RelationalOperation{repository.AND}, false, false},
	}

	for _, test := range tests {
		result, err := extractObjectAndCheckConditions(test.object, params, test.conditionalOps, test.relationalOps)

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

		if result != test.expectedResult {
			t.Errorf("Expected result %v, but got %v", test.expectedResult, result)
		}
	}
}

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

// 	type Address struct {
// 		Street  string
// 		City    string
// 		ZipCode string
// 	}

// 	// Create a slice of struct pointers for the Person struct.
// 	personSlice := CreateStructPointerSlice(Person{}, 3)

// 	// Check if the returned value is a slice of pointers to the correct struct type.
// 	if reflect.TypeOf(personSlice).Kind() != reflect.Slice {
// 		t.Errorf("Expected a slice, got %v", reflect.TypeOf(personSlice))
// 	}

// 	elemType := reflect.TypeOf(personSlice).Elem()
// 	if elemType.Kind() != reflect.Ptr || elemType.Elem() != reflect.TypeOf(Person{}) {
// 		t.Errorf("Expected a slice of pointers to Person, got %v", elemType)
// 	}

// 	// Access and modify elements in the slice.
// 	// Note that you need to use reflection to set field values.
// 	for i := 0; i < 3; i++ {
// 		personPtr := personSlice.([]*Person)[i]
// 		personPtr.Name = fmt.Sprintf("Person%d", i+1)
// 		personPtr.Age = 30 + i
// 	}

// 	// Check if the modifications were successful.
// 	for i, personPtr := range personSlice.([]*Person) {
// 		expectedName := fmt.Sprintf("Person%d", i+1)
// 		expectedAge := 30 + i

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

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

// 	// Create a slice of struct pointers for the Address struct.
// 	addressSlice := CreateStructPointerSlice(Address{}, 2)

// 	// Check if the returned value is a slice of pointers to the correct struct type.
// 	if reflect.TypeOf(addressSlice).Kind() != reflect.Slice {
// 		t.Errorf("Expected a slice, got %v", reflect.TypeOf(addressSlice))
// 	}

// 	elemType = reflect.TypeOf(addressSlice).Elem()
// 	if elemType.Kind() != reflect.Ptr || elemType.Elem() != reflect.TypeOf(Address{}) {
// 		t.Errorf("Expected a slice of pointers to Address, got %v", elemType)
// 	}
// }

func TestCreateStructPointerSlice(t *testing.T) {
	type Person struct {
		Name  string
		Age   int
		City  string
		Email string
	}

	// Create a sample struct object.
	originalStruct := Person{
		Name:  "John",
		Age:   30,
		City:  "New York",
		Email: "john@example.com",
	}

	// Create a slice of pointers to the struct.
	result := CreateStructPointerSlice(originalStruct, 3)

	// Check the type of the result.
	resultType := reflect.TypeOf(result)

	// Ensure that the result is a slice.
	if resultType.Kind() != reflect.Slice {
		t.Errorf("Expected a slice, got %v", resultType.Kind())
	}

	// Check the length of the slice.
	sliceValue := reflect.ValueOf(result)
	if sliceValue.Len() != 3 {
		t.Errorf("Expected slice length of 3, got %v", sliceValue.Len())
	}

	// Check that elements in the slice are pointers to the correct struct type.
	for i := 0; i < sliceValue.Len(); i++ {
		elem := sliceValue.Index(i).Interface()
		elemType := reflect.TypeOf(elem)

		if elemType.Kind() != reflect.Ptr {
			t.Errorf("Expected pointer to struct, got %v", elemType.Kind())
		}

		if elemType.Elem() != reflect.TypeOf(originalStruct) {
			t.Errorf("Expected pointer to %v, got pointer to %v", reflect.TypeOf(originalStruct), elemType.Elem())
		}
	}
}

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

	// Create an instance of the sample struct.
	inputStruct := TestStruct{
		Name: "Alice",
		Age:  30,
	}

	// Call the function to create a new struct object.
	newObject := CreateNewStructObject(inputStruct)

	// Check if the new object is of the same type as the input struct.
	if reflect.TypeOf(newObject) != reflect.TypeOf(inputStruct) {
		t.Errorf("Expected object of type %T, got %T", inputStruct, newObject)
	}

	// If you expect specific default values, you can check them here.
	// For example, check if Age is 30.
	if newObj, ok := newObject.(TestStruct); ok {
		if newObj.Age != 30 {
			t.Errorf("Expected Age to be %d, got %d", inputStruct.Age, newObj.Age)
		}
	} else {
		t.Errorf("Failed to convert newObject to TestStruct")
	}
}

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

	// Create an instance of the sample struct.
	inputStruct := &TestStruct{
		Name: "Alice",
		Age:  30,
	}

	// Call the function to create a new struct object.
	newObject := CreateNewStructObject(inputStruct)

	// Check if the new object is of the same type as the input struct.
	if reflect.TypeOf(newObject) != reflect.TypeOf(inputStruct) {
		t.Errorf("Expected object of type %T, got %T", inputStruct, newObject)
	}

	// If you expect specific default values, you can check them here.
	// For example, check if Age is 30.
	if newObj, ok := newObject.(*TestStruct); ok {
		if newObj.Age != 30 {
			t.Errorf("Expected Age to be %d, got %d", inputStruct.Age, newObj.Age)
		}
	} else {
		t.Errorf("Failed to convert newObject to TestStruct")
	}
}

func TestFindItemByID(t *testing.T) {
	// Create a sample collection
	type TestStruct struct {
		ID   string
		Name string
	}

	collection := []interface{}{
		&TestStruct{ID: "1", Name: "Item 1"},
		&TestStruct{ID: "2", Name: "Item 2"},
		&TestStruct{ID: "3", Name: "Item 3"},
	}

	// Test case 1: Item found
	index, err := findItemByID(collection, &TestStruct{ID: "2"})
	assert.NoError(t, err)
	assert.Equal(t, 1, index)

	// Test case 2: Item not found
	index, err = findItemByID(collection, &TestStruct{ID: "4"})
	assert.Error(t, err)
	assert.Equal(t, -1, index)
}

func TestUpdateCollection(t *testing.T) {
	// Create a sample collection
	type TestStruct struct {
		ID   string
		Name string
	}

	collection := []interface{}{
		&TestStruct{ID: "1", Name: "Item 1"},
		&TestStruct{ID: "2", Name: "Item 2"},
		&TestStruct{ID: "3", Name: "Item 3"},
	}

	// Update an item
	newItem := &TestStruct{ID: "2", Name: "Updated Item 2"}
	updatedCollection, err := UpdateCollection(collection, newItem)
	assert.NoError(t, err)

	// Verify that the item was updated
	assert.Equal(t, newItem, updatedCollection[1])
}

func TestDeleteCollection(t *testing.T) {
	// Create a sample collection
	type TestStruct struct {
		ID   string
		Name string
	}

	collection := []interface{}{
		&TestStruct{ID: "1", Name: "Item 1"},
		&TestStruct{ID: "2", Name: "Item 2"},
		&TestStruct{ID: "3", Name: "Item 3"},
	}

	// Delete an item
	itemToDelete := &TestStruct{ID: "2"}
	updatedCollection, err := DeleteCollection(collection, itemToDelete)
	assert.NoError(t, err)

	// Verify that the item was deleted
	for _, item := range updatedCollection {
		assert.NotEqual(t, itemToDelete, item)
	}
}

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

	type Employee struct {
		Name string
		Age  int
	}

	tests := []struct {
		name     string
		struct1  interface{}
		struct2  interface{}
		expected bool
	}{
		{
			name:     "EqualStructs",
			struct1:  Person{Name: "Alice", Age: 30},
			struct2:  Person{Name: "Alice", Age: 30},
			expected: true,
		},
		{
			name:     "NotEqualStructs",
			struct1:  Person{Name: "Alice", Age: 30},
			struct2:  Person{Name: "Bob", Age: 25},
			expected: false,
		},
		{
			name:     "DifferentStructTypes",
			struct1:  Person{Name: "Alice", Age: 30},
			struct2:  Employee{Name: "Alice", Age: 30},
			expected: false,
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			result := AreStructsEqual(test.struct1, test.struct2)
			if result != test.expected {
				t.Errorf("Expected AreStructsEqual to return %v, but got %v", test.expected, result)
			}
		})
	}
}

func TestGetPropertyNameToUpperCaseMapping(t *testing.T) {
	type User struct {
		FirstName string
		LastName  string
		Email     string
	}

	user := User{}
	mapping, err := GetPropertyNameToUpperCaseMapping(user)
	if err != nil {
		t.Errorf("Expected no error, but got: %v", err)
	}

	expectedMapping := map[string]string{
		"FirstName": "FIRSTNAME",
		"LastName":  "LASTNAME",
		"Email":     "EMAIL",
	}

	if !reflect.DeepEqual(mapping, expectedMapping) {
		t.Errorf("Mapping not as expected. Got: %v, Expected: %v", mapping, expectedMapping)
	}
}

func TestGetPropertyNameToUpperCaseMappingWithNonStruct(t *testing.T) {
	nonStruct := "This is not a struct"
	_, err := GetPropertyNameToUpperCaseMapping(nonStruct)
	if err == nil {
		t.Error("Expected an error, but got none")
	} else if !strings.Contains(err.Error(), "input must be a struct") {
		t.Errorf("Expected error message containing 'input must be a struct', but got: %v", err)
	}
}

func TestGetPropertyNameToUpperCaseMappingWithEmptyStruct(t *testing.T) {
	emptyStruct := struct{}{}
	_, err := GetPropertyNameToUpperCaseMapping(emptyStruct)
	if err != nil {
		t.Errorf("Expected no error, but got: %v", err)
	}
}