refactor use cases

core/identity/application/use-cases/HandleAuthCallbackUseCase.test.ts

@@ -1,12 +1,9 @@
 import { describe, it, expect, vi, type Mock } from 'vitest';
 import { HandleAuthCallbackUseCase } from './HandleAuthCallbackUseCase';
-import type {
-  AuthCallbackCommand,
-  AuthenticatedUser,
-  IdentityProviderPort,
-} from '../ports/IdentityProviderPort';
-import type { AuthSession, IdentitySessionPort } from '../ports/IdentitySessionPort';
-import type { Logger, UseCaseOutputPort } from '@core/shared/application';
+import type { IdentityProviderPort } from '../ports/IdentityProviderPort';
+import type { IdentitySessionPort } from '../ports/IdentitySessionPort';
+import type { Logger } from '@core/shared/application';
+import { Result } from '@core/shared/application/Result';
 
 describe('HandleAuthCallbackUseCase', () => {
   let provider: {
@@ -14,69 +11,97 @@ describe('HandleAuthCallbackUseCase', () => {
   };
   let sessionPort: {
     createSession: Mock;
-    getCurrentSession: Mock;
-    clearSession: Mock;
   };
-  let logger: Logger;
-  let output: UseCaseOutputPort<AuthSession> & { present: Mock };
+  let logger: Logger & { error: Mock };
   let useCase: HandleAuthCallbackUseCase;
 
   beforeEach(() => {
     provider = {
       completeAuth: vi.fn(),
     };
+
     sessionPort = {
       createSession: vi.fn(),
-      getCurrentSession: vi.fn(),
-      clearSession: vi.fn(),
     };
+
     logger = {
       debug: vi.fn(),
       info: vi.fn(),
       warn: vi.fn(),
       error: vi.fn(),
-    } as unknown as Logger;
-    output = {
-      present: vi.fn(),
-    };
+    } as unknown as Logger & { error: Mock };
 
     useCase = new HandleAuthCallbackUseCase(
       provider as unknown as IdentityProviderPort,
       sessionPort as unknown as IdentitySessionPort,
       logger,
-      output,
     );
   });
 
-  it('completes auth and creates a session', async () => {
-    const command: AuthCallbackCommand = {
-      provider: 'IRACING_DEMO',
-      code: 'auth-code',
-      state: 'state-123',
-      returnTo: 'https://app/callback',
-    };
-
-    const user: AuthenticatedUser = {
+  it('successfully handles auth callback and creates session', async () => {
+    const authenticatedUser = {
       id: 'user-1',
-      email: 'test@example.com',
       displayName: 'Test User',
+      email: 'test@example.com',
     };
-
-    const session: AuthSession = {
-      user,
+    const session = {
+      token: 'session-token',
+      user: authenticatedUser,
       issuedAt: Date.now(),
       expiresAt: Date.now() + 1000,
-      token: 'session-token',
     };
 
-    provider.completeAuth.mockResolvedValue(user);
+    provider.completeAuth.mockResolvedValue(authenticatedUser);
     sessionPort.createSession.mockResolvedValue(session);
 
-    const result = await useCase.execute(command);
+    const result = await useCase.execute({
+      code: 'auth-code',
+      state: 'state-123',
+      returnTo: '/dashboard',
+    });
 
-    expect(provider.completeAuth).toHaveBeenCalledWith(command);
-    expect(sessionPort.createSession).toHaveBeenCalledWith(user);
-    expect(output.present).toHaveBeenCalledWith(session);
     expect(result.isOk()).toBe(true);
+    const callbackResult = result.unwrap();
+    expect(callbackResult.token).toBe('session-token');
+    expect(callbackResult.user).toBe(authenticatedUser);
+    expect(provider.completeAuth).toHaveBeenCalledWith({
+      code: 'auth-code',
+      state: 'state-123',
+      returnTo: '/dashboard',
+    });
+    expect(sessionPort.createSession).toHaveBeenCalledWith(authenticatedUser);
   });
-});
+
+  it('returns error when provider call fails', async () => {
+    provider.completeAuth.mockRejectedValue(new Error('Auth failed'));
+
+    const result = await useCase.execute({
+      code: 'invalid-code',
+      state: 'state-123',
+    });
+
+    expect(result.isErr()).toBe(true);
+    expect(result.unwrapErr().code).toBe('REPOSITORY_ERROR');
+    expect(logger.error).toHaveBeenCalled();
+  });
+
+  it('returns error when session creation fails', async () => {
+    const authenticatedUser = {
+      id: 'user-1',
+      displayName: 'Test User',
+      email: 'test@example.com',
+    };
+
+    provider.completeAuth.mockResolvedValue(authenticatedUser);
+    sessionPort.createSession.mockRejectedValue(new Error('Session creation failed'));
+
+    const result = await useCase.execute({
+      code: 'auth-code',
+      state: 'state-123',
+    });
+
+    expect(result.isErr()).toBe(true);
+    expect(result.unwrapErr().code).toBe('REPOSITORY_ERROR');
+    expect(logger.error).toHaveBeenCalled();
+  });
+});