base/backend/model/role_model_test.go

package model

import (
	"context"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
)

// setupRoleTestDB 创建角色测试数据库（使用MySQL）
func setupRoleTestDB(t *testing.T) *gorm.DB {
	t.Helper()

	dsn := "root:dev123456@tcp(219.159.132.177:17173)/base?charset=utf8mb4&parseTime=true&loc=Local"
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
	require.NoError(t, err)

	err = db.AutoMigrate(&Role{})
	require.NoError(t, err)

	// 清理所有数据确保测试隔离（运行后需重启后端以恢复种子数据）
	db.Exec("SET FOREIGN_KEY_CHECKS = 0")
	db.Exec("TRUNCATE TABLE role")
	db.Exec("SET FOREIGN_KEY_CHECKS = 1")

	return db
}

// createTestRole 创建测试角色
func createTestRole(t *testing.T, db *gorm.DB) *Role {
	t.Helper()

	now := time.Now()
	role := &Role{
		Name:        "测试角色",
		Code:        "test_role",
		Description: "测试用",
		IsSystem:    false,
		SortOrder:   10,
		Status:      1,
		CreatedAt:   now,
		UpdatedAt:   now,
	}

	err := db.Create(role).Error
	require.NoError(t, err)

	return role
}

// TestRoleInsert 测试插入角色
func TestRoleInsert(t *testing.T) {
	db := setupRoleTestDB(t)

	ctx := context.Background()
	role := &Role{
		Name:        "新角色",
		Code:        "new_role",
		Description: "新建的角色",
		IsSystem:    false,
		SortOrder:   5,
		Status:      1,
	}

	id, err := RoleInsert(ctx, db, role)

	require.NoError(t, err)
	assert.Greater(t, id, int64(0))
	assert.Equal(t, id, role.Id)

	// 验证数据已保存
	saved, err := RoleFindOne(ctx, db, id)
	require.NoError(t, err)
	assert.Equal(t, "新角色", saved.Name)
	assert.Equal(t, "new_role", saved.Code)
	assert.Equal(t, "新建的角色", saved.Description)
}

// TestRoleFindOne 测试根据ID查询角色
func TestRoleFindOne(t *testing.T) {
	db := setupRoleTestDB(t)

	role := createTestRole(t, db)
	ctx := context.Background()

	found, err := RoleFindOne(ctx, db, role.Id)

	require.NoError(t, err)
	require.NotNil(t, found)
	assert.Equal(t, role.Id, found.Id)
	assert.Equal(t, "测试角色", found.Name)
	assert.Equal(t, "test_role", found.Code)
}

// TestRoleFindOne_NotFound 测试查询不存在的角色
func TestRoleFindOne_NotFound(t *testing.T) {
	db := setupRoleTestDB(t)

	ctx := context.Background()

	found, err := RoleFindOne(ctx, db, 99999)

	require.Error(t, err)
	require.Nil(t, found)
	assert.Equal(t, ErrNotFound, err)
}

// TestRoleFindOneByCode 测试根据编码查询角色
func TestRoleFindOneByCode(t *testing.T) {
	db := setupRoleTestDB(t)

	role := createTestRole(t, db)
	ctx := context.Background()

	found, err := RoleFindOneByCode(ctx, db, "test_role")

	require.NoError(t, err)
	require.NotNil(t, found)
	assert.Equal(t, role.Id, found.Id)
	assert.Equal(t, "测试角色", found.Name)
	assert.Equal(t, "test_role", found.Code)
}

// TestRoleFindOneByCode_NotFound 测试查询不存在的角色编码
func TestRoleFindOneByCode_NotFound(t *testing.T) {
	db := setupRoleTestDB(t)

	ctx := context.Background()

	found, err := RoleFindOneByCode(ctx, db, "nonexistent_code")

	require.Error(t, err)
	require.Nil(t, found)
	assert.Equal(t, ErrNotFound, err)
}

// TestRoleFindAll 测试查询所有启用的角色
func TestRoleFindAll(t *testing.T) {
	db := setupRoleTestDB(t)
	ctx := context.Background()

	// 创建3个角色：2个启用，1个禁用
	now := time.Now()
	roles := []Role{
		{Name: "角色A", Code: "role_a", SortOrder: 2, Status: 1, CreatedAt: now, UpdatedAt: now},
		{Name: "角色B", Code: "role_b", SortOrder: 1, Status: 1, CreatedAt: now, UpdatedAt: now},
		{Name: "角色C", Code: "role_c", SortOrder: 3, Status: 1, CreatedAt: now, UpdatedAt: now},
	}

	for i := range roles {
		err := db.Create(&roles[i]).Error
		require.NoError(t, err)
	}

	// 将角色C设为禁用（status=0是零值，GORM Create时会使用default:1，需要单独更新）
	db.Model(&roles[2]).Update("status", 0)

	// 查询所有启用的角色
	result, err := RoleFindAll(ctx, db)

	require.NoError(t, err)
	assert.Len(t, result, 2)

	// 验证按 sort_order 排序
	assert.Equal(t, "角色B", result[0].Name) // sort_order=1
	assert.Equal(t, "角色A", result[1].Name) // sort_order=2
}

// TestRoleUpdate 测试更新角色
func TestRoleUpdate(t *testing.T) {
	db := setupRoleTestDB(t)

	role := createTestRole(t, db)
	ctx := context.Background()

	// 修改角色数据
	role.Name = "更新后的角色"
	role.Description = "更新后的描述"

	err := RoleUpdate(ctx, db, role)

	require.NoError(t, err)

	// 验证更新结果
	updated, err := RoleFindOne(ctx, db, role.Id)
	require.NoError(t, err)
	assert.Equal(t, "更新后的角色", updated.Name)
	assert.Equal(t, "更新后的描述", updated.Description)
}

// TestRoleDelete 测试删除角色
func TestRoleDelete(t *testing.T) {
	db := setupRoleTestDB(t)

	role := createTestRole(t, db)
	roleId := role.Id
	ctx := context.Background()

	err := RoleDelete(ctx, db, roleId)

	require.NoError(t, err)

	// 验证角色已被删除
	_, err = RoleFindOne(ctx, db, roleId)
	require.Error(t, err)
	assert.Equal(t, ErrNotFound, err)
}