gochat/internal/service/contact_inbox_service_test.go_BAK

package service

import (
	"context"
	"fmt"
	"testing"

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

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

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

func TestContactInboxService_GetByID_成功(t *testing.T) {
	db, _, svc := setupContactInboxService(t)
	account := createTestAccount(t, db)
	contact := createTestContact(t, db, account.ID)
	inbox := createTestInbox(t, db, account.ID, "web_widget")

	// 直接在数据库中创建一条 contact_inbox 记录
	ci := &model.ContactInbox{
		ContactID:   contact.ID,
		InboxID:     inbox.ID,
		SourceID:    "src_123",
		HMACToken:   "hmac_test_token",
		PubsubToken: "pubsub_test_token",
	}
	require.NoError(t, db.Create(ci).Error)

	result, err := svc.GetByID(context.Background(), ci.ID)
	require.NoError(t, err)
	assert.Equal(t, ci.ID, result.ID)
	assert.Equal(t, contact.ID, result.ContactID)
	assert.Equal(t, inbox.ID, result.InboxID)
	assert.Equal(t, "src_123", result.SourceID)
}

func TestContactInboxService_GetByID_不存在(t *testing.T) {
	_, _, svc := setupContactInboxService(t)

	result, err := svc.GetByID(context.Background(), 99999)
	assert.Nil(t, result)
	assert.Error(t, err)
}

// ========== GetByContactAndInbox ==========

func TestContactInboxService_GetByContactAndInbox_成功(t *testing.T) {
	db, _, svc := setupContactInboxService(t)
	account := createTestAccount(t, db)
	contact := createTestContact(t, db, account.ID)
	inbox := createTestInbox(t, db, account.ID, "web_widget")

	ci := &model.ContactInbox{
		ContactID:   contact.ID,
		InboxID:     inbox.ID,
		SourceID:    "src_unique",
		HMACToken:   "hmac_token",
		PubsubToken: "pubsub_token",
	}
	require.NoError(t, db.Create(ci).Error)

	result, err := svc.GetByContactAndInbox(context.Background(), contact.ID, inbox.ID)
	require.NoError(t, err)
	assert.Equal(t, ci.ID, result.ID)
	assert.Equal(t, contact.ID, result.ContactID)
	assert.Equal(t, inbox.ID, result.InboxID)
}

func TestContactInboxService_GetByContactAndInbox_不存在(t *testing.T) {
	_, _, svc := setupContactInboxService(t)

	result, err := svc.GetByContactAndInbox(context.Background(), 99999, 99999)
	assert.Nil(t, result)
	assert.Error(t, err)
}

// ========== ListByContact ==========

func TestContactInboxService_ListByContact_成功(t *testing.T) {
	db, _, svc := setupContactInboxService(t)
	account := createTestAccount(t, db)
	contact := createTestContact(t, db, account.ID)
	inbox1 := createTestInbox(t, db, account.ID, "web_widget")
	inbox2 := createTestInbox(t, db, account.ID, "api")

	ci1 := &model.ContactInbox{ContactID: contact.ID, InboxID: inbox1.ID, SourceID: "src_a", HMACToken: "h1", PubsubToken: "p1"}
	ci2 := &model.ContactInbox{ContactID: contact.ID, InboxID: inbox2.ID, SourceID: "src_b", HMACToken: "h2", PubsubToken: "p2"}
	require.NoError(t, db.Create(ci1).Error)
	require.NoError(t, db.Create(ci2).Error)

	results, err := svc.ListByContact(context.Background(), contact.ID)
	require.NoError(t, err)
	assert.Len(t, results, 2)
}

func TestContactInboxService_ListByContact_空列表(t *testing.T) {
	db, _, svc := setupContactInboxService(t)
	account := createTestAccount(t, db)
	contact := createTestContact(t, db, account.ID)

	results, err := svc.ListByContact(context.Background(), contact.ID)
	require.NoError(t, err)
	assert.Len(t, results, 0)
}

// ========== ListByInbox ==========

func TestContactInboxService_ListByInbox_成功(t *testing.T) {
	db, _, svc := setupContactInboxService(t)
	account := createTestAccount(t, db)
	inbox := createTestInbox(t, db, account.ID, "web_widget")
	contact1 := createTestContact(t, db, account.ID)
	contact2 := createTestContact(t, db, account.ID)

	ci1 := &model.ContactInbox{ContactID: contact1.ID, InboxID: inbox.ID, SourceID: "src_x", HMACToken: "h1", PubsubToken: "p1"}
	ci2 := &model.ContactInbox{ContactID: contact2.ID, InboxID: inbox.ID, SourceID: "src_y", HMACToken: "h2", PubsubToken: "p2"}
	require.NoError(t, db.Create(ci1).Error)
	require.NoError(t, db.Create(ci2).Error)

	results, total, err := svc.ListByInbox(context.Background(), inbox.ID, 0, 10)
	require.NoError(t, err)
	assert.Equal(t, int64(2), total)
	assert.Len(t, results, 2)
}

func TestContactInboxService_ListByInbox_分页(t *testing.T) {
	db, _, svc := setupContactInboxService(t)
	account := createTestAccount(t, db)
	inbox := createTestInbox(t, db, account.ID, "web_widget")

	// 创建3个 contact_inbox 记录
	for i := 0; i < 3; i++ {
		contact := createTestContact(t, db, account.ID)
		ci := &model.ContactInbox{ContactID: contact.ID, InboxID: inbox.ID, SourceID: fmt.Sprintf("src_%d", i), HMACToken: "h", PubsubToken: "p"}
		require.NoError(t, db.Create(ci).Error)
	}

	// 第1页 limit=2
	results, total, err := svc.ListByInbox(context.Background(), inbox.ID, 0, 2)
	require.NoError(t, err)
	assert.Equal(t, int64(3), total)
	assert.Len(t, results, 2)

	// 第2页 offset=2 limit=2
	results2, total2, err2 := svc.ListByInbox(context.Background(), inbox.ID, 2, 2)
	require.NoError(t, err2)
	assert.Equal(t, int64(3), total2)
	assert.Len(t, results2, 1)
}

// ========== GetBySourceID ==========

func TestContactInboxService_GetBySourceID_成功(t *testing.T) {
	db, _, svc := setupContactInboxService(t)
	account := createTestAccount(t, db)
	contact := createTestContact(t, db, account.ID)
	inbox := createTestInbox(t, db, account.ID, "web_widget")

	ci := &model.ContactInbox{ContactID: contact.ID, InboxID: inbox.ID, SourceID: "unique_source_id", HMACToken: "h", PubsubToken: "p"}
	require.NoError(t, db.Create(ci).Error)

	result, err := svc.GetBySourceID(context.Background(), inbox.ID, "unique_source_id")
	require.NoError(t, err)
	assert.Equal(t, ci.ID, result.ID)
	assert.Equal(t, "unique_source_id", result.SourceID)
}

func TestContactInboxService_GetBySourceID_不存在(t *testing.T) {
	_, _, svc := setupContactInboxService(t)

	result, err := svc.GetBySourceID(context.Background(), 99999, "nonexistent_source")
	assert.Nil(t, result)
	assert.Error(t, err)
}

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

func TestContactInboxService_Create_成功(t *testing.T) {
	db, _, svc := setupContactInboxService(t)
	account := createTestAccount(t, db)
	contact := createTestContact(t, db, account.ID)
	inbox := createTestInbox(t, db, account.ID, "web_widget")

	req := CreateContactInboxRequest{
		ContactID: contact.ID,
		InboxID:   inbox.ID,
		SourceID:  "new_source",
	}
	result, err := svc.Create(context.Background(), req)
	require.NoError(t, err)
	assert.NotZero(t, result.ID)
	assert.Equal(t, contact.ID, result.ContactID)
	assert.Equal(t, inbox.ID, result.InboxID)
	assert.Equal(t, "new_source", result.SourceID)
	assert.NotEmpty(t, result.HMACToken)
	assert.NotEmpty(t, result.PubsubToken)
}

func TestContactInboxService_Create_重复记录(t *testing.T) {
	db, _, svc := setupContactInboxService(t)
	account := createTestAccount(t, db)
	contact := createTestContact(t, db, account.ID)
	inbox := createTestInbox(t, db, account.ID, "web_widget")

	req := CreateContactInboxRequest{
		ContactID: contact.ID,
		InboxID:   inbox.ID,
		SourceID:  "dup_source",
	}
	// 第一次创建成功
	result, err := svc.Create(context.Background(), req)
	require.NoError(t, err)
	assert.NotZero(t, result.ID)

	// 第二次创建相同记录应失败
	result2, err2 := svc.Create(context.Background(), req)
	assert.Nil(t, result2)
	assert.Error(t, err2)
	assert.Contains(t, err2.Error(), "already exists")
}

func TestContactInboxService_Create_验证失败(t *testing.T) {
	_, _, svc := setupContactInboxService(t)

	// 缺少必填字段
	req := CreateContactInboxRequest{
		ContactID: 0,
		InboxID:   0,
		SourceID:  "",
	}
	result, err := svc.Create(context.Background(), req)
	assert.Nil(t, result)
	assert.Error(t, err)
}

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

func TestContactInboxService_Delete_成功(t *testing.T) {
	db, _, svc := setupContactInboxService(t)
	account := createTestAccount(t, db)
	contact := createTestContact(t, db, account.ID)
	inbox := createTestInbox(t, db, account.ID, "web_widget")

	ci := &model.ContactInbox{ContactID: contact.ID, InboxID: inbox.ID, SourceID: "del_src", HMACToken: "h", PubsubToken: "p"}
	require.NoError(t, db.Create(ci).Error)

	err := svc.Delete(context.Background(), ci.ID)
	require.NoError(t, err)

	// 确认已删除
	result, err2 := svc.GetByID(context.Background(), ci.ID)
	assert.Nil(t, result)
	assert.Error(t, err2)
}

func TestContactInboxService_Delete_不存在ID(t *testing.T) {
	_, _, svc := setupContactInboxService(t)

	// 删除不存在的ID不会报错 (GORM Delete对不存在记录返回nil)
	err := svc.Delete(context.Background(), 99999)
	assert.NoError(t, err)
}

// ========== DeleteByContactAndInbox ==========

func TestContactInboxService_DeleteByContactAndInbox_成功(t *testing.T) {
	db, _, svc := setupContactInboxService(t)
	account := createTestAccount(t, db)
	contact := createTestContact(t, db, account.ID)
	inbox := createTestInbox(t, db, account.ID, "web_widget")

	ci := &model.ContactInbox{ContactID: contact.ID, InboxID: inbox.ID, SourceID: "del_src", HMACToken: "h", PubsubToken: "p"}
	require.NoError(t, db.Create(ci).Error)

	err := svc.DeleteByContactAndInbox(context.Background(), contact.ID, inbox.ID)
	require.NoError(t, err)

	// 确认已删除
	result, err2 := svc.GetByContactAndInbox(context.Background(), contact.ID, inbox.ID)
	assert.Nil(t, result)
	assert.Error(t, err2)
}

func TestContactInboxService_DeleteByContactAndInbox_不存在(t *testing.T) {
	_, _, svc := setupContactInboxService(t)

	// 删除不存在的组合不会报错
	err := svc.DeleteByContactAndInbox(context.Background(), 99999, 99999)
	assert.NoError(t, err)
}