tercul-backend/internal/adapters/graphql/author_resolvers_test.go

package graphql_test

import (
	"context"
	"os"
	"tercul/internal/adapters/graphql"
	"tercul/internal/adapters/graphql/model"
	"tercul/internal/app/auth"
	"tercul/internal/domain"
	platform_auth "tercul/internal/platform/auth"
	"tercul/internal/testutil"
	"testing"

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

type AuthorResolversTestSuite struct {
	testutil.IntegrationTestSuite
	queryResolver    graphql.QueryResolver
	mutationResolver graphql.MutationResolver
}

func TestAuthorResolvers(t *testing.T) {
	suite.Run(t, new(AuthorResolversTestSuite))
}

func (s *AuthorResolversTestSuite) SetupSuite() {
	s.IntegrationTestSuite.SetupSuite(&testutil.TestConfig{
		DBPath: "author_resolvers_test.db",
	})
}

func (s *AuthorResolversTestSuite) TearDownSuite() {
	s.IntegrationTestSuite.TearDownSuite()
	_ = os.Remove("author_resolvers_test.db")
}

func (s *AuthorResolversTestSuite) SetupTest() {
	s.IntegrationTestSuite.SetupTest()
	resolver := &graphql.Resolver{App: s.App}
	s.queryResolver = resolver.Query()
	s.mutationResolver = resolver.Mutation()
}

// Helper to create a user for tests
func (s *AuthorResolversTestSuite) createUser(username, email, password string, role domain.UserRole) *domain.User {
	resp, err := s.App.Auth.Commands.Register(context.Background(), auth.RegisterInput{
		Username: username,
		Email:    email,
		Password: password,
	})
	s.Require().NoError(err)

	user, err := s.App.User.Queries.User(context.Background(), resp.User.ID)
	s.Require().NoError(err)

	if role != user.Role {
		user.Role = role
		err = s.DB.Save(user).Error
		s.Require().NoError(err)
	}
	return user
}

// Helper to create a context with JWT claims
func (s *AuthorResolversTestSuite) contextWithClaims(user *domain.User) context.Context {
	return testutil.ContextWithClaims(context.Background(), &platform_auth.Claims{
		UserID: user.ID,
		Role:   string(user.Role),
	})
}

func (s *AuthorResolversTestSuite) TestAuthorMutations() {
	user := s.createUser("author-creator", "author-creator@test.com", "password", domain.UserRoleContributor)
	ctx := s.contextWithClaims(user)

	var authorID string

	s.Run("Create Author", func() {
		input := model.AuthorInput{
			Name: "J.R.R. Tolkien",
		}
		author, err := s.mutationResolver.CreateAuthor(ctx, input)
		s.Require().NoError(err)
		s.Require().NotNil(author)
		s.Equal("J.R.R. Tolkien", author.Name)
		authorID = author.ID
	})

	s.Run("Update Author", func() {
		input := model.AuthorInput{
			Name: "John Ronald Reuel Tolkien",
		}
		author, err := s.mutationResolver.UpdateAuthor(s.AdminCtx, authorID, input)
		s.Require().NoError(err)
		s.Require().NotNil(author)
		s.Equal("John Ronald Reuel Tolkien", author.Name)
	})

	s.Run("Delete Author", func() {
		ok, err := s.mutationResolver.DeleteAuthor(s.AdminCtx, authorID)
		s.Require().NoError(err)
		s.True(ok)
	})
}

func (s *AuthorResolversTestSuite) TestAuthorQueries() {
	user := s.createUser("author-reader", "author-reader@test.com", "password", domain.UserRoleReader)
	ctx := s.contextWithClaims(user)

	// Create an author to query
	input := model.AuthorInput{
		Name: "George Orwell",
	}
	createdAuthor, err := s.mutationResolver.CreateAuthor(ctx, input)
	s.Require().NoError(err)

	s.Run("Get Author by ID", func() {
		author, err := s.queryResolver.Author(ctx, createdAuthor.ID)
		s.Require().NoError(err)
		s.Require().NotNil(author)
		s.Equal("George Orwell", author.Name)
	})

	s.Run("List Authors", func() {
		authors, err := s.queryResolver.Authors(ctx, nil, nil, nil, nil)
		s.Require().NoError(err)
		s.Require().NotNil(authors)
		s.True(len(authors) >= 1)
	})
}