Anthrove/otter-space-sdk
5
0
Fork 0
Code Issues Pull Requests Actions Projects Releases 9 Activity

feat(pool): added pool creation

Browse Source 
- added basic CRUD for Pools
This commit is contained in:
SoXX 2024-10-14 13:05:22 +02:00
parent 9a33de96a0
commit c933b2ad63
3 changed files with 535 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

163
pkg/database/pool.go Normal file
View File

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

369
pkg/database/pool_test.go Normal file
View File

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

3
pkg/error/validation.go
View File

@ -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 {