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

package repositorytest

import (
	"context"
	"fmt"
	"sync"
	"testing"
	"time"

	"github.com/google/uuid"
	"github.com/sirupsen/logrus"

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

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

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

func init() {
	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 {
		if err := db.Create(sample).Error; err != nil {
			logrus.Debugf("failed to inject data: %v", err)
		}
		isDone = true
	}
	mutex.Unlock()
}

// 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 := sql.NewRepository(db)

	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)
	if len(results) != 1 {
		t.Fatalf("Expected 1 result, but got %d", len(results))
	}
}

func TestGenericRepository_FindAll_WithComplexQuery(t *testing.T) {
	repo := sql.NewRepository(db)
	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:   1,
			expectedError:         nil,
		},
	}

	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)
			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 := sql.NewRepository(db)

	ctx := context.Background()
	params := map[string]interface{}{
		"text": "text",
		`"id"`: TEST_ID,
	}
	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)
	if len(results) != 1 {
		t.Fatalf("Expected 1 result, but got %d", len(results))
	}
}

func TestGenericRepository_FindOne(t *testing.T) {
	repo := sql.NewRepository(db)

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

	preSeeding()
	// defer removePreseeding()

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

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

func TestGenericRepository_FindByID(t *testing.T) {
	repo := sql.NewRepository(db)

	id := TEST_ID

	preSeeding()
	// 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 := sql.NewRepository(db)

	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 := sql.NewRepository(db)

	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 := sql.NewRepository(db)

	ctx := context.Background()

	now := time.Now().UTC()
	data := sample
	data.DeletedAt = &now
	if err := db.Create(sample).Error; err != nil {
		logrus.Debugf("failed to inject deleted data: %v", err)
	}

	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 := sql.NewRepository(db)

	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,
	}

	if err := db.Create(data).Error; err != nil {
		logrus.Debugf("failed to inject data: %v", err)
	}

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

func TestGenericRepository_Upsert(t *testing.T) {
	repo := sql.NewRepository(db)

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

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

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

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 := sql.NewRepository(db)

	ctx := context.Background()

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

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

func TestGenericRepository_BulkUpsert(t *testing.T) {
	repo := sql.NewRepository(db)

	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 err != nil {
		t.Fatalf("Error in BulkUpsert: %v", err)
	}

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

func TestGenericRepository_Query(t *testing.T) {
	repo := sql.NewRepository(db)

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

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

	if err := db.Create(data).Error; err != nil {
		logrus.Debugf("failed to inject data: %v", err)
	}

	result := []*TestModel{}
	resultsRaw, err := repo.Query(
		ctx,
		fmt.Sprintf(`
			SELECT 
				*
			FROM
				%s
			WHERE
				text = ? AND id = ?
		`, 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)
	if len(results) != 1 {
		t.Fatalf("Expected 1 result, but got %d", len(results))
	}
}

func TestGenericRepository_Query_DELETE(t *testing.T) {
	repo := sql.NewRepository(db)

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

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

	if err := db.Create(data).Error; err != nil {
		logrus.Debugf("failed to inject data: %v", err)
	}

	result := []*TestModel{}
	if _, err := repo.Query(
		ctx,
		fmt.Sprintf(`
			DELETE FROM
				%s
			WHERE
				created_at < ?
		`, 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)
	}
}