gochat/backend/internal/repository/assignment_policy_repo_test.go

package repository

import (
	"context"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"gorm.io/gorm"

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

func setupAssignmentPolicyTestDB(t *testing.T) *gorm.DB {
	t.Helper()
	return setupTestDB(t,
		&model.AssignmentPolicy{},
		&model.InboxAssignmentPolicy{},
	)
}

// ---------------------------------------------------------------------------
// AssignmentPolicyRepo
// ---------------------------------------------------------------------------

func TestAssignmentPolicyRepo_Create(t *testing.T) {
	db := setupAssignmentPolicyTestDB(t)
	ctx := context.Background()
	repo := NewAssignmentPolicyRepo(db)

	policy := &model.AssignmentPolicy{
		AccountID: 1, Name: "P1",
	}
	err := repo.Create(ctx, policy)
	require.NoError(t, err)
	assert.NotZero(t, policy.ID)
}

func TestAssignmentPolicyRepo_FindByID(t *testing.T) {
	db := setupAssignmentPolicyTestDB(t)
	ctx := context.Background()
	repo := NewAssignmentPolicyRepo(db)

	policy := &model.AssignmentPolicy{AccountID: 1, Name: "P1"}
	require.NoError(t, repo.Create(ctx, policy))

	found, err := repo.FindByID(ctx, policy.ID)
	require.NoError(t, err)
	assert.Equal(t, policy.Name, found.Name)
}

func TestAssignmentPolicyRepo_FindByID_NotFound(t *testing.T) {
	db := setupAssignmentPolicyTestDB(t)
	ctx := context.Background()
	repo := NewAssignmentPolicyRepo(db)

	_, err := repo.FindByID(ctx, 99999)
	assert.ErrorIs(t, err, gorm.ErrRecordNotFound)
}

func TestAssignmentPolicyRepo_GetByID(t *testing.T) {
	db := setupAssignmentPolicyTestDB(t)
	ctx := context.Background()
	repo := NewAssignmentPolicyRepo(db)

	policy := &model.AssignmentPolicy{AccountID: 1, Name: "P1"}
	require.NoError(t, repo.Create(ctx, policy))

	found, err := repo.GetByID(ctx, policy.ID)
	require.NoError(t, err)
	assert.Equal(t, policy.ID, found.ID)
}

func TestAssignmentPolicyRepo_FindByAccount(t *testing.T) {
	db := setupAssignmentPolicyTestDB(t)
	ctx := context.Background()
	repo := NewAssignmentPolicyRepo(db)

	require.NoError(t, repo.Create(ctx, &model.AssignmentPolicy{AccountID: 1, Name: "P1"}))
	require.NoError(t, repo.Create(ctx, &model.AssignmentPolicy{AccountID: 1, Name: "P2"}))
	require.NoError(t, repo.Create(ctx, &model.AssignmentPolicy{AccountID: 2, Name: "P3"}))

	policies, err := repo.FindByAccount(ctx, 1)
	require.NoError(t, err)
	assert.Len(t, policies, 2)
}

func TestAssignmentPolicyRepo_FindByAccountAndID(t *testing.T) {
	db := setupAssignmentPolicyTestDB(t)
	ctx := context.Background()
	repo := NewAssignmentPolicyRepo(db)

	policy := &model.AssignmentPolicy{AccountID: 1, Name: "P1"}
	require.NoError(t, repo.Create(ctx, policy))

	found, err := repo.FindByAccountAndID(ctx, 1, policy.ID)
	require.NoError(t, err)
	assert.Equal(t, policy.ID, found.ID)
}

func TestAssignmentPolicyRepo_FindByAccountAndID_NotFound(t *testing.T) {
	db := setupAssignmentPolicyTestDB(t)
	ctx := context.Background()
	repo := NewAssignmentPolicyRepo(db)

	_, err := repo.FindByAccountAndID(ctx, 1, 99999)
	assert.ErrorIs(t, err, gorm.ErrRecordNotFound)
}

func TestAssignmentPolicyRepo_Update(t *testing.T) {
	db := setupAssignmentPolicyTestDB(t)
	ctx := context.Background()
	repo := NewAssignmentPolicyRepo(db)

	policy := &model.AssignmentPolicy{AccountID: 1, Name: "Old"}
	require.NoError(t, repo.Create(ctx, policy))

	policy.Name = "Updated"
	policy.Description = "new desc"
	require.NoError(t, repo.Update(ctx, policy))

	found, _ := repo.FindByID(ctx, policy.ID)
	assert.Equal(t, "Updated", found.Name)
}

func TestAssignmentPolicyRepo_Delete(t *testing.T) {
	db := setupAssignmentPolicyTestDB(t)
	ctx := context.Background()
	repo := NewAssignmentPolicyRepo(db)

	policy := &model.AssignmentPolicy{AccountID: 1, Name: "ToDelete"}
	require.NoError(t, repo.Create(ctx, policy))

	require.NoError(t, repo.Delete(ctx, policy.ID))

	_, err := repo.FindByID(ctx, policy.ID)
	assert.ErrorIs(t, err, gorm.ErrRecordNotFound)
}

func TestAssignmentPolicyRepo_CountAssignedInboxes(t *testing.T) {
	db := setupAssignmentPolicyTestDB(t)
	ctx := context.Background()
	repo := NewAssignmentPolicyRepo(db)
	inboxRepo := NewInboxAssignmentPolicyRepo(db)

	policy := &model.AssignmentPolicy{AccountID: 1, Name: "P1"}
	require.NoError(t, repo.Create(ctx, policy))

	require.NoError(t, inboxRepo.Create(ctx, &model.InboxAssignmentPolicy{InboxID: 1, AssignmentPolicyID: policy.ID}))
	require.NoError(t, inboxRepo.Create(ctx, &model.InboxAssignmentPolicy{InboxID: 2, AssignmentPolicyID: policy.ID}))

	count, err := repo.CountAssignedInboxes(ctx, policy.ID)
	require.NoError(t, err)
	assert.Equal(t, int64(2), count)
}

// ---------------------------------------------------------------------------
// InboxAssignmentPolicyRepo
// ---------------------------------------------------------------------------

func TestInboxAssignmentPolicyRepo_Create(t *testing.T) {
	db := setupAssignmentPolicyTestDB(t)
	ctx := context.Background()
	repo := NewInboxAssignmentPolicyRepo(db)

	iap := &model.InboxAssignmentPolicy{InboxID: 1, AssignmentPolicyID: 1}
	err := repo.Create(ctx, iap)
	require.NoError(t, err)
	assert.NotZero(t, iap.ID)
}

func TestInboxAssignmentPolicyRepo_FindByID(t *testing.T) {
	db := setupAssignmentPolicyTestDB(t)
	ctx := context.Background()
	repo := NewInboxAssignmentPolicyRepo(db)

	iap := &model.InboxAssignmentPolicy{InboxID: 1, AssignmentPolicyID: 1}
	require.NoError(t, repo.Create(ctx, iap))

	found, err := repo.FindByID(ctx, iap.ID)
	require.NoError(t, err)
	assert.Equal(t, iap.ID, found.ID)
}

func TestInboxAssignmentPolicyRepo_FindByID_NotFound(t *testing.T) {
	db := setupAssignmentPolicyTestDB(t)
	ctx := context.Background()
	repo := NewInboxAssignmentPolicyRepo(db)

	_, err := repo.FindByID(ctx, 99999)
	assert.ErrorIs(t, err, gorm.ErrRecordNotFound)
}

func TestInboxAssignmentPolicyRepo_FindByInbox(t *testing.T) {
	db := setupAssignmentPolicyTestDB(t)
	ctx := context.Background()
	repo := NewInboxAssignmentPolicyRepo(db)
	policyRepo := NewAssignmentPolicyRepo(db)

	policy := &model.AssignmentPolicy{AccountID: 1, Name: "P1"}
	require.NoError(t, policyRepo.Create(ctx, policy))
	require.NoError(t, repo.Create(ctx, &model.InboxAssignmentPolicy{InboxID: 10, AssignmentPolicyID: policy.ID}))

	found, err := repo.FindByInbox(ctx, 1, 10)
	require.NoError(t, err)
	assert.Equal(t, policy.ID, found.AssignmentPolicyID)
}

func TestInboxAssignmentPolicyRepo_FindByInbox_NotFound(t *testing.T) {
	db := setupAssignmentPolicyTestDB(t)
	ctx := context.Background()
	repo := NewInboxAssignmentPolicyRepo(db)

	_, err := repo.FindByInbox(ctx, 1, 99999)
	assert.ErrorIs(t, err, gorm.ErrRecordNotFound)
}

func TestInboxAssignmentPolicyRepo_FindPolicyByInbox(t *testing.T) {
	db := setupAssignmentPolicyTestDB(t)
	ctx := context.Background()
	repo := NewInboxAssignmentPolicyRepo(db)
	policyRepo := NewAssignmentPolicyRepo(db)

	policy := &model.AssignmentPolicy{AccountID: 1, Name: "P1"}
	require.NoError(t, policyRepo.Create(ctx, policy))
	require.NoError(t, repo.Create(ctx, &model.InboxAssignmentPolicy{InboxID: 10, AssignmentPolicyID: policy.ID}))

	found, err := repo.FindPolicyByInbox(ctx, 1, 10)
	require.NoError(t, err)
	assert.Equal(t, policy.ID, found.ID)
	assert.Equal(t, "P1", found.Name)
}

func TestInboxAssignmentPolicyRepo_FindPolicyByInbox_NotFound(t *testing.T) {
	db := setupAssignmentPolicyTestDB(t)
	ctx := context.Background()
	repo := NewInboxAssignmentPolicyRepo(db)

	_, err := repo.FindPolicyByInbox(ctx, 1, 99999)
	assert.ErrorIs(t, err, gorm.ErrRecordNotFound)
}

func TestInboxAssignmentPolicyRepo_FindInboxesByPolicy(t *testing.T) {
	db := setupAssignmentPolicyTestDB(t)
	ctx := context.Background()
	repo := NewInboxAssignmentPolicyRepo(db)
	policyRepo := NewAssignmentPolicyRepo(db)

	policy := &model.AssignmentPolicy{AccountID: 1, Name: "P1"}
	require.NoError(t, policyRepo.Create(ctx, policy))

	require.NoError(t, db.Create(&model.Inbox{AccountID: 1, Name: "I1", ChannelType: "web_widget"}).Error)
	require.NoError(t, db.Create(&model.Inbox{AccountID: 1, Name: "I2", ChannelType: "web_widget"}).Error)
	require.NoError(t, repo.Create(ctx, &model.InboxAssignmentPolicy{InboxID: 1, AssignmentPolicyID: policy.ID}))
	require.NoError(t, repo.Create(ctx, &model.InboxAssignmentPolicy{InboxID: 2, AssignmentPolicyID: policy.ID}))

	inboxes, err := repo.FindInboxesByPolicy(ctx, 1, policy.ID)
	require.NoError(t, err)
	assert.Len(t, inboxes, 2)
}

func TestInboxAssignmentPolicyRepo_ReplaceForInbox(t *testing.T) {
	db := setupAssignmentPolicyTestDB(t)
	ctx := context.Background()
	repo := NewInboxAssignmentPolicyRepo(db)

	// Create initial association
	require.NoError(t, repo.Create(ctx, &model.InboxAssignmentPolicy{InboxID: 10, AssignmentPolicyID: 1}))

	// Replace
	result, err := repo.ReplaceForInbox(ctx, 10, 2)
	require.NoError(t, err)
	assert.Equal(t, uint(2), result.AssignmentPolicyID)

	// Verify old one is gone
	all := []model.InboxAssignmentPolicy{}
	db.Find(&all)
	assert.Len(t, all, 1)
}

func TestInboxAssignmentPolicyRepo_DeleteByInbox(t *testing.T) {
	db := setupAssignmentPolicyTestDB(t)
	ctx := context.Background()
	repo := NewInboxAssignmentPolicyRepo(db)

	require.NoError(t, repo.Create(ctx, &model.InboxAssignmentPolicy{InboxID: 10, AssignmentPolicyID: 1}))

	require.NoError(t, repo.DeleteByInbox(ctx, 10))

	_, err := repo.FindByInbox(ctx, 1, 10)
	assert.ErrorIs(t, err, gorm.ErrRecordNotFound)
}

func TestInboxAssignmentPolicyRepo_Update(t *testing.T) {
	db := setupAssignmentPolicyTestDB(t)
	ctx := context.Background()
	repo := NewInboxAssignmentPolicyRepo(db)

	iap := &model.InboxAssignmentPolicy{InboxID: 1, AssignmentPolicyID: 1}
	require.NoError(t, repo.Create(ctx, iap))

	iap.AssignmentPolicyID = 2
	require.NoError(t, repo.Update(ctx, iap))

	found, _ := repo.FindByID(ctx, iap.ID)
	assert.Equal(t, uint(2), found.AssignmentPolicyID)
}

func TestInboxAssignmentPolicyRepo_Delete(t *testing.T) {
	db := setupAssignmentPolicyTestDB(t)
	ctx := context.Background()
	repo := NewInboxAssignmentPolicyRepo(db)

	iap := &model.InboxAssignmentPolicy{InboxID: 1, AssignmentPolicyID: 1}
	require.NoError(t, repo.Create(ctx, iap))

	require.NoError(t, repo.Delete(ctx, iap.ID))

	_, err := repo.FindByID(ctx, iap.ID)
	assert.ErrorIs(t, err, gorm.ErrRecordNotFound)
}