csxj2026/junhong_cmp_fiber
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects 1 Releases Wiki Activity

refactor: align framework cleanup with new bootstrap flow

Browse Source 
Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>
This commit is contained in:
huang
2025-11-19 12:47:25 +08:00
parent 39d14ec093
commit d66323487b
67 changed files with 3020 additions and 3992 deletions
Download Patch File Download Diff File Expand all files Collapse all files

303
tests/unit/data_permission_scope_test.go
View File

@@ -1,303 +0,0 @@
package unit
import (
"context"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/break/junhong_cmp_fiber/internal/model"
"github.com/break/junhong_cmp_fiber/internal/store/postgres"
"github.com/break/junhong_cmp_fiber/pkg/constants"
"github.com/break/junhong_cmp_fiber/pkg/middleware"
"github.com/break/junhong_cmp_fiber/tests/testutils"
)
// TestDataPermissionScope_RootUser 测试 root 用户跳过数据权限过滤
func TestDataPermissionScope_RootUser(t *testing.T) {
db, redisClient := testutils.SetupTestDB(t)
defer testutils.TeardownTestDB(t, db, redisClient)
accountStore := postgres.NewAccountStore(db, redisClient)
ctx := context.Background()
// 创建 root 用户
rootUser := &model.Account{
Username: "root_user",
Phone: "13800000000",
Password: "hashed_password",
UserType: constants.UserTypeRoot,
Status: constants.StatusEnabled,
Creator: 1,
Updater: 1,
}
require.NoError(t, db.Create(rootUser).Error)
// 创建测试数据表（模拟业务表）
type TestData struct {
ID uint `gorm:"primarykey"`
Name string
OwnerID uint
ShopID uint
}
require.NoError(t, db.AutoMigrate(&TestData{}))
// 插入测试数据（不同的 owner_id 和 shop_id）
testData := []TestData{
{Name: "data1", OwnerID: 1, ShopID: 100},
{Name: "data2", OwnerID: 2, ShopID: 200},
{Name: "data3", OwnerID: 3, ShopID: 300},
}
require.NoError(t, db.Create(&testData).Error)
// 设置 root 用户上下文
ctxWithRoot := middleware.SetUserContext(ctx, rootUser.ID, constants.UserTypeRoot, 100)
// 查询（应该返回所有数据，不过滤）
var results []TestData
err := db.WithContext(ctxWithRoot).
Scopes(postgres.DataPermissionScope(ctxWithRoot, accountStore)).
Find(&results).Error
require.NoError(t, err)
assert.Len(t, results, 3, "root 用户应该看到所有数据")
}
// TestDataPermissionScope_NormalUser 测试普通用户数据权限过滤
func TestDataPermissionScope_NormalUser(t *testing.T) {
db, redisClient := testutils.SetupTestDB(t)
defer testutils.TeardownTestDB(t, db, redisClient)
accountStore := postgres.NewAccountStore(db, redisClient)
ctx := context.Background()
// 创建账号层级: A -> B
accountA := &model.Account{
Username: "user_a",
Phone: "13800000001",
Password: "hashed_password",
UserType: constants.UserTypePlatform,
Status: constants.StatusEnabled,
Creator: 1,
Updater: 1,
}
require.NoError(t, db.Create(accountA).Error)
shopIDA := uint(100)
accountA.ShopID = &shopIDA
require.NoError(t, db.Save(accountA).Error)
accountB := &model.Account{
Username: "user_b",
Phone: "13800000002",
Password: "hashed_password",
UserType: constants.UserTypeAgent,
ParentID: &accountA.ID,
Status: constants.StatusEnabled,
Creator: 1,
Updater: 1,
}
require.NoError(t, db.Create(accountB).Error)
shopIDB := uint(100)
accountB.ShopID = &shopIDB
require.NoError(t, db.Save(accountB).Error)
// 创建测试数据表
type TestData struct {
ID uint `gorm:"primarykey"`
Name string
OwnerID uint
ShopID uint
}
require.NoError(t, db.AutoMigrate(&TestData{}))
// 插入测试数据
testData := []TestData{
{Name: "data_a", OwnerID: accountA.ID, ShopID: 100}, // A 的数据
{Name: "data_b", OwnerID: accountB.ID, ShopID: 100}, // B 的数据
{Name: "data_c", OwnerID: 999, ShopID: 100}, // 其他用户数据（同店铺）
{Name: "data_d", OwnerID: accountA.ID, ShopID: 200}, // A 的数据（不同店铺）
}
require.NoError(t, db.Create(&testData).Error)
// A 登录查询（应该看到 A 和 B 的数据，同店铺）
ctxWithA := middleware.SetUserContext(ctx, accountA.ID, constants.UserTypePlatform, 100)
var resultsA []TestData
err := db.WithContext(ctxWithA).
Scopes(postgres.DataPermissionScope(ctxWithA, accountStore)).
Find(&resultsA).Error
require.NoError(t, err)
assert.Len(t, resultsA, 2, "A 应该看到自己和下级 B 的数据")
// B 登录查询（只能看到自己的数据）
ctxWithB := middleware.SetUserContext(ctx, accountB.ID, constants.UserTypeAgent, 100)
var resultsB []TestData
err = db.WithContext(ctxWithB).
Scopes(postgres.DataPermissionScope(ctxWithB, accountStore)).
Find(&resultsB).Error
require.NoError(t, err)
assert.Len(t, resultsB, 1, "B 只能看到自己的数据")
assert.Equal(t, "data_b", resultsB[0].Name)
}
// TestDataPermissionScope_ShopIsolation 测试店铺隔离
func TestDataPermissionScope_ShopIsolation(t *testing.T) {
db, redisClient := testutils.SetupTestDB(t)
defer testutils.TeardownTestDB(t, db, redisClient)
accountStore := postgres.NewAccountStore(db, redisClient)
ctx := context.Background()
// 创建两个账号（同一层级，不同店铺）
shopID100 := uint(100)
accountA := &model.Account{
Username: "user_a",
Phone: "13800000001",
Password: "hashed_password",
UserType: constants.UserTypePlatform,
ShopID: &shopID100,
Status: constants.StatusEnabled,
Creator: 1,
Updater: 1,
}
require.NoError(t, db.Create(accountA).Error)
shopID200 := uint(200)
accountB := &model.Account{
Username: "user_b",
Phone: "13800000002",
Password: "hashed_password",
UserType: constants.UserTypePlatform,
ShopID: &shopID200,
Status: constants.StatusEnabled,
Creator: 1,
Updater: 1,
}
require.NoError(t, db.Create(accountB).Error)
// 创建测试数据表
type TestData struct {
ID uint `gorm:"primarykey"`
Name string
OwnerID uint
ShopID uint
}
require.NoError(t, db.AutoMigrate(&TestData{}))
// 插入测试数据
testData := []TestData{
{Name: "data_shop100", OwnerID: accountA.ID, ShopID: 100},
{Name: "data_shop200", OwnerID: accountB.ID, ShopID: 200},
}
require.NoError(t, db.Create(&testData).Error)
// A 登录查询（只能看到店铺 100 的数据）
ctxWithA := middleware.SetUserContext(ctx, accountA.ID, constants.UserTypePlatform, 100)
var resultsA []TestData
err := db.WithContext(ctxWithA).
Scopes(postgres.DataPermissionScope(ctxWithA, accountStore)).
Find(&resultsA).Error
require.NoError(t, err)
assert.Len(t, resultsA, 1, "A 只能看到店铺 100 的数据")
assert.Equal(t, "data_shop100", resultsA[0].Name)
// B 登录查询（只能看到店铺 200 的数据）
ctxWithB := middleware.SetUserContext(ctx, accountB.ID, constants.UserTypePlatform, 200)
var resultsB []TestData
err = db.WithContext(ctxWithB).
Scopes(postgres.DataPermissionScope(ctxWithB, accountStore)).
Find(&resultsB).Error
require.NoError(t, err)
assert.Len(t, resultsB, 1, "B 只能看到店铺 200 的数据")
assert.Equal(t, "data_shop200", resultsB[0].Name)
}
// TestDataPermissionScope_NoUserContext 测试无用户上下文时不过滤
func TestDataPermissionScope_NoUserContext(t *testing.T) {
db, redisClient := testutils.SetupTestDB(t)
defer testutils.TeardownTestDB(t, db, redisClient)
accountStore := postgres.NewAccountStore(db, redisClient)
ctx := context.Background()
// 创建测试数据表
type TestData struct {
ID uint `gorm:"primarykey"`
Name string
OwnerID uint
ShopID uint
}
require.NoError(t, db.AutoMigrate(&TestData{}))
// 插入测试数据
testData := []TestData{
{Name: "data1", OwnerID: 1, ShopID: 100},
{Name: "data2", OwnerID: 2, ShopID: 200},
}
require.NoError(t, db.Create(&testData).Error)
// 使用没有用户信息的上下文查询（不过滤，可能是系统任务）
var results []TestData
err := db.WithContext(ctx).
Scopes(postgres.DataPermissionScope(ctx, accountStore)).
Find(&results).Error
require.NoError(t, err)
assert.Len(t, results, 0, "无用户上下文时应该返回空数据（根据 scopes.go 的实现）")
}
// TestDataPermissionScope_ErrorHandling 测试查询下级 ID 失败时的降级策略
func TestDataPermissionScope_ErrorHandling(t *testing.T) {
db, redisClient := testutils.SetupTestDB(t)
defer testutils.TeardownTestDB(t, db, redisClient)
accountStore := postgres.NewAccountStore(db, redisClient)
ctx := context.Background()
// 创建测试账号
accountA := &model.Account{
Username: "user_a",
Phone: "13800000001",
Password: "hashed_password",
UserType: constants.UserTypePlatform,
Status: constants.StatusEnabled,
Creator: 1,
Updater: 1,
}
require.NoError(t, db.Create(accountA).Error)
shopIDA := uint(100)
accountA.ShopID = &shopIDA
require.NoError(t, db.Save(accountA).Error)
// 创建测试数据表
type TestData struct {
ID uint `gorm:"primarykey"`
Name string
OwnerID uint
ShopID uint
}
require.NoError(t, db.AutoMigrate(&TestData{}))
// 插入测试数据
testData := []TestData{
{Name: "data_a", OwnerID: accountA.ID, ShopID: 100},
{Name: "data_b", OwnerID: 999, ShopID: 100},
}
require.NoError(t, db.Create(&testData).Error)
// 关闭 Redis 连接以模拟错误（递归查询失败）
redisClient.Close()
// 使用 A 的上下文查询（降级策略：只返回自己的数据）
ctxWithA := middleware.SetUserContext(ctx, accountA.ID, constants.UserTypePlatform, 100)
var resultsA []TestData
err := db.WithContext(ctxWithA).
Scopes(postgres.DataPermissionScope(ctxWithA, accountStore)).
Find(&resultsA).Error
require.NoError(t, err)
// 降级策略应该只返回自己的数据
assert.Len(t, resultsA, 1, "查询下级 ID 失败时，应该降级为只返回自己的数据")
assert.Equal(t, "data_a", resultsA[0].Name)
}

502
tests/unit/model_test.go
View File

@@ -1,502 +0,0 @@
package unit
import (
"testing"
"time"
"github.com/break/junhong_cmp_fiber/internal/model"
"github.com/break/junhong_cmp_fiber/pkg/constants"
"github.com/go-playground/validator/v10"
"github.com/stretchr/testify/assert"
)
// TestUserValidation 测试用户模型验证
func TestUserValidation(t *testing.T) {
validate := validator.New()
t.Run("有效的创建用户请求", func(t *testing.T) {
req := &model.CreateUserRequest{
Username: "validuser",
Email: "valid@example.com",
Password: "password123",
}
err := validate.Struct(req)
assert.NoError(t, err)
})
t.Run("用户名太短", func(t *testing.T) {
req := &model.CreateUserRequest{
Username: "ab", // 少于 3 个字符
Email: "valid@example.com",
Password: "password123",
}
err := validate.Struct(req)
assert.Error(t, err)
})
t.Run("用户名太长", func(t *testing.T) {
req := &model.CreateUserRequest{
Username: "a123456789012345678901234567890123456789012345678901", // 超过 50 个字符
Email: "valid@example.com",
Password: "password123",
}
err := validate.Struct(req)
assert.Error(t, err)
})
t.Run("无效的邮箱格式", func(t *testing.T) {
req := &model.CreateUserRequest{
Username: "validuser",
Email: "invalid-email",
Password: "password123",
}
err := validate.Struct(req)
assert.Error(t, err)
})
t.Run("密码太短", func(t *testing.T) {
req := &model.CreateUserRequest{
Username: "validuser",
Email: "valid@example.com",
Password: "short", // 少于 8 个字符
}
err := validate.Struct(req)
assert.Error(t, err)
})
t.Run("缺少必填字段", func(t *testing.T) {
req := &model.CreateUserRequest{
Username: "validuser",
// 缺少 Email 和 Password
}
err := validate.Struct(req)
assert.Error(t, err)
})
}
// TestUserUpdateValidation 测试用户更新验证
func TestUserUpdateValidation(t *testing.T) {
validate := validator.New()
t.Run("有效的更新请求", func(t *testing.T) {
email := "newemail@example.com"
status := constants.UserStatusActive
req := &model.UpdateUserRequest{
Email: &email,
Status: &status,
}
err := validate.Struct(req)
assert.NoError(t, err)
})
t.Run("无效的邮箱格式", func(t *testing.T) {
email := "invalid-email"
req := &model.UpdateUserRequest{
Email: &email,
}
err := validate.Struct(req)
assert.Error(t, err)
})
t.Run("无效的状态值", func(t *testing.T) {
status := "invalid_status"
req := &model.UpdateUserRequest{
Status: &status,
}
err := validate.Struct(req)
assert.Error(t, err)
})
t.Run("空更新请求", func(t *testing.T) {
req := &model.UpdateUserRequest{}
err := validate.Struct(req)
assert.NoError(t, err) // 空更新请求应该是有效的
})
}
// TestOrderValidation 测试订单模型验证
func TestOrderValidation(t *testing.T) {
validate := validator.New()
t.Run("有效的创建订单请求", func(t *testing.T) {
req := &model.CreateOrderRequest{
OrderID: "ORD-2025-001",
UserID: 1,
Amount: 10000,
Remark: "测试订单",
}
err := validate.Struct(req)
assert.NoError(t, err)
})
t.Run("订单号太短", func(t *testing.T) {
req := &model.CreateOrderRequest{
OrderID: "ORD-123", // 少于 10 个字符
UserID: 1,
Amount: 10000,
}
err := validate.Struct(req)
assert.Error(t, err)
})
t.Run("订单号太长", func(t *testing.T) {
req := &model.CreateOrderRequest{
OrderID: "ORD-12345678901234567890123456789012345678901234567890", // 超过 50 个字符
UserID: 1,
Amount: 10000,
}
err := validate.Struct(req)
assert.Error(t, err)
})
t.Run("用户ID无效", func(t *testing.T) {
req := &model.CreateOrderRequest{
OrderID: "ORD-2025-001",
UserID: 0, // 用户ID必须大于0
Amount: 10000,
}
err := validate.Struct(req)
assert.Error(t, err)
})
t.Run("金额为负数", func(t *testing.T) {
req := &model.CreateOrderRequest{
OrderID: "ORD-2025-001",
UserID: 1,
Amount: -1000, // 金额不能为负数
}
err := validate.Struct(req)
assert.Error(t, err)
})
t.Run("缺少必填字段", func(t *testing.T) {
req := &model.CreateOrderRequest{
OrderID: "ORD-2025-001",
// 缺少 UserID 和 Amount
}
err := validate.Struct(req)
assert.Error(t, err)
})
}
// TestOrderUpdateValidation 测试订单更新验证
func TestOrderUpdateValidation(t *testing.T) {
validate := validator.New()
t.Run("有效的更新请求", func(t *testing.T) {
status := constants.OrderStatusPaid
remark := "已支付"
req := &model.UpdateOrderRequest{
Status: &status,
Remark: &remark,
}
err := validate.Struct(req)
assert.NoError(t, err)
})
t.Run("无效的状态值", func(t *testing.T) {
status := "invalid_status"
req := &model.UpdateOrderRequest{
Status: &status,
}
err := validate.Struct(req)
assert.Error(t, err)
})
}
// TestUserModel 测试用户模型
func TestUserModel(t *testing.T) {
t.Run("创建用户模型", func(t *testing.T) {
user := &model.User{
Username: "testuser",
Email: "test@example.com",
Password: "hashedpassword",
Status: constants.UserStatusActive,
}
assert.Equal(t, "testuser", user.Username)
assert.Equal(t, "test@example.com", user.Email)
assert.Equal(t, constants.UserStatusActive, user.Status)
})
t.Run("用户表名", func(t *testing.T) {
user := &model.User{}
assert.Equal(t, "tb_user", user.TableName())
})
t.Run("软删除字段", func(t *testing.T) {
user := &model.User{
Username: "testuser",
Email: "test@example.com",
Password: "hashedpassword",
Status: constants.UserStatusActive,
}
// DeletedAt 应该是 nil (未删除)
assert.True(t, user.DeletedAt.Time.IsZero())
})
t.Run("LastLoginAt 可选字段", func(t *testing.T) {
user := &model.User{
Username: "testuser",
Email: "test@example.com",
Password: "hashedpassword",
Status: constants.UserStatusActive,
}
assert.Nil(t, user.LastLoginAt)
// 设置登录时间
now := time.Now()
user.LastLoginAt = &now
assert.NotNil(t, user.LastLoginAt)
assert.Equal(t, now, *user.LastLoginAt)
})
}
// TestOrderModel 测试订单模型
func TestOrderModel(t *testing.T) {
t.Run("创建订单模型", func(t *testing.T) {
order := &model.Order{
OrderID: "ORD-2025-001",
UserID: 1,
Amount: 10000,
Status: constants.OrderStatusPending,
Remark: "测试订单",
}
assert.Equal(t, "ORD-2025-001", order.OrderID)
assert.Equal(t, uint(1), order.UserID)
assert.Equal(t, int64(10000), order.Amount)
assert.Equal(t, constants.OrderStatusPending, order.Status)
})
t.Run("订单表名", func(t *testing.T) {
order := &model.Order{}
assert.Equal(t, "tb_order", order.TableName())
})
t.Run("可选时间字段", func(t *testing.T) {
order := &model.Order{
OrderID: "ORD-2025-001",
UserID: 1,
Amount: 10000,
Status: constants.OrderStatusPending,
}
assert.Nil(t, order.PaidAt)
assert.Nil(t, order.CompletedAt)
// 设置支付时间
now := time.Now()
order.PaidAt = &now
assert.NotNil(t, order.PaidAt)
assert.Equal(t, now, *order.PaidAt)
})
}
// TestBaseModel 测试基础模型
func TestBaseModel(t *testing.T) {
t.Run("BaseModel 字段", func(t *testing.T) {
user := &model.User{
Username: "testuser",
Email: "test@example.com",
Password: "hashedpassword",
Status: constants.UserStatusActive,
}
// ID 应该是 0 (未保存)
assert.Zero(t, user.ID)
// 时间戳应该是零值
assert.True(t, user.CreatedAt.IsZero())
assert.True(t, user.UpdatedAt.IsZero())
})
}
// TestUserStatusConstants 测试用户状态常量
func TestUserStatusConstants(t *testing.T) {
t.Run("用户状态常量定义", func(t *testing.T) {
assert.Equal(t, "active", constants.UserStatusActive)
assert.Equal(t, "inactive", constants.UserStatusInactive)
assert.Equal(t, "suspended", constants.UserStatusSuspended)
})
t.Run("用户状态验证", func(t *testing.T) {
validStatuses := []string{
constants.UserStatusActive,
constants.UserStatusInactive,
constants.UserStatusSuspended,
}
for _, status := range validStatuses {
user := &model.User{
Username: "testuser",
Email: "test@example.com",
Password: "hashedpassword",
Status: status,
}
assert.Contains(t, validStatuses, user.Status)
}
})
}
// TestOrderStatusConstants 测试订单状态常量
func TestOrderStatusConstants(t *testing.T) {
t.Run("订单状态常量定义", func(t *testing.T) {
assert.Equal(t, "pending", constants.OrderStatusPending)
assert.Equal(t, "paid", constants.OrderStatusPaid)
assert.Equal(t, "processing", constants.OrderStatusProcessing)
assert.Equal(t, "completed", constants.OrderStatusCompleted)
assert.Equal(t, "cancelled", constants.OrderStatusCancelled)
})
t.Run("订单状态流转", func(t *testing.T) {
order := &model.Order{
OrderID: "ORD-2025-001",
UserID: 1,
Amount: 10000,
Status: constants.OrderStatusPending,
}
// 订单状态流转：pending -> paid -> processing -> completed
assert.Equal(t, constants.OrderStatusPending, order.Status)
order.Status = constants.OrderStatusPaid
assert.Equal(t, constants.OrderStatusPaid, order.Status)
order.Status = constants.OrderStatusProcessing
assert.Equal(t, constants.OrderStatusProcessing, order.Status)
order.Status = constants.OrderStatusCompleted
assert.Equal(t, constants.OrderStatusCompleted, order.Status)
})
t.Run("订单取消", func(t *testing.T) {
order := &model.Order{
OrderID: "ORD-2025-002",
UserID: 1,
Amount: 10000,
Status: constants.OrderStatusPending,
}
// 从任何状态都可以取消
order.Status = constants.OrderStatusCancelled
assert.Equal(t, constants.OrderStatusCancelled, order.Status)
})
}
// TestUserResponse 测试用户响应模型
func TestUserResponse(t *testing.T) {
t.Run("创建用户响应", func(t *testing.T) {
now := time.Now()
resp := &model.UserResponse{
ID: 1,
Username: "testuser",
Email: "test@example.com",
Status: constants.UserStatusActive,
CreatedAt: now,
UpdatedAt: now,
}
assert.Equal(t, uint(1), resp.ID)
assert.Equal(t, "testuser", resp.Username)
assert.Equal(t, "test@example.com", resp.Email)
assert.Equal(t, constants.UserStatusActive, resp.Status)
})
t.Run("用户响应不包含密码", func(t *testing.T) {
// UserResponse 结构体不应该包含 Password 字段
resp := &model.UserResponse{
ID: 1,
Username: "testuser",
Email: "test@example.com",
Status: constants.UserStatusActive,
}
// 验证结构体大小合理 (不包含密码字段)
assert.NotNil(t, resp)
})
}
// TestListResponse 测试列表响应模型
func TestListResponse(t *testing.T) {
t.Run("用户列表响应", func(t *testing.T) {
users := []model.UserResponse{
{ID: 1, Username: "user1", Email: "user1@example.com", Status: constants.UserStatusActive},
{ID: 2, Username: "user2", Email: "user2@example.com", Status: constants.UserStatusActive},
}
resp := &model.ListUsersResponse{
Users: users,
Page: 1,
PageSize: 20,
Total: 100,
TotalPages: 5,
}
assert.Equal(t, 2, len(resp.Users))
assert.Equal(t, 1, resp.Page)
assert.Equal(t, 20, resp.PageSize)
assert.Equal(t, int64(100), resp.Total)
assert.Equal(t, 5, resp.TotalPages)
})
t.Run("订单列表响应", func(t *testing.T) {
orders := []model.OrderResponse{
{ID: 1, OrderID: "ORD-001", UserID: 1, Amount: 10000, Status: constants.OrderStatusPending},
{ID: 2, OrderID: "ORD-002", UserID: 1, Amount: 20000, Status: constants.OrderStatusPaid},
}
resp := &model.ListOrdersResponse{
Orders: orders,
Page: 1,
PageSize: 20,
Total: 50,
TotalPages: 3,
}
assert.Equal(t, 2, len(resp.Orders))
assert.Equal(t, 1, resp.Page)
assert.Equal(t, 20, resp.PageSize)
assert.Equal(t, int64(50), resp.Total)
assert.Equal(t, 3, resp.TotalPages)
})
}
// TestFieldTags 测试字段标签
func TestFieldTags(t *testing.T) {
t.Run("User GORM 标签", func(t *testing.T) {
user := &model.User{}
// 验证 TableName 方法存在
tableName := user.TableName()
assert.Equal(t, "tb_user", tableName)
})
t.Run("Order GORM 标签", func(t *testing.T) {
order := &model.Order{}
// 验证 TableName 方法存在
tableName := order.TableName()
assert.Equal(t, "tb_order", tableName)
})
}

550
tests/unit/store_test.go
View File

@@ -1,550 +0,0 @@
package unit
import (
"context"
"errors"
"testing"
"time"
"github.com/break/junhong_cmp_fiber/internal/model"
"github.com/break/junhong_cmp_fiber/internal/store/postgres"
"github.com/break/junhong_cmp_fiber/pkg/constants"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"go.uber.org/zap"
"gorm.io/driver/sqlite"
"gorm.io/gorm"
"gorm.io/gorm/logger"
)
// setupTestStore 创建内存数据库用于单元测试
func setupTestStore(t *testing.T) (*postgres.Store, func()) {
// 使用 SQLite 内存数据库进行单元测试
db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{
Logger: logger.Default.LogMode(logger.Silent),
})
require.NoError(t, err, "创建内存数据库失败")
// 自动迁移
err = db.AutoMigrate(&model.User{}, &model.Order{})
require.NoError(t, err, "数据库迁移失败")
// 创建测试 logger
testLogger := zap.NewNop()
store := postgres.NewStore(db, testLogger)
cleanup := func() {
sqlDB, _ := db.DB()
if sqlDB != nil {
sqlDB.Close()
}
}
return store, cleanup
}
// TestUserStore 测试用户 Store 层
func TestUserStore(t *testing.T) {
store, cleanup := setupTestStore(t)
defer cleanup()
ctx := context.Background()
t.Run("创建用户成功", func(t *testing.T) {
user := &model.User{
Username: "testuser",
Email: "test@example.com",
Password: "hashedpassword",
Status: constants.UserStatusActive,
}
err := store.User.Create(ctx, user)
assert.NoError(t, err)
assert.NotZero(t, user.ID)
assert.False(t, user.CreatedAt.IsZero())
assert.False(t, user.UpdatedAt.IsZero())
})
t.Run("创建重复用户名失败", func(t *testing.T) {
user1 := &model.User{
Username: "duplicate",
Email: "user1@example.com",
Password: "password1",
Status: constants.UserStatusActive,
}
err := store.User.Create(ctx, user1)
require.NoError(t, err)
// 尝试创建相同用户名
user2 := &model.User{
Username: "duplicate",
Email: "user2@example.com",
Password: "password2",
Status: constants.UserStatusActive,
}
err = store.User.Create(ctx, user2)
assert.Error(t, err, "应该返回唯一约束错误")
})
t.Run("根据ID查询用户", func(t *testing.T) {
user := &model.User{
Username: "findbyid",
Email: "findbyid@example.com",
Password: "hashedpassword",
Status: constants.UserStatusActive,
}
err := store.User.Create(ctx, user)
require.NoError(t, err)
found, err := store.User.GetByID(ctx, user.ID)
assert.NoError(t, err)
assert.Equal(t, user.Username, found.Username)
assert.Equal(t, user.Email, found.Email)
})
t.Run("查询不存在的用户", func(t *testing.T) {
_, err := store.User.GetByID(ctx, 99999)
assert.Error(t, err)
assert.Equal(t, gorm.ErrRecordNotFound, err)
})
t.Run("根据用户名查询用户", func(t *testing.T) {
user := &model.User{
Username: "findbyname",
Email: "findbyname@example.com",
Password: "hashedpassword",
Status: constants.UserStatusActive,
}
err := store.User.Create(ctx, user)
require.NoError(t, err)
found, err := store.User.GetByUsername(ctx, "findbyname")
assert.NoError(t, err)
assert.Equal(t, user.ID, found.ID)
})
t.Run("更新用户", func(t *testing.T) {
user := &model.User{
Username: "updatetest",
Email: "update@example.com",
Password: "hashedpassword",
Status: constants.UserStatusActive,
}
err := store.User.Create(ctx, user)
require.NoError(t, err)
// 更新用户
user.Email = "newemail@example.com"
user.Status = constants.UserStatusInactive
err = store.User.Update(ctx, user)
assert.NoError(t, err)
// 验证更新
found, err := store.User.GetByID(ctx, user.ID)
assert.NoError(t, err)
assert.Equal(t, "newemail@example.com", found.Email)
assert.Equal(t, constants.UserStatusInactive, found.Status)
})
t.Run("软删除用户", func(t *testing.T) {
user := &model.User{
Username: "deletetest",
Email: "delete@example.com",
Password: "hashedpassword",
Status: constants.UserStatusActive,
}
err := store.User.Create(ctx, user)
require.NoError(t, err)
// 软删除
err = store.User.Delete(ctx, user.ID)
assert.NoError(t, err)
// 验证已删除
_, err = store.User.GetByID(ctx, user.ID)
assert.Error(t, err)
assert.Equal(t, gorm.ErrRecordNotFound, err)
})
t.Run("分页列表查询", func(t *testing.T) {
// 创建10个用户
for i := 1; i <= 10; i++ {
user := &model.User{
Username: "listuser" + string(rune('0'+i)),
Email: "list" + string(rune('0'+i)) + "@example.com",
Password: "password",
Status: constants.UserStatusActive,
}
err := store.User.Create(ctx, user)
require.NoError(t, err)
}
// 第一页
users, total, err := store.User.List(ctx, 1, 5)
assert.NoError(t, err)
assert.GreaterOrEqual(t, len(users), 5)
assert.GreaterOrEqual(t, total, int64(10))
// 第二页
users2, total2, err := store.User.List(ctx, 2, 5)
assert.NoError(t, err)
assert.GreaterOrEqual(t, len(users2), 5)
assert.Equal(t, total, total2)
// 验证不同页的数据不同
if len(users) > 0 && len(users2) > 0 {
assert.NotEqual(t, users[0].ID, users2[0].ID)
}
})
}
// TestOrderStore 测试订单 Store 层
func TestOrderStore(t *testing.T) {
store, cleanup := setupTestStore(t)
defer cleanup()
ctx := context.Background()
// 创建测试用户
user := &model.User{
Username: "orderuser",
Email: "orderuser@example.com",
Password: "hashedpassword",
Status: constants.UserStatusActive,
}
err := store.User.Create(ctx, user)
require.NoError(t, err)
t.Run("创建订单成功", func(t *testing.T) {
order := &model.Order{
OrderID: "ORD-TEST-001",
UserID: user.ID,
Amount: 10000,
Status: constants.OrderStatusPending,
Remark: "测试订单",
}
err := store.Order.Create(ctx, order)
assert.NoError(t, err)
assert.NotZero(t, order.ID)
assert.False(t, order.CreatedAt.IsZero())
})
t.Run("创建重复订单号失败", func(t *testing.T) {
order1 := &model.Order{
OrderID: "ORD-DUP-001",
UserID: user.ID,
Amount: 10000,
Status: constants.OrderStatusPending,
}
err := store.Order.Create(ctx, order1)
require.NoError(t, err)
// 尝试创建相同订单号
order2 := &model.Order{
OrderID: "ORD-DUP-001",
UserID: user.ID,
Amount: 20000,
Status: constants.OrderStatusPending,
}
err = store.Order.Create(ctx, order2)
assert.Error(t, err, "应该返回唯一约束错误")
})
t.Run("根据ID查询订单", func(t *testing.T) {
order := &model.Order{
OrderID: "ORD-FIND-001",
UserID: user.ID,
Amount: 20000,
Status: constants.OrderStatusPending,
}
err := store.Order.Create(ctx, order)
require.NoError(t, err)
found, err := store.Order.GetByID(ctx, order.ID)
assert.NoError(t, err)
assert.Equal(t, order.OrderID, found.OrderID)
assert.Equal(t, order.Amount, found.Amount)
})
t.Run("根据订单号查询", func(t *testing.T) {
order := &model.Order{
OrderID: "ORD-FIND-002",
UserID: user.ID,
Amount: 30000,
Status: constants.OrderStatusPending,
}
err := store.Order.Create(ctx, order)
require.NoError(t, err)
found, err := store.Order.GetByOrderID(ctx, "ORD-FIND-002")
assert.NoError(t, err)
assert.Equal(t, order.ID, found.ID)
})
t.Run("根据用户ID列表查询", func(t *testing.T) {
// 创建多个订单
for i := 1; i <= 5; i++ {
order := &model.Order{
OrderID: "ORD-LIST-" + string(rune('0'+i)),
UserID: user.ID,
Amount: int64(i * 10000),
Status: constants.OrderStatusPending,
}
err := store.Order.Create(ctx, order)
require.NoError(t, err)
}
orders, total, err := store.Order.ListByUserID(ctx, user.ID, 1, 10)
assert.NoError(t, err)
assert.GreaterOrEqual(t, len(orders), 5)
assert.GreaterOrEqual(t, total, int64(5))
})
t.Run("更新订单状态", func(t *testing.T) {
order := &model.Order{
OrderID: "ORD-UPDATE-001",
UserID: user.ID,
Amount: 50000,
Status: constants.OrderStatusPending,
}
err := store.Order.Create(ctx, order)
require.NoError(t, err)
// 更新状态
now := time.Now()
order.Status = constants.OrderStatusPaid
order.PaidAt = &now
err = store.Order.Update(ctx, order)
assert.NoError(t, err)
// 验证更新
found, err := store.Order.GetByID(ctx, order.ID)
assert.NoError(t, err)
assert.Equal(t, constants.OrderStatusPaid, found.Status)
assert.NotNil(t, found.PaidAt)
})
t.Run("软删除订单", func(t *testing.T) {
order := &model.Order{
OrderID: "ORD-DELETE-001",
UserID: user.ID,
Amount: 60000,
Status: constants.OrderStatusPending,
}
err := store.Order.Create(ctx, order)
require.NoError(t, err)
// 软删除
err = store.Order.Delete(ctx, order.ID)
assert.NoError(t, err)
// 验证已删除
_, err = store.Order.GetByID(ctx, order.ID)
assert.Error(t, err)
assert.Equal(t, gorm.ErrRecordNotFound, err)
})
}
// TestStoreTransaction 测试事务功能
func TestStoreTransaction(t *testing.T) {
store, cleanup := setupTestStore(t)
defer cleanup()
ctx := context.Background()
t.Run("事务提交成功", func(t *testing.T) {
var userID uint
var orderID uint
err := store.Transaction(ctx, func(tx *postgres.Store) error {
// 创建用户
user := &model.User{
Username: "txuser1",
Email: "txuser1@example.com",
Password: "hashedpassword",
Status: constants.UserStatusActive,
}
if err := tx.User.Create(ctx, user); err != nil {
return err
}
userID = user.ID
// 创建订单
order := &model.Order{
OrderID: "ORD-TX-001",
UserID: user.ID,
Amount: 10000,
Status: constants.OrderStatusPending,
}
if err := tx.Order.Create(ctx, order); err != nil {
return err
}
orderID = order.ID
return nil
})
assert.NoError(t, err)
// 验证用户和订单都已创建
user, err := store.User.GetByID(ctx, userID)
assert.NoError(t, err)
assert.Equal(t, "txuser1", user.Username)
order, err := store.Order.GetByID(ctx, orderID)
assert.NoError(t, err)
assert.Equal(t, "ORD-TX-001", order.OrderID)
})
t.Run("事务回滚", func(t *testing.T) {
var userID uint
err := store.Transaction(ctx, func(tx *postgres.Store) error {
// 创建用户
user := &model.User{
Username: "rollbackuser",
Email: "rollback@example.com",
Password: "hashedpassword",
Status: constants.UserStatusActive,
}
if err := tx.User.Create(ctx, user); err != nil {
return err
}
userID = user.ID
// 模拟错误，触发回滚
return errors.New("模拟错误")
})
assert.Error(t, err)
assert.Equal(t, "模拟错误", err.Error())
// 验证用户未创建（已回滚）
_, err = store.User.GetByID(ctx, userID)
assert.Error(t, err)
assert.Equal(t, gorm.ErrRecordNotFound, err)
})
t.Run("嵌套事务回滚", func(t *testing.T) {
var user1ID, user2ID uint
err := store.Transaction(ctx, func(tx1 *postgres.Store) error {
// 外层事务：创建第一个用户
user1 := &model.User{
Username: "nested1",
Email: "nested1@example.com",
Password: "password",
Status: constants.UserStatusActive,
}
if err := tx1.User.Create(ctx, user1); err != nil {
return err
}
user1ID = user1.ID
// 内层事务：创建第二个用户并失败
err := tx1.Transaction(ctx, func(tx2 *postgres.Store) error {
user2 := &model.User{
Username: "nested2",
Email: "nested2@example.com",
Password: "password",
Status: constants.UserStatusActive,
}
if err := tx2.User.Create(ctx, user2); err != nil {
return err
}
user2ID = user2.ID
// 内层事务失败
return errors.New("内层事务失败")
})
// 内层事务失败导致外层事务也失败
return err
})
assert.Error(t, err)
// 验证两个用户都未创建
_, err = store.User.GetByID(ctx, user1ID)
assert.Error(t, err)
_, err = store.User.GetByID(ctx, user2ID)
assert.Error(t, err)
})
}
// TestConcurrentAccess 测试并发访问
func TestConcurrentAccess(t *testing.T) {
store, cleanup := setupTestStore(t)
defer cleanup()
ctx := context.Background()
t.Run("并发创建用户", func(t *testing.T) {
concurrency := 20
errChan := make(chan error, concurrency)
for i := 0; i < concurrency; i++ {
go func(index int) {
user := &model.User{
Username: "concurrent" + string(rune('A'+index)),
Email: "concurrent" + string(rune('A'+index)) + "@example.com",
Password: "password",
Status: constants.UserStatusActive,
}
errChan <- store.User.Create(ctx, user)
}(i)
}
// 收集结果
successCount := 0
for i := 0; i < concurrency; i++ {
err := <-errChan
if err == nil {
successCount++
}
}
assert.Equal(t, concurrency, successCount, "所有并发创建应该成功")
})
t.Run("并发读写同一用户", func(t *testing.T) {
// 创建测试用户
user := &model.User{
Username: "rwuser",
Email: "rwuser@example.com",
Password: "password",
Status: constants.UserStatusActive,
}
err := store.User.Create(ctx, user)
require.NoError(t, err)
concurrency := 10
done := make(chan bool, concurrency*2)
// 并发读
for i := 0; i < concurrency; i++ {
go func() {
_, err := store.User.GetByID(ctx, user.ID)
assert.NoError(t, err)
done <- true
}()
}
// 并发写
for i := 0; i < concurrency; i++ {
go func(index int) {
user.Status = constants.UserStatusActive
err := store.User.Update(ctx, user)
assert.NoError(t, err)
done <- true
}(i)
}
// 等待所有操作完成
for i := 0; i < concurrency*2; i++ {
<-done
}
})
}