feat: 实现门店套餐分配功能并统一测试基础设施

新增功能：
- 门店套餐分配管理（shop_package_allocation）：支持门店套餐库存管理
- 门店套餐系列分配管理（shop_series_allocation）：支持套餐系列分配和佣金层级设置
- 我的套餐查询（my_package）：支持门店查询自己的套餐分配情况

测试改进：
- 统一集成测试基础设施，新增 testutils.NewIntegrationTestEnv
- 重构所有集成测试使用新的测试环境设置
- 移除旧的测试辅助函数和冗余测试文件
- 新增 test_helpers_test.go 统一任务测试辅助

技术细节：
- 新增数据库迁移 000025_create_shop_allocation_tables
- 新增 3 个 Handler、Service、Store 和对应的单元测试
- 更新 OpenAPI 文档和文档生成器
- 测试覆盖率：Service 层 > 90%

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

tests/integration/permission_test.go

@@ -1,164 +1,38 @@
 package integration
 
 import (
-	"bytes"
-	"context"
 	"encoding/json"
 	"fmt"
-	"net/http/httptest"
 	"testing"
 	"time"
 
 	"github.com/gofiber/fiber/v2"
-	"github.com/redis/go-redis/v9"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"github.com/testcontainers/testcontainers-go"
-	testcontainers_postgres "github.com/testcontainers/testcontainers-go/modules/postgres"
-	testcontainers_redis "github.com/testcontainers/testcontainers-go/modules/redis"
-	"github.com/testcontainers/testcontainers-go/wait"
-	"go.uber.org/zap"
-	"gorm.io/driver/postgres"
-	"gorm.io/gorm"
-	"gorm.io/gorm/logger"
 
-	"github.com/break/junhong_cmp_fiber/internal/bootstrap"
-	"github.com/break/junhong_cmp_fiber/internal/handler/admin"
 	"github.com/break/junhong_cmp_fiber/internal/model"
 	"github.com/break/junhong_cmp_fiber/internal/model/dto"
-	"github.com/break/junhong_cmp_fiber/internal/routes"
-	permissionService "github.com/break/junhong_cmp_fiber/internal/service/permission"
-	postgresStore "github.com/break/junhong_cmp_fiber/internal/store/postgres"
 	"github.com/break/junhong_cmp_fiber/pkg/constants"
 	"github.com/break/junhong_cmp_fiber/pkg/errors"
-	"github.com/break/junhong_cmp_fiber/pkg/middleware"
 	"github.com/break/junhong_cmp_fiber/pkg/response"
+	"github.com/break/junhong_cmp_fiber/tests/testutils/integ"
 )
 
-// permTestEnv 权限测试环境
-type permTestEnv struct {
-	tx                *gorm.DB
-	rdb               *redis.Client
-	app               *fiber.App
-	permissionService *permissionService.Service
-	cleanup           func()
-}
-
-// setupPermTestEnv 设置权限测试环境
-func setupPermTestEnv(t *testing.T) *permTestEnv {
-	t.Helper()
-
-	ctx := context.Background()
-
-	// 启动 PostgreSQL 容器
-	pgContainer, err := testcontainers_postgres.RunContainer(ctx,
-		testcontainers.WithImage("postgres:14-alpine"),
-		testcontainers_postgres.WithDatabase("testdb"),
-		testcontainers_postgres.WithUsername("postgres"),
-		testcontainers_postgres.WithPassword("password"),
-		testcontainers.WithWaitStrategy(
-			wait.ForLog("database system is ready to accept connections").
-				WithOccurrence(2).
-				WithStartupTimeout(30*time.Second),
-		),
-	)
-	require.NoError(t, err, "启动 PostgreSQL 容器失败")
-
-	pgConnStr, err := pgContainer.ConnectionString(ctx, "sslmode=disable")
-	require.NoError(t, err)
-
-	// 启动 Redis 容器
-	redisContainer, err := testcontainers_redis.Run(ctx,
-		"redis:6-alpine",
-	)
-	require.NoError(t, err, "启动 Redis 容器失败")
-
-	redisHost, err := redisContainer.Host(ctx)
-	require.NoError(t, err)
-	redisPort, err := redisContainer.MappedPort(ctx, "6379")
-	require.NoError(t, err)
-
-	// 连接数据库
-	tx, err := gorm.Open(postgres.Open(pgConnStr), &gorm.Config{
-		Logger: logger.Default.LogMode(logger.Silent),
-	})
-	require.NoError(t, err)
-
-	// 自动迁移
-	err = tx.AutoMigrate(
-		&model.Permission{},
-	)
-	require.NoError(t, err)
-
-	// 连接 Redis
-	rdb := redis.NewClient(&redis.Options{
-		Addr: fmt.Sprintf("%s:%s", redisHost, redisPort.Port()),
-	})
-
-	// 初始化 Store
-	permStore := postgresStore.NewPermissionStore(tx)
-	accountRoleStore := postgresStore.NewAccountRoleStore(tx, rdb)
-	rolePermStore := postgresStore.NewRolePermissionStore(tx, rdb)
-
-	// 初始化 Service
-	permSvc := permissionService.New(permStore, accountRoleStore, rolePermStore, rdb)
-
-	// 初始化 Handler
-	permHandler := admin.NewPermissionHandler(permSvc)
-
-	app := fiber.New(fiber.Config{
-		ErrorHandler: errors.SafeErrorHandler(zap.NewNop()),
-	})
-
-	app.Use(func(c *fiber.Ctx) error {
-		ctx := middleware.SetUserContext(c.UserContext(), middleware.NewSimpleUserContext(1, constants.UserTypeSuperAdmin, 0))
-		c.SetUserContext(ctx)
-		return c.Next()
-	})
-
-	services := &bootstrap.Handlers{
-		Permission: permHandler,
-	}
-	middlewares := &bootstrap.Middlewares{
-		AdminAuth: func(c *fiber.Ctx) error { return c.Next() },
-		H5Auth:    func(c *fiber.Ctx) error { return c.Next() },
-	}
-	routes.RegisterRoutes(app, services, middlewares)
-
-	return &permTestEnv{
-		tx:                tx,
-		rdb:               rdb,
-		app:               app,
-		permissionService: permSvc,
-		cleanup: func() {
-			if err := pgContainer.Terminate(ctx); err != nil {
-				t.Logf("终止 PostgreSQL 容器失败: %v", err)
-			}
-			if err := redisContainer.Terminate(ctx); err != nil {
-				t.Logf("终止 Redis 容器失败: %v", err)
-			}
-		},
-	}
-}
-
-// TestPermissionAPI_Create 测试创建权限 API
 func TestPermissionAPI_Create(t *testing.T) {
-	env := setupPermTestEnv(t)
-	defer env.cleanup()
+	env := integ.NewIntegrationTestEnv(t)
 
 	t.Run("成功创建权限", func(t *testing.T) {
+		// 权限编码必须符合 module:action 格式（两边都以小写字母开头）
+		permCode := fmt.Sprintf("test:action%d", time.Now().UnixNano())
 		reqBody := dto.CreatePermissionRequest{
-			PermName: "用户管理",
-			PermCode: "user:manage",
+			PermName: fmt.Sprintf("test_permission_%d", time.Now().UnixNano()),
+			PermCode: permCode,
 			PermType: constants.PermissionTypeMenu,
 			URL:      "/admin/users",
 		}
 
 		jsonBody, _ := json.Marshal(reqBody)
-		req := httptest.NewRequest("POST", "/api/admin/permissions", bytes.NewReader(jsonBody))
-		req.Header.Set("Content-Type", "application/json")
-
-		resp, err := env.app.Test(req)
+		resp, err := env.AsSuperAdmin().Request("POST", "/api/admin/permissions", jsonBody)
 		require.NoError(t, err)
 		assert.Equal(t, fiber.StatusOK, resp.StatusCode)
 
@@ -167,34 +41,26 @@ func TestPermissionAPI_Create(t *testing.T) {
 		require.NoError(t, err)
 		assert.Equal(t, 0, result.Code)
 
-		// 验证数据库中权限已创建
 		var count int64
-		env.tx.Model(&model.Permission{}).Where("perm_code = ?", "user:manage").Count(&count)
+		env.RawDB().Model(&model.Permission{}).Where("perm_code = ?", permCode).Count(&count)
 		assert.Equal(t, int64(1), count)
 	})
 
 	t.Run("权限编码重复时返回错误", func(t *testing.T) {
-		// 先创建一个权限
-		existingPerm := &model.Permission{
-			PermName: "已存在权限",
-			PermCode: "existing:perm",
-			PermType: constants.PermissionTypeMenu,
-			Status:   constants.StatusEnabled,
-		}
-		env.tx.Create(existingPerm)
+		existingPerm := env.CreateTestPermission(
+			fmt.Sprintf("test_permission_%d", time.Now().UnixNano()),
+			fmt.Sprintf("test:dup%d", time.Now().UnixNano()),
+			constants.PermissionTypeMenu,
+		)
 
-		// 尝试创建相同编码的权限
 		reqBody := dto.CreatePermissionRequest{
-			PermName: "新权限",
-			PermCode: "existing:perm",
+			PermName: fmt.Sprintf("test_permission_%d", time.Now().UnixNano()),
+			PermCode: existingPerm.PermCode,
 			PermType: constants.PermissionTypeMenu,
 		}
 
 		jsonBody, _ := json.Marshal(reqBody)
-		req := httptest.NewRequest("POST", "/api/admin/permissions", bytes.NewReader(jsonBody))
-		req.Header.Set("Content-Type", "application/json")
-
-		resp, err := env.app.Test(req)
+		resp, err := env.AsSuperAdmin().Request("POST", "/api/admin/permissions", jsonBody)
 		require.NoError(t, err)
 
 		var result response.Response
@@ -204,62 +70,45 @@ func TestPermissionAPI_Create(t *testing.T) {
 	})
 
 	t.Run("创建子权限", func(t *testing.T) {
-		parentPerm := &model.Permission{
-			PermName: "系统管理",
-			PermCode: "system:manage",
-			PermType: constants.PermissionTypeMenu,
-			Status:   constants.StatusEnabled,
-		}
-		env.tx.Create(parentPerm)
+		parentPermCode := fmt.Sprintf("test:parent%d", time.Now().UnixNano())
+		parentPerm := env.CreateTestPermission(
+			fmt.Sprintf("test_permission_%d", time.Now().UnixNano()),
+			parentPermCode,
+			constants.PermissionTypeMenu,
+		)
 
+		childPermCode := fmt.Sprintf("test:child%d", time.Now().UnixNano())
 		reqBody := dto.CreatePermissionRequest{
-			PermName: "用户列表",
-			PermCode: "user:list",
+			PermName: fmt.Sprintf("test_permission_%d", time.Now().UnixNano()),
+			PermCode: childPermCode,
 			PermType: constants.PermissionTypeButton,
 			ParentID: &parentPerm.ID,
 		}
 
 		jsonBody, _ := json.Marshal(reqBody)
-		req := httptest.NewRequest("POST", "/api/admin/permissions", bytes.NewReader(jsonBody))
-		req.Header.Set("Content-Type", "application/json")
-
-		resp, err := env.app.Test(req)
+		resp, err := env.AsSuperAdmin().Request("POST", "/api/admin/permissions", jsonBody)
 		require.NoError(t, err)
 		assert.Equal(t, fiber.StatusOK, resp.StatusCode)
 
 		var child model.Permission
-		err = env.tx.Where("perm_code = ?", "user:list").First(&child).Error
+		err = env.RawDB().Where("perm_code = ?", childPermCode).First(&child).Error
 		require.NoError(t, err, "子权限应该已创建")
 		require.NotNil(t, child.ParentID, "子权限的 ParentID 应该已设置")
 		assert.Equal(t, parentPerm.ID, *child.ParentID)
 	})
 }
 
-// TestPermissionAPI_Get 测试获取权限详情 API
 func TestPermissionAPI_Get(t *testing.T) {
-	env := setupPermTestEnv(t)
-	defer env.cleanup()
+	env := integ.NewIntegrationTestEnv(t)
 
-	// 添加测试中间件
-	testUserID := uint(1)
-	env.app.Use(func(c *fiber.Ctx) error {
-		ctx := middleware.SetUserContext(c.UserContext(), middleware.NewSimpleUserContext(testUserID, constants.UserTypeSuperAdmin, 0))
-		c.SetUserContext(ctx)
-		return c.Next()
-	})
-
-	// 创建测试权限
-	testPerm := &model.Permission{
-		PermName: "获取测试权限",
-		PermCode: "get:test:perm",
-		PermType: constants.PermissionTypeMenu,
-		Status:   constants.StatusEnabled,
-	}
-	env.tx.Create(testPerm)
+	testPerm := env.CreateTestPermission(
+		fmt.Sprintf("test_permission_%d", time.Now().UnixNano()),
+		fmt.Sprintf("test:get%d", time.Now().UnixNano()),
+		constants.PermissionTypeMenu,
+	)
 
 	t.Run("成功获取权限详情", func(t *testing.T) {
-		req := httptest.NewRequest("GET", fmt.Sprintf("/api/admin/permissions/%d", testPerm.ID), nil)
-		resp, err := env.app.Test(req)
+		resp, err := env.AsSuperAdmin().Request("GET", fmt.Sprintf("/api/admin/permissions/%d", testPerm.ID), nil)
 		require.NoError(t, err)
 		assert.Equal(t, fiber.StatusOK, resp.StatusCode)
 
@@ -270,8 +119,7 @@ func TestPermissionAPI_Get(t *testing.T) {
 	})
 
 	t.Run("权限不存在时返回错误", func(t *testing.T) {
-		req := httptest.NewRequest("GET", "/api/admin/permissions/99999", nil)
-		resp, err := env.app.Test(req)
+		resp, err := env.AsSuperAdmin().Request("GET", "/api/admin/permissions/99999", nil)
 		require.NoError(t, err)
 
 		var result response.Response
@@ -281,27 +129,14 @@ func TestPermissionAPI_Get(t *testing.T) {
 	})
 }
 
-// TestPermissionAPI_Update 测试更新权限 API
 func TestPermissionAPI_Update(t *testing.T) {
-	env := setupPermTestEnv(t)
-	defer env.cleanup()
+	env := integ.NewIntegrationTestEnv(t)
 
-	// 添加测试中间件
-	testUserID := uint(1)
-	env.app.Use(func(c *fiber.Ctx) error {
-		ctx := middleware.SetUserContext(c.UserContext(), middleware.NewSimpleUserContext(testUserID, constants.UserTypeSuperAdmin, 0))
-		c.SetUserContext(ctx)
-		return c.Next()
-	})
-
-	// 创建测试权限
-	testPerm := &model.Permission{
-		PermName: "更新测试权限",
-		PermCode: "update:test:perm",
-		PermType: constants.PermissionTypeMenu,
-		Status:   constants.StatusEnabled,
-	}
-	env.tx.Create(testPerm)
+	testPerm := env.CreateTestPermission(
+		fmt.Sprintf("test_permission_%d", time.Now().UnixNano()),
+		fmt.Sprintf("test:upd%d", time.Now().UnixNano()),
+		constants.PermissionTypeMenu,
+	)
 
 	t.Run("成功更新权限", func(t *testing.T) {
 		newName := "更新后权限"
@@ -310,83 +145,46 @@ func TestPermissionAPI_Update(t *testing.T) {
 		}
 
 		jsonBody, _ := json.Marshal(reqBody)
-		req := httptest.NewRequest("PUT", fmt.Sprintf("/api/admin/permissions/%d", testPerm.ID), bytes.NewReader(jsonBody))
-		req.Header.Set("Content-Type", "application/json")
-
-		resp, err := env.app.Test(req)
+		resp, err := env.AsSuperAdmin().Request("PUT", fmt.Sprintf("/api/admin/permissions/%d", testPerm.ID), jsonBody)
 		require.NoError(t, err)
 		assert.Equal(t, fiber.StatusOK, resp.StatusCode)
 
-		// 验证数据库已更新
 		var updated model.Permission
-		env.tx.First(&updated, testPerm.ID)
+		env.RawDB().First(&updated, testPerm.ID)
 		assert.Equal(t, newName, updated.PermName)
 	})
 }
 
-// TestPermissionAPI_Delete 测试删除权限 API
 func TestPermissionAPI_Delete(t *testing.T) {
-	env := setupPermTestEnv(t)
-	defer env.cleanup()
-
-	// 添加测试中间件
-	testUserID := uint(1)
-	env.app.Use(func(c *fiber.Ctx) error {
-		ctx := middleware.SetUserContext(c.UserContext(), middleware.NewSimpleUserContext(testUserID, constants.UserTypeSuperAdmin, 0))
-		c.SetUserContext(ctx)
-		return c.Next()
-	})
+	env := integ.NewIntegrationTestEnv(t)
 
 	t.Run("成功软删除权限", func(t *testing.T) {
-		// 创建测试权限
-		testPerm := &model.Permission{
-			PermName: "删除测试权限",
-			PermCode: "delete:test:perm",
-			PermType: constants.PermissionTypeMenu,
-			Status:   constants.StatusEnabled,
-		}
-		env.tx.Create(testPerm)
+		testPerm := env.CreateTestPermission(
+			fmt.Sprintf("test_permission_%d", time.Now().UnixNano()),
+			fmt.Sprintf("test:del%d", time.Now().UnixNano()),
+			constants.PermissionTypeMenu,
+		)
 
-		req := httptest.NewRequest("DELETE", fmt.Sprintf("/api/admin/permissions/%d", testPerm.ID), nil)
-		resp, err := env.app.Test(req)
+		resp, err := env.AsSuperAdmin().Request("DELETE", fmt.Sprintf("/api/admin/permissions/%d", testPerm.ID), nil)
 		require.NoError(t, err)
 		assert.Equal(t, fiber.StatusOK, resp.StatusCode)
 
-		// 验证权限已软删除
 		var deleted model.Permission
-		err = env.tx.Unscoped().First(&deleted, testPerm.ID).Error
+		err = env.RawDB().Unscoped().First(&deleted, testPerm.ID).Error
 		require.NoError(t, err)
 		assert.NotNil(t, deleted.DeletedAt)
 	})
 }
 
-// TestPermissionAPI_List 测试权限列表 API
 func TestPermissionAPI_List(t *testing.T) {
-	env := setupPermTestEnv(t)
-	defer env.cleanup()
+	env := integ.NewIntegrationTestEnv(t)
 
-	// 添加测试中间件
-	testUserID := uint(1)
-	env.app.Use(func(c *fiber.Ctx) error {
-		ctx := middleware.SetUserContext(c.UserContext(), middleware.NewSimpleUserContext(testUserID, constants.UserTypeSuperAdmin, 0))
-		c.SetUserContext(ctx)
-		return c.Next()
-	})
-
-	// 创建多个测试权限
 	for i := 1; i <= 5; i++ {
-		perm := &model.Permission{
-			PermName: fmt.Sprintf("列表测试权限_%d", i),
-			PermCode: fmt.Sprintf("list:test:perm:%d", i),
-			PermType: constants.PermissionTypeMenu,
-			Status:   constants.StatusEnabled,
-		}
-		env.tx.Create(perm)
+		env.CreateTestPermission(fmt.Sprintf("列表测试权限_%d", i), fmt.Sprintf("list:perm%d", i), constants.PermissionTypeMenu)
 	}
 
 	t.Run("成功获取权限列表", func(t *testing.T) {
-		req := httptest.NewRequest("GET", "/api/admin/permissions?page=1&page_size=10", nil)
-		resp, err := env.app.Test(req)
+		resp, err := env.AsSuperAdmin().Request("GET", "/api/admin/permissions?page=1&page_size=10", nil)
 		require.NoError(t, err)
 		assert.Equal(t, fiber.StatusOK, resp.StatusCode)
 
@@ -397,59 +195,45 @@ func TestPermissionAPI_List(t *testing.T) {
 	})
 
 	t.Run("按类型过滤权限", func(t *testing.T) {
-		req := httptest.NewRequest("GET", fmt.Sprintf("/api/admin/permissions?perm_type=%d", constants.PermissionTypeMenu), nil)
-		resp, err := env.app.Test(req)
+		resp, err := env.AsSuperAdmin().Request("GET", fmt.Sprintf("/api/admin/permissions?perm_type=%d", constants.PermissionTypeMenu), nil)
 		require.NoError(t, err)
 		assert.Equal(t, fiber.StatusOK, resp.StatusCode)
 	})
 }
 
-// TestPermissionAPI_GetTree 测试获取权限树 API
 func TestPermissionAPI_GetTree(t *testing.T) {
-	env := setupPermTestEnv(t)
-	defer env.cleanup()
+	env := integ.NewIntegrationTestEnv(t)
 
-	// 添加测试中间件
-	testUserID := uint(1)
-	env.app.Use(func(c *fiber.Ctx) error {
-		ctx := middleware.SetUserContext(c.UserContext(), middleware.NewSimpleUserContext(testUserID, constants.UserTypeSuperAdmin, 0))
-		c.SetUserContext(ctx)
-		return c.Next()
-	})
+	rootPerm := env.CreateTestPermission(
+		fmt.Sprintf("test_permission_%d", time.Now().UnixNano()),
+		fmt.Sprintf("test:root%d", time.Now().UnixNano()),
+		constants.PermissionTypeMenu,
+	)
 
-	// 创建层级权限结构
-	// 根权限
-	rootPerm := &model.Permission{
-		PermName: "系统管理",
-		PermCode: "system",
-		PermType: constants.PermissionTypeMenu,
-		Status:   constants.StatusEnabled,
-	}
-	env.tx.Create(rootPerm)
-
-	// 子权限
+	childPermCode := fmt.Sprintf("test:child%d", time.Now().UnixNano())
 	childPerm := &model.Permission{
-		PermName: "用户管理",
-		PermCode: "system:user",
-		PermType: constants.PermissionTypeMenu,
-		ParentID: &rootPerm.ID,
-		Status:   constants.StatusEnabled,
+		BaseModel: model.BaseModel{Creator: 1, Updater: 1},
+		PermName:  fmt.Sprintf("test_permission_%d", time.Now().UnixNano()),
+		PermCode:  childPermCode,
+		PermType:  constants.PermissionTypeMenu,
+		ParentID:  &rootPerm.ID,
+		Status:    constants.StatusEnabled,
 	}
-	env.tx.Create(childPerm)
+	env.TX.Create(childPerm)
 
-	// 孙子权限
+	grandchildPermCode := fmt.Sprintf("test:grand%d", time.Now().UnixNano())
 	grandchildPerm := &model.Permission{
-		PermName: "用户列表",
-		PermCode: "system:user:list",
-		PermType: constants.PermissionTypeButton,
-		ParentID: &childPerm.ID,
-		Status:   constants.StatusEnabled,
+		BaseModel: model.BaseModel{Creator: 1, Updater: 1},
+		PermName:  fmt.Sprintf("test_permission_%d", time.Now().UnixNano()),
+		PermCode:  grandchildPermCode,
+		PermType:  constants.PermissionTypeButton,
+		ParentID:  &childPerm.ID,
+		Status:    constants.StatusEnabled,
 	}
-	env.tx.Create(grandchildPerm)
+	env.TX.Create(grandchildPerm)
 
 	t.Run("成功获取权限树", func(t *testing.T) {
-		req := httptest.NewRequest("GET", "/api/admin/permissions/tree", nil)
-		resp, err := env.app.Test(req)
+		resp, err := env.AsSuperAdmin().Request("GET", "/api/admin/permissions/tree", nil)
 		require.NoError(t, err)
 		assert.Equal(t, fiber.StatusOK, resp.StatusCode)
 
@@ -460,48 +244,41 @@ func TestPermissionAPI_GetTree(t *testing.T) {
 	})
 }
 
-// TestPermissionAPI_GetTreeByAvailableForRoleType 测试按角色类型过滤权限树 API
 func TestPermissionAPI_GetTreeByRoleType(t *testing.T) {
-	env := setupPermTestEnv(t)
-	defer env.cleanup()
-
-	testUserID := uint(1)
-	env.app.Use(func(c *fiber.Ctx) error {
-		ctx := middleware.SetUserContext(c.UserContext(), middleware.NewSimpleUserContext(testUserID, constants.UserTypeSuperAdmin, 0))
-		c.SetUserContext(ctx)
-		return c.Next()
-	})
+	env := integ.NewIntegrationTestEnv(t)
 
 	platformPerm := &model.Permission{
-		PermName:              "平台权限",
-		PermCode:              "platform:manage",
+		BaseModel:             model.BaseModel{Creator: 1, Updater: 1},
+		PermName:              fmt.Sprintf("test_permission_%d", time.Now().UnixNano()),
+		PermCode:              fmt.Sprintf("test:plat%d", time.Now().UnixNano()),
 		PermType:              constants.PermissionTypeMenu,
 		AvailableForRoleTypes: "1",
 		Status:                constants.StatusEnabled,
 	}
-	env.tx.Create(platformPerm)
+	env.TX.Create(platformPerm)
 
 	customerPerm := &model.Permission{
-		PermName:              "客户权限",
-		PermCode:              "customer:manage",
+		BaseModel:             model.BaseModel{Creator: 1, Updater: 1},
+		PermName:              fmt.Sprintf("test_permission_%d", time.Now().UnixNano()),
+		PermCode:              fmt.Sprintf("test:cust%d", time.Now().UnixNano()),
 		PermType:              constants.PermissionTypeMenu,
 		AvailableForRoleTypes: "2",
 		Status:                constants.StatusEnabled,
 	}
-	env.tx.Create(customerPerm)
+	env.TX.Create(customerPerm)
 
 	commonPerm := &model.Permission{
-		PermName:              "通用权限",
-		PermCode:              "common:view",
+		BaseModel:             model.BaseModel{Creator: 1, Updater: 1},
+		PermName:              fmt.Sprintf("test_permission_%d", time.Now().UnixNano()),
+		PermCode:              fmt.Sprintf("test:comm%d", time.Now().UnixNano()),
 		PermType:              constants.PermissionTypeMenu,
 		AvailableForRoleTypes: "1,2",
 		Status:                constants.StatusEnabled,
 	}
-	env.tx.Create(commonPerm)
+	env.TX.Create(commonPerm)
 
 	t.Run("按角色类型过滤权限树-平台角色", func(t *testing.T) {
-		req := httptest.NewRequest("GET", fmt.Sprintf("/api/admin/permissions/tree?available_for_role_type=%d", constants.RoleTypePlatform), nil)
-		resp, err := env.app.Test(req)
+		resp, err := env.AsSuperAdmin().Request("GET", fmt.Sprintf("/api/admin/permissions/tree?available_for_role_type=%d", constants.RoleTypePlatform), nil)
 		require.NoError(t, err)
 		assert.Equal(t, fiber.StatusOK, resp.StatusCode)
 
@@ -512,8 +289,7 @@ func TestPermissionAPI_GetTreeByRoleType(t *testing.T) {
 	})
 
 	t.Run("按角色类型过滤权限树-客户角色", func(t *testing.T) {
-		req := httptest.NewRequest("GET", "/api/admin/permissions/tree?available_for_role_type=2", nil)
-		resp, err := env.app.Test(req)
+		resp, err := env.AsSuperAdmin().Request("GET", "/api/admin/permissions/tree?available_for_role_type=2", nil)
 		require.NoError(t, err)
 		assert.Equal(t, fiber.StatusOK, resp.StatusCode)
 
@@ -524,8 +300,7 @@ func TestPermissionAPI_GetTreeByRoleType(t *testing.T) {
 	})
 
 	t.Run("按平台和角色类型过滤", func(t *testing.T) {
-		req := httptest.NewRequest("GET", "/api/admin/permissions/tree?platform=all&available_for_role_type=1", nil)
-		resp, err := env.app.Test(req)
+		resp, err := env.AsSuperAdmin().Request("GET", "/api/admin/permissions/tree?platform=all&available_for_role_type=1", nil)
 		require.NoError(t, err)
 		assert.Equal(t, fiber.StatusOK, resp.StatusCode)
 
@@ -536,48 +311,41 @@ func TestPermissionAPI_GetTreeByRoleType(t *testing.T) {
 	})
 }
 
-// TestPermissionAPI_FilterByAvailableForRoleType 测试按角色类型过滤权限
 func TestPermissionAPI_FilterByAvailableForRoleTypes(t *testing.T) {
-	env := setupPermTestEnv(t)
-	defer env.cleanup()
-
-	testUserID := uint(1)
-	env.app.Use(func(c *fiber.Ctx) error {
-		ctx := middleware.SetUserContext(c.UserContext(), middleware.NewSimpleUserContext(testUserID, constants.UserTypeSuperAdmin, 0))
-		c.SetUserContext(ctx)
-		return c.Next()
-	})
+	env := integ.NewIntegrationTestEnv(t)
 
 	platformPerm := &model.Permission{
-		PermName:              "平台专用权限",
-		PermCode:              "platform:only",
+		BaseModel:             model.BaseModel{Creator: 1, Updater: 1},
+		PermName:              fmt.Sprintf("test_permission_%d", time.Now().UnixNano()),
+		PermCode:              fmt.Sprintf("test:fplat%d", time.Now().UnixNano()),
 		PermType:              constants.PermissionTypeMenu,
 		AvailableForRoleTypes: "1",
 		Status:                constants.StatusEnabled,
 	}
-	env.tx.Create(platformPerm)
+	env.TX.Create(platformPerm)
 
 	customerPerm := &model.Permission{
-		PermName:              "客户专用权限",
-		PermCode:              "customer:only",
+		BaseModel:             model.BaseModel{Creator: 1, Updater: 1},
+		PermName:              fmt.Sprintf("test_permission_%d", time.Now().UnixNano()),
+		PermCode:              fmt.Sprintf("test:fcust%d", time.Now().UnixNano()),
 		PermType:              constants.PermissionTypeMenu,
 		AvailableForRoleTypes: "2",
 		Status:                constants.StatusEnabled,
 	}
-	env.tx.Create(customerPerm)
+	env.TX.Create(customerPerm)
 
 	commonPerm := &model.Permission{
-		PermName:              "通用权限",
-		PermCode:              "common:all",
+		BaseModel:             model.BaseModel{Creator: 1, Updater: 1},
+		PermName:              fmt.Sprintf("test_permission_%d", time.Now().UnixNano()),
+		PermCode:              fmt.Sprintf("test:fcomm%d", time.Now().UnixNano()),
 		PermType:              constants.PermissionTypeMenu,
 		AvailableForRoleTypes: "1,2",
 		Status:                constants.StatusEnabled,
 	}
-	env.tx.Create(commonPerm)
+	env.TX.Create(commonPerm)
 
 	t.Run("过滤平台角色可用权限", func(t *testing.T) {
-		req := httptest.NewRequest("GET", "/api/admin/permissions?available_for_role_type=1", nil)
-		resp, err := env.app.Test(req)
+		resp, err := env.AsSuperAdmin().Request("GET", "/api/admin/permissions?available_for_role_type=1", nil)
 		require.NoError(t, err)
 		assert.Equal(t, fiber.StatusOK, resp.StatusCode)
 
@@ -588,8 +356,7 @@ func TestPermissionAPI_FilterByAvailableForRoleTypes(t *testing.T) {
 	})
 
 	t.Run("按角色类型过滤权限树", func(t *testing.T) {
-		req := httptest.NewRequest("GET", fmt.Sprintf("/api/admin/permissions/tree?available_for_role_type=%d", constants.RoleTypePlatform), nil)
-		resp, err := env.app.Test(req)
+		resp, err := env.AsSuperAdmin().Request("GET", fmt.Sprintf("/api/admin/permissions/tree?available_for_role_type=%d", constants.RoleTypePlatform), nil)
 		require.NoError(t, err)
 		assert.Equal(t, fiber.StatusOK, resp.StatusCode)