tercul-backend/internal/data/sql/work_repository_test.go

package sql_test

import (
	"context"
	"testing"
	"tercul/internal/data/sql"
	"tercul/internal/domain"
	"tercul/internal/platform/config"
	"tercul/internal/testutil"

	"github.com/stretchr/testify/suite"
)

type WorkRepositoryTestSuite struct {
	testutil.IntegrationTestSuite
	WorkRepo domain.WorkRepository
}

func (s *WorkRepositoryTestSuite) SetupSuite() {
	s.IntegrationTestSuite.SetupSuite(testutil.DefaultTestConfig())
	cfg, err := config.LoadConfig()
	s.Require().NoError(err)
	s.WorkRepo = sql.NewWorkRepository(s.DB, cfg)
}

func (s *WorkRepositoryTestSuite) SetupTest() {
	s.IntegrationTestSuite.SetupTest()
	s.DB.Exec("DELETE FROM work_copyrights")
	s.DB.Exec("DELETE FROM copyrights")
	s.DB.Exec("DELETE FROM works")
}

func (s *WorkRepositoryTestSuite) TestCreateWork() {
	s.Run("should create a new work with a copyright", func() {
		// Arrange
		copyright := &domain.Copyright{
			Name:          "Test Copyright",
			Identificator: "TC-123",
		}
		s.Require().NoError(s.DB.Create(copyright).Error)

		workModel := &domain.Work{
			Title: "New Test Work",
			TranslatableModel: domain.TranslatableModel{
				Language: "en",
			},
			Copyrights: []*domain.Copyright{copyright},
		}

		// Act
		err := s.WorkRepo.Create(context.Background(), workModel)

		// Assert
		s.Require().NoError(err)
		s.NotZero(workModel.ID)

		// Verify that the work was actually created in the database
		var foundWork domain.Work
		err = s.DB.Preload("Copyrights").First(&foundWork, workModel.ID).Error
		s.Require().NoError(err)
		s.Equal("New Test Work", foundWork.Title)
		s.Equal("en", foundWork.Language)
		s.Require().Len(foundWork.Copyrights, 1)
		s.Equal("Test Copyright", foundWork.Copyrights[0].Name)
	})
}

func (s *WorkRepositoryTestSuite) TestGetWorkByID() {
	s.Run("should return a work by ID with copyrights", func() {
		// Arrange
		copyright := &domain.Copyright{
			Name:          "Test Copyright",
			Identificator: "TC-123",
		}
		s.Require().NoError(s.DB.Create(copyright).Error)

		workModel := s.CreateTestWork(s.AdminCtx, "Test Work", "en", "Test content")
		s.Require().NoError(s.DB.Model(workModel).Association("Copyrights").Append(copyright))

		// Act
		foundWork, err := s.WorkRepo.GetByID(context.Background(), workModel.ID)

		// Assert
		s.Require().NoError(err)
		s.Require().NotNil(foundWork)
		s.Equal(workModel.ID, foundWork.ID)
		s.Equal("Test Work", foundWork.Title)
	})

	s.Run("should return error if work not found", func() {
		// Act
		foundWork, err := s.WorkRepo.GetByID(context.Background(), 999)

		// Assert
		s.Require().Error(err)
		s.Nil(foundWork)
	})
}

func (s *WorkRepositoryTestSuite) TestUpdateWork() {
	s.Run("should update an existing work and its copyrights", func() {
		// Arrange
		copyright1 := &domain.Copyright{Name: "C1", Identificator: "C1"}
		copyright2 := &domain.Copyright{Name: "C2", Identificator: "C2"}
		s.Require().NoError(s.DB.Create(&copyright1).Error)
		s.Require().NoError(s.DB.Create(&copyright2).Error)

		workModel := s.CreateTestWork(s.AdminCtx, "Original Title", "en", "Original content")
		s.Require().NoError(s.DB.Model(workModel).Association("Copyrights").Append(copyright1))

		workModel.Title = "Updated Title"
		s.Require().NoError(s.DB.Model(workModel).Association("Copyrights").Replace(copyright2))

		// Act
		err := s.WorkRepo.Update(context.Background(), workModel)

		// Assert
		s.Require().NoError(err)

		// Verify that the work was actually updated in the database
		var foundWork domain.Work
		err = s.DB.Preload("Copyrights").First(&foundWork, workModel.ID).Error
		s.Require().NoError(err)
		s.Equal("Updated Title", foundWork.Title)
		s.Require().Len(foundWork.Copyrights, 1)
		s.Equal("C2", foundWork.Copyrights[0].Name)
	})
}

func (s *WorkRepositoryTestSuite) TestDeleteWork() {
	s.Run("should delete an existing work and its associations", func() {
		// Arrange
		workModel := s.CreateTestWork(s.AdminCtx, "To Be Deleted", "en", "Content")
		copyright := &domain.Copyright{Name: "C1", Identificator: "C1"}
		s.Require().NoError(s.DB.Create(copyright).Error)
		s.Require().NoError(s.DB.Model(workModel).Association("Copyrights").Append(copyright))

		// Act
		err := s.WorkRepo.Delete(context.Background(), workModel.ID)

		// Assert
		s.Require().NoError(err)

		// Verify that the work was actually deleted from the database
		var foundWork domain.Work
		err = s.DB.First(&foundWork, workModel.ID).Error
		s.Require().Error(err)

		// Verify that the association in the join table is also deleted
		var count int64
		s.DB.Table("work_copyrights").Where("work_id = ?", workModel.ID).Count(&count)
		s.Zero(count)
	})
}

func TestWorkRepository(t *testing.T) {
	suite.Run(t, new(WorkRepositoryTestSuite))
}