gridpilot.gg/apps/website/lib/page-queries/auth/ResetPasswordPageQuery.test.ts

import { describe, it, expect, vi, beforeEach } from 'vitest';
import { ResetPasswordPageQuery } from './ResetPasswordPageQuery';
import { AuthPageService } from '@/lib/services/auth/AuthPageService';
import { Result } from '@/lib/contracts/Result';
import { ResetPasswordViewDataBuilder } from '@/lib/builders/view-data/ResetPasswordViewDataBuilder';
import { SearchParamParser } from '@/lib/routing/search-params/SearchParamParser';

// Mock dependencies
const mockProcessForgotPasswordParams = vi.fn();
const mockProcessLoginParams = vi.fn();
const mockProcessResetPasswordParams = vi.fn();
const mockProcessSignupParams = vi.fn();
vi.mock('@/lib/services/auth/AuthPageService', () => {
  return {
    AuthPageService: class {
      processForgotPasswordParams = mockProcessForgotPasswordParams;
      processLoginParams = mockProcessLoginParams;
      processResetPasswordParams = mockProcessResetPasswordParams;
      processSignupParams = mockProcessSignupParams;
    },
  };
});

vi.mock('@/lib/routing/search-params/SearchParamParser', () => ({
  SearchParamParser: {
    parseAuth: vi.fn(),
  },
}));

vi.mock('@/lib/builders/view-data/ResetPasswordViewDataBuilder', () => ({
  ResetPasswordViewDataBuilder: {
    build: vi.fn(),
  },
}));

describe('ResetPasswordPageQuery', () => {
  let query: ResetPasswordPageQuery;
  let mockServiceInstance: any;
  let mockSearchParams: URLSearchParams;

  beforeEach(() => {
    vi.clearAllMocks();
    mockServiceInstance = {
      processResetPasswordParams: mockProcessResetPasswordParams,
    };
    query = new ResetPasswordPageQuery(mockServiceInstance as any);
    mockSearchParams = new URLSearchParams('returnTo=/login&token=reset123');
  });

  it('should return view data when search params are valid and service succeeds', async () => {
    const parsedParams = { returnTo: '/login', token: 'reset123' };
    const serviceOutput = { email: 'test@example.com' };
    const viewData = { email: 'test@example.com', returnTo: '/login' };

    (SearchParamParser.parseAuth as any).mockReturnValue(Result.ok(parsedParams));
    mockServiceInstance.processResetPasswordParams.mockResolvedValue(Result.ok(serviceOutput));
    (ResetPasswordViewDataBuilder.build as any).mockReturnValue(viewData);

    const result = await query.execute(mockSearchParams);

    expect(result.isOk()).toBe(true);
    expect(result.unwrap()).toEqual(viewData);
    expect(SearchParamParser.parseAuth).toHaveBeenCalledWith(mockSearchParams);
    expect(mockServiceInstance.processResetPasswordParams).toHaveBeenCalledWith(parsedParams);
    expect(ResetPasswordViewDataBuilder.build).toHaveBeenCalledWith(serviceOutput);
  });

  it('should return error when search params are invalid', async () => {
    (SearchParamParser.parseAuth as any).mockReturnValue(Result.err('Invalid params'));

    const result = await query.execute(mockSearchParams);

    expect(result.isErr()).toBe(true);
    expect(result.getError()).toBe('Invalid search parameters: Invalid params');
  });

  it('should return error when service fails', async () => {
    const parsedParams = { returnTo: '/login', token: 'reset123' };

    (SearchParamParser.parseAuth as any).mockReturnValue(Result.ok(parsedParams));
    mockServiceInstance.processResetPasswordParams.mockResolvedValue(
      Result.err({ message: 'Service error' })
    );

    const result = await query.execute(mockSearchParams);

    expect(result.isErr()).toBe(true);
    expect(result.getError()).toBe('Service error');
  });

  it('should return error on exception', async () => {
    const parsedParams = { returnTo: '/login', token: 'reset123' };

    (SearchParamParser.parseAuth as any).mockReturnValue(Result.ok(parsedParams));
    mockServiceInstance.processResetPasswordParams.mockRejectedValue(new Error('Unexpected error'));

    const result = await query.execute(mockSearchParams);

    expect(result.isErr()).toBe(true);
    expect(result.getError()).toBe('Unexpected error');
  });

  it('should provide a static execute method', async () => {
    const parsedParams = { returnTo: '/login', token: 'reset123' };
    const serviceOutput = { email: 'test@example.com' };
    const viewData = { email: 'test@example.com', returnTo: '/login' };

    (SearchParamParser.parseAuth as any).mockReturnValue(Result.ok(parsedParams));
    mockServiceInstance.processResetPasswordParams.mockResolvedValue(Result.ok(serviceOutput));
    (ResetPasswordViewDataBuilder.build as any).mockReturnValue(viewData);

    const result = await ResetPasswordPageQuery.execute(mockSearchParams);

    expect(result.isOk()).toBe(true);
    expect(result.unwrap()).toEqual(viewData);
  });

  it('should handle Record<string, string | string[] | undefined> input', async () => {
    const recordParams = { returnTo: '/login', token: 'reset123' };
    const parsedParams = { returnTo: '/login', token: 'reset123' };
    const serviceOutput = { email: 'test@example.com' };
    const viewData = { email: 'test@example.com', returnTo: '/login' };

    (SearchParamParser.parseAuth as any).mockReturnValue(Result.ok(parsedParams));
    mockServiceInstance.processResetPasswordParams.mockResolvedValue(Result.ok(serviceOutput));
    (ResetPasswordViewDataBuilder.build as any).mockReturnValue(viewData);

    const result = await query.execute(recordParams);

    expect(result.isOk()).toBe(true);
    expect(result.unwrap()).toEqual(viewData);
    expect(SearchParamParser.parseAuth).toHaveBeenCalledWith(recordParams);
  });
});