858 lines
23 KiB
Go
858 lines
23 KiB
Go
package repository
|
||
|
||
import (
|
||
"testing"
|
||
"time"
|
||
|
||
"github.com/topfans/backend/pkg/database"
|
||
"github.com/topfans/backend/pkg/models"
|
||
"gorm.io/gorm"
|
||
)
|
||
|
||
// setupTestDB 设置测试数据库
|
||
func setupTestDB(t *testing.T) *gorm.DB {
|
||
config := database.Config{
|
||
Host: "localhost",
|
||
Port: 5432,
|
||
User: "haihuizhu",
|
||
Password: "admin",
|
||
DBName: "top-fans",
|
||
SSLMode: "disable",
|
||
TimeZone: "Asia/Shanghai",
|
||
}
|
||
|
||
if err := database.Init(config); err != nil {
|
||
t.Skipf("Skipping test: failed to connect to test database: %v", err)
|
||
}
|
||
|
||
db := database.GetDB()
|
||
|
||
// 只迁移好友相关表（假设基础表已存在）
|
||
// 注意：如果表已存在，AutoMigrate会自动更新表结构
|
||
if err := db.AutoMigrate(&models.FriendRequest{}, &models.Friendship{}); err != nil {
|
||
t.Logf("Warning: Failed to migrate friend tables (may already exist): %v", err)
|
||
// 不要失败，继续测试
|
||
}
|
||
|
||
return db
|
||
}
|
||
|
||
// cleanupTestDB 清理测试数据
|
||
func cleanupTestDB(t *testing.T, db *gorm.DB) {
|
||
// 清理测试数据（注意外键约束顺序）
|
||
db.Exec("DELETE FROM friendships WHERE user_id IN (SELECT id FROM users WHERE mobile LIKE '188%')")
|
||
db.Exec("DELETE FROM friend_requests WHERE from_user_id IN (SELECT id FROM users WHERE mobile LIKE '188%')")
|
||
db.Exec("DELETE FROM fan_profiles WHERE user_id IN (SELECT id FROM users WHERE mobile LIKE '188%')")
|
||
db.Exec("DELETE FROM users WHERE mobile LIKE '188%'")
|
||
db.Exec("DELETE FROM stars WHERE identity_id LIKE 'test_social_%'")
|
||
}
|
||
|
||
// createTestStar 创建测试用明星
|
||
func createTestStar(t *testing.T, db *gorm.DB, identityID string) *models.Star {
|
||
star := &models.Star{
|
||
Name: "测试明星-" + identityID,
|
||
IdentityID: identityID,
|
||
IsActive: true,
|
||
}
|
||
if err := db.Create(star).Error; err != nil {
|
||
t.Fatalf("Failed to create test star: %v", err)
|
||
}
|
||
return star
|
||
}
|
||
|
||
// createTestUser 创建测试用户
|
||
func createTestUser(t *testing.T, db *gorm.DB, mobile string) *models.User {
|
||
user := &models.User{
|
||
Mobile: mobile,
|
||
PasswordHash: "test_hash",
|
||
IsActive: true,
|
||
}
|
||
if err := db.Create(user).Error; err != nil {
|
||
t.Fatalf("Failed to create test user: %v", err)
|
||
}
|
||
return user
|
||
}
|
||
|
||
// createTestFanProfile 创建测试粉丝档案
|
||
func createTestFanProfile(t *testing.T, db *gorm.DB, userID, starID int64, nickname string) *models.FanProfile {
|
||
profile := &models.FanProfile{
|
||
UserID: userID,
|
||
StarID: starID,
|
||
Nickname: nickname,
|
||
Level: 1,
|
||
Social: 0,
|
||
}
|
||
if err := db.Create(profile).Error; err != nil {
|
||
t.Fatalf("Failed to create test fan profile: %v", err)
|
||
}
|
||
return profile
|
||
}
|
||
|
||
// ==================== 好友请求相关测试 ====================
|
||
|
||
func TestSocialRepository_CreateRequest(t *testing.T) {
|
||
db := setupTestDB(t)
|
||
defer cleanupTestDB(t, db)
|
||
|
||
repo := NewSocialRepository()
|
||
|
||
// 创建测试数据
|
||
star := createTestStar(t, db, "test_social_001")
|
||
user1 := createTestUser(t, db, "18800000001")
|
||
user2 := createTestUser(t, db, "18800000002")
|
||
|
||
// 创建好友请求
|
||
expiresAt := time.Now().Add(30 * 24 * time.Hour).UnixMilli()
|
||
message := "你好，我想加你为好友"
|
||
request := &models.FriendRequest{
|
||
FromUserID: user1.ID,
|
||
ToUserID: user2.ID,
|
||
StarID: star.StarID,
|
||
Message: &message,
|
||
Status: models.FriendRequestStatusPending,
|
||
ExpiresAt: &expiresAt,
|
||
}
|
||
|
||
err := repo.CreateRequest(request)
|
||
if err != nil {
|
||
t.Fatalf("CreateRequest failed: %v", err)
|
||
}
|
||
|
||
// 验证
|
||
if request.ID == 0 {
|
||
t.Fatal("Request ID should not be zero after creation")
|
||
}
|
||
|
||
if request.CreatedAt == 0 {
|
||
t.Fatal("CreatedAt should be set")
|
||
}
|
||
|
||
// 测试nil请求
|
||
err = repo.CreateRequest(nil)
|
||
if err == nil {
|
||
t.Fatal("Expected error for nil request")
|
||
}
|
||
}
|
||
|
||
func TestSocialRepository_GetRequestByID(t *testing.T) {
|
||
db := setupTestDB(t)
|
||
defer cleanupTestDB(t, db)
|
||
|
||
repo := NewSocialRepository()
|
||
|
||
// 创建测试数据
|
||
star := createTestStar(t, db, "test_social_002")
|
||
user1 := createTestUser(t, db, "18800000003")
|
||
user2 := createTestUser(t, db, "18800000004")
|
||
|
||
expiresAt := time.Now().Add(30 * 24 * time.Hour).UnixMilli()
|
||
message := "测试消息"
|
||
request := &models.FriendRequest{
|
||
FromUserID: user1.ID,
|
||
ToUserID: user2.ID,
|
||
StarID: star.StarID,
|
||
Message: &message,
|
||
Status: models.FriendRequestStatusPending,
|
||
ExpiresAt: &expiresAt,
|
||
}
|
||
db.Create(request)
|
||
|
||
// 测试正常查询
|
||
retrieved, err := repo.GetRequestByID(request.ID)
|
||
if err != nil {
|
||
t.Fatalf("GetRequestByID failed: %v", err)
|
||
}
|
||
|
||
if retrieved == nil {
|
||
t.Fatal("Retrieved request should not be nil")
|
||
}
|
||
|
||
if retrieved.ID != request.ID {
|
||
t.Errorf("ID mismatch: expected %d, got %d", request.ID, retrieved.ID)
|
||
}
|
||
|
||
if retrieved.FromUserID != user1.ID {
|
||
t.Errorf("FromUserID mismatch: expected %d, got %d", user1.ID, retrieved.FromUserID)
|
||
}
|
||
|
||
// 测试不存在的请求
|
||
retrieved, err = repo.GetRequestByID(99999)
|
||
if err != nil {
|
||
t.Fatalf("GetRequestByID failed for non-existent request: %v", err)
|
||
}
|
||
|
||
if retrieved != nil {
|
||
t.Fatal("Expected nil for non-existent request")
|
||
}
|
||
}
|
||
|
||
func TestSocialRepository_GetRequestsByUser(t *testing.T) {
|
||
db := setupTestDB(t)
|
||
defer cleanupTestDB(t, db)
|
||
|
||
repo := NewSocialRepository()
|
||
|
||
// 创建测试数据
|
||
star := createTestStar(t, db, "test_social_003")
|
||
user1 := createTestUser(t, db, "18800000005")
|
||
user2 := createTestUser(t, db, "18800000006")
|
||
user3 := createTestUser(t, db, "18800000007")
|
||
|
||
// 创建多个请求
|
||
expiresAt := time.Now().Add(30 * 24 * time.Hour).UnixMilli()
|
||
message := "测试消息"
|
||
|
||
// user1 -> user2 (pending)
|
||
request1 := &models.FriendRequest{
|
||
FromUserID: user1.ID,
|
||
ToUserID: user2.ID,
|
||
StarID: star.StarID,
|
||
Message: &message,
|
||
Status: models.FriendRequestStatusPending,
|
||
ExpiresAt: &expiresAt,
|
||
}
|
||
db.Create(request1)
|
||
|
||
// user1 -> user3 (accepted)
|
||
request2 := &models.FriendRequest{
|
||
FromUserID: user1.ID,
|
||
ToUserID: user3.ID,
|
||
StarID: star.StarID,
|
||
Message: &message,
|
||
Status: models.FriendRequestStatusAccepted,
|
||
ExpiresAt: &expiresAt,
|
||
}
|
||
db.Create(request2)
|
||
|
||
// user3 -> user1 (pending)
|
||
request3 := &models.FriendRequest{
|
||
FromUserID: user3.ID,
|
||
ToUserID: user1.ID,
|
||
StarID: star.StarID,
|
||
Message: &message,
|
||
Status: models.FriendRequestStatusPending,
|
||
ExpiresAt: &expiresAt,
|
||
}
|
||
db.Create(request3)
|
||
|
||
// 测试获取发出的请求（sent）
|
||
sentRequests, total, err := repo.GetRequestsByUser(user1.ID, star.StarID, models.FriendRequestTypeSent, "", 1, 10)
|
||
if err != nil {
|
||
t.Fatalf("GetRequestsByUser (sent) failed: %v", err)
|
||
}
|
||
|
||
if total != 2 {
|
||
t.Errorf("Expected 2 sent requests, got %d", total)
|
||
}
|
||
|
||
if len(sentRequests) != 2 {
|
||
t.Errorf("Expected 2 sent requests in list, got %d", len(sentRequests))
|
||
}
|
||
|
||
// 测试获取收到的请求（received）
|
||
_, total, err = repo.GetRequestsByUser(user1.ID, star.StarID, models.FriendRequestTypeReceived, "", 1, 10)
|
||
if err != nil {
|
||
t.Fatalf("GetRequestsByUser (received) failed: %v", err)
|
||
}
|
||
|
||
if total != 1 {
|
||
t.Errorf("Expected 1 received request, got %d", total)
|
||
}
|
||
|
||
// 测试状态筛选
|
||
_, total, err = repo.GetRequestsByUser(user1.ID, star.StarID, models.FriendRequestTypeSent, models.FriendRequestStatusPending, 1, 10)
|
||
if err != nil {
|
||
t.Fatalf("GetRequestsByUser (pending) failed: %v", err)
|
||
}
|
||
|
||
if total != 1 {
|
||
t.Errorf("Expected 1 pending sent request, got %d", total)
|
||
}
|
||
|
||
// 测试分页
|
||
pagedRequests, total, err := repo.GetRequestsByUser(user1.ID, star.StarID, models.FriendRequestTypeSent, "", 1, 1)
|
||
if err != nil {
|
||
t.Fatalf("GetRequestsByUser (paged) failed: %v", err)
|
||
}
|
||
|
||
if total != 2 {
|
||
t.Errorf("Expected total 2, got %d", total)
|
||
}
|
||
|
||
if len(pagedRequests) != 1 {
|
||
t.Errorf("Expected 1 request in page, got %d", len(pagedRequests))
|
||
}
|
||
|
||
// 测试无效的请求类型
|
||
_, _, err = repo.GetRequestsByUser(user1.ID, star.StarID, "invalid", "", 1, 10)
|
||
if err == nil {
|
||
t.Fatal("Expected error for invalid request type")
|
||
}
|
||
}
|
||
|
||
func TestSocialRepository_GetLatestRequest(t *testing.T) {
|
||
db := setupTestDB(t)
|
||
defer cleanupTestDB(t, db)
|
||
|
||
repo := NewSocialRepository()
|
||
|
||
// 创建测试数据
|
||
star := createTestStar(t, db, "test_social_004")
|
||
user1 := createTestUser(t, db, "18800000008")
|
||
user2 := createTestUser(t, db, "18800000009")
|
||
|
||
// 创建多个历史请求
|
||
expiresAt := time.Now().Add(30 * 24 * time.Hour).UnixMilli()
|
||
message := "第一次请求"
|
||
|
||
// 第一次请求（rejected）
|
||
request1 := &models.FriendRequest{
|
||
FromUserID: user1.ID,
|
||
ToUserID: user2.ID,
|
||
StarID: star.StarID,
|
||
Message: &message,
|
||
Status: models.FriendRequestStatusRejected,
|
||
ExpiresAt: &expiresAt,
|
||
}
|
||
db.Create(request1)
|
||
|
||
time.Sleep(10 * time.Millisecond) // 确保时间不同
|
||
|
||
// 第二次请求（pending）
|
||
message2 := "第二次请求"
|
||
request2 := &models.FriendRequest{
|
||
FromUserID: user1.ID,
|
||
ToUserID: user2.ID,
|
||
StarID: star.StarID,
|
||
Message: &message2,
|
||
Status: models.FriendRequestStatusPending,
|
||
ExpiresAt: &expiresAt,
|
||
}
|
||
db.Create(request2)
|
||
|
||
// 获取最新请求
|
||
latest, err := repo.GetLatestRequest(user1.ID, user2.ID, star.StarID)
|
||
if err != nil {
|
||
t.Fatalf("GetLatestRequest failed: %v", err)
|
||
}
|
||
|
||
if latest == nil {
|
||
t.Fatal("Latest request should not be nil")
|
||
}
|
||
|
||
if latest.ID != request2.ID {
|
||
t.Errorf("Expected latest request ID %d, got %d", request2.ID, latest.ID)
|
||
}
|
||
|
||
if latest.Status != models.FriendRequestStatusPending {
|
||
t.Errorf("Expected status pending, got %s", latest.Status)
|
||
}
|
||
|
||
// 测试不存在的请求
|
||
latest, err = repo.GetLatestRequest(99999, 99999, star.StarID)
|
||
if err != nil {
|
||
t.Fatalf("GetLatestRequest failed for non-existent: %v", err)
|
||
}
|
||
|
||
if latest != nil {
|
||
t.Fatal("Expected nil for non-existent request")
|
||
}
|
||
}
|
||
|
||
func TestSocialRepository_UpdateRequestStatus(t *testing.T) {
|
||
db := setupTestDB(t)
|
||
defer cleanupTestDB(t, db)
|
||
|
||
repo := NewSocialRepository()
|
||
|
||
// 创建测试数据
|
||
star := createTestStar(t, db, "test_social_005")
|
||
user1 := createTestUser(t, db, "18800000010")
|
||
user2 := createTestUser(t, db, "18800000011")
|
||
|
||
expiresAt := time.Now().Add(30 * 24 * time.Hour).UnixMilli()
|
||
message := "测试消息"
|
||
request := &models.FriendRequest{
|
||
FromUserID: user1.ID,
|
||
ToUserID: user2.ID,
|
||
StarID: star.StarID,
|
||
Message: &message,
|
||
Status: models.FriendRequestStatusPending,
|
||
ExpiresAt: &expiresAt,
|
||
}
|
||
db.Create(request)
|
||
|
||
// 更新状态（不更新处理时间）
|
||
err := repo.UpdateRequestStatus(request.ID, models.FriendRequestStatusAccepted, nil)
|
||
if err != nil {
|
||
t.Fatalf("UpdateRequestStatus failed: %v", err)
|
||
}
|
||
|
||
// 验证更新
|
||
retrieved, _ := repo.GetRequestByID(request.ID)
|
||
if retrieved.Status != models.FriendRequestStatusAccepted {
|
||
t.Errorf("Expected status accepted, got %s", retrieved.Status)
|
||
}
|
||
|
||
if retrieved.ProcessedAt != nil {
|
||
t.Error("ProcessedAt should be nil when not provided")
|
||
}
|
||
|
||
// 更新状态（更新处理时间）
|
||
processedAt := time.Now().UnixMilli()
|
||
err = repo.UpdateRequestStatus(request.ID, models.FriendRequestStatusRejected, &processedAt)
|
||
if err != nil {
|
||
t.Fatalf("UpdateRequestStatus with processedAt failed: %v", err)
|
||
}
|
||
|
||
// 验证更新
|
||
retrieved, _ = repo.GetRequestByID(request.ID)
|
||
if retrieved.Status != models.FriendRequestStatusRejected {
|
||
t.Errorf("Expected status rejected, got %s", retrieved.Status)
|
||
}
|
||
|
||
if retrieved.ProcessedAt == nil {
|
||
t.Fatal("ProcessedAt should not be nil")
|
||
}
|
||
|
||
if *retrieved.ProcessedAt != processedAt {
|
||
t.Errorf("ProcessedAt mismatch: expected %d, got %d", processedAt, *retrieved.ProcessedAt)
|
||
}
|
||
|
||
// 测试不存在的请求
|
||
err = repo.UpdateRequestStatus(99999, models.FriendRequestStatusAccepted, nil)
|
||
if err == nil {
|
||
t.Fatal("Expected error for non-existent request")
|
||
}
|
||
}
|
||
|
||
// ==================== 好友关系相关测试 ====================
|
||
|
||
func TestSocialRepository_CreateFriendshipPair(t *testing.T) {
|
||
db := setupTestDB(t)
|
||
defer cleanupTestDB(t, db)
|
||
|
||
repo := NewSocialRepository()
|
||
|
||
// 创建测试数据
|
||
star := createTestStar(t, db, "test_social_006")
|
||
user1 := createTestUser(t, db, "18800000012")
|
||
user2 := createTestUser(t, db, "18800000013")
|
||
|
||
// 创建双向好友关系
|
||
err := repo.CreateFriendshipPair(user1.ID, user2.ID, star.StarID)
|
||
if err != nil {
|
||
t.Fatalf("CreateFriendshipPair failed: %v", err)
|
||
}
|
||
|
||
// 验证 A→B 关系
|
||
var friendship1 models.Friendship
|
||
err = db.Where("user_id = ? AND friend_id = ? AND star_id = ?", user1.ID, user2.ID, star.StarID).First(&friendship1).Error
|
||
if err != nil {
|
||
t.Fatalf("Failed to find friendship A→B: %v", err)
|
||
}
|
||
|
||
if friendship1.Status != models.FriendshipStatusAccepted {
|
||
t.Errorf("Expected status accepted, got %s", friendship1.Status)
|
||
}
|
||
|
||
// 验证 B→A 关系
|
||
var friendship2 models.Friendship
|
||
err = db.Where("user_id = ? AND friend_id = ? AND star_id = ?", user2.ID, user1.ID, star.StarID).First(&friendship2).Error
|
||
if err != nil {
|
||
t.Fatalf("Failed to find friendship B→A: %v", err)
|
||
}
|
||
|
||
if friendship2.Status != models.FriendshipStatusAccepted {
|
||
t.Errorf("Expected status accepted, got %s", friendship2.Status)
|
||
}
|
||
|
||
// 测试重复创建（应该失败，因为有唯一索引）
|
||
err = repo.CreateFriendshipPair(user1.ID, user2.ID, star.StarID)
|
||
if err == nil {
|
||
t.Fatal("Expected error for duplicate friendship")
|
||
}
|
||
}
|
||
|
||
func TestSocialRepository_CheckFriendship(t *testing.T) {
|
||
db := setupTestDB(t)
|
||
defer cleanupTestDB(t, db)
|
||
|
||
repo := NewSocialRepository()
|
||
|
||
// 创建测试数据
|
||
star := createTestStar(t, db, "test_social_007")
|
||
user1 := createTestUser(t, db, "18800000014")
|
||
user2 := createTestUser(t, db, "18800000015")
|
||
user3 := createTestUser(t, db, "18800000016")
|
||
|
||
// 创建好友关系
|
||
repo.CreateFriendshipPair(user1.ID, user2.ID, star.StarID)
|
||
|
||
// 测试已存在的好友关系
|
||
isFriend, err := repo.CheckFriendship(user1.ID, user2.ID, star.StarID)
|
||
if err != nil {
|
||
t.Fatalf("CheckFriendship failed: %v", err)
|
||
}
|
||
|
||
if !isFriend {
|
||
t.Error("Expected users to be friends")
|
||
}
|
||
|
||
// 测试反向关系
|
||
isFriend, err = repo.CheckFriendship(user2.ID, user1.ID, star.StarID)
|
||
if err != nil {
|
||
t.Fatalf("CheckFriendship (reverse) failed: %v", err)
|
||
}
|
||
|
||
if !isFriend {
|
||
t.Error("Expected reverse friendship to exist")
|
||
}
|
||
|
||
// 测试不存在的好友关系
|
||
isFriend, err = repo.CheckFriendship(user1.ID, user3.ID, star.StarID)
|
||
if err != nil {
|
||
t.Fatalf("CheckFriendship (non-friend) failed: %v", err)
|
||
}
|
||
|
||
if isFriend {
|
||
t.Error("Expected users to not be friends")
|
||
}
|
||
}
|
||
|
||
func TestSocialRepository_GetFriendsByUser(t *testing.T) {
|
||
db := setupTestDB(t)
|
||
defer cleanupTestDB(t, db)
|
||
|
||
repo := NewSocialRepository()
|
||
|
||
// 创建测试数据
|
||
star := createTestStar(t, db, "test_social_008")
|
||
user1 := createTestUser(t, db, "18800000017")
|
||
user2 := createTestUser(t, db, "18800000018")
|
||
user3 := createTestUser(t, db, "18800000019")
|
||
user4 := createTestUser(t, db, "18800000020")
|
||
|
||
// 创建粉丝档案（为关键词搜索准备）
|
||
createTestFanProfile(t, db, user2.ID, star.StarID, "张三")
|
||
createTestFanProfile(t, db, user3.ID, star.StarID, "李四")
|
||
createTestFanProfile(t, db, user4.ID, star.StarID, "王五")
|
||
|
||
// 创建好友关系
|
||
repo.CreateFriendshipPair(user1.ID, user2.ID, star.StarID)
|
||
repo.CreateFriendshipPair(user1.ID, user3.ID, star.StarID)
|
||
repo.CreateFriendshipPair(user1.ID, user4.ID, star.StarID)
|
||
|
||
// 设置备注
|
||
remark := "小张"
|
||
db.Model(&models.Friendship{}).Where("user_id = ? AND friend_id = ?", user1.ID, user2.ID).Update("remark", remark)
|
||
|
||
// 测试获取所有好友
|
||
friends, total, err := repo.GetFriendsByUser(user1.ID, star.StarID, "", 1, 10)
|
||
if err != nil {
|
||
t.Fatalf("GetFriendsByUser failed: %v", err)
|
||
}
|
||
|
||
if total != 3 {
|
||
t.Errorf("Expected 3 friends, got %d", total)
|
||
}
|
||
|
||
if len(friends) != 3 {
|
||
t.Errorf("Expected 3 friends in list, got %d", len(friends))
|
||
}
|
||
|
||
// 测试关键词搜索（搜索昵称）
|
||
friends, total, err = repo.GetFriendsByUser(user1.ID, star.StarID, "张", 1, 10)
|
||
if err != nil {
|
||
t.Fatalf("GetFriendsByUser with keyword failed: %v", err)
|
||
}
|
||
|
||
if total != 1 {
|
||
t.Errorf("Expected 1 friend matching '张', got %d", total)
|
||
}
|
||
|
||
// 测试关键词搜索（搜索备注）
|
||
friends, total, err = repo.GetFriendsByUser(user1.ID, star.StarID, "小张", 1, 10)
|
||
if err != nil {
|
||
t.Fatalf("GetFriendsByUser with remark keyword failed: %v", err)
|
||
}
|
||
|
||
if total != 1 {
|
||
t.Errorf("Expected 1 friend matching '小张', got %d", total)
|
||
}
|
||
|
||
// 测试分页
|
||
friends, total, err = repo.GetFriendsByUser(user1.ID, star.StarID, "", 1, 2)
|
||
if err != nil {
|
||
t.Fatalf("GetFriendsByUser with pagination failed: %v", err)
|
||
}
|
||
|
||
if total != 3 {
|
||
t.Errorf("Expected total 3, got %d", total)
|
||
}
|
||
|
||
if len(friends) != 2 {
|
||
t.Errorf("Expected 2 friends in first page, got %d", len(friends))
|
||
}
|
||
|
||
// 测试第二页
|
||
friends, total, err = repo.GetFriendsByUser(user1.ID, star.StarID, "", 2, 2)
|
||
if err != nil {
|
||
t.Fatalf("GetFriendsByUser second page failed: %v", err)
|
||
}
|
||
|
||
if len(friends) != 1 {
|
||
t.Errorf("Expected 1 friend in second page, got %d", len(friends))
|
||
}
|
||
}
|
||
|
||
func TestSocialRepository_DeleteFriendshipPair(t *testing.T) {
|
||
db := setupTestDB(t)
|
||
defer cleanupTestDB(t, db)
|
||
|
||
repo := NewSocialRepository()
|
||
|
||
// 创建测试数据
|
||
star := createTestStar(t, db, "test_social_009")
|
||
user1 := createTestUser(t, db, "18800000021")
|
||
user2 := createTestUser(t, db, "18800000022")
|
||
|
||
// 创建好友关系
|
||
repo.CreateFriendshipPair(user1.ID, user2.ID, star.StarID)
|
||
|
||
// 验证关系存在
|
||
isFriend, _ := repo.CheckFriendship(user1.ID, user2.ID, star.StarID)
|
||
if !isFriend {
|
||
t.Fatal("Friendship should exist before deletion")
|
||
}
|
||
|
||
// 删除好友关系
|
||
err := repo.DeleteFriendshipPair(user1.ID, user2.ID, star.StarID)
|
||
if err != nil {
|
||
t.Fatalf("DeleteFriendshipPair failed: %v", err)
|
||
}
|
||
|
||
// 验证 A→B 关系已删除
|
||
isFriend, _ = repo.CheckFriendship(user1.ID, user2.ID, star.StarID)
|
||
if isFriend {
|
||
t.Error("Friendship A→B should be deleted")
|
||
}
|
||
|
||
// 验证 B→A 关系已删除
|
||
isFriend, _ = repo.CheckFriendship(user2.ID, user1.ID, star.StarID)
|
||
if isFriend {
|
||
t.Error("Friendship B→A should be deleted")
|
||
}
|
||
|
||
// 测试删除不存在的关系
|
||
err = repo.DeleteFriendshipPair(user1.ID, user2.ID, star.StarID)
|
||
if err == nil {
|
||
t.Fatal("Expected error for non-existent friendship")
|
||
}
|
||
}
|
||
|
||
func TestSocialRepository_UpdateRemark(t *testing.T) {
|
||
db := setupTestDB(t)
|
||
defer cleanupTestDB(t, db)
|
||
|
||
repo := NewSocialRepository()
|
||
|
||
// 创建测试数据
|
||
star := createTestStar(t, db, "test_social_010")
|
||
user1 := createTestUser(t, db, "18800000023")
|
||
user2 := createTestUser(t, db, "18800000024")
|
||
|
||
// 创建好友关系
|
||
repo.CreateFriendshipPair(user1.ID, user2.ID, star.StarID)
|
||
|
||
// 更新备注
|
||
newRemark := "我的好朋友"
|
||
err := repo.UpdateRemark(user1.ID, user2.ID, star.StarID, newRemark)
|
||
if err != nil {
|
||
t.Fatalf("UpdateRemark failed: %v", err)
|
||
}
|
||
|
||
// 验证更新
|
||
var friendship models.Friendship
|
||
db.Where("user_id = ? AND friend_id = ? AND star_id = ?", user1.ID, user2.ID, star.StarID).First(&friendship)
|
||
|
||
if friendship.Remark == nil {
|
||
t.Fatal("Remark should not be nil")
|
||
}
|
||
|
||
if *friendship.Remark != newRemark {
|
||
t.Errorf("Remark mismatch: expected %s, got %s", newRemark, *friendship.Remark)
|
||
}
|
||
|
||
// 验证反向关系的备注未改变
|
||
var reverseFriendship models.Friendship
|
||
db.Where("user_id = ? AND friend_id = ? AND star_id = ?", user2.ID, user1.ID, star.StarID).First(&reverseFriendship)
|
||
|
||
if reverseFriendship.Remark != nil {
|
||
t.Error("Reverse friendship remark should not be updated")
|
||
}
|
||
|
||
// 测试更新不存在的关系
|
||
err = repo.UpdateRemark(99999, 99999, star.StarID, "test")
|
||
if err == nil {
|
||
t.Fatal("Expected error for non-existent friendship")
|
||
}
|
||
}
|
||
|
||
func TestSocialRepository_CountFriends(t *testing.T) {
|
||
db := setupTestDB(t)
|
||
defer cleanupTestDB(t, db)
|
||
|
||
repo := NewSocialRepository()
|
||
|
||
// 创建测试数据
|
||
star := createTestStar(t, db, "test_social_011")
|
||
user1 := createTestUser(t, db, "18800000025")
|
||
user2 := createTestUser(t, db, "18800000026")
|
||
user3 := createTestUser(t, db, "18800000027")
|
||
user4 := createTestUser(t, db, "18800000028")
|
||
|
||
// 创建好友关系
|
||
repo.CreateFriendshipPair(user1.ID, user2.ID, star.StarID)
|
||
repo.CreateFriendshipPair(user1.ID, user3.ID, star.StarID)
|
||
repo.CreateFriendshipPair(user1.ID, user4.ID, star.StarID)
|
||
|
||
// 统计好友数量
|
||
count, err := repo.CountFriends(user1.ID, star.StarID)
|
||
if err != nil {
|
||
t.Fatalf("CountFriends failed: %v", err)
|
||
}
|
||
|
||
if count != 3 {
|
||
t.Errorf("Expected 3 friends, got %d", count)
|
||
}
|
||
|
||
// 测试user2的好友数量
|
||
count, err = repo.CountFriends(user2.ID, star.StarID)
|
||
if err != nil {
|
||
t.Fatalf("CountFriends for user2 failed: %v", err)
|
||
}
|
||
|
||
if count != 1 {
|
||
t.Errorf("Expected 1 friend for user2, got %d", count)
|
||
}
|
||
|
||
// 测试没有好友的用户
|
||
user5 := createTestUser(t, db, "18800000029")
|
||
count, err = repo.CountFriends(user5.ID, star.StarID)
|
||
if err != nil {
|
||
t.Fatalf("CountFriends for user with no friends failed: %v", err)
|
||
}
|
||
|
||
if count != 0 {
|
||
t.Errorf("Expected 0 friends, got %d", count)
|
||
}
|
||
}
|
||
|
||
// ==================== 边界情况和集成测试 ====================
|
||
|
||
func TestSocialRepository_CompleteFlow(t *testing.T) {
|
||
db := setupTestDB(t)
|
||
defer cleanupTestDB(t, db)
|
||
|
||
repo := NewSocialRepository()
|
||
|
||
// 创建测试数据
|
||
star := createTestStar(t, db, "test_social_012")
|
||
userA := createTestUser(t, db, "18800000030")
|
||
userB := createTestUser(t, db, "18800000031")
|
||
|
||
// 1. A 发送好友请求给 B
|
||
expiresAt := time.Now().Add(30 * 24 * time.Hour).UnixMilli()
|
||
message := "你好，我想加你为好友"
|
||
request := &models.FriendRequest{
|
||
FromUserID: userA.ID,
|
||
ToUserID: userB.ID,
|
||
StarID: star.StarID,
|
||
Message: &message,
|
||
Status: models.FriendRequestStatusPending,
|
||
ExpiresAt: &expiresAt,
|
||
}
|
||
err := repo.CreateRequest(request)
|
||
if err != nil {
|
||
t.Fatalf("Failed to create request: %v", err)
|
||
}
|
||
|
||
// 2. B 查看收到的请求
|
||
_, total, err := repo.GetRequestsByUser(userB.ID, star.StarID, models.FriendRequestTypeReceived, models.FriendRequestStatusPending, 1, 10)
|
||
if err != nil {
|
||
t.Fatalf("Failed to get received requests: %v", err)
|
||
}
|
||
|
||
if total != 1 {
|
||
t.Errorf("Expected 1 received request, got %d", total)
|
||
}
|
||
|
||
// 3. B 接受请求
|
||
processedAt := time.Now().UnixMilli()
|
||
err = repo.UpdateRequestStatus(request.ID, models.FriendRequestStatusAccepted, &processedAt)
|
||
if err != nil {
|
||
t.Fatalf("Failed to update request status: %v", err)
|
||
}
|
||
|
||
// 4. 创建双向好友关系
|
||
err = repo.CreateFriendshipPair(userA.ID, userB.ID, star.StarID)
|
||
if err != nil {
|
||
t.Fatalf("Failed to create friendship: %v", err)
|
||
}
|
||
|
||
// 5. 验证好友关系
|
||
isFriend, err := repo.CheckFriendship(userA.ID, userB.ID, star.StarID)
|
||
if err != nil || !isFriend {
|
||
t.Fatal("Failed to verify friendship")
|
||
}
|
||
|
||
// 6. A 设置 B 的备注
|
||
err = repo.UpdateRemark(userA.ID, userB.ID, star.StarID, "B的昵称")
|
||
if err != nil {
|
||
t.Fatalf("Failed to update remark: %v", err)
|
||
}
|
||
|
||
// 7. 查询好友列表
|
||
friends, _, err := repo.GetFriendsByUser(userA.ID, star.StarID, "", 1, 10)
|
||
if err != nil {
|
||
t.Fatalf("Failed to get friends: %v", err)
|
||
}
|
||
|
||
if len(friends) != 1 {
|
||
t.Errorf("Expected 1 friend, got %d", len(friends))
|
||
}
|
||
|
||
// 8. 统计好友数量
|
||
count, err := repo.CountFriends(userA.ID, star.StarID)
|
||
if err != nil {
|
||
t.Fatalf("Failed to count friends: %v", err)
|
||
}
|
||
|
||
if count != 1 {
|
||
t.Errorf("Expected count 1, got %d", count)
|
||
}
|
||
|
||
// 9. A 删除好友
|
||
err = repo.DeleteFriendshipPair(userA.ID, userB.ID, star.StarID)
|
||
if err != nil {
|
||
t.Fatalf("Failed to delete friendship: %v", err)
|
||
}
|
||
|
||
// 10. 验证好友关系已删除
|
||
isFriend, err = repo.CheckFriendship(userA.ID, userB.ID, star.StarID)
|
||
if err != nil || isFriend {
|
||
t.Fatal("Friendship should be deleted")
|
||
}
|
||
|
||
// 11. 验证好友数量为0
|
||
count, err = repo.CountFriends(userA.ID, star.StarID)
|
||
if err != nil {
|
||
t.Fatalf("Failed to count friends after deletion: %v", err)
|
||
}
|
||
|
||
if count != 0 {
|
||
t.Errorf("Expected count 0, got %d", count)
|
||
}
|
||
}
|