To gitea and beyond, let's go(-yco)

2025-11-10 19:12:09 +01:00
parent 8f6133392d
commit 71a031342b
245 changed files with 83994 additions and 0 deletions
--- a/internal/repositories/database_test.go
+++ b/internal/repositories/database_test.go
@@ -0,0 +1,628 @@
+package repositories
+
+import (
+	"fmt"
+	"testing"
+
+	"goyco/internal/database"
+
+	"gorm.io/gorm"
+)
+
+func TestDatabase_AssertUserExists(t *testing.T) {
+	suite := NewTestSuite(t)
+
+	t.Run("existing user", func(t *testing.T) {
+		suite.Reset()
+
+		user := suite.CreateTestUser("testuser", "test@example.com", "password123")
+
+		retrieved := suite.AssertUserExists(user.ID)
+		if retrieved == nil {
+			t.Fatal("Expected user, got nil")
+		}
+
+		if retrieved.ID != user.ID {
+			t.Errorf("Expected user ID %d, got %d", user.ID, retrieved.ID)
+		}
+	})
+}
+
+func TestDatabase_AssertUserNotExists(t *testing.T) {
+	suite := NewTestSuite(t)
+
+	t.Run("non-existing user", func(t *testing.T) {
+		suite.Reset()
+
+		suite.AssertUserNotExists(999)
+	})
+}
+
+func TestDatabase_AssertPostExists(t *testing.T) {
+	suite := NewTestSuite(t)
+
+	t.Run("existing post", func(t *testing.T) {
+		suite.Reset()
+
+		user := suite.CreateTestUser("testuser", "test@example.com", "password123")
+		post := suite.CreateTestPost(user.ID, "Test Post", "https://example.com", "Test content")
+
+		retrieved := suite.AssertPostExists(post.ID)
+		if retrieved == nil {
+			t.Fatal("Expected post, got nil")
+		}
+
+		if retrieved.ID != post.ID {
+			t.Errorf("Expected post ID %d, got %d", post.ID, retrieved.ID)
+		}
+	})
+}
+
+func TestDatabase_AssertPostNotExists(t *testing.T) {
+	suite := NewTestSuite(t)
+
+	t.Run("non-existing post", func(t *testing.T) {
+		suite.Reset()
+
+		suite.AssertPostNotExists(999)
+	})
+}
+
+func TestDatabase_AssertVoteExists(t *testing.T) {
+	suite := NewTestSuite(t)
+
+	t.Run("existing vote", func(t *testing.T) {
+		suite.Reset()
+
+		user := suite.CreateTestUser("testuser", "test@example.com", "password123")
+		post := suite.CreateTestPost(user.ID, "Test Post", "https://example.com", "Test content")
+		vote := suite.CreateTestVote(user.ID, post.ID, database.VoteUp)
+
+		retrieved := suite.AssertVoteExists(vote.ID)
+		if retrieved == nil {
+			t.Fatal("Expected vote, got nil")
+		}
+
+		if retrieved.ID != vote.ID {
+			t.Errorf("Expected vote ID %d, got %d", vote.ID, retrieved.ID)
+		}
+	})
+}
+
+func TestDatabase_AssertVoteNotExists(t *testing.T) {
+	suite := NewTestSuite(t)
+
+	t.Run("non-existing vote", func(t *testing.T) {
+		suite.Reset()
+
+		suite.AssertVoteNotExists(999)
+	})
+}
+
+func TestDatabase_AssertAccountDeletionRequestExists(t *testing.T) {
+	suite := NewTestSuite(t)
+
+	t.Run("existing request", func(t *testing.T) {
+		suite.Reset()
+
+		user := suite.CreateTestUser("testuser", "test@example.com", "password123")
+		request := suite.CreateTestAccountDeletionRequest(user.ID, "token-hash-123")
+
+		retrieved := suite.AssertAccountDeletionRequestExists("token-hash-123")
+		if retrieved == nil {
+			t.Fatal("Expected request, got nil")
+		}
+
+		if retrieved.ID != request.ID {
+			t.Errorf("Expected request ID %d, got %d", request.ID, retrieved.ID)
+		}
+	})
+}
+
+func TestDatabase_AssertAccountDeletionRequestNotExists(t *testing.T) {
+	suite := NewTestSuite(t)
+
+	t.Run("non-existing request", func(t *testing.T) {
+		suite.Reset()
+
+		suite.AssertAccountDeletionRequestNotExists("nonexistent-token")
+	})
+}
+
+func TestDatabase_GetUserCount(t *testing.T) {
+	suite := NewTestSuite(t)
+
+	t.Run("empty database", func(t *testing.T) {
+		suite.Reset()
+
+		count := suite.GetUserCount()
+		if count != 0 {
+			t.Errorf("Expected 0 users, got %d", count)
+		}
+	})
+
+	t.Run("with users", func(t *testing.T) {
+		suite.Reset()
+
+		suite.CreateTestUser("user1", "user1@example.com", "password123")
+		suite.CreateTestUser("user2", "user2@example.com", "password123")
+
+		count := suite.GetUserCount()
+		if count != 2 {
+			t.Errorf("Expected 2 users, got %d", count)
+		}
+	})
+}
+
+func TestDatabase_GetPostCount(t *testing.T) {
+	suite := NewTestSuite(t)
+
+	t.Run("empty database", func(t *testing.T) {
+		suite.Reset()
+
+		count := suite.GetPostCount()
+		if count != 0 {
+			t.Errorf("Expected 0 posts, got %d", count)
+		}
+	})
+
+	t.Run("with posts", func(t *testing.T) {
+		suite.Reset()
+
+		user := suite.CreateTestUser("testuser", "test@example.com", "password123")
+		suite.CreateTestPost(user.ID, "Post 1", "https://example.com/1", "Content 1")
+		suite.CreateTestPost(user.ID, "Post 2", "https://example.com/2", "Content 2")
+
+		count := suite.GetPostCount()
+		if count != 2 {
+			t.Errorf("Expected 2 posts, got %d", count)
+		}
+	})
+}
+
+func TestDatabase_GetVoteCount(t *testing.T) {
+	suite := NewTestSuite(t)
+
+	t.Run("empty database", func(t *testing.T) {
+		suite.Reset()
+
+		count := suite.GetVoteCount()
+		if count != 0 {
+			t.Errorf("Expected 0 votes, got %d", count)
+		}
+	})
+
+	t.Run("with votes", func(t *testing.T) {
+		suite.Reset()
+
+		user1 := suite.CreateTestUser("user1", "user1@example.com", "password123")
+		user2 := suite.CreateTestUser("user2", "user2@example.com", "password123")
+		post := suite.CreateTestPost(user1.ID, "Test Post", "https://example.com", "Test content")
+
+		suite.CreateTestVote(user1.ID, post.ID, database.VoteUp)
+		suite.CreateTestVote(user2.ID, post.ID, database.VoteDown)
+
+		count := suite.GetVoteCount()
+		if count != 2 {
+			t.Errorf("Expected 2 votes, got %d", count)
+		}
+	})
+}
+
+func TestDatabase_GetAccountDeletionRequestCount(t *testing.T) {
+	suite := NewTestSuite(t)
+
+	t.Run("empty database", func(t *testing.T) {
+		suite.Reset()
+
+		count := suite.GetAccountDeletionRequestCount()
+		if count != 0 {
+			t.Errorf("Expected 0 requests, got %d", count)
+		}
+	})
+
+	t.Run("with requests", func(t *testing.T) {
+		suite.Reset()
+
+		user1 := suite.CreateTestUser("user1", "user1@example.com", "password123")
+		user2 := suite.CreateTestUser("user2", "user2@example.com", "password123")
+		suite.CreateTestAccountDeletionRequest(user1.ID, "token-hash-1")
+		suite.CreateTestAccountDeletionRequest(user2.ID, "token-hash-2")
+
+		count := suite.GetAccountDeletionRequestCount()
+		if count != 2 {
+			t.Errorf("Expected 2 requests, got %d", count)
+		}
+	})
+}
+
+func TestDatabase_Reset(t *testing.T) {
+	suite := NewTestSuite(t)
+
+	t.Run("reset clears all data", func(t *testing.T) {
+		suite.Reset()
+
+		user := suite.CreateTestUser("testuser", "test@example.com", "password123")
+		post := suite.CreateTestPost(user.ID, "Test Post", "https://example.com", "Test content")
+		suite.CreateTestVote(user.ID, post.ID, database.VoteUp)
+		suite.CreateTestAccountDeletionRequest(user.ID, "token-hash-123")
+
+		if suite.GetUserCount() != 1 {
+			t.Errorf("Expected 1 user before reset, got %d", suite.GetUserCount())
+		}
+		if suite.GetPostCount() != 1 {
+			t.Errorf("Expected 1 post before reset, got %d", suite.GetPostCount())
+		}
+		if suite.GetVoteCount() != 1 {
+			t.Errorf("Expected 1 vote before reset, got %d", suite.GetVoteCount())
+		}
+		if suite.GetAccountDeletionRequestCount() != 1 {
+			t.Errorf("Expected 1 request before reset, got %d", suite.GetAccountDeletionRequestCount())
+		}
+
+		suite.Reset()
+
+		if suite.GetUserCount() != 0 {
+			t.Errorf("Expected 0 users after reset, got %d", suite.GetUserCount())
+		}
+		if suite.GetPostCount() != 0 {
+			t.Errorf("Expected 0 posts after reset, got %d", suite.GetPostCount())
+		}
+		if suite.GetVoteCount() != 0 {
+			t.Errorf("Expected 0 votes after reset, got %d", suite.GetVoteCount())
+		}
+		if suite.GetAccountDeletionRequestCount() != 0 {
+			t.Errorf("Expected 0 requests after reset, got %d", suite.GetAccountDeletionRequestCount())
+		}
+	})
+}
+
+func TestDatabase_CreateTestUser(t *testing.T) {
+	suite := NewTestSuite(t)
+
+	t.Run("successful creation", func(t *testing.T) {
+		suite.Reset()
+
+		user := suite.CreateTestUser("testuser", "test@example.com", "password123")
+
+		if user.ID == 0 {
+			t.Error("Expected user ID to be assigned")
+		}
+
+		if user.Username != "testuser" {
+			t.Errorf("Expected username 'testuser', got %s", user.Username)
+		}
+
+		if user.Email != "test@example.com" {
+			t.Errorf("Expected email 'test@example.com', got %s", user.Email)
+		}
+
+		if !user.EmailVerified {
+			t.Error("Expected user to be email verified")
+		}
+	})
+}
+
+func TestDatabase_CreateTestPost(t *testing.T) {
+	suite := NewTestSuite(t)
+
+	t.Run("successful creation", func(t *testing.T) {
+		suite.Reset()
+
+		user := suite.CreateTestUser("testuser", "test@example.com", "password123")
+		post := suite.CreateTestPost(user.ID, "Test Post", "https://example.com", "Test content")
+
+		if post.ID == 0 {
+			t.Error("Expected post ID to be assigned")
+		}
+
+		if post.Title != "Test Post" {
+			t.Errorf("Expected title 'Test Post', got %s", post.Title)
+		}
+
+		if post.URL != "https://example.com" {
+			t.Errorf("Expected URL 'https://example.com', got %s", post.URL)
+		}
+
+		if post.Content != "Test content" {
+			t.Errorf("Expected content 'Test content', got %s", post.Content)
+		}
+
+		if post.AuthorID == nil || *post.AuthorID != user.ID {
+			t.Errorf("Expected author ID %d, got %v", user.ID, post.AuthorID)
+		}
+	})
+}
+
+func TestDatabase_CreateTestVote(t *testing.T) {
+	suite := NewTestSuite(t)
+
+	t.Run("successful creation", func(t *testing.T) {
+		suite.Reset()
+
+		user := suite.CreateTestUser("testuser", "test@example.com", "password123")
+		post := suite.CreateTestPost(user.ID, "Test Post", "https://example.com", "Test content")
+		vote := suite.CreateTestVote(user.ID, post.ID, database.VoteUp)
+
+		if vote.ID == 0 {
+			t.Error("Expected vote ID to be assigned")
+		}
+
+		if vote.UserID == nil || *vote.UserID != user.ID {
+			t.Errorf("Expected user ID %d, got %v", user.ID, vote.UserID)
+		}
+
+		if vote.PostID != post.ID {
+			t.Errorf("Expected post ID %d, got %d", post.ID, vote.PostID)
+		}
+
+		if vote.Type != database.VoteUp {
+			t.Errorf("Expected vote type %v, got %v", database.VoteUp, vote.Type)
+		}
+	})
+}
+
+func TestDatabase_CreateTestAccountDeletionRequest(t *testing.T) {
+	suite := NewTestSuite(t)
+
+	t.Run("successful creation", func(t *testing.T) {
+		suite.Reset()
+
+		user := suite.CreateTestUser("testuser", "test@example.com", "password123")
+		request := suite.CreateTestAccountDeletionRequest(user.ID, "token-hash-123")
+
+		if request.ID == 0 {
+			t.Error("Expected request ID to be assigned")
+		}
+
+		if request.UserID != user.ID {
+			t.Errorf("Expected user ID %d, got %d", user.ID, request.UserID)
+		}
+
+		if request.TokenHash != "token-hash-123" {
+			t.Errorf("Expected token hash 'token-hash-123', got %s", request.TokenHash)
+		}
+	})
+}
+
+func TestApplyPagination(t *testing.T) {
+	suite := NewTestSuite(t)
+
+	tests := []struct {
+		name             string
+		limit            int
+		offset           int
+		setupQuery       func(*gorm.DB) *gorm.DB
+		verifyPagination func(*testing.T, *gorm.DB, int, int)
+	}{
+		{
+			name:   "limit > 0 and offset > 0",
+			limit:  10,
+			offset: 5,
+			setupQuery: func(db *gorm.DB) *gorm.DB {
+				return db.Model(&database.User{})
+			},
+			verifyPagination: func(t *testing.T, query *gorm.DB, limit, offset int) {
+				for i := 0; i < 20; i++ {
+					suite.CreateTestUser(
+						fmt.Sprintf("testuser_%d", i),
+						fmt.Sprintf("user%d@example.com", i),
+						"password123",
+					)
+				}
+
+				var users []database.User
+				result := query.Find(&users)
+				if result.Error != nil {
+					t.Fatalf("Query failed: %v", result.Error)
+				}
+
+				if len(users) != limit {
+					t.Errorf("Expected %d users, got %d", limit, len(users))
+				}
+			},
+		},
+		{
+			name:   "limit > 0 and offset = 0",
+			limit:  5,
+			offset: 0,
+			setupQuery: func(db *gorm.DB) *gorm.DB {
+				return db.Model(&database.User{})
+			},
+			verifyPagination: func(t *testing.T, query *gorm.DB, limit, offset int) {
+				for i := 0; i < 10; i++ {
+					suite.CreateTestUser(
+						fmt.Sprintf("testuser_%d", i),
+						fmt.Sprintf("user%d@example.com", i),
+						"password123",
+					)
+				}
+
+				var users []database.User
+				result := query.Find(&users)
+				if result.Error != nil {
+					t.Fatalf("Query failed: %v", result.Error)
+				}
+
+				if len(users) != limit {
+					t.Errorf("Expected %d users, got %d", limit, len(users))
+				}
+			},
+		},
+		{
+			name:   "limit = 0 (should not apply limit)",
+			limit:  0,
+			offset: 5,
+			setupQuery: func(db *gorm.DB) *gorm.DB {
+				return db.Model(&database.User{})
+			},
+			verifyPagination: func(t *testing.T, query *gorm.DB, limit, offset int) {
+				for i := 0; i < 10; i++ {
+					suite.CreateTestUser(
+						fmt.Sprintf("testuser_%d", i),
+						fmt.Sprintf("user%d@example.com", i),
+						"password123",
+					)
+				}
+
+				var users []database.User
+				result := query.Find(&users)
+				if result.Error != nil {
+					t.Fatalf("Query failed: %v", result.Error)
+				}
+
+				expected := 5
+				if len(users) != expected {
+					t.Errorf("Expected %d users with offset %d, got %d", expected, offset, len(users))
+				}
+			},
+		},
+		{
+			name:   "offset = 0 (should not apply offset)",
+			limit:  10,
+			offset: 0,
+			setupQuery: func(db *gorm.DB) *gorm.DB {
+				return db.Model(&database.User{})
+			},
+			verifyPagination: func(t *testing.T, query *gorm.DB, limit, offset int) {
+				for i := 0; i < 15; i++ {
+					suite.CreateTestUser(
+						fmt.Sprintf("testuser_%d", i),
+						fmt.Sprintf("user%d@example.com", i),
+						"password123",
+					)
+				}
+
+				var users []database.User
+				result := query.Find(&users)
+				if result.Error != nil {
+					t.Fatalf("Query failed: %v", result.Error)
+				}
+
+				if len(users) != limit {
+					t.Errorf("Expected %d users, got %d", limit, len(users))
+				}
+			},
+		},
+		{
+			name:   "limit = 0 and offset = 0 (should not apply pagination)",
+			limit:  0,
+			offset: 0,
+			setupQuery: func(db *gorm.DB) *gorm.DB {
+				return db.Model(&database.User{})
+			},
+			verifyPagination: func(t *testing.T, query *gorm.DB, limit, offset int) {
+				for i := 0; i < 10; i++ {
+					suite.CreateTestUser(
+						fmt.Sprintf("testuser_%d", i),
+						fmt.Sprintf("user%d@example.com", i),
+						"password123",
+					)
+				}
+
+				var users []database.User
+				result := query.Find(&users)
+				if result.Error != nil {
+					t.Fatalf("Query failed: %v", result.Error)
+				}
+
+				if len(users) != 10 {
+					t.Errorf("Expected all 10 users, got %d", len(users))
+				}
+			},
+		},
+		{
+			name:   "negative limit (should not apply limit)",
+			limit:  -5,
+			offset: 10,
+			setupQuery: func(db *gorm.DB) *gorm.DB {
+				return db.Model(&database.User{})
+			},
+			verifyPagination: func(t *testing.T, query *gorm.DB, limit, offset int) {
+				for i := 0; i < 20; i++ {
+					suite.CreateTestUser(
+						fmt.Sprintf("testuser_%d", i),
+						fmt.Sprintf("user%d@example.com", i),
+						"password123",
+					)
+				}
+
+				var users []database.User
+				result := query.Find(&users)
+				if result.Error != nil {
+					t.Fatalf("Query failed: %v", result.Error)
+				}
+
+				expected := 10
+				if len(users) != expected {
+					t.Errorf("Expected %d users with offset %d, got %d", expected, offset, len(users))
+				}
+			},
+		},
+		{
+			name:   "negative offset (should not apply offset)",
+			limit:  10,
+			offset: -5,
+			setupQuery: func(db *gorm.DB) *gorm.DB {
+				return db.Model(&database.User{})
+			},
+			verifyPagination: func(t *testing.T, query *gorm.DB, limit, offset int) {
+				for i := 0; i < 15; i++ {
+					suite.CreateTestUser(
+						fmt.Sprintf("testuser_%d", i),
+						fmt.Sprintf("user%d@example.com", i),
+						"password123",
+					)
+				}
+
+				var users []database.User
+				result := query.Find(&users)
+				if result.Error != nil {
+					t.Fatalf("Query failed: %v", result.Error)
+				}
+
+				if len(users) != limit {
+					t.Errorf("Expected %d users, got %d", limit, len(users))
+				}
+			},
+		},
+		{
+			name:   "large limit and offset values",
+			limit:  1000,
+			offset: 500,
+			setupQuery: func(db *gorm.DB) *gorm.DB {
+				return db.Model(&database.User{})
+			},
+			verifyPagination: func(t *testing.T, query *gorm.DB, limit, offset int) {
+				for i := 0; i < 2000; i++ {
+					suite.CreateTestUser(
+						fmt.Sprintf("testuser_%d", i),
+						fmt.Sprintf("user%d@example.com", i),
+						"password123",
+					)
+				}
+
+				var users []database.User
+				result := query.Find(&users)
+				if result.Error != nil {
+					t.Fatalf("Query failed: %v", result.Error)
+				}
+
+				if len(users) != limit {
+					t.Errorf("Expected %d users, got %d", limit, len(users))
+				}
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			suite.Reset()
+
+			baseQuery := tt.setupQuery(suite.DB)
+			paginatedQuery := ApplyPagination(baseQuery, tt.limit, tt.offset)
+
+			tt.verifyPagination(t, paginatedQuery, tt.limit, tt.offset)
+		})
+	}
+}