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

package graphql_test

import (
	"context"
	"fmt"
	"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 TranslationResolversTestSuite struct {
	testutil.IntegrationTestSuite
	queryResolver    graphql.QueryResolver
	mutationResolver graphql.MutationResolver
}

func TestTranslationResolvers(t *testing.T) {
	suite.Run(t, new(TranslationResolversTestSuite))
}

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

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

func (s *TranslationResolversTestSuite) 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 *TranslationResolversTestSuite) 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 *TranslationResolversTestSuite) contextWithClaims(user *domain.User) context.Context {
	return testutil.ContextWithClaims(context.Background(), &platform_auth.Claims{
		UserID: user.ID,
		Role:   string(user.Role),
	})
}

func (s *TranslationResolversTestSuite) TestCreateTranslation() {
	user := s.createUser("translator", "translator@test.com", "password", domain.UserRoleContributor)
	ctx := s.contextWithClaims(user)
	work := s.CreateTestWork(ctx, "Test Work for Translation", "en", "Original Content")

	s.Run("Success", func() {
		// Arrange
		content := "Translated Content"
		input := model.TranslationInput{
			Name:     "Spanish Translation",
			Language: "es",
			WorkID:   fmt.Sprintf("%d", work.ID),
			Content:  &content,
		}

		// Act
		translation, err := s.mutationResolver.CreateTranslation(ctx, input)

		// Assert
		s.Require().NoError(err)
		s.Require().NotNil(translation)
		s.Equal("Spanish Translation", translation.Name)
		s.Equal("es", translation.Language)
		s.Equal("Translated Content", *translation.Content)
	})
}

func (s *TranslationResolversTestSuite) TestUpdateTranslation() {
	user := s.createUser("translator-updater", "translator-updater@test.com", "password", domain.UserRoleContributor)
	ctx := s.contextWithClaims(user)
	work := s.CreateTestWork(ctx, "Test Work for Translation Update", "en", "Original Content")

	content := "Initial Translated Content"
	createInput := model.TranslationInput{
		Name:     "Updatable Translation",
		Language: "fr",
		WorkID:   fmt.Sprintf("%d", work.ID),
		Content:  &content,
	}
	createdTranslation, err := s.mutationResolver.CreateTranslation(ctx, createInput)
	s.Require().NoError(err)

	s.Run("Success", func() {
		// Arrange
		updatedContent := "Updated French Content"
		updateInput := model.TranslationInput{
			Name:     "Updated French Translation",
			Language: "fr",
			WorkID:   fmt.Sprintf("%d", work.ID),
			Content:  &updatedContent,
		}

		// Act
		updatedTranslation, err := s.mutationResolver.UpdateTranslation(ctx, createdTranslation.ID, updateInput)

		// Assert
		s.Require().NoError(err)
		s.Require().NotNil(updatedTranslation)
		s.Equal("Updated French Translation", updatedTranslation.Name)
		s.Equal("fr", updatedTranslation.Language)
		s.Equal("Updated French Content", *updatedTranslation.Content)
	})
}

func (s *TranslationResolversTestSuite) TestDeleteTranslation() {
	user := s.createUser("translator-deletor", "translator-deletor@test.com", "password", domain.UserRoleContributor)
	ctx := s.contextWithClaims(user)
	work := s.CreateTestWork(ctx, "Test Work for Translation Deletion", "en", "Original Content")

	content := "Content to be deleted"
	createInput := model.TranslationInput{
		Name:     "Deletable Translation",
		Language: "de",
		WorkID:   fmt.Sprintf("%d", work.ID),
		Content:  &content,
	}
	createdTranslation, err := s.mutationResolver.CreateTranslation(ctx, createInput)
	s.Require().NoError(err)

	s.Run("Success", func() {
		// Act
		ok, err := s.mutationResolver.DeleteTranslation(ctx, createdTranslation.ID)

		// Assert
		s.Require().NoError(err)
		s.True(ok)
	})
}

func (s *TranslationResolversTestSuite) TestTranslationQueries() {
	user := s.createUser("translator-reader", "translator-reader@test.com", "password", domain.UserRoleContributor)
	ctx := s.contextWithClaims(user)
	work := s.CreateTestWork(ctx, "Test Work for Translation Queries", "en", "Original Content")

	content := "Queried Content"
	createInput := model.TranslationInput{
		Name:     "Queried Translation",
		Language: "it",
		WorkID:   fmt.Sprintf("%d", work.ID),
		Content:  &content,
	}
	createdTranslation, err := s.mutationResolver.CreateTranslation(ctx, createInput)
	s.Require().NoError(err)

	s.Run("Get Translation by ID", func() {
		// Act
		translation, err := s.queryResolver.Translation(ctx, createdTranslation.ID)

		// Assert
		s.Require().NoError(err)
		s.Require().NotNil(translation)
		s.Equal("Queried Translation", translation.Name)
	})

	s.Run("List Translations for a Work", func() {
		// Act
		translations, err := s.queryResolver.Translations(ctx, fmt.Sprintf("%d", work.ID), nil, nil, nil)

		// Assert
		s.Require().NoError(err)
		s.Require().NotNil(translations)
		s.Len(translations, 2) // Original + Italian
	})
}