app-cloudep-permission-server/pkg/repository/role_permission_test.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 SetupTestRolePermissionRepository(db string) (repository.RolePermissionRepository, 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 := RoleRepositoryParam{
		Conf: conf,
	}
	repo := NewRolePermissionRepository(param)
	_, _ = repo.Index20250225UP(context.Background())

	return repo, tearDown, nil
}

func TestRolePermissionRepository_Create(t *testing.T) {
	repo, tearDown, err := SetupTestRolePermissionRepository("testDB")
	assert.NoError(t, err)
	defer tearDown()

	testCases := []struct {
		name      string
		input     entity.RolePermission
		expectErr bool
	}{
		{
			name: "成功插入新的 RolePermission",
			input: entity.RolePermission{
				RoleID:       "role_1",
				PermissionID: "perm_1",
			},
			expectErr: false,
		},
		{
			name: "插入已經有 ID 的 RolePermission",
			input: entity.RolePermission{
				ID:           primitive.NewObjectID(),
				RoleID:       "role_2",
				PermissionID: "perm_2",
				CreateAt:     time.Now().UnixNano(),
				UpdateAt:     time.Now().UnixNano(),
			},
			expectErr: false,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			err := repo.Create(context.Background(), []entity.RolePermission{tc.input})

			if tc.expectErr {
				assert.Error(t, err, "應該返回錯誤")
			} else {
				assert.NoError(t, err, "不應該返回錯誤")
			}
		})
	}
}

func TestRolePermissionRepository_Delete(t *testing.T) {
	repo, tearDown, err := SetupTestRolePermissionRepository("testDB")
	assert.NoError(t, err)
	defer tearDown()

	// 先準備測試資料
	existingRolePermission := entity.RolePermission{
		ID:           primitive.NewObjectID(),
		RoleID:       "role_1",
		PermissionID: "perm_1",
	}

	err = repo.Create(context.Background(), []entity.RolePermission{existingRolePermission})
	assert.NoError(t, err, "應該成功插入測試資料")

	testCases := []struct {
		name       string
		roleID     string
		permission string
		expectErr  bool
	}{
		{
			name:       "成功刪除已存在的 RolePermission",
			roleID:     "role_1",
			permission: "perm_1",
			expectErr:  false,
		},
		{
			name:       "刪除不存在的 RolePermission，不應該報錯",
			roleID:     "role_2",
			permission: "perm_2",
			expectErr:  false,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			err := repo.Delete(context.Background(), tc.roleID, []string{tc.permission})

			if tc.expectErr {
				assert.Error(t, err, "應該返回錯誤")
			} else {
				assert.NoError(t, err, "不應該返回錯誤")
			}
		})
	}
}

func TestRolePermissionRepository_GetByPermissionID(t *testing.T) {
	repo, tearDown, err := SetupTestRolePermissionRepository("testDB")
	assert.NoError(t, err)
	defer tearDown()

	// 先準備測試資料
	existingRolePermissions := []entity.RolePermission{
		{
			ID:           primitive.NewObjectID(),
			RoleID:       "role_1",
			PermissionID: "perm_1",
		},
		{
			ID:           primitive.NewObjectID(),
			RoleID:       "role_2",
			PermissionID: "perm_2",
		},
		{
			ID:           primitive.NewObjectID(),
			RoleID:       "role_3",
			PermissionID: "perm_3",
		},
	}

	for _, rp := range existingRolePermissions {
		err := repo.Create(context.Background(), []entity.RolePermission{rp})
		assert.NoError(t, err, "應該成功插入測試資料")
	}

	testCases := []struct {
		name          string
		permissionIDs []string
		expectedCount int
		expectErr     bool
	}{
		{
			name:          "成功查詢符合的 RolePermission",
			permissionIDs: []string{"perm_1", "perm_2"},
			expectedCount: 2,
			expectErr:     false,
		},
		{
			name:          "查詢時沒有符合條件的 RolePermission",
			permissionIDs: []string{"perm_99"},
			expectedCount: 0,
			expectErr:     false,
		},
		{
			name:          "查詢時發生資料庫錯誤",
			permissionIDs: nil, // 模擬無效的參數
			expectedCount: 0,
			expectErr:     true,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			results, err := repo.GetByPermissionID(context.Background(), tc.permissionIDs)

			if tc.expectErr {
				assert.Error(t, err, "應該返回錯誤")
			} else {
				assert.NoError(t, err, "不應該返回錯誤")
				assert.Len(t, results, tc.expectedCount, "回傳結果數量應符合預期")
			}
		})
	}
}

func TestRolePermissionRepository_Get(t *testing.T) {
	repo, tearDown, err := SetupTestRolePermissionRepository("testDB")
	assert.NoError(t, err)
	defer tearDown()

	// 先準備測試資料
	existingRolePermissions := []entity.RolePermission{
		{
			ID:           primitive.NewObjectID(),
			RoleID:       "role_1",
			PermissionID: "perm_1",
		},
		{
			ID:           primitive.NewObjectID(),
			RoleID:       "role_1",
			PermissionID: "perm_2",
		},
		{
			ID:           primitive.NewObjectID(),
			RoleID:       "role_2",
			PermissionID: "perm_3",
		},
	}

	for _, rp := range existingRolePermissions {
		err := repo.Create(context.Background(), []entity.RolePermission{rp})
		assert.NoError(t, err, "應該成功插入測試資料")
	}

	testCases := []struct {
		name          string
		roleID        string
		expectedCount int
		expectErr     bool
	}{
		{
			name:          "成功查詢符合的 RolePermission",
			roleID:        "role_1",
			expectedCount: 2,
			expectErr:     false,
		},
		{
			name:          "查詢時沒有符合條件的 RolePermission",
			roleID:        "role_99",
			expectedCount: 0,
			expectErr:     false,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			results, err := repo.Get(context.Background(), tc.roleID)

			if tc.expectErr {
				assert.Error(t, err, "應該返回錯誤")
			} else {
				assert.NoError(t, err, "不應該返回錯誤")
				assert.Len(t, results, tc.expectedCount, "回傳結果數量應符合預期")
			}
		})
	}
}