anthrove/otter-space-sdk
Archived
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 10 Wiki Activity

BREAKING CHANGE: V2 of thr SDK #12

Merged
fenpaws merged 124 commits from develop/postgresql into main 2024-07-01 20:46:28 +00:00
Conversation 0 Commits 124 Files Changed 59 +798 -10
5 changed files with 798 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit d759e072f7 - Show all commits

94
internal/postgres/tag.go
View File

@ -184,3 +184,97 @@ func DeleteTagAlias(ctx context.Context, db *gorm.DB, tagAliasName models.Anthro
return nil
}
func CreateTagGroup(ctx context.Context, db *gorm.DB, tagGroupName models.AnthroveTagGroupName, tagID models.AnthroveTagID) error {
if tagGroupName == "" {
return &otterError.EntityValidationFailed{Reason: "tagGroupName cannot be empty"}
}
if tagID == "" {
return &otterError.EntityValidationFailed{Reason: "tagID cannot be empty"}
}
result := db.WithContext(ctx).Create(&models.TagGroup{
Name: string(tagGroupName),
TagID: string(tagID),
})
if result.Error != nil {
if errors.Is(result.Error, gorm.ErrDuplicatedKey) {
return &otterError.EntityAlreadyExists{}
}
return result.Error
}
log.WithFields(log.Fields{
"tag_group_name": tagGroupName,
"tag_group_tag_id": tagID,
}).Trace("database: created tagGroup")
return nil
}
func GetAllTagGroup(ctx context.Context, db *gorm.DB) ([]models.TagGroup, error) {
var tagGroups []models.TagGroup
result := db.WithContext(ctx).Find(&tagGroups)
if result.Error != nil {
if errors.Is(result.Error, gorm.ErrRecordNotFound) {
return nil, &otterError.NoDataFound{}
}
return nil, result.Error
}
log.WithFields(log.Fields{
"tag_alias_length": len(tagGroups),
}).Trace("database: created tagGroup")
return tagGroups, nil
}
func GetAllTagGroupByTag(ctx context.Context, db *gorm.DB, tagID models.AnthroveTagID) ([]models.TagGroup, error) {
var tagGroups []models.TagGroup
if tagID == "" {
return nil, &otterError.EntityValidationFailed{Reason: "tagID cannot be empty"}
}
result := db.WithContext(ctx).Where("tag_id = ?", tagID).Find(&tagGroups)
if result.Error != nil {
if errors.Is(result.Error, gorm.ErrRecordNotFound) {
return nil, &otterError.NoDataFound{}
}
return nil, result.Error
}
log.WithFields(log.Fields{
"tag_alias_length": len(tagGroups),
"tag_alias_tag_id": tagID,
}).Trace("database: get specific tagGroup")
return tagGroups, nil
}
func DeleteTagGroup(ctx context.Context, db *gorm.DB, tagGroupName models.AnthroveTagGroupName) error {
if tagGroupName == "" {
return &otterError.EntityValidationFailed{Reason: "tagGroupName cannot be empty"}
}
result := db.WithContext(ctx).Delete(&models.TagGroup{Name: string(tagGroupName)})
if result.Error != nil {
if errors.Is(result.Error, gorm.ErrRecordNotFound) {
return &otterError.NoDataFound{}
}
return result.Error
}
log.WithFields(log.Fields{
"tag_alias_name": tagGroupName,
}).Trace("database: deleted tagAlias")
return nil
}

349
internal/postgres/tag_test.go
View File

@ -596,3 +596,352 @@ func TestDeleteTagAlias(t *testing.T) {
})
}
}
func TestCreateTagGroup(t *testing.T) {
// Setup trow away container
ctx := context.Background()
container, gormDB, err := test.StartPostgresContainer(ctx)
if err != nil {
t.Fatalf("Could not start PostgreSQL container: %v", err)
}
defer container.Terminate(ctx)
// Setup Test
validTagGroupName01 := models.AnthroveTagGroupName("httyd")
validTagGroupName02 := models.AnthroveTagGroupName("dragon")
validTagID := models.AnthroveTagID("toothless")
validTag := &models.Tag{
Name: string(validTagID),
Type: models.Character,
}
err = CreateTag(ctx, gormDB, validTag)
if err != nil {
t.Fatal(err)
}
// Test
type args struct {
ctx context.Context
db *gorm.DB
tagGroupName models.AnthroveTagGroupName
tagID models.AnthroveTagID
}
tests := []struct {
name string
args args
wantErr bool
}{
{
name: "Test 1: Valid Data",
args: args{
ctx: ctx,
db: gormDB,
tagGroupName: validTagGroupName01,
tagID: validTagID,
},
wantErr: false,
},
{
name: "Test 2: No TagGroupName",
args: args{
ctx: ctx,
db: gormDB,
tagGroupName: "",
tagID: validTagID,
},
wantErr: true,
},
{
name: "Test 4: No tagID",
args: args{
ctx: ctx,
db: gormDB,
tagGroupName: validTagGroupName01,
tagID: "",
},
wantErr: true,
},
{
name: "Test 5: Duplicate tagID",
args: args{
ctx: ctx,
db: gormDB,
tagGroupName: validTagGroupName01,
tagID: validTagID,
},
wantErr: true,
},
{
name: "Test 6: Invalide tagID",
args: args{
ctx: ctx,
db: gormDB,
tagGroupName: validTagGroupName02,
tagID: "aaa",
},
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if err := CreateTagGroup(tt.args.ctx, tt.args.db, tt.args.tagGroupName, tt.args.tagID); (err != nil) != tt.wantErr {
t.Errorf("CreateTagGroup() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestGetAllTagGroup(t *testing.T) {
// Setup trow away container
ctx := context.Background()
container, gormDB, err := test.StartPostgresContainer(ctx)
if err != nil {
t.Fatalf("Could not start PostgreSQL container: %v", err)
}
defer container.Terminate(ctx)
// Setup Test
validTagID := models.AnthroveTagID("toothless")
validTagGroupes := []models.AnthroveTagGroupName{"httyd", "dragon", "scaly"}
validTag := &models.Tag{
Name: string(validTagID),
Type: models.Character,
}
expectedResult := []models.TagGroup{
{
Name: string(validTagGroupes[0]),
TagID: string(validTagID),
},
{
Name: string(validTagGroupes[1]),
TagID: string(validTagID),
},
{
Name: string(validTagGroupes[2]),
TagID: string(validTagID),
},
}
err = CreateTag(ctx, gormDB, validTag)
if err != nil {
t.Fatal(err)
}
for _, tagGroupName := range validTagGroupes {
err = CreateTagGroup(ctx, gormDB, tagGroupName, validTagID)
}
// Test
type args struct {
ctx context.Context
db *gorm.DB
}
tests := []struct {
name string
args args
want []models.TagGroup
wantErr bool
}{
{
name: "Test 1: Get Data",
args: args{
ctx: ctx,
db: gormDB,
},
want: expectedResult,
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := GetAllTagGroup(tt.args.ctx, tt.args.db)
if (err != nil) != tt.wantErr {
t.Errorf("GetAllTagGroup() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("GetAllTagGroup() got = %v, want %v", got, tt.want)
}
})
}
}
func TestGetAllTagGroupByTag(t *testing.T) {
// Setup trow away container
ctx := context.Background()
container, gormDB, err := test.StartPostgresContainer(ctx)
if err != nil {
t.Fatalf("Could not start PostgreSQL container: %v", err)
}
defer container.Terminate(ctx)
// Setup Test
validTagID := models.AnthroveTagID("toothless")
validTagGroupes := []models.AnthroveTagGroupName{"httyd", "dragon", "scaly"}
validTag := &models.Tag{
Name: string(validTagID),
Type: models.Character,
}
expectedResult := []models.TagGroup{
{
Name: string(validTagGroupes[0]),
TagID: string(validTagID),
},
{
Name: string(validTagGroupes[1]),
TagID: string(validTagID),
},
{
Name: string(validTagGroupes[2]),
TagID: string(validTagID),
},
}
err = CreateTag(ctx, gormDB, validTag)
if err != nil {
t.Fatal(err)
}
for _, tagGroupName := range validTagGroupes {
err = CreateTagGroup(ctx, gormDB, tagGroupName, validTagID)
}
// Test
type args struct {
ctx context.Context
db *gorm.DB
tagID models.AnthroveTagID
}
tests := []struct {
name string
args args
want []models.TagGroup
wantErr bool
}{
{
name: "Test 1: Valid TagID",
args: args{
ctx: ctx,
db: gormDB,
tagID: validTagID,
},
want: expectedResult,
wantErr: false,
},
{
name: "Test 2: No TagID",
args: args{
ctx: ctx,
db: gormDB,
tagID: "",
},
want: nil,
wantErr: true,
},
{
name: "Test 3: Invalid TagID",
args: args{
ctx: ctx,
db: gormDB,
tagID: "adads",
},
want: []models.TagGroup{},
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := GetAllTagGroupByTag(tt.args.ctx, tt.args.db, tt.args.tagID)
if (err != nil) != tt.wantErr {
t.Errorf("GetAllTagGroupByTag() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("GetAllTagGroupByTag() got = %v, want %v", got, tt.want)
}
})
}
}
func TestDeleteTagGroup(t *testing.T) {
// Setup trow away container
ctx := context.Background()
container, gormDB, err := test.StartPostgresContainer(ctx)
if err != nil {
t.Fatalf("Could not start PostgreSQL container: %v", err)
}
defer container.Terminate(ctx)
// Setup Test
validTagID := models.AnthroveTagID("toothless")
validTagGroupes := []models.AnthroveTagGroupName{"httyd", "dragon", "scaly"}
validTag := &models.Tag{
Name: string(validTagID),
Type: models.Character,
}
err = CreateTag(ctx, gormDB, validTag)
if err != nil {
t.Fatal(err)
}
for _, tagGroupName := range validTagGroupes {
err = CreateTagGroup(ctx, gormDB, tagGroupName, validTagID)
}
// Test
type args struct {
ctx context.Context
db *gorm.DB
tagGroupName models.AnthroveTagGroupName
}
tests := []struct {
name string
args args
wantErr bool
}{
{
name: "Test 1: Valid AnthroveTagGroupName",
args: args{
ctx: ctx,
db: gormDB,
tagGroupName: validTagGroupes[0],
},
wantErr: false,
},
{
name: "Test 2: Invalid AnthroveTagGroupName",
args: args{
ctx: ctx,
db: gormDB,
tagGroupName: "asdad",
},
wantErr: false,
},
{
name: "Test 3: No AnthroveTagGroupName",
args: args{
ctx: ctx,
db: gormDB,
tagGroupName: "",
},
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if err := DeleteTagGroup(tt.args.ctx, tt.args.db, tt.args.tagGroupName); (err != nil) != tt.wantErr {
t.Errorf("DeleteTagAlias() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}

14
pkg/database/postgres.go
View File

@ -181,24 +181,20 @@ func (p *postgresqlConnection) DeleteTagAlias(ctx context.Context, tagAliasName
return postgres.DeleteTagAlias(ctx, p.db, tagAliasName)
}
func (p *postgresqlConnection) CreateTagGroup(ctx context.Context, tagGroupName models.AnthroveTagGroupName, tagID models.AnthroveTagID) {
//TODO implement me
panic("implement me")
func (p *postgresqlConnection) CreateTagGroup(ctx context.Context, tagGroupName models.AnthroveTagGroupName, tagID models.AnthroveTagID) error {
return postgres.CreateTagGroup(ctx, p.db, tagGroupName, tagID)
}
func (p *postgresqlConnection) GetAllTagGroup(ctx context.Context) ([]models.TagGroup, error) {
//TODO implement me
panic("implement me")
return postgres.GetAllTagGroup(ctx, p.db)
}
func (p *postgresqlConnection) GetAllTagGroupByTag(ctx context.Context, tagID models.AnthroveTagID) ([]models.TagGroup, error) {
//TODO implement me
panic("implement me")
return postgres.GetAllTagGroupByTag(ctx, p.db, tagID)
}
func (p *postgresqlConnection) DeleteTagGroup(ctx context.Context, tagGroupName models.AnthroveTagGroupName) error {
//TODO implement me
panic("implement me")
return postgres.DeleteTagGroup(ctx, p.db, tagGroupName)
}
// HELPER

349
pkg/database/postgres_test.go
View File

@ -2367,3 +2367,352 @@ func Test_postgresqlConnection_DeleteTagAlias(t *testing.T) {
})
}
}
//--------------------------
func Test_postgresqlConnection_CreateTagGroup(t *testing.T) {
// Setup trow away container
ctx := context.Background()
container, gormDB, err := test.StartPostgresContainer(ctx)
if err != nil {
t.Fatalf("Could not start PostgreSQL container: %v", err)
}
defer container.Terminate(ctx)
// Setup Test
validTagGroupName01 := models.AnthroveTagGroupName("httyd")
validTagGroupName02 := models.AnthroveTagGroupName("dragon")
validTagID := models.AnthroveTagID("toothless")
validTag := &models.Tag{
Name: string(validTagID),
Type: models.Character,
}
err = postgres.CreateTag(ctx, gormDB, validTag)
if err != nil {
t.Fatal(err)
}
// Test
type args struct {
ctx context.Context
tagGroupName models.AnthroveTagGroupName
tagID models.AnthroveTagID
}
tests := []struct {
name string
args args
wantErr bool
}{
{
name: "Test 1: Valid Data",
args: args{
ctx: ctx,
tagGroupName: validTagGroupName01,
tagID: validTagID,
},
wantErr: false,
},
{
name: "Test 2: No TagGroupName",
args: args{
ctx: ctx,
tagGroupName: "",
tagID: validTagID,
},
wantErr: true,
},
{
name: "Test 4: No tagID",
args: args{
ctx: ctx,
tagGroupName: validTagGroupName01,
tagID: "",
},
wantErr: true,
},
{
name: "Test 5: Duplicate tagID",
args: args{
ctx: ctx,
tagGroupName: validTagGroupName01,
tagID: validTagID,
},
wantErr: true,
},
{
name: "Test 6: Invalide tagID",
args: args{
ctx: ctx,
tagGroupName: validTagGroupName02,
tagID: "aaa",
},
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
p := &postgresqlConnection{
db: gormDB,
debug: true,
}
if err := p.CreateTagGroup(tt.args.ctx, tt.args.tagGroupName, tt.args.tagID); (err != nil) != tt.wantErr {
t.Errorf("CreateTagGroup() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func Test_postgresqlConnection_GetAllTagGroup(t *testing.T) {
// Setup trow away container
ctx := context.Background()
container, gormDB, err := test.StartPostgresContainer(ctx)
if err != nil {
t.Fatalf("Could not start PostgreSQL container: %v", err)
}
defer container.Terminate(ctx)
// Setup Test
validTagID := models.AnthroveTagID("toothless")
validTagGroupes := []models.AnthroveTagGroupName{"httyd", "dragon", "scaly"}
validTag := &models.Tag{
Name: string(validTagID),
Type: models.Character,
}
expectedResult := []models.TagGroup{
{
Name: string(validTagGroupes[0]),
TagID: string(validTagID),
},
{
Name: string(validTagGroupes[1]),
TagID: string(validTagID),
},
{
Name: string(validTagGroupes[2]),
TagID: string(validTagID),
},
}
err = postgres.CreateTag(ctx, gormDB, validTag)
if err != nil {
t.Fatal(err)
}
for _, tagGroupName := range validTagGroupes {
err = postgres.CreateTagGroup(ctx, gormDB, tagGroupName, validTagID)
}
// Test
type args struct {
ctx context.Context
}
tests := []struct {
name string
args args
want []models.TagGroup
wantErr bool
}{
{
name: "Test 1: Get Data",
args: args{ctx: ctx},
want: expectedResult,
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
p := &postgresqlConnection{
db: gormDB,
debug: true,
}
got, err := p.GetAllTagGroup(tt.args.ctx)
if (err != nil) != tt.wantErr {
t.Errorf("GetAllTagGroup() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("GetAllTagGroup() got = %v, want %v", got, tt.want)
}
})
}
}
func Test_postgresqlConnection_GetAllTagGroupByTag(t *testing.T) {
// Setup trow away container
ctx := context.Background()
container, gormDB, err := test.StartPostgresContainer(ctx)
if err != nil {
t.Fatalf("Could not start PostgreSQL container: %v", err)
}
defer container.Terminate(ctx)
// Setup Test
validTagID := models.AnthroveTagID("toothless")
validTagGroupes := []models.AnthroveTagGroupName{"httyd", "dragon", "scaly"}
validTag := &models.Tag{
Name: string(validTagID),
Type: models.Character,
}
expectedResult := []models.TagGroup{
{
Name: string(validTagGroupes[0]),
TagID: string(validTagID),
},
{
Name: string(validTagGroupes[1]),
TagID: string(validTagID),
},
{
Name: string(validTagGroupes[2]),
TagID: string(validTagID),
},
}
err = postgres.CreateTag(ctx, gormDB, validTag)
if err != nil {
t.Fatal(err)
}
for _, tagGroupName := range validTagGroupes {
err = postgres.CreateTagGroup(ctx, gormDB, tagGroupName, validTagID)
}
// Test
type args struct {
ctx context.Context
tagID models.AnthroveTagID
}
tests := []struct {
name string
args args
want []models.TagGroup
wantErr bool
}{
{
name: "Test 1: Valid TagID",
args: args{
ctx: ctx,
tagID: validTagID,
},
want: expectedResult,
wantErr: false,
},
{
name: "Test 2: No TagID",
args: args{
ctx: ctx,
tagID: "",
},
want: nil,
wantErr: true,
},
{
name: "Test 3: Invalid TagID",
args: args{
ctx: ctx,
tagID: "adads",
},
want: []models.TagGroup{},
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
p := &postgresqlConnection{
db: gormDB,
debug: true,
}
got, err := p.GetAllTagGroupByTag(tt.args.ctx, tt.args.tagID)
if (err != nil) != tt.wantErr {
t.Errorf("GetAllTagGroupByTag() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("GetAllTagGroupByTag() got = %v, want %v", got, tt.want)
}
})
}
}
func Test_postgresqlConnection_DeleteTagGroup(t *testing.T) {
// Setup trow away container
ctx := context.Background()
container, gormDB, err := test.StartPostgresContainer(ctx)
if err != nil {
t.Fatalf("Could not start PostgreSQL container: %v", err)
}
defer container.Terminate(ctx)
// Setup Test
validTagID := models.AnthroveTagID("toothless")
validTagGroupes := []models.AnthroveTagGroupName{"httyd", "dragon", "scaly"}
validTag := &models.Tag{
Name: string(validTagID),
Type: models.Character,
}
err = postgres.CreateTag(ctx, gormDB, validTag)
if err != nil {
t.Fatal(err)
}
for _, tagGroupName := range validTagGroupes {
err = postgres.CreateTagGroup(ctx, gormDB, tagGroupName, validTagID)
}
// Test
type args struct {
ctx context.Context
tagGroupName models.AnthroveTagGroupName
}
tests := []struct {
name string
args args
wantErr bool
}{
{
name: "Test 1: Valid AnthroveTagGroupName",
args: args{
ctx: ctx,
tagGroupName: validTagGroupes[0],
},
wantErr: false,
},
{
name: "Test 2: Invalid AnthroveTagGroupName",
args: args{
ctx: ctx,
tagGroupName: "asdad",
},
wantErr: false,
},
{
name: "Test 3: No AnthroveTagGroupName",
args: args{
ctx: ctx,
tagGroupName: "",
},
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
p := &postgresqlConnection{
db: gormDB,
debug: true,
}
if err := p.DeleteTagGroup(tt.args.ctx, tt.args.tagGroupName); (err != nil) != tt.wantErr {
t.Errorf("DeleteTagAlias() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}

2
pkg/database/taggroup.go
View File

@ -7,7 +7,7 @@ import (
)
type TagGroup interface {
CreateTagGroup(ctx context.Context, tagGroupName models.AnthroveTagGroupName, tagID models.AnthroveTagID)
CreateTagGroup(ctx context.Context, tagGroupName models.AnthroveTagGroupName, tagID models.AnthroveTagID) error
GetAllTagGroup(ctx context.Context) ([]models.TagGroup, error)