feat(test): added post, tags & fixed issues

fully tested post & tags. Also found bugs with the tests. Those are now fixed.

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

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

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 (

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

pkg/models/userFavorite.go

@@ -2,8 +2,8 @@ package models
 
 type UserFavorite struct {
 	BaseModel[UserFavoriteID]
-	UserID       string       `json:"user_id"`
+	UserID       UserID       `json:"user_id"`
-	PostID       string       `json:"post_id"`
+	PostID       PostID       `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(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
+}