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

package memcachedtest

import (
	"context"
	"fmt"
	"reflect"
	"testing"
	"time"

	"github.com/google/uuid"

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

type TestModel struct {
	ID   string
	Name string
	Age  int
}

var sample []*TestModel

func init() {
	sample = append(sample, &TestModel{
		ID:   "1",
		Name: "Alice",
		Age:  30,
	})
	sample = append(sample, &TestModel{
		ID:   "2",
		Name: "Bob",
		Age:  25,
	})
	sample = append(sample, &TestModel{
		ID:   "3",
		Name: "Charlie",
		Age:  35,
	})
}

func preSeeding(key string) {
	bytes, _ := cast.ToBytes(sample)
	// Insert test data into Redis
	redisClient.Set(
		context.Background(),
		key,
		bytes,
		15*time.Minute,
	)

	for _, s := range sample {
		bytes, _ := cast.ToBytes(s)
		// Insert test data into Redis
		redisClient.Set(
			context.Background(),
			fmt.Sprintf("%s%s%s", key, memcached.CONJUNCTION, s.ID),
			bytes,
			15*time.Minute,
		)
	}
}

func removePreseeding(key string) {
	redisClient.Del(
		context.Background(),
		key,
	)

	for _, s := range sample {
		redisClient.Del(
			context.Background(),
			fmt.Sprintf("%s%s%s", key, memcached.CONJUNCTION, s.ID),
		)
	}
}

func TestGenericRepository_FindAll(t *testing.T) {
	// Create a GenericRepository instance
	key := "testKey"
	repo := memcached.NewRepository(redisClient, key, 0, []*memcached.KeyIdentifier{})

	preSeeding(key)

	params := map[string]interface{}{"NAME": "Alice"}
	conditionalOperations := []repository.ConditionalOperation{repository.EQUAL_WITH}
	relationalOperations := []repository.RelationalOperation{}
	page := 0
	limit := 10
	result := []*TestModel{}

	// Test FindAll
	foundData, err := repo.FindAll(context.Background(), params, conditionalOperations, relationalOperations, page, limit, result)
	if err != nil {
		t.Errorf("FindAll failed: %v", err)
	}

	// Check if the data was found
	if len(foundData.([]interface{})) != 1 {
		t.Errorf("FindAll did not return the expected number of results")
	}
}

func TestGenericRepository_Insert(t *testing.T) {
	// Create a GenericRepository instance
	key := "testKey"
	repo := memcached.NewRepository(redisClient, key, 0, []*memcached.KeyIdentifier{})

	preSeeding(key)

	data := &TestModel{
		ID:   "4",
		Name: "David",
		Age:  28,
	}

	// Test Insert
	_, err := repo.Insert(context.Background(), data)
	if err != nil {
		t.Errorf("Insert failed: %v", err)
	}

	// Check if the data was inserted into Redis
	resultRaw, err := redisClient.Get(context.Background(), key).Result()
	if err != nil {
		t.Errorf("Insert did not insert data into Redis")
	}

	result := []*TestModel{}
	cast.FromBytes([]byte(resultRaw), &result)

	if !reflect.DeepEqual(data, result[0]) {
		t.Errorf("should got %v, but got %v", data, result[3])
	}
}

func TestGenericRepository_Update(t *testing.T) {
	key := "testKey"
	// Create a GenericRepository instance
	repo := memcached.NewRepository(redisClient, key, 0, []*memcached.KeyIdentifier{})

	preSeeding(key)

	data := &TestModel{
		ID:   "2",
		Name: "Updated Bob",
		Age:  26,
	}

	// Test Update
	_, err := repo.Update(context.Background(), data)
	if err != nil {
		t.Errorf("Update failed: %v", err)
	}

	// Check if the data was updated in Redis
	resultRaw, err := redisClient.Get(context.Background(), key).Result()
	if err != nil {
		t.Errorf("update did not update data into Redis")
	}

	result := []*TestModel{}
	cast.FromBytes([]byte(resultRaw), &result)

	if !reflect.DeepEqual(data, result[1]) {
		t.Errorf("should got %v, but got %v", data, result)
	}
}

func TestGenericRepository_Delete(t *testing.T) {
	// Create a GenericRepository instance
	key := "testKey"
	repo := memcached.NewRepository(redisClient, key, 15*time.Minute, []*memcached.KeyIdentifier{})

	preSeeding(key)

	data := &TestModel{
		ID:   "2",
		Name: "Bob",
		Age:  25,
	}

	// Test Delete
	_, err := repo.Delete(context.Background(), data)
	if err != nil {
		t.Errorf("Delete failed: %v", err)
	}

	// Check if the data was deleted from Redis
	resultRaw, err := redisClient.Get(context.Background(), key).Result()
	if err != nil {
		t.Errorf("update did not update data into Redis")
	}

	result := []*TestModel{}
	cast.FromBytes([]byte(resultRaw), &result)

	if memcached.AreStructsEqual(data, result[1]) {
		t.Errorf("should got %v, but got %v", data, result[1])
	}
}

func TestGenericRepository_Upsert(t *testing.T) {
	// Create a GenericRepository instance
	key := "testKey"
	repo := memcached.NewRepository(redisClient, key, 15*time.Minute, []*memcached.KeyIdentifier{})

	preSeeding(key)

	data := &TestModel{
		ID:   "4",
		Name: "David",
		Age:  28,
	}

	// Test Upsert
	_, err := repo.Upsert(context.Background(), data)
	if err != nil {
		t.Errorf("Upsert failed: %v", err)
	}

	// Check if the data was upserted in Redis
	resultRaw, err := redisClient.Get(context.Background(), key).Result()
	if err != nil {
		t.Errorf("update did not update data into Redis")
	}

	result := []*TestModel{}
	cast.FromBytes([]byte(resultRaw), &result)

	if !memcached.AreStructsEqual(data, result[3]) {
		t.Errorf("should got %v, but got %v", data, result)
	}
}

func TestGenericRepository_BulkInsert(t *testing.T) {
	// Create a GenericRepository instance
	key := "testKey"
	repo := memcached.NewRepository(redisClient, key, 0, []*memcached.KeyIdentifier{})

	// Test BulkInsert
	_, err := repo.BulkInsert(context.Background(), sample)
	if err != nil {
		t.Errorf("BulkInsert failed: %v", err)
	}

	// Check if the data was bulk inserted into Redis
	resultRaw, err := redisClient.Get(context.Background(), key).Result()
	if err != nil {
		t.Errorf("update did not update data into Redis")
	}

	result := []*TestModel{}
	cast.FromBytes([]byte(resultRaw), &result)

	if len(sample) != len(result) {
		t.Errorf("should got %v, but got %v", sample, result)
	}
}

func TestGenericRepository_BulkUpsert(t *testing.T) {
	// Create a GenericRepository instance
	key := "testKey"
	repo := memcached.NewRepository(redisClient, key, 0, []*memcached.KeyIdentifier{})

	// Test BulkUpsert
	_, err := repo.BulkUpsert(context.Background(), sample)
	if err != nil {
		t.Errorf("BulkUpsert failed: %v", err)
	}

	// Check if the data was bulk upserted in Redis
	resultRaw, err := redisClient.Get(context.Background(), key).Result()
	if err != nil {
		t.Errorf("update did not update data into Redis")
	}

	result := []*TestModel{}
	cast.FromBytes([]byte(resultRaw), &result)

	if len(sample) != len(result) {
		t.Errorf("should got %v, but got %v", sample, result)
	}
}

func TestGenericRepository_FindOne(t *testing.T) {
	// Create a GenericRepository instance
	key := "testKey"

	repo := memcached.NewRepository(redisClient, key, 15*time.Minute, []*memcached.KeyIdentifier{})

	preSeeding(key)

	keyParam := "NAME"
	value := "Alice"
	result := &TestModel{}

	// Test FindOne
	foundData, err := repo.FindOne(context.Background(), keyParam, value, &result)
	if err != nil {
		t.Errorf("FindOne failed: %v", err)
	}

	// Check if the data was found
	if foundData == nil {
		t.Errorf("FindOne did not find the expected data")
	}

	expected := &TestModel{
		ID:   "1",
		Name: "Alice",
		Age:  30,
	}
	cast.TransformObject(foundData, &result)
	if !memcached.AreStructsEqual(expected, result) {
		t.Errorf("expected %v, got %v", expected, result)
	}
}

func TestGenericRepository_FindByID(t *testing.T) {
	var TEST_ID = uuid.MustParse("25ebc2e2-7fd2-47a0-bd2f-a8ec6e4d0163")

	// Create a GenericRepository instance
	key := "testKey"
	repo := memcached.NewRepository(redisClient, key, 15*time.Minute, []*memcached.KeyIdentifier{})

	preSeeding(key)

	sample = append(sample, &TestModel{
		ID:   TEST_ID.String(),
		Name: "Test",
		Age:  1,
	})

	bytes, _ := cast.ToBytes(sample)
	// Insert test data into Redis
	redisClient.Set(
		context.Background(),
		fmt.Sprintf("%s%s%s", key, memcached.CONJUNCTION, TEST_ID.String()),
		bytes,
		15*time.Minute,
	)

	result := &TestModel{}

	// Test FindByID
	foundData, err := repo.FindByID(context.Background(), TEST_ID, &result)
	if err != nil {
		t.Errorf("FindByID failed: %v", err)
	}

	// Check if the data was found
	if foundData == nil {
		t.Errorf("FindByID did not find the expected data")
	}
}

func TestGenericRepository_Query(t *testing.T) {
	// Create a GenericRepository instance
	key := "testKey"
	repo := memcached.NewRepository(redisClient, key, 0, []*memcached.KeyIdentifier{})

	query := "SELECT * FROM testKey WHERE Name = ?"
	params := []interface{}{"Alice"}
	result := []struct {
		ID   string
		Name string
		Age  int
	}{}

	// Test Query
	_, err := repo.Query(context.Background(), query, params, &result)
	if err != repository.ErrNotImplement {
		t.Errorf("Query did not return the expected error")
	}
}

func TestNewRepository(t *testing.T) {
	key := "testKey"
	expirationDuration := time.Duration(0)
	keyIdentifiers := []*memcached.KeyIdentifier{}
	repo := memcached.NewRepository(redisClient, key, expirationDuration, keyIdentifiers)

	// Check if the repository was created successfully
	if repo == nil {
		t.Errorf("NewRepository did not create a repository")
	}
}

func TestNewMutableRepository(t *testing.T) {
	key := "testKey"
	expirationDuration := time.Duration(0)
	keyIdentifiers := []*memcached.KeyIdentifier{}
	repo := memcached.NewMutableRepository(redisClient, key, expirationDuration, keyIdentifiers)

	// Check if the repository was created successfully
	if repo == nil {
		t.Errorf("NewMutableRepository did not create a repository")
	}
}

func TestNewImmutableRepository(t *testing.T) {
	key := "testKey"
	expirationDuration := time.Duration(0)
	keyIdentifiers := []*memcached.KeyIdentifier{}
	repo := memcached.NewImmutableRepository(redisClient, key, expirationDuration, keyIdentifiers)

	// Check if the repository was created successfully
	if repo == nil {
		t.Errorf("NewImmutableRepository did not create a repository")
	}
}