gochat/backend/internal/repository/contact_note_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 TestContactNoteRepo_Create(t *testing.T) {
	db := setupTestDB(t, &model.ContactNote{})
	repo := NewContactNoteRepo(db)

	account := &model.Account{Name: "CNCreateOrg", Locale: "en", Active: true}
	require.NoError(t, db.Create(account).Error)
	contact := createTestContact(t, db, account.ID, "CN Contact", "cn@test.com")
	user := &model.User{Name: "CNUser", Email: "cnuser@test.com", AccountID: account.ID}
	require.NoError(t, db.Create(user).Error)

	note := &model.ContactNote{
		ContactID: contact.ID,
		UserID:    user.ID,
		Content:   "test note",
	}
	err := repo.Create(context.Background(), note)
	assert.NoError(t, err)
	assert.NotZero(t, note.ID)
}

func TestContactNoteRepo_FindByContact(t *testing.T) {
	db := setupTestDB(t, &model.ContactNote{})
	repo := NewContactNoteRepo(db)

	account := &model.Account{Name: "CNFindOrg", Locale: "en", Active: true}
	require.NoError(t, db.Create(account).Error)
	contact := createTestContact(t, db, account.ID, "CNFind", "cnfind@test.com")
	user := &model.User{Name: "CNFindUser", Email: "cnfinduser@test.com", AccountID: account.ID}
	require.NoError(t, db.Create(user).Error)

	for i := 0; i < 3; i++ {
		require.NoError(t, repo.Create(context.Background(), &model.ContactNote{
			ContactID: contact.ID, UserID: user.ID, Content: "note",
		}))
	}

	notes, err := repo.FindByContact(context.Background(), contact.ID)
	assert.NoError(t, err)
	assert.Len(t, notes, 3)
}

func TestContactNoteRepo_FindByID(t *testing.T) {
	db := setupTestDB(t, &model.ContactNote{})
	repo := NewContactNoteRepo(db)

	account := &model.Account{Name: "CNByIDOrg", Locale: "en", Active: true}
	require.NoError(t, db.Create(account).Error)
	contact := createTestContact(t, db, account.ID, "CNByID", "cnbyid@test.com")
	user := &model.User{Name: "CNByIDUser", Email: "cnbyiduser@test.com", AccountID: account.ID}
	require.NoError(t, db.Create(user).Error)

	note := &model.ContactNote{ContactID: contact.ID, UserID: user.ID, Content: "find me"}
	require.NoError(t, repo.Create(context.Background(), note))

	found, err := repo.FindByID(context.Background(), note.ID)
	assert.NoError(t, err)
	assert.Equal(t, note.ID, found.ID)
	assert.Equal(t, "find me", found.Content)
}

func TestContactNoteRepo_FindByID_NotFound(t *testing.T) {
	db := setupTestDB(t, &model.ContactNote{})
	repo := NewContactNoteRepo(db)

	_, err := repo.FindByID(context.Background(), 9999)
	assert.Error(t, err)
	assert.ErrorIs(t, err, gorm.ErrRecordNotFound)
}

func TestContactNoteRepo_Update(t *testing.T) {
	db := setupTestDB(t, &model.ContactNote{})
	repo := NewContactNoteRepo(db)

	account := &model.Account{Name: "CNUpdOrg", Locale: "en", Active: true}
	require.NoError(t, db.Create(account).Error)
	contact := createTestContact(t, db, account.ID, "CNUpd", "cnupd@test.com")
	user := &model.User{Name: "CNUpdUser", Email: "cnupduser@test.com", AccountID: account.ID}
	require.NoError(t, db.Create(user).Error)

	note := &model.ContactNote{ContactID: contact.ID, UserID: user.ID, Content: "original"}
	require.NoError(t, repo.Create(context.Background(), note))

	note.Content = "updated"
	err := repo.Update(context.Background(), note)
	assert.NoError(t, err)

	found, _ := repo.FindByID(context.Background(), note.ID)
	assert.Equal(t, "updated", found.Content)
}

func TestContactNoteRepo_Delete(t *testing.T) {
	db := setupTestDB(t, &model.ContactNote{})
	repo := NewContactNoteRepo(db)

	account := &model.Account{Name: "CNDelOrg", Locale: "en", Active: true}
	require.NoError(t, db.Create(account).Error)
	contact := createTestContact(t, db, account.ID, "CNDel", "cndel@test.com")
	user := &model.User{Name: "CNDelUser", Email: "cndeluser@test.com", AccountID: account.ID}
	require.NoError(t, db.Create(user).Error)

	note := &model.ContactNote{ContactID: contact.ID, UserID: user.ID, Content: "delete me"}
	require.NoError(t, repo.Create(context.Background(), note))

	err := repo.Delete(context.Background(), note.ID)
	assert.NoError(t, err)

	_, err = repo.FindByID(context.Background(), note.ID)
	assert.Error(t, err)
}

func TestContactNoteRepo_ReparentNotes(t *testing.T) {
	db := setupTestDB(t, &model.ContactNote{})
	repo := NewContactNoteRepo(db)

	account := &model.Account{Name: "CNRepOrg", Locale: "en", Active: true}
	require.NoError(t, db.Create(account).Error)
	contact1 := createTestContact(t, db, account.ID, "CNRep1", "cnrep1@test.com")
	contact2 := createTestContact(t, db, account.ID, "CNRep2", "cnrep2@test.com")
	user := &model.User{Name: "CNRepUser", Email: "cnrepuser@test.com", AccountID: account.ID}
	require.NoError(t, db.Create(user).Error)

	for i := 0; i < 3; i++ {
		require.NoError(t, repo.Create(context.Background(), &model.ContactNote{
			ContactID: contact1.ID, UserID: user.ID, Content: "reparent",
		}))
	}

	err := repo.ReparentNotes(context.Background(), contact1.ID, contact2.ID)
	assert.NoError(t, err)

	notes, err := repo.FindByContact(context.Background(), contact2.ID)
	assert.NoError(t, err)
	assert.Len(t, notes, 3)

	oldNotes, err := repo.FindByContact(context.Background(), contact1.ID)
	assert.NoError(t, err)
	assert.Len(t, oldNotes, 0)
}