diff --git a/pkg/database/favorite.go b/pkg/database/favorite.go index 335cf65..32c71a8 100644 --- a/pkg/database/favorite.go +++ b/pkg/database/favorite.go @@ -82,6 +82,8 @@ func CreateUserFavoriteInBatch(ctx context.Context, userFav []models.UserFavorit return nil } +// UpdateUserFavorite updates the user post information in the database. +// Only supports the undulation of userFavorites, for this set the DeletedAt.Valid to false func UpdateUserFavorite(ctx context.Context, userFav models.UserFavorite) error { ctx, span, localLogger := utils.SetupTracing(ctx, tracer, "UpdateUserFavorite") defer span.End() @@ -104,11 +106,11 @@ func UpdateUserFavorite(ctx context.Context, userFav models.UserFavorite) error return utils.HandleError(ctx, span, localLogger, &otterError.EntityValidationFailed{Reason: otterError.UserFavoriteIDIsEmpty}) } - if !userFav.DeletedAt.Valid { + if userFav.DeletedAt.Valid == true { return nil } - result := client.WithContext(ctx).Model(&userFav).Update("deleted_at", gorm.DeletedAt{}) + result := client.WithContext(ctx).Unscoped().Model(&models.UserFavorite{}).Where("id", userFav.ID).Update("deleted_at", nil) if result.Error != nil { if errors.Is(result.Error, gorm.ErrRecordNotFound) { return utils.HandleError(ctx, span, localLogger, &otterError.Database{Reason: otterError.NoDataFound}) @@ -184,7 +186,7 @@ func DeleteUserFavorite(ctx context.Context, id models.UserFavoriteID) error { return utils.HandleError(ctx, span, localLogger, &otterError.EntityValidationFailed{Reason: otterError.UserFavoriteIDToShort}) } - result := client.WithContext(ctx).Delete(&userFavorite, "id = ?", id) + result := client.WithContext(ctx).Delete(&userFavorite, id) if result.Error != nil { if errors.Is(result.Error, gorm.ErrRecordNotFound) { return utils.HandleError(ctx, span, localLogger, &otterError.Database{Reason: otterError.NoDataFound}) diff --git a/pkg/database/favorite_test.go b/pkg/database/favorite_test.go new file mode 100644 index 0000000..9311a9c --- /dev/null +++ b/pkg/database/favorite_test.go @@ -0,0 +1,761 @@ +package database + +import ( + "context" + "fmt" + "reflect" + "testing" + "time" + + "git.anthrove.art/Anthrove/otter-space-sdk/v2/pkg/models" + "git.anthrove.art/Anthrove/otter-space-sdk/v2/test" + "go.opentelemetry.io/contrib/bridges/otellogrus" + "go.opentelemetry.io/otel" + "gorm.io/gorm" +) + +func TestCreateUserFavorite(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) + } + + client = gormDB + + // Setup open telemetry + tracer = otel.Tracer(tracingName) + + hook := otellogrus.NewHook(tracingName) + logger.AddHook(hook) + + defer container.Terminate(ctx) + + // -- -- Setup Tests + + // -- Create Source to test with + validSource := models.Source{ + DisplayName: "e621", + Domain: "e621.net", + Icon: "e621.net/icon.png", + } + validSource, err = CreateSource(ctx, validSource) + if err != nil { + t.Fatalf("CreateSource err: %v", err) + } + // -- + + // -- Create User to test with + userID := models.UserID(models.UserID(fmt.Sprintf("%025s", "User1"))) + validUser := models.User{ + BaseModel: models.BaseModel[models.UserID]{ + ID: userID, + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + DeletedAt: gorm.DeletedAt{}, + }, + Favorites: nil, + Sources: []models.UserSource{ + { + BaseModel: models.BaseModel[models.UserSourceID]{ + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + DeletedAt: gorm.DeletedAt{}, + }, + UserID: userID, + SourceID: validSource.ID, + ScrapeTimeInterval: "P1D", + AccountUsername: "marry", + AccountID: "poppens", + LastScrapeTime: time.Now(), + AccountValidate: false, + AccountValidationKey: "im-a-key", + }, + }, + } + validUser, err = CreateUser(ctx, validUser) + if err != nil { + t.Fatalf("CreateUser err: %v", err) + } + // -- + + // -- Create Post to test with + validPost := models.Post{ + BaseModel: models.BaseModel[models.PostID]{ + ID: models.PostID(fmt.Sprintf("%025s", "Post1")), + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + DeletedAt: gorm.DeletedAt{}, + }, + Rating: models.SFW, + } + validPost, err = CreatePost(ctx, validPost) + if err != nil { + t.Fatalf("CreatePost err: %v", err) + } + // -- + + // -- Create UserFavorite to test with + validFavorite := models.UserFavorite{ + BaseModel: models.BaseModel[models.UserFavoriteID]{ + ID: models.UserFavoriteID(fmt.Sprintf("%025s", "Favorite1")), + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + DeletedAt: gorm.DeletedAt{}, + }, + UserID: validUser.ID, + PostID: validPost.ID, + UserSourceID: validUser.Sources[0].ID, + } + // -- + + // -- -- Tests + type args struct { + ctx context.Context + userFav models.UserFavorite + } + tests := []struct { + name string + args args + want models.UserFavorite + wantErr bool + }{ + { + name: "Test 01: Valid UserFavorite", + args: args{ + ctx: ctx, + userFav: validFavorite, + }, + want: validFavorite, + wantErr: false, + }, + { + name: "Test 02: Duplicate UserFavorite", + args: args{ + ctx: ctx, + userFav: validFavorite, + }, + want: models.UserFavorite{}, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := CreateUserFavorite(tt.args.ctx, tt.args.userFav) + if (err != nil) != tt.wantErr { + t.Errorf("CreateUserFavorite() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("CreateUserFavorite() got = %v, want %v", got, tt.want) + } + }) + } +} + +func TestCreateUserFavoriteInBatch(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) + } + + client = gormDB + + // Setup open telemetry + tracer = otel.Tracer(tracingName) + + hook := otellogrus.NewHook(tracingName) + logger.AddHook(hook) + + defer container.Terminate(ctx) + + // -- -- Setup Tests + + // -- Create Source to test with + validSource := models.Source{ + DisplayName: "e621", + Domain: "e621.net", + Icon: "e621.net/icon.png", + } + validSource, err = CreateSource(ctx, validSource) + if err != nil { + t.Fatalf("CreateSource err: %v", err) + } + // -- + + // -- Create User to test with + userID := models.UserID(models.UserID(fmt.Sprintf("%025s", "User1"))) + validUser := models.User{ + BaseModel: models.BaseModel[models.UserID]{ + ID: userID, + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + DeletedAt: gorm.DeletedAt{}, + }, + Favorites: nil, + Sources: []models.UserSource{ + { + BaseModel: models.BaseModel[models.UserSourceID]{ + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + DeletedAt: gorm.DeletedAt{}, + }, + UserID: userID, + SourceID: validSource.ID, + ScrapeTimeInterval: "P1D", + AccountUsername: "marry", + AccountID: "poppens", + LastScrapeTime: time.Now(), + AccountValidate: false, + AccountValidationKey: "im-a-key", + }, + }, + } + validUser, err = CreateUser(ctx, validUser) + if err != nil { + t.Fatalf("CreateUser err: %v", err) + } + // -- + + // -- Create Post to test with + validPost := models.Post{ + BaseModel: models.BaseModel[models.PostID]{ + ID: models.PostID(fmt.Sprintf("%025s", "Post1")), + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + DeletedAt: gorm.DeletedAt{}, + }, + Rating: models.SFW, + } + validPost, err = CreatePost(ctx, validPost) + if err != nil { + t.Fatalf("CreatePost err: %v", err) + } + // -- + + // -- Create UserFavorites to test with + validUserFavorite := test.GenerateRandomUserFavorites(validUser.ID, validPost.ID, validUser.Sources[0].ID, 10) + // -- + + // -- -- Tests + type args struct { + ctx context.Context + userFav []models.UserFavorite + batchSize int + } + tests := []struct { + name string + args args + wantErr bool + }{ + { + name: "Test 01: Valid UserFavorite", + args: args{ + ctx: ctx, + userFav: validUserFavorite, + batchSize: len(validUserFavorite), + }, + wantErr: false, + }, + { + name: "Test 02: Duplicate UserFavorite", + args: args{ + ctx: ctx, + userFav: validUserFavorite, + batchSize: len(validUserFavorite), + }, + wantErr: true, + }, + { + name: "Test 03: Nil UserFavorite", + args: args{ + ctx: ctx, + userFav: nil, + batchSize: len(validUserFavorite), + }, + wantErr: true, + }, + { + name: "Test 04: Empty UserFavorite", + args: args{ + ctx: ctx, + userFav: []models.UserFavorite{}, + batchSize: len(validUserFavorite), + }, + wantErr: true, + }, + { + name: "Test 08: Empty Batch Size", + args: args{ + ctx: ctx, + userFav: []models.UserFavorite{}, + batchSize: 0, + }, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if err := CreateUserFavoriteInBatch(tt.args.ctx, tt.args.userFav, tt.args.batchSize); (err != nil) != tt.wantErr { + t.Errorf("CreateUserFavoriteInBatch() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func TestUpdateUserFavorite(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) + } + + client = gormDB + + // Setup open telemetry + tracer = otel.Tracer(tracingName) + + hook := otellogrus.NewHook(tracingName) + logger.AddHook(hook) + + defer container.Terminate(ctx) + + // -- -- Setup Tests + + // -- Create Source to test with + validSource := models.Source{ + DisplayName: "e621", + Domain: "e621.net", + Icon: "e621.net/icon.png", + } + validSource, err = CreateSource(ctx, validSource) + if err != nil { + t.Fatalf("CreateSource err: %v", err) + } + // -- + + // -- Create User to test with + userID := models.UserID(models.UserID(fmt.Sprintf("%025s", "User1"))) + validUser := models.User{ + BaseModel: models.BaseModel[models.UserID]{ + ID: userID, + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + DeletedAt: gorm.DeletedAt{}, + }, + Favorites: nil, + Sources: []models.UserSource{ + { + BaseModel: models.BaseModel[models.UserSourceID]{ + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + DeletedAt: gorm.DeletedAt{}, + }, + UserID: userID, + SourceID: validSource.ID, + ScrapeTimeInterval: "P1D", + AccountUsername: "marry", + AccountID: "poppens", + LastScrapeTime: time.Now(), + AccountValidate: false, + AccountValidationKey: "im-a-key", + }, + }, + } + validUser, err = CreateUser(ctx, validUser) + if err != nil { + t.Fatalf("CreateUser err: %v", err) + } + // -- + + // -- Create Post to test with + validPost := models.Post{ + BaseModel: models.BaseModel[models.PostID]{ + ID: models.PostID(fmt.Sprintf("%025s", "Post1")), + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + DeletedAt: gorm.DeletedAt{}, + }, + Rating: models.SFW, + } + validPost, err = CreatePost(ctx, validPost) + if err != nil { + t.Fatalf("CreatePost err: %v", err) + } + // -- + + // -- Create UserFavorite to test with + validFavorite := models.UserFavorite{ + BaseModel: models.BaseModel[models.UserFavoriteID]{ + ID: models.UserFavoriteID(fmt.Sprintf("%025s", "Favorite1")), + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + DeletedAt: gorm.DeletedAt{}, + }, + UserID: validUser.ID, + PostID: validPost.ID, + UserSourceID: validUser.Sources[0].ID, + } + validFavorite, err = CreateUserFavorite(ctx, validFavorite) + if err != nil { + t.Fatalf("CreateUserFavorite err: %v", err) + } + // -- + + // -- Update UserFavorite + validUpdateFavorite := validFavorite + validFavorite.DeletedAt = gorm.DeletedAt{ + Time: time.Time{}, + Valid: false, + } + // -- + + // -- Delete UserFavorite + err = DeleteUserFavorite(ctx, validFavorite.ID) + if err != nil { + t.Fatalf("CreateUserFavorite err: %v", err) + } + // -- + + // -- -- Tests + type args struct { + ctx context.Context + userFav models.UserFavorite + } + tests := []struct { + name string + args args + wantErr bool + }{ + { + name: "Test 01: Valid Update for UserFavorite", + args: args{ + ctx: ctx, + userFav: validUpdateFavorite, + }, + wantErr: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if err := UpdateUserFavorite(tt.args.ctx, tt.args.userFav); (err != nil) != tt.wantErr { + t.Errorf("UpdateUserFavorite() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func TestGetUserFavoritesByID(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) + } + + client = gormDB + + // Setup open telemetry + tracer = otel.Tracer(tracingName) + + hook := otellogrus.NewHook(tracingName) + logger.AddHook(hook) + + defer container.Terminate(ctx) + + // -- -- Setup Tests + + // -- Create Source to test with + validSource := models.Source{ + DisplayName: "e621", + Domain: "e621.net", + Icon: "e621.net/icon.png", + } + validSource, err = CreateSource(ctx, validSource) + if err != nil { + t.Fatalf("CreateSource err: %v", err) + } + // -- + + // -- Create User to test with + userID := models.UserID(models.UserID(fmt.Sprintf("%025s", "User1"))) + validUser := models.User{ + BaseModel: models.BaseModel[models.UserID]{ + ID: userID, + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + DeletedAt: gorm.DeletedAt{}, + }, + Favorites: nil, + Sources: []models.UserSource{ + { + BaseModel: models.BaseModel[models.UserSourceID]{ + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + DeletedAt: gorm.DeletedAt{}, + }, + UserID: userID, + SourceID: validSource.ID, + ScrapeTimeInterval: "P1D", + AccountUsername: "marry", + AccountID: "poppens", + LastScrapeTime: time.Now(), + AccountValidate: false, + AccountValidationKey: "im-a-key", + }, + }, + } + validUser, err = CreateUser(ctx, validUser) + if err != nil { + t.Fatalf("CreateUser err: %v", err) + } + // -- + + // -- Create Post to test with + validPost := models.Post{ + BaseModel: models.BaseModel[models.PostID]{ + ID: models.PostID(fmt.Sprintf("%025s", "Post1")), + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + DeletedAt: gorm.DeletedAt{}, + }, + Rating: models.SFW, + } + validPost, err = CreatePost(ctx, validPost) + if err != nil { + t.Fatalf("CreatePost err: %v", err) + } + // -- + + // -- Create UserFavorite to test with + validFavorite := models.UserFavorite{ + BaseModel: models.BaseModel[models.UserFavoriteID]{ + ID: models.UserFavoriteID(fmt.Sprintf("%025s", "Favorite1")), + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + DeletedAt: gorm.DeletedAt{}, + }, + UserID: validUser.ID, + PostID: validPost.ID, + UserSourceID: validUser.Sources[0].ID, + } + validFavorite, err = CreateUserFavorite(ctx, validFavorite) + if err != nil { + t.Fatalf("CreateUserFavorite err: %v", err) + } + // -- + + // -- -- Tests + type args struct { + ctx context.Context + id models.UserFavoriteID + } + tests := []struct { + name string + args args + want models.UserFavorite + wantErr bool + }{ + { + name: "Test 01: Valid UserFavoriteID", + args: args{ + ctx: ctx, + id: validFavorite.ID, + }, + want: validFavorite, + wantErr: false, + }, + { + name: "Test 03: Empty UserFavoriteID", + args: args{ + ctx: ctx, + id: "", + }, + wantErr: true, + }, + { + name: "Test 04: Short UserFavoriteID", + args: args{ + ctx: ctx, + id: "111", + }, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := GetUserFavoritesByID(tt.args.ctx, tt.args.id) + if (err != nil) != tt.wantErr { + t.Errorf("GetUserFavoritesByID() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !checkUserFavoriteID(got, tt.want) { + t.Errorf("GetUserFavoritesByID() got = %v, want %v", got, tt.want) + } + }) + } +} + +func TestDeleteUserFavorite(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) + } + + client = gormDB + + // Setup open telemetry + tracer = otel.Tracer(tracingName) + + hook := otellogrus.NewHook(tracingName) + logger.AddHook(hook) + + defer container.Terminate(ctx) + + // -- -- Setup Tests + + // -- Create Source to test with + validSource := models.Source{ + DisplayName: "e621", + Domain: "e621.net", + Icon: "e621.net/icon.png", + } + validSource, err = CreateSource(ctx, validSource) + if err != nil { + t.Fatalf("CreateSource err: %v", err) + } + // -- + + // -- Create User to test with + userID := models.UserID(models.UserID(fmt.Sprintf("%025s", "User1"))) + validUser := models.User{ + BaseModel: models.BaseModel[models.UserID]{ + ID: userID, + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + DeletedAt: gorm.DeletedAt{}, + }, + Favorites: nil, + Sources: []models.UserSource{ + { + BaseModel: models.BaseModel[models.UserSourceID]{ + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + DeletedAt: gorm.DeletedAt{}, + }, + UserID: userID, + SourceID: validSource.ID, + ScrapeTimeInterval: "P1D", + AccountUsername: "marry", + AccountID: "poppens", + LastScrapeTime: time.Now(), + AccountValidate: false, + AccountValidationKey: "im-a-key", + }, + }, + } + validUser, err = CreateUser(ctx, validUser) + if err != nil { + t.Fatalf("CreateUser err: %v", err) + } + // -- + + // -- Create Post to test with + validPost := models.Post{ + BaseModel: models.BaseModel[models.PostID]{ + ID: models.PostID(fmt.Sprintf("%025s", "Post1")), + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + DeletedAt: gorm.DeletedAt{}, + }, + Rating: models.SFW, + } + validPost, err = CreatePost(ctx, validPost) + if err != nil { + t.Fatalf("CreatePost err: %v", err) + } + // -- + + // -- Create UserFavorite to test with + validFavorite := models.UserFavorite{ + BaseModel: models.BaseModel[models.UserFavoriteID]{ + ID: models.UserFavoriteID(fmt.Sprintf("%025s", "Favorite1")), + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + DeletedAt: gorm.DeletedAt{}, + }, + UserID: validUser.ID, + PostID: validPost.ID, + UserSourceID: validUser.Sources[0].ID, + } + validFavorite, err = CreateUserFavorite(ctx, validFavorite) + if err != nil { + t.Fatalf("CreateUserFavorite err: %v", err) + } + // -- + + // -- -- Tests + type args struct { + ctx context.Context + id models.UserFavoriteID + } + tests := []struct { + name string + args args + wantErr bool + }{ + { + name: "Test 01: Delete Valid UserFavorite", + args: args{ + ctx: ctx, + id: validFavorite.ID, + }, + wantErr: false, + }, + { + name: "Test 02: Delete not existed UserFavorite", + args: args{ + ctx: ctx, + id: validFavorite.ID, + }, + wantErr: false, + }, + { + name: "Test 03: Empty UserFavoriteID", + args: args{ + ctx: ctx, + id: "", + }, + wantErr: true, + }, + { + name: "Test 04: Short UserFavoriteID", + args: args{ + ctx: ctx, + id: "111", + }, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if err := DeleteUserFavorite(tt.args.ctx, tt.args.id); (err != nil) != tt.wantErr { + t.Errorf("DeleteUserFavorite() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func checkUserFavoriteID(got models.UserFavorite, want models.UserFavorite) bool { + if got.ID != want.ID { + return false + } + + return true +} diff --git a/pkg/database/migrations/001_inital_database.sql b/pkg/database/migrations/001_inital_database.sql index 60d779d..95bde1d 100644 --- a/pkg/database/migrations/001_inital_database.sql +++ b/pkg/database/migrations/001_inital_database.sql @@ -2,7 +2,8 @@ CREATE TYPE Rating AS ENUM ( 'safe', 'questionable', - 'explicit' + 'explicit', + 'unknown' ); CREATE TYPE TagType AS ENUM ( diff --git a/pkg/database/post_test.go b/pkg/database/post_test.go index eba1030..0b35721 100644 --- a/pkg/database/post_test.go +++ b/pkg/database/post_test.go @@ -3,14 +3,15 @@ package database import ( "context" "fmt" + "reflect" + "testing" + "time" + "git.anthrove.art/Anthrove/otter-space-sdk/v2/pkg/models" "git.anthrove.art/Anthrove/otter-space-sdk/v2/test" "go.opentelemetry.io/contrib/bridges/otellogrus" "go.opentelemetry.io/otel" "gorm.io/gorm" - "reflect" - "testing" - "time" ) func TestCreatePost(t *testing.T) { @@ -110,7 +111,7 @@ func TestCreatePostInBatch(t *testing.T) { // -- -- Setup Tests // -- Create Posts to test with - validPosts := test.GenerateRandomPosts(5) + validPosts := test.GenerateRandomPosts(20) // -- // -- -- Tests diff --git a/pkg/models/userFavorite.go b/pkg/models/userFavorite.go index 920d22a..16fc87d 100644 --- a/pkg/models/userFavorite.go +++ b/pkg/models/userFavorite.go @@ -2,8 +2,8 @@ package models type UserFavorite struct { BaseModel[UserFavoriteID] - UserID string `json:"user_id"` - PostID string `json:"post_id"` + UserID UserID `json:"user_id"` + PostID PostID `json:"post_id"` UserSourceID UserSourceID `json:"user_source_id"` UserSource UserSource `json:"-" gorm:"foreignKey:ID;references:UserSourceID"` } diff --git a/test/generator.go b/test/generator.go index 333704a..1642ad3 100644 --- a/test/generator.go +++ b/test/generator.go @@ -11,11 +11,11 @@ import ( "gorm.io/gorm" ) -func GenerateRandomTags(numTags int) []models.Tag { +func GenerateRandomTags(num int) []models.Tag { var tags []models.Tag tagTypes := []models.TagType{"general", "species", "character", "artist", "lore", "meta", "invalid", "copyright"} - for i := 0; i < numTags; i++ { + for i := 0; i < num; i++ { id, _ := gonanoid.New(10) tagName := spew.Sprintf("tag_name_%s", id) @@ -32,10 +32,10 @@ func GenerateRandomTags(numTags int) []models.Tag { return tags } -func GenerateRandomTagGroups(tags []models.Tag, numGroups int) []models.TagGroup { +func GenerateRandomTagGroups(tags []models.Tag, num int) []models.TagGroup { var tagGroups []models.TagGroup - for i := 0; i < numGroups; i++ { + for i := 0; i < num; i++ { id, _ := gonanoid.New(10) groupName := fmt.Sprintf("tag_group_%s", id) randomTag := tags[rand.Intn(len(tags))] @@ -51,10 +51,10 @@ func GenerateRandomTagGroups(tags []models.Tag, numGroups int) []models.TagGroup return tagGroups } -func GenerateRandomTagAlias(tags []models.Tag, numGroups int) []models.TagAlias { +func GenerateRandomTagAlias(tags []models.Tag, num int) []models.TagAlias { var tagAliases []models.TagAlias - for i := 0; i < numGroups; i++ { + for i := 0; i < num; i++ { id, _ := gonanoid.New(10) groupName := fmt.Sprintf("tag_alias_%s", id) randomTag := tags[rand.Intn(len(tags))] @@ -70,10 +70,10 @@ func GenerateRandomTagAlias(tags []models.Tag, numGroups int) []models.TagAlias return tagAliases } -func GenerateRandomSources(numTags int) []models.Source { +func GenerateRandomSources(num int) []models.Source { var sources []models.Source - for i := 0; i < numTags; i++ { + for i := 0; i < num; i++ { id, _ := gonanoid.New(10) displayName, _ := gonanoid.New(10) domain, _ := gonanoid.New(10) @@ -100,11 +100,11 @@ func GenerateRandomSources(numTags int) []models.Source { return sources } -func GenerateRandomPosts(numTags int) []models.Post { +func GenerateRandomPosts(num int) []models.Post { var sources []models.Post ratings := []models.Rating{"safe", "explicit", "questionable", "unknown"} - for i := 0; i < numTags; i++ { + for i := 0; i < num; i++ { id, _ := gonanoid.New(10) id = spew.Sprintf("source_name_%s", id) rating := ratings[rand.Intn(len(ratings))] @@ -124,3 +124,28 @@ func GenerateRandomPosts(numTags int) []models.Post { return sources } + +func GenerateRandomUserFavorites(userID models.UserID, postID models.PostID, userSourceID models.UserSourceID, num int) []models.UserFavorite { + var userFavorites []models.UserFavorite + + for i := 0; i < num; i++ { + id, _ := gonanoid.New(6) + id = spew.Sprintf("user_favorite_name_%s", id) + + source := models.UserFavorite{ + BaseModel: models.BaseModel[models.UserFavoriteID]{ + ID: models.UserFavoriteID(id), + CreatedAt: time.Now(), + UpdatedAt: time.Now(), + DeletedAt: gorm.DeletedAt{}, + }, + UserID: userID, + PostID: postID, + UserSourceID: userSourceID, + } + + userFavorites = append(userFavorites, source) + } + + return userFavorites +}