pkg/database/favorite.go

@@ -82,8 +82,6 @@ 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()
@@ -106,11 +104,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 == true {
+	if !userFav.DeletedAt.Valid {
 		return nil
 	}
 
-	result := client.WithContext(ctx).Unscoped().Model(&models.UserFavorite{}).Where("id", userFav.ID).Update("deleted_at", nil)
+	result := client.WithContext(ctx).Model(&userFav).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})
@@ -186,7 +184,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)
+	result := client.WithContext(ctx).Delete(&userFavorite, "id = ?", id)
 	if result.Error != nil {
 		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
 			return utils.HandleError(ctx, span, localLogger, &otterError.Database{Reason: otterError.NoDataFound})

pkg/database/favorite_test.go

@@ -1,761 +0,0 @@
-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
-}

pkg/database/migrations/001_inital_database.sql

@@ -2,8 +2,7 @@
 CREATE TYPE Rating AS ENUM (
     'safe',
     'questionable',
-    'explicit',
+    'explicit'
-    'unknown'
     );
 
 CREATE TYPE TagType AS ENUM (

pkg/database/post.go

@@ -118,11 +118,6 @@ func GetPostByID(ctx context.Context, id models.PostID) (models.Post, error) {
 	return post, nil
 }
 
-// UpdatePost updates the user post information in the database.
-// Only a few parameter can be updated:
-//   - Rating
-//   - Tags
-//   - References
 func UpdatePost(ctx context.Context, anthrovePost models.Post) error {
 	ctx, span, localLogger := utils.SetupTracing(ctx, tracer, "UpdatePost")
 	defer span.End()
@@ -146,9 +141,6 @@ func UpdatePost(ctx context.Context, anthrovePost models.Post) error {
 	}
 
 	updatePost := models.Post{
-		BaseModel: models.BaseModel[models.PostID]{
-			ID: anthrovePost.ID,
-		},
 		Rating:     anthrovePost.Rating,
 		Tags:       anthrovePost.Tags,
 		References: anthrovePost.References,

pkg/database/post_test.go

@@ -1,454 +0,0 @@
-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 TestCreatePost(t *testing.T) {
-	// Setup trow away container
-	ctx := context.Background()
-	container, gormDB, err := test.StartPostgresContainer(ctx)
-	if err != nil {
-		logger.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 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,
-	}
-	// --
-
-	// -- -- Tests
-	type args struct {
-		ctx  context.Context
-		post models.Post
-	}
-	tests := []struct {
-		name    string
-		args    args
-		want    models.Post
-		wantErr bool
-	}{
-		{
-			name: "Test 01: Valid Post",
-			args: args{
-				ctx:  ctx,
-				post: validPost,
-			},
-			want:    validPost,
-			wantErr: false,
-		},
-		{
-			name: "Test 02: Duplicate Post",
-			args: args{
-				ctx:  ctx,
-				post: validPost,
-			},
-			want:    models.Post{},
-			wantErr: true,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := CreatePost(tt.args.ctx, tt.args.post)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("CreatePost() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("CreatePost() got = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func TestCreatePostInBatch(t *testing.T) {
-	// Setup trow away container
-	ctx := context.Background()
-	container, gormDB, err := test.StartPostgresContainer(ctx)
-	if err != nil {
-		logger.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 Posts to test with
-	validPosts := test.GenerateRandomPosts(20)
-	// --
-
-	// -- -- Tests
-	type args struct {
-		ctx       context.Context
-		post      []models.Post
-		batchSize int
-	}
-	tests := []struct {
-		name    string
-		args    args
-		wantErr bool
-	}{
-		{
-			name: "Test 01: Valid Posts",
-			args: args{
-				ctx:       ctx,
-				post:      validPosts,
-				batchSize: len(validPosts),
-			},
-			wantErr: false,
-		},
-		{
-			name: "Test 02: Duplicate Posts",
-			args: args{
-				ctx:       ctx,
-				post:      validPosts,
-				batchSize: len(validPosts),
-			},
-			wantErr: true,
-		},
-		{
-			name: "Test 03: Nil Posts",
-			args: args{
-				ctx:       ctx,
-				post:      nil,
-				batchSize: len(validPosts),
-			},
-			wantErr: true,
-		},
-		{
-			name: "Test 04: Empty Posts",
-			args: args{
-				ctx:       ctx,
-				post:      []models.Post{},
-				batchSize: len(validPosts),
-			},
-			wantErr: true,
-		},
-		{
-			name: "Test 08: Empty Batch Size",
-			args: args{
-				ctx:       ctx,
-				post:      []models.Post{},
-				batchSize: 0,
-			},
-			wantErr: true,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if err := CreatePostInBatch(tt.args.ctx, tt.args.post, tt.args.batchSize); (err != nil) != tt.wantErr {
-				t.Errorf("CreatePostInBatch() error = %v, wantErr %v", err, tt.wantErr)
-			}
-		})
-	}
-}
-
-func TestGetPostByID(t *testing.T) {
-	// Setup trow away container
-	ctx := context.Background()
-	container, gormDB, err := test.StartPostgresContainer(ctx)
-	if err != nil {
-		logger.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 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 {
-		logger.Fatal(err)
-	}
-	// --
-
-	// -- -- Tests
-	type args struct {
-		ctx context.Context
-		id  models.PostID
-	}
-	tests := []struct {
-		name    string
-		args    args
-		want    models.Post
-		wantErr bool
-	}{
-		{
-			name: "Test 01: Valid PostID",
-			args: args{
-				ctx: ctx,
-				id:  validPost.ID,
-			},
-			want:    validPost,
-			wantErr: false,
-		},
-		{
-			name: "Test 03: Empty PostID",
-			args: args{
-				ctx: ctx,
-				id:  "",
-			},
-			wantErr: true,
-		},
-		{
-			name: "Test 04: Short PostID",
-			args: args{
-				ctx: ctx,
-				id:  "111",
-			},
-			wantErr: true,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := GetPostByID(tt.args.ctx, tt.args.id)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("GetPostByID() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if !checkPostID(got, tt.want) {
-				t.Errorf("GetPostByID() got = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func TestUpdatePost(t *testing.T) {
-	// Setup trow away container
-	ctx := context.Background()
-	container, gormDB, err := test.StartPostgresContainer(ctx)
-	if err != nil {
-		logger.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 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 {
-		logger.Fatal(err)
-	}
-	// --
-
-	// -- Create Updates models for Post
-	validUpdatePost := validPost
-	validUpdatePost.Rating = models.NSFW
-
-	invalidUpdatePost := models.Post{}
-	// --
-
-	// -- -- Tests
-	type args struct {
-		ctx          context.Context
-		anthrovePost models.Post
-	}
-	tests := []struct {
-		name    string
-		args    args
-		wantErr bool
-	}{
-		{
-			name: "Test 01: Valid Update for Post",
-			args: args{
-				ctx:          ctx,
-				anthrovePost: validUpdatePost,
-			},
-			wantErr: false,
-		},
-		{
-			name: "Test 02: Invalid Update for Post",
-			args: args{
-				ctx:          ctx,
-				anthrovePost: invalidUpdatePost,
-			},
-			wantErr: true,
-		},
-		{
-			name: "Test 03: Empty ID for Update for Post",
-			args: args{
-				ctx:          ctx,
-				anthrovePost: models.Post{BaseModel: models.BaseModel[models.PostID]{ID: ""}},
-			},
-			wantErr: true,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if err := UpdatePost(tt.args.ctx, tt.args.anthrovePost); (err != nil) != tt.wantErr {
-				t.Errorf("UpdatePost() error = %v, wantErr %v", err, tt.wantErr)
-			}
-		})
-	}
-}
-
-func TestDeletePost(t *testing.T) {
-	// Setup trow away container
-	ctx := context.Background()
-	container, gormDB, err := test.StartPostgresContainer(ctx)
-	if err != nil {
-		logger.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 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 {
-		logger.Fatal(err)
-	}
-	// --
-
-	// -- -- Tests
-	type args struct {
-		ctx context.Context
-		id  models.PostID
-	}
-	tests := []struct {
-		name    string
-		args    args
-		wantErr bool
-	}{
-		{
-			name: "Test 01: Delete Valid Post",
-			args: args{
-				ctx: ctx,
-				id:  validPost.ID,
-			},
-			wantErr: false,
-		},
-		{
-			name: "Test 02: Delete not existed Post",
-			args: args{
-				ctx: ctx,
-				id:  validPost.ID,
-			},
-			wantErr: false,
-		},
-		{
-			name: "Test 03: Empty PostID",
-			args: args{
-				ctx: ctx,
-				id:  "",
-			},
-			wantErr: true,
-		},
-		{
-			name: "Test 04: Short PostID",
-			args: args{
-				ctx: ctx,
-				id:  "111",
-			},
-			wantErr: true,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if err := DeletePost(tt.args.ctx, tt.args.id); (err != nil) != tt.wantErr {
-				t.Errorf("DeletePost() error = %v, wantErr %v", err, tt.wantErr)
-			}
-		})
-	}
-}
-
-func checkPostID(got models.Post, want models.Post) bool {
-	if got.ID != want.ID {
-		return false
-	}
-
-	return true
-}

pkg/models/userFavorite.go

@@ -2,8 +2,8 @@ package models
 
 type UserFavorite struct {
 	BaseModel[UserFavoriteID]
-	UserID       UserID       `json:"user_id"`
+	UserID       string       `json:"user_id"`
-	PostID       PostID       `json:"post_id"`
+	PostID       string       `json:"post_id"`
 	UserSourceID UserSourceID `json:"user_source_id"`
 	UserSource   UserSource   `json:"-" gorm:"foreignKey:ID;references:UserSourceID"`
 }

test/generator.go

@@ -11,11 +11,11 @@ import (
 	"gorm.io/gorm"
 )
 
-func GenerateRandomTags(num int) []models.Tag {
+func GenerateRandomTags(numTags int) []models.Tag {
 	var tags []models.Tag
 	tagTypes := []models.TagType{"general", "species", "character", "artist", "lore", "meta", "invalid", "copyright"}
 
-	for i := 0; i < num; i++ {
+	for i := 0; i < numTags; i++ {
 		id, _ := gonanoid.New(10)
 		tagName := spew.Sprintf("tag_name_%s", id)
 
@@ -32,10 +32,10 @@ func GenerateRandomTags(num int) []models.Tag {
 	return tags
 }
 
-func GenerateRandomTagGroups(tags []models.Tag, num int) []models.TagGroup {
+func GenerateRandomTagGroups(tags []models.Tag, numGroups int) []models.TagGroup {
 	var tagGroups []models.TagGroup
 
-	for i := 0; i < num; i++ {
+	for i := 0; i < numGroups; 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, num int) []models.TagGroup {
 	return tagGroups
 }
 
-func GenerateRandomTagAlias(tags []models.Tag, num int) []models.TagAlias {
+func GenerateRandomTagAlias(tags []models.Tag, numGroups int) []models.TagAlias {
 	var tagAliases []models.TagAlias
 
-	for i := 0; i < num; i++ {
+	for i := 0; i < numGroups; 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, num int) []models.TagAlias {
 	return tagAliases
 }
 
-func GenerateRandomSources(num int) []models.Source {
+func GenerateRandomSources(numTags int) []models.Source {
 	var sources []models.Source
 
-	for i := 0; i < num; i++ {
+	for i := 0; i < numTags; i++ {
 		id, _ := gonanoid.New(10)
 		displayName, _ := gonanoid.New(10)
 		domain, _ := gonanoid.New(10)
@@ -99,53 +99,3 @@ func GenerateRandomSources(num int) []models.Source {
 
 	return sources
 }
-
-func GenerateRandomPosts(num int) []models.Post {
-	var sources []models.Post
-	ratings := []models.Rating{"safe", "explicit", "questionable", "unknown"}
-
-	for i := 0; i < num; i++ {
-		id, _ := gonanoid.New(10)
-		id = spew.Sprintf("source_name_%s", id)
-		rating := ratings[rand.Intn(len(ratings))]
-
-		source := models.Post{
-			BaseModel: models.BaseModel[models.PostID]{
-				ID:        models.PostID(id),
-				CreatedAt: time.Now(),
-				UpdatedAt: time.Now(),
-				DeletedAt: gorm.DeletedAt{},
-			},
-			Rating: rating,
-		}
-
-		sources = append(sources, source)
-	}
-
-	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
-}