From c933b2ad63b8bcde1bc03d03124ed074fee603a5 Mon Sep 17 00:00:00 2001 From: SoXX Date: Mon, 14 Oct 2024 13:05:22 +0200 Subject: [PATCH] feat(pool): added pool creation - added basic CRUD for Pools --- pkg/database/pool.go | 163 +++++++++++++++++ pkg/database/pool_test.go | 369 ++++++++++++++++++++++++++++++++++++++ pkg/error/validation.go | 3 + 3 files changed, 535 insertions(+) create mode 100644 pkg/database/pool.go create mode 100644 pkg/database/pool_test.go diff --git a/pkg/database/pool.go b/pkg/database/pool.go new file mode 100644 index 0000000..4e4947d --- /dev/null +++ b/pkg/database/pool.go @@ -0,0 +1,163 @@ +package database + +import ( + "context" + "errors" + + "git.anthrove.art/Anthrove/otter-space-sdk/v4/internal/utils" + otterError "git.anthrove.art/Anthrove/otter-space-sdk/v4/pkg/error" + "git.anthrove.art/Anthrove/otter-space-sdk/v4/pkg/models" + log "github.com/sirupsen/logrus" + "go.opentelemetry.io/otel/attribute" + "gorm.io/gorm" +) + +func CreatePool(ctx context.Context, pool models.Pool) (models.Pool, error) { + ctx, span, localLogger := utils.SetupTracing(ctx, tracer, "CreatePool") + defer span.End() + + localLogger = localLogger.WithFields(log.Fields{ + "pool_id": pool.ID, + }) + + span.SetAttributes( + attribute.String("pool_id", string(pool.ID)), + ) + + utils.HandleEvent(span, localLogger, "Starting pool creation") + + if client == nil { + return models.Pool{}, utils.HandleError(ctx, span, localLogger, &otterError.Database{Reason: otterError.DatabaseIsNotConnected}) + } + + result := client.WithContext(ctx).Create(&pool) + if result.Error != nil { + if errors.Is(result.Error, gorm.ErrDuplicatedKey) { + return models.Pool{}, utils.HandleError(ctx, span, localLogger, &otterError.Database{Reason: otterError.DuplicateKey}) + } + return models.Pool{}, utils.HandleError(ctx, span, localLogger, result.Error) + } + + utils.HandleEvent(span, localLogger, "pool created successfully") + return pool, nil +} + +func GetPoolByID(ctx context.Context, id models.PoolID) (models.Pool, error) { + ctx, span, localLogger := utils.SetupTracing(ctx, tracer, "GetPool") + defer span.End() + + localLogger = localLogger.WithFields(log.Fields{ + "pool_id": id, + }) + + span.SetAttributes( + attribute.String("pool_id", string(id)), + ) + + utils.HandleEvent(span, localLogger, "Starting get pool by ID") + + var pool models.Pool + + if client == nil { + return models.Pool{}, utils.HandleError(ctx, span, localLogger, &otterError.Database{Reason: otterError.DatabaseIsNotConnected}) + } + + if len(id) == 0 { + return models.Pool{}, utils.HandleError(ctx, span, localLogger, &otterError.EntityValidationFailed{Reason: otterError.PoolIDIsEmpty}) + } + + result := client.WithContext(ctx).First(&pool, "id = ?", id) + if result.Error != nil { + if errors.Is(result.Error, gorm.ErrRecordNotFound) { + return models.Pool{}, utils.HandleError(ctx, span, localLogger, &otterError.Database{Reason: otterError.NoDataFound}) + } + return models.Pool{}, utils.HandleError(ctx, span, localLogger, result.Error) + } + + utils.HandleEvent(span, localLogger, "pool retrieved successfully") + return pool, nil +} + +// UpdatePool updates the pool information in the database. +// Only supports changing the Name and the Category of the Pool +func UpdatePool(ctx context.Context, pool models.Pool) error { + ctx, span, localLogger := utils.SetupTracing(ctx, tracer, "UpdatePool") + defer span.End() + + localLogger = localLogger.WithFields(log.Fields{ + "pool_id": pool.ID, + }) + + span.SetAttributes( + attribute.String("pool_id", string(pool.ID)), + ) + + utils.HandleEvent(span, localLogger, "Starting post update") + + if client == nil { + return utils.HandleError(ctx, span, localLogger, &otterError.Database{Reason: otterError.DatabaseIsNotConnected}) + } + + if len(pool.ID) == 0 { + return utils.HandleError(ctx, span, localLogger, &otterError.EntityValidationFailed{Reason: otterError.PoolIDIsEmpty}) + } + + updatePost := models.Pool{ + BaseModel: models.BaseModel[models.PoolID]{ + ID: pool.ID, + }, + Name: pool.Name, + Category: pool.Category, + } + + result := client.WithContext(ctx).Model(&updatePost).Update("deleted_at", gorm.DeletedAt{}) + if result.Error != nil { + if errors.Is(result.Error, gorm.ErrRecordNotFound) { + return utils.HandleError(ctx, span, localLogger, &otterError.Database{Reason: otterError.NoDataFound}) + } + return utils.HandleError(ctx, span, localLogger, result.Error) + } + + utils.HandleEvent(span, localLogger, "pool updated successfully") + return nil +} + +func DeletePool(ctx context.Context, id models.PoolID) error { + ctx, span, localLogger := utils.SetupTracing(ctx, tracer, "DeletePool") + defer span.End() + + localLogger = localLogger.WithFields(log.Fields{ + "pool_id": id, + }) + + span.SetAttributes( + attribute.String("pool_id", string(id)), + ) + + utils.HandleEvent(span, localLogger, "Starting delete pool") + + var pool models.Pool + + if client == nil { + return utils.HandleError(ctx, span, localLogger, &otterError.Database{Reason: otterError.DatabaseIsNotConnected}) + } + + if len(id) == 0 { + return utils.HandleError(ctx, span, localLogger, &otterError.EntityValidationFailed{Reason: otterError.PoolIDIsEmpty}) + } + + if len(id) != 25 { + return utils.HandleError(ctx, span, localLogger, &otterError.EntityValidationFailed{Reason: otterError.PoolIDToShort}) + } + + result := client.WithContext(ctx).Delete(&pool, "id = ?", id) + if result.Error != nil { + if errors.Is(result.Error, gorm.ErrRecordNotFound) { + return utils.HandleError(ctx, span, localLogger, &otterError.Database{Reason: otterError.NoDataFound}) + } + return utils.HandleError(ctx, span, localLogger, result.Error) + } + + utils.HandleEvent(span, localLogger, "pool deleted successfully") + return nil +} diff --git a/pkg/database/pool_test.go b/pkg/database/pool_test.go new file mode 100644 index 0000000..344c874 --- /dev/null +++ b/pkg/database/pool_test.go @@ -0,0 +1,369 @@ +package database + +import ( + "context" + "fmt" + "reflect" + "testing" + "time" + + "git.anthrove.art/Anthrove/otter-space-sdk/v4/pkg/models" + "git.anthrove.art/Anthrove/otter-space-sdk/v4/test" + "go.opentelemetry.io/contrib/bridges/otellogrus" + "go.opentelemetry.io/otel" + "gorm.io/gorm" +) + +func TestCreatePool(t *testing.T) { + // Setup trow away container + ctx := context.Background() + container, gormDB, err := test.StartPostgresContainer(ctx) + if err != nil { + logger.Fatalf("Could not start PoolgreSQL container: %v", err) + } + + client = gormDB + + // Setup open telemetry + tracer = otel.Tracer(tracingName) + + hook := otellogrus.NewHook(tracingName) + logger.AddHook(hook) + + defer container.Terminate(ctx) + + // -- -- Setup Tests + + // -- Create Pool to test with + validPool := models.Pool{ + BaseModel: models.BaseModel[models.PoolID]{ + ID: models.PoolID(fmt.Sprintf("%025s", "Pool1")), + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + DeletedAt: gorm.DeletedAt{}, + }, + Name: "Test Pool 01", + Category: models.Series, + } + // -- + + // -- -- Tests + type args struct { + ctx context.Context + post models.Pool + } + tests := []struct { + name string + args args + want models.Pool + wantErr bool + }{ + { + name: "Test 01: Valid Pool", + args: args{ + ctx: ctx, + post: validPool, + }, + want: validPool, + wantErr: false, + }, + { + name: "Test 02: Duplicate Pool", + args: args{ + ctx: ctx, + post: validPool, + }, + want: models.Pool{}, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := CreatePool(tt.args.ctx, tt.args.post) + if (err != nil) != tt.wantErr { + t.Errorf("CreatePool() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("CreatePool() got = %v, want %v", got, tt.want) + } + }) + } +} + +func TestGetPoolByID(t *testing.T) { + // Setup trow away container + ctx := context.Background() + container, gormDB, err := test.StartPostgresContainer(ctx) + if err != nil { + logger.Fatalf("Could not start PoolgreSQL container: %v", err) + } + + client = gormDB + + // Setup open telemetry + tracer = otel.Tracer(tracingName) + + hook := otellogrus.NewHook(tracingName) + logger.AddHook(hook) + + defer container.Terminate(ctx) + + // -- -- Setup Tests + + // -- Create Pool to test with + validPool := models.Pool{ + BaseModel: models.BaseModel[models.PoolID]{ + ID: models.PoolID(fmt.Sprintf("%025s", "Pool1")), + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + DeletedAt: gorm.DeletedAt{}, + }, + Name: "Test Pool 01", + Category: models.Series, + } + + validPool, err = CreatePool(ctx, validPool) + if err != nil { + logger.Fatal(err) + } + // -- + + // -- -- Tests + type args struct { + ctx context.Context + id models.PoolID + } + tests := []struct { + name string + args args + want models.Pool + wantErr bool + }{ + { + name: "Test 01: Valid PoolID", + args: args{ + ctx: ctx, + id: validPool.ID, + }, + want: validPool, + wantErr: false, + }, + { + name: "Test 03: Empty PoolID", + args: args{ + ctx: ctx, + id: "", + }, + wantErr: true, + }, + { + name: "Test 04: Short PoolID", + args: args{ + ctx: ctx, + id: "111", + }, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := GetPoolByID(tt.args.ctx, tt.args.id) + if (err != nil) != tt.wantErr { + t.Errorf("GetPoolByID() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !checkPoolID(got, tt.want) { + t.Errorf("GetPoolByID() got = %v, want %v", got, tt.want) + } + }) + } +} + +func TestUpdatePool(t *testing.T) { + // Setup trow away container + ctx := context.Background() + container, gormDB, err := test.StartPostgresContainer(ctx) + if err != nil { + logger.Fatalf("Could not start PoolgreSQL container: %v", err) + } + + client = gormDB + + // Setup open telemetry + tracer = otel.Tracer(tracingName) + + hook := otellogrus.NewHook(tracingName) + logger.AddHook(hook) + + defer container.Terminate(ctx) + + // -- -- Setup Tests + + // -- Create Pool to test with + validPool := models.Pool{ + BaseModel: models.BaseModel[models.PoolID]{ + ID: models.PoolID(fmt.Sprintf("%025s", "Pool1")), + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + DeletedAt: gorm.DeletedAt{}, + }, + Name: "Test Pool 01", + Category: models.Series, + } + + validPool, err = CreatePool(ctx, validPool) + if err != nil { + logger.Fatal(err) + } + // -- + + // -- Create Updates models for Pool + validUpdatePool := validPool + validUpdatePool.Name = "Updated Test Pool" + validUpdatePool.Category = models.Collection + + invalidUpdatePool := models.Pool{} + // -- + + // -- -- Tests + type args struct { + ctx context.Context + anthrovePool models.Pool + } + tests := []struct { + name string + args args + wantErr bool + }{ + { + name: "Test 01: Valid Update for Pool", + args: args{ + ctx: ctx, + anthrovePool: validUpdatePool, + }, + wantErr: false, + }, + { + name: "Test 02: Invalid Update for Pool", + args: args{ + ctx: ctx, + anthrovePool: invalidUpdatePool, + }, + wantErr: true, + }, + { + name: "Test 03: Empty ID for Update for Pool", + args: args{ + ctx: ctx, + anthrovePool: models.Pool{BaseModel: models.BaseModel[models.PoolID]{ID: ""}}, + }, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if err := UpdatePool(tt.args.ctx, tt.args.anthrovePool); (err != nil) != tt.wantErr { + t.Errorf("UpdatePool() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func TestDeletePool(t *testing.T) { + // Setup trow away container + ctx := context.Background() + container, gormDB, err := test.StartPostgresContainer(ctx) + if err != nil { + logger.Fatalf("Could not start PoolgreSQL container: %v", err) + } + + client = gormDB + + // Setup open telemetry + tracer = otel.Tracer(tracingName) + + hook := otellogrus.NewHook(tracingName) + logger.AddHook(hook) + + defer container.Terminate(ctx) + + // -- -- Setup Tests + + // -- Create Pool to test with + validPool := models.Pool{ + BaseModel: models.BaseModel[models.PoolID]{ + ID: models.PoolID(fmt.Sprintf("%025s", "Pool1")), + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + DeletedAt: gorm.DeletedAt{}, + }, + Name: "Test Pool 01", + Category: models.Series, + } + + validPool, err = CreatePool(ctx, validPool) + if err != nil { + logger.Fatal(err) + } + // -- + + // -- -- Tests + type args struct { + ctx context.Context + id models.PoolID + } + tests := []struct { + name string + args args + wantErr bool + }{ + { + name: "Test 01: Delete Valid Pool", + args: args{ + ctx: ctx, + id: validPool.ID, + }, + wantErr: false, + }, + { + name: "Test 02: Delete not existed Pool", + args: args{ + ctx: ctx, + id: validPool.ID, + }, + wantErr: false, + }, + { + name: "Test 03: Empty PoolID", + args: args{ + ctx: ctx, + id: "", + }, + wantErr: true, + }, + { + name: "Test 04: Short PoolID", + args: args{ + ctx: ctx, + id: "111", + }, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if err := DeletePool(tt.args.ctx, tt.args.id); (err != nil) != tt.wantErr { + t.Errorf("DeletePool() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func checkPoolID(got models.Pool, want models.Pool) bool { + if got.ID != want.ID { + return false + } + + return true +} diff --git a/pkg/error/validation.go b/pkg/error/validation.go index 889744b..cec926a 100644 --- a/pkg/error/validation.go +++ b/pkg/error/validation.go @@ -30,6 +30,9 @@ const ( PostIDToShort = "PostID needs to be 25 characters long" BatchSizeIsEmpty = "batchSize cannot be empty" + + PoolIDIsEmpty = "PoolID cannot be empty" + PoolIDToShort = "PoolID needs to be 25 characters long" ) type EntityValidationFailed struct {