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

package repositorytest

import (
	"context"
	"fmt"
	"log"
	"strings"
	"sync"
	"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/nosql"
)

var TEST_ID = uuid.MustParse("25ebc2e2-7fd2-47a0-bd2f-a8ec6e4d0163")

var sample *TestModel
var mutex sync.Mutex
var isDone bool
var keySpace string

func init() {
	keySpace = "example"
	isDone = false
	sample = &TestModel{
		ID:        TEST_ID,
		Text:      "text",
		CreatedAt: time.Now().UTC(),
		CreatedBy: uuid.Nil,
		UpdatedAt: time.Now().UTC(),
		UpdatedBy: uuid.Nil,
	}
}

func preSeeding() {
	mutex.Lock()
	if !isDone {
		// tableName := repository.GetTableName(sample)
		// query := fmt.Sprintf("INSERT INTO %s ?", tableName)
		// if err := db.Query(query, sample).Exec(); err != nil {
		// 	log.Fatalf("failed to inject data: %v", err)
		// }
		tableName := repository.GetTableName(sample)
		columns, values, err := nosql.GetPropertyNamesAndValues(sample)
		if err != nil {
			log.Fatalf("failed to inject data: %v", err)
		}
		paramString := ""
		for i := 0; i < len(values); i++ {
			paramString += "?,"
		}

		if len(paramString) > 0 {
			paramString = paramString[:len(paramString)-1]
		}

		query := fmt.Sprintf("INSERT INTO %s.%s (%s) VALUES (%s)", keySpace, tableName, strings.Join(columns, ","), paramString)
		if err = db.Query(query, values...).Exec(); err != nil {
			log.Fatalf("failed to inject data: %v", err)
		}
		isDone = true
	}
	mutex.Unlock()
}

func insert(data *TestModel) {
	tableName := repository.GetTableName(data)
	columns, values, err := nosql.GetPropertyNamesAndValues(data)
	if err != nil {
		log.Fatalf("failed to inject data: %v", err)
	}
	paramString := ""
	for i := 0; i < len(values); i++ {
		paramString += "?,"
	}

	if len(paramString) > 0 {
		paramString = paramString[:len(paramString)-1]
	}

	query := fmt.Sprintf("INSERT INTO %s.%s (%s) VALUES (%s)", keySpace, tableName, strings.Join(columns, ","), paramString)
	if err = db.Query(query, values...).Exec(); err != nil {
		log.Fatalf("failed to inject data: %v", err)
	}
}

// func removePreseeding() {
// 	mutex.Lock()
// 	if isDone {
// 		if err := db.Delete(sample).Error; err != nil {
// 			logrus.Debugf("failed to remove seed data: %v", err)
// 		}
// 		isDone = false
// 	}
// 	mutex.Unlock()
// }

func TestGenericRepository_FindAll(t *testing.T) {
	repo := nosql.NewRepository(db, keySpace)

	ctx := context.Background()
	params := map[string]interface{}{"text": "text"}
	conditionalOperations := []repository.ConditionalOperation{repository.EQUAL_WITH}
	page := 1
	limit := 10

	preSeeding()
	// defer removePreseeding()

	resultsRaw, err := repo.FindAll(ctx, params, conditionalOperations, nil, page, limit, []*TestModel{})
	if err != nil {
		t.Fatalf("Error in FindAll: %v", err)
	}

	/*
		alternative casting:
		results := []*TestModel{}
		cast.TransformObject(resultsRaw, &results)
	*/
	// results := resultsRaw.([]*TestModel)
	results := []*TestModel{}
	cast.TransformObject(resultsRaw, &results)
	if len(results) == 0 {
		t.Fatalf("Expected not 0 result, but got %d", len(results))
	}
}

func TestGenericRepository_FindAll_WithComplexQuery(t *testing.T) {
	repo := nosql.NewRepository(db, keySpace)
	ctx := context.Background()

	preSeeding()
	// // defer removePreseeding()

	testCases := []struct {
		name                  string
		params                map[string]interface{}
		conditionalOperations []repository.ConditionalOperation
		page                  int
		limit                 int
		expectedResultCount   int
		expectedError         error
	}{
		{
			name:                  "FindAll with IN Query",
			params:                map[string]interface{}{"id": []interface{}{TEST_ID}},
			conditionalOperations: []repository.ConditionalOperation{repository.IN},
			page:                  1,
			limit:                 10,
			expectedResultCount:   1,
			expectedError:         nil,
		},
		{
			name:                  "FindAll with ILIKE Query",
			params:                map[string]interface{}{"text": "ex"},
			conditionalOperations: []repository.ConditionalOperation{repository.ILIKE},
			page:                  1,
			limit:                 10,
			expectedResultCount:   0,
			expectedError:         repository.ErrNotImplement,
		},
	}

	for _, test := range testCases {
		t.Run(test.name, func(t *testing.T) {
			resultsRaw, err := repo.FindAll(ctx, test.params, test.conditionalOperations, nil, test.page, test.limit, []*TestModel{})
			if err != test.expectedError {
				t.Fatalf("Expected %v, but got %v", test.expectedError, err)
			}

			/*
				alternative casting:
				results := []*TestModel{}
				cast.TransformObject(resultsRaw, &results)
			*/
			// results := resultsRaw.([]*TestModel)
			results := []*TestModel{}
			cast.TransformObject(resultsRaw, &results)
			if len(results) != test.expectedResultCount {
				t.Fatalf("Expected %d result, but got %d", test.expectedResultCount, len(results))
			}
		})
	}
}

func TestGenericRepository_FindAll_WithRelationalOperation(t *testing.T) {
	repo := nosql.NewRepository(db, keySpace)

	ctx := context.Background()
	params := map[string]interface{}{
		"text": "text",
		"id":   TEST_ID.String(),
	}
	conditionalOperations := []repository.ConditionalOperation{repository.EQUAL_WITH, repository.EQUAL_WITH}
	relationalOperations := []repository.RelationalOperation{repository.AND}
	page := 1
	limit := 10

	preSeeding()
	// defer removePreseeding()

	resultsRaw, err := repo.FindAll(ctx, params, conditionalOperations, relationalOperations, page, limit, []*TestModel{})
	if err != nil {
		t.Fatalf("Error in FindAll: %v", err)
	}

	/*
		alternative casting:
		results := []*TestModel{}
		cast.TransformObject(resultsRaw, &results)
	*/
	// results := resultsRaw.([]*TestModel)
	results := []*TestModel{}
	cast.TransformObject(resultsRaw, &results)
	if len(results) != 1 {
		t.Fatalf("Expected 1 result, but got %d", len(results))
	}
}

func TestGenericRepository_FindOne(t *testing.T) {
	repo := nosql.NewRepository(db, keySpace)

	ctx := context.Background()
	key := "text"
	value := "unique text4"

	id, _ := uuid.NewRandom()
	data := &TestModel{
		ID:        id,
		Text:      "unique text4",
		CreatedAt: time.Now().UTC(),
		CreatedBy: uuid.Nil,
		UpdatedAt: time.Now().UTC(),
		UpdatedBy: uuid.Nil,
	}

	insert(data)

	result := &TestModel{}
	_, err := repo.FindOne(ctx, key, value, result)
	if err != nil {
		t.Fatalf("Error in FindOne: %v", err)
	}

	if result.ID != data.ID || result.Text != data.Text {
		t.Fatalf("Unexpected result: %+v", result)
	}
}

func TestGenericRepository_FindByID(t *testing.T) {
	repo := nosql.NewRepository(db, keySpace)

	id := uuid.New()
	data := sample
	data.ID = id
	data.Text = "test"

	insert(data)
	// defer removePreseeding()

	ctx := context.Background()
	result := &TestModel{}
	_, err := repo.FindByID(ctx, id, result)
	if err != nil {
		t.Fatalf("Error in FindByID: %v", err)
	}

	if result.ID != id || result.Text != sample.Text {
		t.Fatalf("Unexpected result: %+v", result)
	}
}

func TestGenericRepository_Insert(t *testing.T) {
	repo := nosql.NewRepository(db, keySpace)

	ctx := context.Background()
	id, _ := uuid.NewRandom()
	data := &TestModel{
		ID:        id,
		Text:      "test insert",
		CreatedAt: time.Now().UTC(),
		CreatedBy: uuid.Nil,
		UpdatedAt: time.Now().UTC(),
		UpdatedBy: uuid.Nil,
	}

	result, err := repo.Insert(ctx, data)
	if err != nil {
		t.Fatalf("Error in Insert: %v", err)
	}

	if result.(*TestModel) == nil {
		t.Fatalf("Unexpected result: %+v", result)
	}
}

func TestGenericRepository_Update(t *testing.T) {
	repo := nosql.NewRepository(db, keySpace)

	ctx := context.Background()

	preSeeding()
	// defer removePreseeding()

	data := sample
	data.Text = "updated text"

	result, err := repo.Update(ctx, data)
	if err != nil {
		t.Fatalf("Error in Update: %v", err)
	}

	if result.(*TestModel).ID != TEST_ID {
		t.Fatalf("Unexpected result: %+v", result)
	}
}

func TestGenericRepository_Update_DataDeleted_ErrNotFound(t *testing.T) {
	repo := nosql.NewRepository(db, keySpace)

	ctx := context.Background()

	data := sample
	data.ID = uuid.New()
	data.Text = "updated text"

	_, err := repo.Update(ctx, data)
	if err != repository.ErrNotFound {
		t.Fatalf("expected %v, got %v", repository.ErrNotFound, err)
	}
}

func TestGenericRepository_Delete(t *testing.T) {
	repo := nosql.NewRepository(db, keySpace)

	ctx := context.Background()

	id, _ := uuid.NewRandom()
	data := &TestModel{
		ID:        id,
		Text:      "test insert",
		CreatedAt: time.Now().UTC(),
		CreatedBy: uuid.Nil,
		UpdatedAt: time.Now().UTC(),
		UpdatedBy: uuid.Nil,
	}

	insert(data)

	_, err := repo.Delete(ctx, data)
	if err != nil {
		t.Fatalf("Error in Delete: %v", err)
	}
}

func TestGenericRepository_Upsert(t *testing.T) {
	repo := nosql.NewRepository(db, keySpace)

	ctx := context.Background()
	data := sample

	result, err := repo.Upsert(ctx, data)

	if result != nil {
		t.Errorf("expected %v, got %v", nil, result)
	}
	if err != repository.ErrNotImplement {
		t.Errorf("expected %v, got %v", repository.ErrNotImplement, err)
	}
}

func TestGenericRepository_BulkInsert(t *testing.T) {
	id, _ := uuid.NewRandom()
	secondId, _ := uuid.NewRandom()
	sample.ID = secondId
	data := []*TestModel{
		sample,
		&TestModel{
			ID:        id,
			Text:      "test bulk insert",
			CreatedAt: time.Now().UTC(),
			CreatedBy: uuid.Nil,
			UpdatedAt: time.Now().UTC(),
			UpdatedBy: uuid.Nil,
		},
	}

	repo := nosql.NewRepository(db, keySpace)

	ctx := context.Background()

	resultsRaw, err := repo.BulkInsert(ctx, data)

	if resultsRaw != nil {
		t.Errorf("expected %v, got %v", nil, resultsRaw)
	}
	if err != repository.ErrNotImplement {
		t.Errorf("expected %v, got %v", repository.ErrNotImplement, err)
	}
}

func TestGenericRepository_BulkUpsert(t *testing.T) {
	repo := nosql.NewRepository(db, keySpace)

	preSeeding()
	// defer removePreseeding()

	one := sample
	one.Text = "updated text"
	id, _ := uuid.NewRandom()
	data := []*TestModel{
		one,
		&TestModel{
			ID:        id,
			Text:      "test bulk insert",
			CreatedAt: time.Now().UTC(),
			CreatedBy: uuid.Nil,
			UpdatedAt: time.Now().UTC(),
			UpdatedBy: uuid.Nil,
		},
	}

	ctx := context.Background()

	resultsRaw, err := repo.BulkUpsert(ctx, data)

	if resultsRaw != nil {
		t.Errorf("expected %v, got %v", nil, resultsRaw)
	}
	if err != repository.ErrNotImplement {
		t.Errorf("expected %v, got %v", repository.ErrNotImplement, err)
	}
}

func TestGenericRepository_Query(t *testing.T) {
	repo := nosql.NewRepository(db, keySpace)

	ctx := context.Background()
	id, _ := uuid.NewRandom()
	params := []interface{}{
		"text",
		id.String(),
	}

	data := &TestModel{
		ID:        id,
		Text:      "text",
		CreatedAt: time.Now().UTC(),
		CreatedBy: uuid.Nil,
		UpdatedAt: time.Now().UTC(),
		UpdatedBy: uuid.Nil,
	}

	insert(data)

	result := []*TestModel{}
	resultsRaw, err := repo.Query(
		ctx,
		fmt.Sprintf(`SELECT * FROM %s.%s WHERE text = ? AND id = ? ALLOW FILTERING;`, keySpace, repository.GetTableName(&TestModel{})),
		params,
		result,
	)
	if err != nil {
		t.Fatalf("Error in Query: %v", err)
	}

	/*
		alternative casting:
		results := []*TestModel{}
		cast.TransformObject(resultsRaw, &results)
	*/
	// results := resultsRaw.([]*TestModel)

	results := []*TestModel{}
	cast.TransformObject(resultsRaw, &results)
	if len(results) != 1 {
		t.Fatalf("Expected 1 result, but got %d", len(results))
	}
}

func TestGenericRepository_Query_DELETE(t *testing.T) {
	repo := nosql.NewRepository(db, keySpace)

	ctx := context.Background()
	id, _ := uuid.NewRandom()
	params := []interface{}{
		time.Now().UTC(),
	}

	data := &TestModel{
		ID:        id,
		Text:      "test insert",
		CreatedAt: time.Now().UTC(),
		CreatedBy: uuid.Nil,
		UpdatedAt: time.Now().UTC(),
		UpdatedBy: uuid.Nil,
	}

	insert(data)

	result := []*TestModel{}
	if _, err := repo.Query(
		ctx,
		fmt.Sprintf(`DELETE FROM %s WHERE createdat < ? ALLOW FILTERING;`, repository.GetTableName(&TestModel{})),
		params,
		result,
	); err != nil {
		t.Fatalf("Error in Query: %v", err)
	}

	if _, err := repo.FindByID(ctx, id, result); err != nil && err != repository.ErrNotFound {
		t.Fatalf("expected %v, got %v", repository.ErrNotFound, err)
	}
}