fix issues in core

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

@@ -2,12 +2,15 @@ import { describe, it, expect, vi, type Mock } from 'vitest';
 import { GetUserUseCase } from './GetUserUseCase';
 import { User } from '../../domain/entities/User';
 import type { IUserRepository, StoredUser } from '../../domain/repositories/IUserRepository';
+import type { Logger, UseCaseOutputPort } from '@core/shared/application';
+import type { Result } from '@core/shared/application/Result';
 
 describe('GetUserUseCase', () => {
   let userRepository: {
     findById: Mock;
   };
-
+  let logger: Logger;
+  let output: UseCaseOutputPort<any> & { present: Mock };
   let useCase: GetUserUseCase;
 
   beforeEach(() => {
@@ -15,7 +18,22 @@ describe('GetUserUseCase', () => {
       findById: vi.fn(),
     };
 
-    useCase = new GetUserUseCase(userRepository as unknown as IUserRepository);
+    logger = {
+      debug: vi.fn(),
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    } as unknown as Logger;
+
+    output = {
+      present: vi.fn(),
+    };
+
+    useCase = new GetUserUseCase(
+      userRepository as unknown as IUserRepository,
+      logger,
+      output,
+    );
   });
 
   it('returns a User when the user exists', async () => {
@@ -31,18 +49,24 @@ describe('GetUserUseCase', () => {
 
     userRepository.findById.mockResolvedValue(storedUser);
 
-    const result = await useCase.execute('user-1');
+    const result = await useCase.execute({ userId: 'user-1' });
 
     expect(userRepository.findById).toHaveBeenCalledWith('user-1');
-    expect(result).toBeInstanceOf(User);
-    expect(result.getId().value).toBe('user-1');
-    expect(result.getDisplayName()).toBe('Test User');
+    expect(result.isOk()).toBe(true);
+    expect(output.present).toHaveBeenCalled();
+    const callArgs = output.present.mock.calls?.[0]?.[0] as Result<any, any>;
+    const user = callArgs.unwrap().user;
+    expect(user).toBeInstanceOf(User);
+    expect(user.getId().value).toBe('user-1');
+    expect(user.getDisplayName()).toBe('Test User');
   });
 
-  it('throws when the user does not exist', async () => {
+  it('returns error when the user does not exist', async () => {
     userRepository.findById.mockResolvedValue(null);
 
-    await expect(useCase.execute('missing-user')).rejects.toThrow('User not found');
+    const result = await useCase.execute({ userId: 'missing-user' });
+
     expect(userRepository.findById).toHaveBeenCalledWith('missing-user');
+    expect(result.isErr()).toBe(true);
   });
-});
+});