gochat/internal/service/custom_role_service_test.go

package service

import (
	"context"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"

	"github.com/gochat/gochat/internal/model"
	"github.com/gochat/gochat/internal/repository"
)

// ========== Test Setup ==========

func setupCustomRoleServiceTest(t *testing.T) (*CustomRoleService, *gorm.DB) {
	t.Helper()

	db, err := gorm.Open(sqlite.Open("file::memory:"), &gorm.Config{
		Logger: logger.Default.LogMode(logger.Silent),
	})
	require.NoError(t, err, "failed to open SQLite test db")

	require.NoError(t, db.AutoMigrate(
		&model.Account{},
		&model.CustomRole{},
	), "failed to auto-migrate")

	t.Cleanup(func() {
		sqlDB, _ := db.DB()
		sqlDB.Close()
	})

	repo := repository.NewCustomRoleRepo(db)
	svc := NewCustomRoleService(repo)
	return svc, db
}

func createCRSvcTestAccount(t *testing.T, db *gorm.DB) *model.Account {
	t.Helper()
	account := &model.Account{Name: "CustomRoleSvcOrg", Locale: "en", Active: true}
	require.NoError(t, db.Create(account).Error)
	return account
}

// ========== List ==========

func TestCustomRoleService_List(t *testing.T) {
	svc, db := setupCustomRoleServiceTest(t)
	account := createCRSvcTestAccount(t, db)

	// Create 2 roles
	_, err := svc.Create(context.Background(), account.ID, CreateCustomRoleRequest{
		Name: "Supervisor",
		Permissions: map[model.PermissionDimension]model.PermissionLevel{
			model.DimensionConversationManage: model.PermissionLevelFull,
		},
	})
	require.NoError(t, err)

	_, err = svc.Create(context.Background(), account.ID, CreateCustomRoleRequest{
		Name: "TeamLead",
		Permissions: map[model.PermissionDimension]model.PermissionLevel{
			model.DimensionConversationManage: model.PermissionLevelRead,
		},
	})
	require.NoError(t, err)

	roles, total, err := svc.List(context.Background(), account.ID, 1, 25)
	assert.NoError(t, err)
	assert.Equal(t, int64(2), total)
	assert.Len(t, roles, 2)
}

func TestCustomRoleService_List_Empty(t *testing.T) {
	svc, db := setupCustomRoleServiceTest(t)
	account := createCRSvcTestAccount(t, db)

	roles, total, err := svc.List(context.Background(), account.ID, 1, 25)
	assert.NoError(t, err)
	assert.Equal(t, int64(0), total)
	assert.Len(t, roles, 0)
}

// ========== Create ==========

func TestCustomRoleService_Create(t *testing.T) {
	svc, db := setupCustomRoleServiceTest(t)
	account := createCRSvcTestAccount(t, db)

	role, err := svc.Create(context.Background(), account.ID, CreateCustomRoleRequest{
		Name: "Supervisor",
		Permissions: map[model.PermissionDimension]model.PermissionLevel{
			model.DimensionConversationManage:    model.PermissionLevelFull,
			model.DimensionConversationDelete:    model.PermissionLevelNone,
			model.DimensionContactManage:         model.PermissionLevelRead,
			model.DimensionReportManage:          model.PermissionLevelNone,
			model.DimensionKnowledgeBaseManage:   model.PermissionLevelNone,
			model.DimensionAutomationManage:      model.PermissionLevelNone,
		},
	})
	assert.NoError(t, err)
	assert.NotZero(t, role.ID)
	assert.Equal(t, "Supervisor", role.Name)
}

func TestCustomRoleService_Create_EmptyPermissions(t *testing.T) {
	svc, db := setupCustomRoleServiceTest(t)
	account := createCRSvcTestAccount(t, db)

	// Create with nil permissions — should default to "{}"
	role, err := svc.Create(context.Background(), account.ID, CreateCustomRoleRequest{
		Name:        "EmptyRole",
		Permissions: nil,
	})
	assert.NoError(t, err)
	assert.NotZero(t, role.ID)
}

// ========== GetByID ==========

func TestCustomRoleService_GetByID(t *testing.T) {
	svc, db := setupCustomRoleServiceTest(t)
	account := createCRSvcTestAccount(t, db)

	created, err := svc.Create(context.Background(), account.ID, CreateCustomRoleRequest{
		Name: "TeamLead",
		Permissions: map[model.PermissionDimension]model.PermissionLevel{
			model.DimensionConversationManage: model.PermissionLevelRead,
		},
	})
	require.NoError(t, err)

	found, err := svc.GetByID(context.Background(), created.ID, account.ID)
	assert.NoError(t, err)
	assert.Equal(t, created.ID, found.ID)
	assert.Equal(t, "TeamLead", found.Name)
}

func TestCustomRoleService_GetByID_WrongAccount(t *testing.T) {
	svc, db := setupCustomRoleServiceTest(t)
	account := createCRSvcTestAccount(t, db)

	created, err := svc.Create(context.Background(), account.ID, CreateCustomRoleRequest{
		Name: "TeamLead",
		Permissions: map[model.PermissionDimension]model.PermissionLevel{
			model.DimensionConversationManage: model.PermissionLevelRead,
		},
	})
	require.NoError(t, err)

	// Wrong account should fail
	_, err = svc.GetByID(context.Background(), created.ID, 9999)
	assert.Error(t, err)
}

// ========== Update ==========

func TestCustomRoleService_Update(t *testing.T) {
	svc, db := setupCustomRoleServiceTest(t)
	account := createCRSvcTestAccount(t, db)

	created, err := svc.Create(context.Background(), account.ID, CreateCustomRoleRequest{
		Name: "Supervisor",
		Permissions: map[model.PermissionDimension]model.PermissionLevel{
			model.DimensionConversationManage: model.PermissionLevelFull,
		},
	})
	require.NoError(t, err)

	updated, err := svc.Update(context.Background(), created.ID, account.ID, UpdateCustomRoleRequest{
		Name: "Senior Supervisor",
	})
	assert.NoError(t, err)
	assert.Equal(t, "Senior Supervisor", updated.Name)
}

func TestCustomRoleService_Update_NotFound(t *testing.T) {
	svc, _ := setupCustomRoleServiceTest(t)

	_, err := svc.Update(context.Background(), 9999, 9999, UpdateCustomRoleRequest{
		Name: "Ghost",
	})
	assert.Error(t, err)
}

// ========== Delete ==========

func TestCustomRoleService_Delete(t *testing.T) {
	svc, db := setupCustomRoleServiceTest(t)
	account := createCRSvcTestAccount(t, db)

	created, err := svc.Create(context.Background(), account.ID, CreateCustomRoleRequest{
		Name: "Supervisor",
		Permissions: map[model.PermissionDimension]model.PermissionLevel{
			model.DimensionConversationManage: model.PermissionLevelFull,
		},
	})
	require.NoError(t, err)

	err = svc.Delete(context.Background(), created.ID, account.ID)
	assert.NoError(t, err)

	// Should no longer be visible via GetByID
	_, err = svc.GetByID(context.Background(), created.ID, account.ID)
	assert.Error(t, err)
}

func TestCustomRoleService_Delete_NotFound(t *testing.T) {
	svc, _ := setupCustomRoleServiceTest(t)

	err := svc.Delete(context.Background(), 9999, 9999)
	// GORM soft-delete on non-existent returns no error (0 rows)
	assert.NoError(t, err)
}