336 lines
9.4 KiB
Go
336 lines
9.4 KiB
Go
package repository
|
||
|
||
import (
|
||
"context"
|
||
"fmt"
|
||
"testing"
|
||
"time"
|
||
|
||
"code.30cm.net/digimon/app-cloudep-permission-server/pkg/domain/entity"
|
||
"code.30cm.net/digimon/app-cloudep-permission-server/pkg/domain/repository"
|
||
mgo "code.30cm.net/digimon/library-go/mongo"
|
||
"github.com/stretchr/testify/assert"
|
||
"go.mongodb.org/mongo-driver/bson/primitive"
|
||
)
|
||
|
||
func SetupTestUserRoleRepository(db string) (repository.UserRoleRepository, func(), error) {
|
||
h, p, tearDown, err := startMongoContainer()
|
||
if err != nil {
|
||
return nil, nil, err
|
||
}
|
||
|
||
conf := &mgo.Conf{
|
||
Schema: Schema,
|
||
Host: fmt.Sprintf("%s:%s", h, p),
|
||
Database: db,
|
||
MaxStaleness: 300,
|
||
MaxPoolSize: 100,
|
||
MinPoolSize: 100,
|
||
MaxConnIdleTime: 300,
|
||
Compressors: []string{},
|
||
EnableStandardReadWriteSplitMode: false,
|
||
ConnectTimeoutMs: 3000,
|
||
}
|
||
|
||
param := UserRoleRepositoryParam{
|
||
Conf: conf,
|
||
}
|
||
repo := NewUserRoleRepository(param)
|
||
_, _ = repo.Index20250225UP(context.Background())
|
||
|
||
return repo, tearDown, nil
|
||
}
|
||
|
||
func TestUserRoleRepository_CreateUserRole(t *testing.T) {
|
||
repo, tearDown, err := SetupTestUserRoleRepository("testDB")
|
||
assert.NoError(t, err)
|
||
defer tearDown()
|
||
|
||
testCases := []struct {
|
||
name string
|
||
input entity.UserRole
|
||
expectErr bool
|
||
}{
|
||
{
|
||
name: "成功新增使用者角色",
|
||
input: entity.UserRole{
|
||
UID: "user_123",
|
||
RoleID: "role_456",
|
||
},
|
||
expectErr: false,
|
||
},
|
||
{
|
||
name: "異常：無效的輸入",
|
||
input: entity.UserRole{
|
||
RoleID: "role_456",
|
||
},
|
||
expectErr: true,
|
||
},
|
||
}
|
||
|
||
for _, tc := range testCases {
|
||
t.Run(tc.name, func(t *testing.T) {
|
||
err := repo.CreateUserRole(context.Background(), tc.input)
|
||
if tc.expectErr {
|
||
assert.Error(t, err, "應該返回錯誤")
|
||
} else {
|
||
assert.NoError(t, err, "不應該返回錯誤")
|
||
|
||
// 檢查資料是否真的被插入
|
||
var inserted entity.UserRole
|
||
inserted, err = repo.GetByUserID(context.Background(), tc.input.UID)
|
||
assert.NoError(t, err, "應該能找到插入的資料")
|
||
assert.Equal(t, tc.input.UID, inserted.UID, "UID 應該匹配")
|
||
assert.Equal(t, tc.input.RoleID, inserted.RoleID, "RoleID 應該匹配")
|
||
assert.NotZero(t, inserted.CreateAt, "CreateAt 應該被設定")
|
||
assert.NotZero(t, inserted.UpdateAt, "UpdateAt 應該被設定")
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
func TestUserRoleRepository_UpdateUserRole(t *testing.T) {
|
||
repo, tearDown, err := SetupTestUserRoleRepository("testDB")
|
||
assert.NoError(t, err)
|
||
defer tearDown()
|
||
|
||
// 先插入測試數據
|
||
existingUserRole := entity.UserRole{
|
||
ID: primitive.NewObjectID(),
|
||
UID: "user_123",
|
||
RoleID: "role_123",
|
||
CreateAt: time.Now().UTC().UnixNano(),
|
||
UpdateAt: time.Now().UTC().UnixNano(),
|
||
}
|
||
|
||
err = repo.CreateUserRole(context.Background(), existingUserRole)
|
||
assert.NoError(t, err, "初始化數據應該成功")
|
||
|
||
testCases := []struct {
|
||
name string
|
||
uid string
|
||
newRoleID string
|
||
expectErr bool
|
||
expectedRole string
|
||
}{
|
||
{
|
||
name: "成功更新使用者角色",
|
||
uid: "user_123",
|
||
newRoleID: "role_456",
|
||
expectErr: false,
|
||
expectedRole: "role_456",
|
||
},
|
||
{
|
||
name: "異常：更新的 UID 不存在",
|
||
uid: "non_existent_user",
|
||
newRoleID: "role_789",
|
||
expectErr: true,
|
||
expectedRole: "",
|
||
},
|
||
}
|
||
|
||
for _, tc := range testCases {
|
||
t.Run(tc.name, func(t *testing.T) {
|
||
_, err = repo.UpdateUserRole(context.Background(), tc.uid, tc.newRoleID)
|
||
|
||
if tc.expectErr {
|
||
assert.Error(t, err, "應該返回錯誤")
|
||
} else {
|
||
assert.NoError(t, err, "不應該返回錯誤")
|
||
// 檢查資料是否真的被更新
|
||
found, err := repo.GetByUserID(context.Background(), tc.uid)
|
||
assert.NoError(t, err, "應該能找到更新後的資料")
|
||
assert.Equal(t, tc.expectedRole, found.RoleID, "RoleID 應該匹配更新的值")
|
||
assert.NotZero(t, found.UpdateAt, "UpdateAt 應該被更新")
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
func TestUserRoleRepository_CountUsersByRole(t *testing.T) {
|
||
repo, tearDown, err := SetupTestUserRoleRepository("testDB")
|
||
assert.NoError(t, err)
|
||
defer tearDown()
|
||
|
||
// 先插入測試數據
|
||
testUsers := []entity.UserRole{
|
||
{ID: primitive.NewObjectID(), UID: "user_1", RoleID: "role_admin"},
|
||
{ID: primitive.NewObjectID(), UID: "user_2", RoleID: "role_admin"},
|
||
{ID: primitive.NewObjectID(), UID: "user_3", RoleID: "role_user"},
|
||
{ID: primitive.NewObjectID(), UID: "user_4", RoleID: "role_user"},
|
||
{ID: primitive.NewObjectID(), UID: "user_5", RoleID: "role_user"},
|
||
}
|
||
|
||
for _, user := range testUsers {
|
||
err := repo.CreateUserRole(context.Background(), user)
|
||
assert.NoError(t, err, "應該成功插入測試數據")
|
||
}
|
||
|
||
testCases := []struct {
|
||
name string
|
||
expectedData []repository.RoleUserCount
|
||
expectErr bool
|
||
}{
|
||
{
|
||
name: "成功統計角色使用者數量",
|
||
expectedData: []repository.RoleUserCount{
|
||
{RoleID: "role_admin", Count: 2},
|
||
{RoleID: "role_user", Count: 3},
|
||
},
|
||
expectErr: false,
|
||
},
|
||
//{
|
||
// name: "無資料時回傳空結果",
|
||
// expectedData: []repository.RoleUserCount{},
|
||
// expectErr: false,
|
||
//},
|
||
}
|
||
|
||
for _, tc := range testCases {
|
||
t.Run(tc.name, func(t *testing.T) {
|
||
result, err := repo.CountUsersByRole(context.Background())
|
||
|
||
if tc.expectErr {
|
||
assert.Error(t, err, "應該返回錯誤")
|
||
} else {
|
||
assert.NoError(t, err, "不應該返回錯誤")
|
||
assert.ElementsMatch(t, tc.expectedData, result, "結果應該匹配預期的使用者數量統計")
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestUserRoleRepository_GetUsersByRoleID 測試 GetUsersByRoleID 查詢指定 RoleID 的使用者
|
||
func TestUserRoleRepository_GetUsersByRoleID(t *testing.T) {
|
||
repo, tearDown, err := SetupTestUserRoleRepository("testDB")
|
||
assert.NoError(t, err)
|
||
defer tearDown()
|
||
|
||
// 插入測試數據
|
||
testUsers := []entity.UserRole{
|
||
{ID: primitive.NewObjectID(), UID: "user_1", RoleID: "role_admin"},
|
||
{ID: primitive.NewObjectID(), UID: "user_2", RoleID: "role_admin"},
|
||
{ID: primitive.NewObjectID(), UID: "user_3", RoleID: "role_user"},
|
||
{ID: primitive.NewObjectID(), UID: "user_4", RoleID: "role_user"},
|
||
{ID: primitive.NewObjectID(), UID: "user_5", RoleID: "role_user"},
|
||
}
|
||
|
||
for _, user := range testUsers {
|
||
err := repo.CreateUserRole(context.Background(), user)
|
||
assert.NoError(t, err, "應該成功插入測試數據")
|
||
}
|
||
|
||
// 測試案例
|
||
testCases := []struct {
|
||
name string
|
||
roleID string
|
||
expectedData []entity.UserRole
|
||
expectErr bool
|
||
}{
|
||
{
|
||
name: "成功查詢 role_admin 的使用者",
|
||
roleID: "role_admin",
|
||
expectedData: []entity.UserRole{
|
||
{UID: "user_1", RoleID: "role_admin"},
|
||
{UID: "user_2", RoleID: "role_admin"},
|
||
},
|
||
expectErr: false,
|
||
},
|
||
{
|
||
name: "成功查詢 role_user 的使用者",
|
||
roleID: "role_user",
|
||
expectedData: []entity.UserRole{
|
||
{UID: "user_3", RoleID: "role_user"},
|
||
{UID: "user_4", RoleID: "role_user"},
|
||
{UID: "user_5", RoleID: "role_user"},
|
||
},
|
||
expectErr: false,
|
||
},
|
||
{
|
||
name: "查詢 role_guest，應回傳空陣列",
|
||
roleID: "role_guest",
|
||
expectedData: []entity.UserRole{},
|
||
expectErr: false,
|
||
},
|
||
}
|
||
|
||
for _, tc := range testCases {
|
||
t.Run(tc.name, func(t *testing.T) {
|
||
result, err := repo.GetUsersByRoleID(context.Background(), tc.roleID)
|
||
|
||
if tc.expectErr {
|
||
assert.Error(t, err, "應該返回錯誤")
|
||
} else {
|
||
assert.NoError(t, err, "不應該返回錯誤")
|
||
compute := make([]entity.UserRole, 0, len(result))
|
||
res := make([]entity.UserRole, 0, len(result))
|
||
|
||
for _, item := range result {
|
||
compute = append(compute, entity.UserRole{
|
||
RoleID: item.RoleID,
|
||
UID: item.UID,
|
||
})
|
||
}
|
||
|
||
for _, item := range tc.expectedData {
|
||
res = append(res, entity.UserRole{
|
||
RoleID: item.RoleID,
|
||
UID: item.UID,
|
||
})
|
||
}
|
||
assert.ElementsMatch(t, compute, res, "結果應該匹配預期的使用者列表")
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
// TestUserRoleRepository_GetAll 測試 GetAll 取得所有使用者角色
|
||
func TestUserRoleRepository_GetAll(t *testing.T) {
|
||
repo, tearDown, err := SetupTestUserRoleRepository("testDB")
|
||
assert.NoError(t, err)
|
||
defer tearDown()
|
||
|
||
// 插入測試數據
|
||
testUsers := []entity.UserRole{
|
||
{ID: primitive.NewObjectID(), UID: "user_1", RoleID: "role_admin"},
|
||
{ID: primitive.NewObjectID(), UID: "user_2", RoleID: "role_editor"},
|
||
{ID: primitive.NewObjectID(), UID: "user_3", RoleID: "role_viewer"},
|
||
}
|
||
|
||
for _, user := range testUsers {
|
||
err := repo.CreateUserRole(context.Background(), user)
|
||
assert.NoError(t, err, "應該成功插入測試數據")
|
||
}
|
||
|
||
// 測試案例
|
||
testCases := []struct {
|
||
name string
|
||
expectedData []*entity.UserRole
|
||
expectErr bool
|
||
}{
|
||
{
|
||
name: "成功獲取所有使用者角色",
|
||
expectedData: []*entity.UserRole{
|
||
{UID: "user_1", RoleID: "role_admin"},
|
||
{UID: "user_2", RoleID: "role_editor"},
|
||
{UID: "user_3", RoleID: "role_viewer"},
|
||
},
|
||
expectErr: false,
|
||
},
|
||
}
|
||
|
||
for _, tc := range testCases {
|
||
t.Run(tc.name, func(t *testing.T) {
|
||
result, err := repo.GetAll(context.Background())
|
||
|
||
if tc.expectErr {
|
||
assert.Error(t, err, "應該返回錯誤")
|
||
} else {
|
||
assert.NoError(t, err, "不應該返回錯誤")
|
||
assert.Len(t, result, len(tc.expectedData), "結果應該包含正確數量的使用者角色")
|
||
//assert.ElementsMatch(t, tc.expectedData, result, "結果應該匹配預期的使用者角色")
|
||
}
|
||
})
|
||
}
|
||
}
|