gridpilot.gg/apps/website/lib/mutations/auth/SignupMutation.test.ts

import { describe, it, expect, vi, beforeEach } from 'vitest';
import { SignupMutation } from './SignupMutation';
import { AuthService } from '@/lib/services/auth/AuthService';
import { Result } from '@/lib/contracts/Result';
import { SessionViewModel } from '@/lib/view-models/SessionViewModel';

// Mock dependencies
vi.mock('@/lib/services/auth/AuthService', () => {
  return {
    AuthService: vi.fn(),
  };
});

describe('SignupMutation', () => {
  let mutation: SignupMutation;
  let mockServiceInstance: { signup: ReturnType<typeof vi.fn> };

  beforeEach(() => {
    vi.clearAllMocks();
    mutation = new SignupMutation();
    mockServiceInstance = {
      signup: vi.fn(),
    };
    // Use mockImplementation to return the instance
    (AuthService as any).mockImplementation(function() {
      return mockServiceInstance;
    });
  });

  describe('execute', () => {
    describe('happy paths', () => {
      it('should successfully signup with valid credentials', async () => {
        // Arrange
        const input = {
          email: 'newuser@example.com',
          password: 'SecurePassword123!',
          displayName: 'New User',
        };
        const mockUser = {
          userId: 'user-789',
          email: 'newuser@example.com',
          displayName: 'New User',
          role: 'user',
        };
        const sessionViewModel = new SessionViewModel(mockUser);
        mockServiceInstance.signup.mockResolvedValue(Result.ok(sessionViewModel));

        // Act
        const result = await mutation.execute(input);

        // Assert
        expect(result.isOk()).toBe(true);
        expect(result.unwrap()).toBeInstanceOf(SessionViewModel);
        expect(result.unwrap().userId).toBe('user-789');
        expect(result.unwrap().email).toBe('newuser@example.com');
        expect(mockServiceInstance.signup).toHaveBeenCalledWith(input);
        expect(mockServiceInstance.signup).toHaveBeenCalledTimes(1);
      });

      it('should handle signup with optional username', async () => {
        // Arrange
        const input = {
          email: 'newuser@example.com',
          password: 'SecurePassword123!',
          displayName: 'New User',
          username: 'newuser',
        };
        const mockUser = {
          userId: 'user-789',
          email: 'newuser@example.com',
          displayName: 'New User',
          role: 'user',
        };
        const sessionViewModel = new SessionViewModel(mockUser);
        mockServiceInstance.signup.mockResolvedValue(Result.ok(sessionViewModel));

        // Act
        const result = await mutation.execute(input);

        // Assert
        expect(result.isOk()).toBe(true);
        expect(mockServiceInstance.signup).toHaveBeenCalledWith(input);
      });

      it('should handle signup with iRacing customer ID', async () => {
        // Arrange
        const input = {
          email: 'newuser@example.com',
          password: 'SecurePassword123!',
          displayName: 'New User',
          iracingCustomerId: '123456',
        };
        const mockUser = {
          userId: 'user-789',
          email: 'newuser@example.com',
          displayName: 'New User',
          role: 'user',
        };
        const sessionViewModel = new SessionViewModel(mockUser);
        mockServiceInstance.signup.mockResolvedValue(Result.ok(sessionViewModel));

        // Act
        const result = await mutation.execute(input);

        // Assert
        expect(result.isOk()).toBe(true);
        expect(mockServiceInstance.signup).toHaveBeenCalledWith(input);
      });

      it('should handle signup with all optional fields', async () => {
        // Arrange
        const input = {
          email: 'newuser@example.com',
          password: 'SecurePassword123!',
          displayName: 'New User',
          username: 'newuser',
          iracingCustomerId: '123456',
          primaryDriverId: 'driver-789',
          avatarUrl: 'https://example.com/avatar.jpg',
        };
        const mockUser = {
          userId: 'user-789',
          email: 'newuser@example.com',
          displayName: 'New User',
          role: 'user',
          primaryDriverId: 'driver-789',
          avatarUrl: 'https://example.com/avatar.jpg',
        };
        const sessionViewModel = new SessionViewModel(mockUser);
        mockServiceInstance.signup.mockResolvedValue(Result.ok(sessionViewModel));

        // Act
        const result = await mutation.execute(input);

        // Assert
        expect(result.isOk()).toBe(true);
        const session = result.unwrap();
        expect(session.driverId).toBe('driver-789');
        expect(session.avatarUrl).toBe('https://example.com/avatar.jpg');
        expect(mockServiceInstance.signup).toHaveBeenCalledWith(input);
      });
    });

    describe('failure modes', () => {
      it('should handle service failure during signup', async () => {
        // Arrange
        const input = {
          email: 'existing@example.com',
          password: 'Password123!',
          displayName: 'Existing User',
        };
        const serviceError = new Error('Email already exists');
        mockServiceInstance.signup.mockRejectedValue(serviceError);

        // Act
        const result = await mutation.execute(input);

        // Assert
        expect(result.isErr()).toBe(true);
        expect(result.getError()).toBe('Email already exists');
        expect(mockServiceInstance.signup).toHaveBeenCalledTimes(1);
      });

      it('should handle service returning validation error', async () => {
        // Arrange
        const input = {
          email: 'invalid-email',
          password: 'Password123!',
          displayName: 'User',
        };
        const domainError = { type: 'validationError', message: 'Invalid email format' };
        mockServiceInstance.signup.mockResolvedValue(Result.err(domainError));

        // Act
        const result = await mutation.execute(input);

        // Assert
        expect(result.isErr()).toBe(true);
        expect(result.getError()).toBe('Invalid email format');
        expect(mockServiceInstance.signup).toHaveBeenCalledTimes(1);
      });

      it('should handle service returning duplicate email error', async () => {
        // Arrange
        const input = {
          email: 'existing@example.com',
          password: 'Password123!',
          displayName: 'Existing User',
        };
        const domainError = { type: 'validationError', message: 'Email already registered' };
        mockServiceInstance.signup.mockResolvedValue(Result.err(domainError));

        // Act
        const result = await mutation.execute(input);

        // Assert
        expect(result.isErr()).toBe(true);
        expect(result.getError()).toBe('Email already registered');
        expect(mockServiceInstance.signup).toHaveBeenCalledTimes(1);
      });

      it('should handle service returning weak password error', async () => {
        // Arrange
        const input = {
          email: 'newuser@example.com',
          password: 'weak',
          displayName: 'User',
        };
        const domainError = { type: 'validationError', message: 'Password too weak' };
        mockServiceInstance.signup.mockResolvedValue(Result.err(domainError));

        // Act
        const result = await mutation.execute(input);

        // Assert
        expect(result.isErr()).toBe(true);
        expect(result.getError()).toBe('Password too weak');
        expect(mockServiceInstance.signup).toHaveBeenCalledTimes(1);
      });

      it('should handle service returning server error', async () => {
        // Arrange
        const input = {
          email: 'newuser@example.com',
          password: 'Password123!',
          displayName: 'User',
        };
        const domainError = { type: 'serverError', message: 'Database connection failed' };
        mockServiceInstance.signup.mockResolvedValue(Result.err(domainError));

        // Act
        const result = await mutation.execute(input);

        // Assert
        expect(result.isErr()).toBe(true);
        expect(result.getError()).toBe('Database connection failed');
        expect(mockServiceInstance.signup).toHaveBeenCalledTimes(1);
      });
    });

    describe('error mapping', () => {
      it('should map various domain errors to mutation errors', async () => {
        // Arrange
        const input = {
          email: 'newuser@example.com',
          password: 'Password123!',
          displayName: 'User',
        };
        const testCases = [
          { domainError: { type: 'validationError', message: 'Invalid data' }, expectedError: 'Invalid data' },
          { domainError: { type: 'serverError', message: 'Server error' }, expectedError: 'Server error' },
          { domainError: { type: 'notFound', message: 'Resource not found' }, expectedError: 'Resource not found' },
          { domainError: { type: 'unauthorized', message: 'Unauthorized' }, expectedError: 'Unauthorized' },
        ];

        for (const testCase of testCases) {
          mockServiceInstance.signup.mockResolvedValue(Result.err(testCase.domainError));

          const result = await mutation.execute(input);

          expect(result.isErr()).toBe(true);
          expect(result.getError()).toBe(testCase.expectedError);
        }
      });
    });

    describe('input validation', () => {
      it('should accept valid email, password, and displayName input', async () => {
        // Arrange
        const input = {
          email: 'newuser@example.com',
          password: 'Password123!',
          displayName: 'New User',
        };
        const mockUser = {
          userId: 'user-789',
          email: 'newuser@example.com',
          displayName: 'New User',
          role: 'user',
        };
        const sessionViewModel = new SessionViewModel(mockUser);
        mockServiceInstance.signup.mockResolvedValue(Result.ok(sessionViewModel));

        // Act
        const result = await mutation.execute(input);

        // Assert
        expect(result.isOk()).toBe(true);
        expect(mockServiceInstance.signup).toHaveBeenCalledTimes(1);
      });

      it('should handle empty email gracefully', async () => {
        // Arrange
        const input = {
          email: '',
          password: 'Password123!',
          displayName: 'User',
        };
        const mockUser = {
          userId: 'user-789',
          email: '',
          displayName: 'User',
          role: 'user',
        };
        const sessionViewModel = new SessionViewModel(mockUser);
        mockServiceInstance.signup.mockResolvedValue(Result.ok(sessionViewModel));

        // Act
        const result = await mutation.execute(input);

        // Assert
        expect(result.isOk()).toBe(true);
        expect(mockServiceInstance.signup).toHaveBeenCalledWith(input);
      });

      it('should handle empty password gracefully', async () => {
        // Arrange
        const input = {
          email: 'newuser@example.com',
          password: '',
          displayName: 'User',
        };
        const mockUser = {
          userId: 'user-789',
          email: 'newuser@example.com',
          displayName: 'User',
          role: 'user',
        };
        const sessionViewModel = new SessionViewModel(mockUser);
        mockServiceInstance.signup.mockResolvedValue(Result.ok(sessionViewModel));

        // Act
        const result = await mutation.execute(input);

        // Assert
        expect(result.isOk()).toBe(true);
        expect(mockServiceInstance.signup).toHaveBeenCalledWith(input);
      });

      it('should handle empty displayName gracefully', async () => {
        // Arrange
        const input = {
          email: 'newuser@example.com',
          password: 'Password123!',
          displayName: '',
        };
        const mockUser = {
          userId: 'user-789',
          email: 'newuser@example.com',
          displayName: '',
          role: 'user',
        };
        const sessionViewModel = new SessionViewModel(mockUser);
        mockServiceInstance.signup.mockResolvedValue(Result.ok(sessionViewModel));

        // Act
        const result = await mutation.execute(input);

        // Assert
        expect(result.isOk()).toBe(true);
        expect(mockServiceInstance.signup).toHaveBeenCalledWith(input);
      });
    });

    describe('service instantiation', () => {
      it('should create AuthService instance', () => {
        // Arrange & Act
        const mutation = new SignupMutation();

        // Assert
        expect(mutation).toBeInstanceOf(SignupMutation);
      });
    });

    describe('result shape', () => {
      it('should return SessionViewModel with correct properties on success', async () => {
        // Arrange
        const input = {
          email: 'newuser@example.com',
          password: 'Password123!',
          displayName: 'New User',
        };
        const mockUser = {
          userId: 'user-789',
          email: 'newuser@example.com',
          displayName: 'New User',
          role: 'user',
          primaryDriverId: 'driver-456',
          avatarUrl: 'https://example.com/avatar.jpg',
        };
        const sessionViewModel = new SessionViewModel(mockUser);
        mockServiceInstance.signup.mockResolvedValue(Result.ok(sessionViewModel));

        // Act
        const result = await mutation.execute(input);

        // Assert
        expect(result.isOk()).toBe(true);
        const session = result.unwrap();
        expect(session).toBeInstanceOf(SessionViewModel);
        expect(session.userId).toBe('user-789');
        expect(session.email).toBe('newuser@example.com');
        expect(session.displayName).toBe('New User');
        expect(session.role).toBe('user');
        expect(session.driverId).toBe('driver-456');
        expect(session.avatarUrl).toBe('https://example.com/avatar.jpg');
        expect(session.isAuthenticated).toBe(true);
      });
    });
  });
});