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

package repositorytest

import (
	"context"
	"fmt"
	"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 immutableSample *ImmutableTestModel

func init() {
	isDone = false
	immutableSample = &ImmutableTestModel{
		ID:        TEST_ID,
		Text:      "text",
		CreatedAt: time.Now().UTC(),
		CreatedBy: uuid.Nil,
	}
}

func preSeedingImmutable() {
	mutex.Lock()
	if !isDone {
		if err := db.Create(immutableSample).Error; err != nil {
			logrus.Debugf("failed to inject data: %v", err)
		}
		isDone = true
	}
	mutex.Unlock()
}

func TestImmutableGenericRepository_FindAll(t *testing.T) {
	repo := sql.NewImmutableRepository(db)

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

	preSeedingImmutable()
	// defer removePreseeding()

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

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

func TestImmutableGenericRepository_FindAll_WithRelationalOperation(t *testing.T) {
	repo := sql.NewImmutableRepository(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

	preSeedingImmutable()
	// defer removePreseeding()

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

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

func TestImmutableGenericRepository_FindOne(t *testing.T) {
	repo := sql.NewImmutableRepository(db)

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

	preSeedingImmutable()
	// defer removePreseeding()

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

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

func TestImmutableGenericRepository_FindByID(t *testing.T) {
	repo := sql.NewImmutableRepository(db)

	id := TEST_ID

	preSeedingImmutable()
	// defer removePreseeding()

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

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

func TestImmutableGenericRepository_Insert(t *testing.T) {
	repo := sql.NewImmutableRepository(db)

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

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

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

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

	repo := sql.NewImmutableRepository(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.([]*ImmutableTestModel)
	if len(results) != 2 {
		t.Fatalf("Expected 2 results, but got %d", len(results))
	}
}

func TestImmutableGenericRepository_Query(t *testing.T) {
	repo := sql.NewImmutableRepository(db)

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

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

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

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

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