tercul-backend/internal/app/monetization/queries_test.go

package monetization

import (
	"context"
	"errors"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/suite"
	"tercul/internal/domain"
	"testing"
)

type MonetizationQueriesSuite struct {
	suite.Suite
	repo          *mockMonetizationRepository
	workRepo      *mockWorkRepository
	authorRepo    *mockAuthorRepository
	bookRepo      *mockBookRepository
	publisherRepo *mockPublisherRepository
	sourceRepo    *mockSourceRepository
	queries       *MonetizationQueries
}

func (s *MonetizationQueriesSuite) SetupTest() {
	s.repo = &mockMonetizationRepository{}
	s.workRepo = &mockWorkRepository{}
	s.authorRepo = &mockAuthorRepository{}
	s.bookRepo = &mockBookRepository{}
	s.publisherRepo = &mockPublisherRepository{}
	s.sourceRepo = &mockSourceRepository{}
	s.queries = NewMonetizationQueries(s.repo, s.workRepo, s.authorRepo, s.bookRepo, s.publisherRepo, s.sourceRepo)
}

func TestMonetizationQueriesSuite(t *testing.T) {
	suite.Run(t, new(MonetizationQueriesSuite))
}

func (s *MonetizationQueriesSuite) TestGetMonetizationByID_Success() {
	monetization := &domain.Monetization{Amount: 10.0}
	monetization.ID = 1
	s.repo.getByIDFunc = func(ctx context.Context, id uint) (*domain.Monetization, error) {
		return monetization, nil
	}
	m, err := s.queries.GetMonetizationByID(context.Background(), 1)
	assert.NoError(s.T(), err)
	assert.Equal(s.T(), monetization, m)
}

func (s *MonetizationQueriesSuite) TestGetMonetizationByID_ZeroID() {
	m, err := s.queries.GetMonetizationByID(context.Background(), 0)
	assert.Error(s.T(), err)
	assert.Nil(s.T(), m)
}

func (s *MonetizationQueriesSuite) TestListMonetizations_Success() {
	monetizations := []domain.Monetization{{Amount: 10.0}}
	s.repo.listAllFunc = func(ctx context.Context) ([]domain.Monetization, error) {
		return monetizations, nil
	}
	m, err := s.queries.ListMonetizations(context.Background())
	assert.NoError(s.T(), err)
	assert.Equal(s.T(), monetizations, m)
}

func (s *MonetizationQueriesSuite) TestGetMonetizationsForWork_Success() {
	monetizations := []*domain.Monetization{{Amount: 10.0}}
	s.workRepo.getByIDWithOptionsFunc = func(ctx context.Context, id uint, options *domain.QueryOptions) (*domain.Work, error) {
		return &domain.Work{Monetizations: monetizations}, nil
	}
	m, err := s.queries.GetMonetizationsForWork(context.Background(), 1)
	assert.NoError(s.T(), err)
	assert.Equal(s.T(), monetizations, m)
}

func (s *MonetizationQueriesSuite) TestGetMonetizationsForWork_RepoError() {
	s.workRepo.getByIDWithOptionsFunc = func(ctx context.Context, id uint, options *domain.QueryOptions) (*domain.Work, error) {
		return nil, errors.New("db error")
	}
	m, err := s.queries.GetMonetizationsForWork(context.Background(), 1)
	assert.Error(s.T(), err)
	assert.Nil(s.T(), m)
}

func (s *MonetizationQueriesSuite) TestGetMonetizationsForAuthor_Success() {
	monetizations := []*domain.Monetization{{Amount: 10.0}}
	s.authorRepo.getByIDWithOptionsFunc = func(ctx context.Context, id uint, options *domain.QueryOptions) (*domain.Author, error) {
		return &domain.Author{Monetizations: monetizations}, nil
	}
	m, err := s.queries.GetMonetizationsForAuthor(context.Background(), 1)
	assert.NoError(s.T(), err)
	assert.Equal(s.T(), monetizations, m)
}

func (s *MonetizationQueriesSuite) TestGetMonetizationsForAuthor_RepoError() {
	s.authorRepo.getByIDWithOptionsFunc = func(ctx context.Context, id uint, options *domain.QueryOptions) (*domain.Author, error) {
		return nil, errors.New("db error")
	}
	m, err := s.queries.GetMonetizationsForAuthor(context.Background(), 1)
	assert.Error(s.T(), err)
	assert.Nil(s.T(), m)
}

func (s *MonetizationQueriesSuite) TestGetMonetizationsForBook_Success() {
	monetizations := []*domain.Monetization{{Amount: 10.0}}
	s.bookRepo.getByIDWithOptionsFunc = func(ctx context.Context, id uint, options *domain.QueryOptions) (*domain.Book, error) {
		return &domain.Book{Monetizations: monetizations}, nil
	}
	m, err := s.queries.GetMonetizationsForBook(context.Background(), 1)
	assert.NoError(s.T(), err)
	assert.Equal(s.T(), monetizations, m)
}

func (s *MonetizationQueriesSuite) TestGetMonetizationsForBook_RepoError() {
	s.bookRepo.getByIDWithOptionsFunc = func(ctx context.Context, id uint, options *domain.QueryOptions) (*domain.Book, error) {
		return nil, errors.New("db error")
	}
	m, err := s.queries.GetMonetizationsForBook(context.Background(), 1)
	assert.Error(s.T(), err)
	assert.Nil(s.T(), m)
}

func (s *MonetizationQueriesSuite) TestGetMonetizationsForPublisher_Success() {
	monetizations := []*domain.Monetization{{Amount: 10.0}}
	s.publisherRepo.getByIDWithOptionsFunc = func(ctx context.Context, id uint, options *domain.QueryOptions) (*domain.Publisher, error) {
		return &domain.Publisher{Monetizations: monetizations}, nil
	}
	m, err := s.queries.GetMonetizationsForPublisher(context.Background(), 1)
	assert.NoError(s.T(), err)
	assert.Equal(s.T(), monetizations, m)
}

func (s *MonetizationQueriesSuite) TestGetMonetizationsForPublisher_RepoError() {
	s.publisherRepo.getByIDWithOptionsFunc = func(ctx context.Context, id uint, options *domain.QueryOptions) (*domain.Publisher, error) {
		return nil, errors.New("db error")
	}
	m, err := s.queries.GetMonetizationsForPublisher(context.Background(), 1)
	assert.Error(s.T(), err)
	assert.Nil(s.T(), m)
}

func (s *MonetizationQueriesSuite) TestGetMonetizationsForSource_Success() {
	monetizations := []*domain.Monetization{{Amount: 10.0}}
	s.sourceRepo.getByIDWithOptionsFunc = func(ctx context.Context, id uint, options *domain.QueryOptions) (*domain.Source, error) {
		return &domain.Source{Monetizations: monetizations}, nil
	}
	m, err := s.queries.GetMonetizationsForSource(context.Background(), 1)
	assert.NoError(s.T(), err)
	assert.Equal(s.T(), monetizations, m)
}

func (s *MonetizationQueriesSuite) TestGetMonetizationsForSource_RepoError() {
	s.sourceRepo.getByIDWithOptionsFunc = func(ctx context.Context, id uint, options *domain.QueryOptions) (*domain.Source, error) {
		return nil, errors.New("db error")
	}
	m, err := s.queries.GetMonetizationsForSource(context.Background(), 1)
	assert.Error(s.T(), err)
	assert.Nil(s.T(), m)
}