(feat) 1er test fail mise en place a voir plutart

node_app/jest-e2e.config.js

@@ -6,4 +6,4 @@ module.exports = {
   transform: {
     '^.+\\.(t|j)s$': 'ts-jest',
   },
-};
+};

node_app/jest.config.js

@@ -8,4 +8,4 @@ module.exports = {
   collectCoverageFrom: ['**/*.(t|j)s'],
   coverageDirectory: '../coverage',
   testEnvironment: 'node',
-};
+};

node_app/src/infrastructure/services/auth.service.spec.ts

@@ -1,48 +1,31 @@
 import { Test, TestingModule } from '@nestjs/testing';
-import { JwtService } from '@nestjs/jwt';
-import { AuthService } from './auth.service';
 import { MockAuthService } from './mocks/auth.service.mock';
+import { User } from 'src/domain/entities/user.entity';
+
+const mockUser: User = {
+  id: 1,
+  email: 'test@example.com',
+  name: 'Utilisateur Test',
+  address: '123 Rue de Test',
+  telephone: '+33123456789',
+  otherName: 'Test',
+  password: 'password',
+};
 
 describe('AuthService', () => {
-  let service: AuthService;
-  let jwtService: JwtService;
-  let userRepository: any;
-  let hasherService: any;
+  let service: MockAuthService;
 
   beforeEach(async () => {
-    // Créer des mocks pour les dépendances
-    userRepository = {
-      findByEmail: jest.fn(),
-    };
-
-    hasherService = {
-      compare: jest.fn(),
-    };
-
-    jwtService = {
-      sign: jest.fn(),
-      verify: jest.fn(),
-    } as unknown as JwtService;
-
     const module: TestingModule = await Test.createTestingModule({
       providers: [
-        AuthService,
-        {
-          provide: 'IUserRepository',
-          useValue: userRepository,
-        },
-        {
-          provide: 'IHasherService',
-          useValue: hasherService,
-        },
         {
-          provide: JwtService,
-          useValue: jwtService,
+          provide: 'IAuthService',
+          useClass: MockAuthService,
         },
       ],
     }).compile();
 
-    service = module.get<AuthService>(AuthService);
+    service = module.get<MockAuthService>('IAuthService');
   });
 
   it('should be defined', () => {
@@ -50,64 +33,57 @@ describe('AuthService', () => {
   });
 
   describe('validateUser', () => {
-    it('should return user object when credentials are valid', async () => {
-      // Arrange
-      const mockUser = {
-        id: 1,
-        email: 'test@example.com',
-        password: 'hashedPassword',
-        name: 'Test User',
-      };
-      
-      userRepository.findByEmail.mockResolvedValue(mockUser);
-      hasherService.compare.mockResolvedValue(true);
-
+    it('devrait retourner un objet utilisateur lorsque les identifiants sont valides', async () => {
       // Act
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
       const result = await service.validateUser('test@example.com', 'password');
-
       // Assert
-      expect(result).toEqual({
-        id: 1,
-        email: 'test@example.com',
-        name: 'Test User',
-      });
-      expect(userRepository.findByEmail).toHaveBeenCalledWith('test@example.com');
-      expect(hasherService.compare).toHaveBeenCalledWith('password', 'hashedPassword');
+      expect(result).toBeDefined();
+      expect(result).toEqual(mockUser);
     });
 
-    it('should return null when user is not found', async () => {
-      // Arrange
-      userRepository.findByEmail.mockResolvedValue(null);
-
+    it('devrait retourner null lorsque les identifiants sont invalides', async () => {
       // Act
-      const result = await service.validateUser('nonexistent@example.com', 'password');
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      const result = await service.validateUser(
+        'test@example.com',
+        'mauvais_mot_de_passe',
+      );
 
       // Assert
       expect(result).toBeNull();
-      expect(userRepository.findByEmail).toHaveBeenCalledWith('nonexistent@example.com');
-      expect(hasherService.compare).not.toHaveBeenCalled();
     });
   });
 
   describe('generateToken', () => {
-    it('should generate a JWT token', async () => {
-      // Arrange
-      const mockUser = {
-        id: 1,
-        email: 'test@example.com',
-      };
-      const mockToken = 'jwt-token';
-      jwtService.sign.mockReturnValue(mockToken);
+    it('devrait générer un token JWT', async () => {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      const result = await service.generateToken(mockUser);
+      // Assert
+      expect(result).toBe('mock-jwt-token-for-testing-purposes');
+    });
+  });
 
+  describe('verifyToken', () => {
+    it('devrait vérifier un token valide', async () => {
       // Act
-      const result = await service.generateToken(mockUser);
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      const result = await service.verifyToken(
+        'mock-jwt-token-for-testing-purposes',
+      );
 
       // Assert
-      expect(result).toBe(mockToken);
-      expect(jwtService.sign).toHaveBeenCalledWith({
+      expect(result).toEqual({
         email: 'test@example.com',
         sub: 1,
       });
     });
+
+    it('devrait rejeter un token invalide', async () => {
+      // Act & Assert
+      await expect(service.verifyToken('token-invalide')).rejects.toThrow(
+        'Token invalide',
+      );
+    });
   });
-});
+});

node_app/src/infrastructure/services/auth.service.ts

@@ -3,6 +3,7 @@ import { JwtService } from '@nestjs/jwt';
 import { IAuthService } from '../../application/interfaces/i-auth.service';
 import { IUserRepository } from '../../application/interfaces/i-user.repository';
 import { IHasherService } from '../../application/interfaces/i-hasher.service';
+import { User } from 'src/domain/entities/user.entity';
 
 @Injectable()
 export class AuthService implements IAuthService {
@@ -14,21 +15,32 @@ export class AuthService implements IAuthService {
     private readonly jwtService: JwtService,
   ) {}
 
-  async validateUser(email: string, password: string): Promise<any> {
-    const user = await this.userRepository.findByEmail(email);
+  async validateUser(email: string, password: string): Promise<User | null> {
+    const user: User | null = await this.userRepository.findByEmail(email);
     if (user && (await this.hasherService.compare(password, user.password))) {
-      const { password, ...result } = user;
+      const result = user;
       return result;
     }
     return null;
   }
 
-  async generateToken(user: any): Promise<string> {
-    const payload = { email: user.email, sub: user.id };
-    return this.jwtService.sign(payload);
+  async generateToken(user: User): Promise<string> {
+    return new Promise<string>((resolve) => {
+      const payload = { email: user.email, sub: user.id };
+      const token = this.jwtService.sign(payload);
+      resolve(token);
+    });
   }
 
-  async verifyToken(token: string): Promise<any> {
-    return this.jwtService.verify(token);
+  async verifyToken(token: string): Promise<string> {
+    return new Promise<string>((resolve, reject) => {
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const decoded = this.jwtService.verify(token);
+        resolve(decoded as string);
+      } catch (error) {
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
   }
 }

node_app/src/infrastructure/services/mocks/auth.service.mock.ts

@@ -1,39 +1,90 @@
-import { Injectable } from '@nestjs/common';
+import { Inject, Injectable } from '@nestjs/common';
 import { IAuthService } from '../../../application/interfaces/i-auth.service';
+import { User } from 'src/domain/entities/user.entity';
+import { JwtService } from '@nestjs/jwt';
 
 @Injectable()
 export class MockAuthService implements IAuthService {
+  @Inject()
+  private readonly jwtService: JwtService;
   // Utilisateur fictif pour les tests
-  private readonly mockUser = {
+  private readonly mockUser: User = {
     id: 1,
     email: 'test@example.com',
     name: 'Utilisateur Test',
     address: '123 Rue de Test',
     telephone: '+33123456789',
     otherName: 'Test',
+    password: 'password',
   };
 
   // Token fictif pour les tests
   private readonly mockToken = 'mock-jwt-token-for-testing-purposes';
 
-  async validateUser(email: string, password: string): Promise<any> {
-    // Simuler la validation d'un utilisateur
-    if (email === 'test@example.com' && password === 'password') {
-      return this.mockUser;
-    }
-    return null;
-  }
+  // Utilisation de jest.fn() pour créer des fonctions espions
+  validateUser = jest
+    .fn()
+    .mockImplementation(
+      async (email: string, password: string): Promise<User> => {
+        return new Promise((resolve, reject) => {
+          try {
+            if (
+              email === this.mockUser.email &&
+              password === this.mockUser.password
+            ) {
+              resolve(this.mockUser);
+            } else {
+              reject(new Error('Identifiants invalides'));
+            }
+          } catch (error) {
+            reject(
+              error instanceof Error
+                ? error
+                : new Error('An unexpected error occurred'),
+            );
+          }
+        });
+      },
+    );
 
-  async generateToken(user: any): Promise<string> {
-    // Retourner un token fictif
-    return this.mockToken;
-  }
+  generateToken = jest
+    .fn()
+    .mockImplementation(async (user: User): Promise<string> => {
+      return new Promise((resolve, reject) => {
+        try {
+          const playload: { email: string; sub: number } = {
+            email: user.email,
+            sub: user.id,
+          };
+          const token: string = this.jwtService.sign(playload);
+          console.log('lala =>', token);
+          //if (token === this.mockToken)
+          return resolve(token);
+        } catch (error) {
+          return reject(
+            error instanceof Error
+              ? error
+              : new Error('An unexpected error occurred'),
+          );
+        }
+      });
+    });
 
-  async verifyToken(token: string): Promise<any> {
-    // Simuler la vérification d'un token
-    if (token === this.mockToken) {
-      return { email: this.mockUser.email, sub: this.mockUser.id };
-    }
-    throw new Error('Token invalide');
-  }
+  verifyToken = jest
+    .fn()
+    .mockImplementation(async (token: string): Promise<string> => {
+      return new Promise((resolve, reject) => {
+        try {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          const goodToken = this.jwtService.verify(token);
+          resolve(goodToken as string);
+        } catch (error) {
+          return reject(
+            error instanceof Error
+              ? error
+              : new Error('An unexpected error occurred'),
+          );
+        }
+      });
+    });
 }

node_app/src/presentation/controllers/user.controller.spec.ts

@@ -0,0 +1,57 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { UserController } from './user.controller';
+import { CreateUserUseCase } from '../../application/use-cases/create-user.use-case';
+import { MockAuthService } from '../../infrastructure/services/mocks/auth.service.mock';
+import { MockUserRepository } from '../../infrastructure/services/mocks/user.repository.mock';
+
+describe('UserController', () => {
+  let controller: UserController;
+  let authService: MockAuthService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [UserController],
+      providers: [
+        CreateUserUseCase,
+        {
+          provide: 'IAuthService',
+          useClass: MockAuthService,
+        },
+        {
+          provide: 'IUserRepository',
+          useClass: MockUserRepository,
+        },
+      ],
+    }).compile();
+
+    controller = module.get<UserController>(UserController);
+    authService = module.get<MockAuthService>('IAuthService');
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+
+  // Exemple de test utilisant le mock
+  it('devrait authentifier un utilisateur avec des identifiants valides', async () => {
+    // Arrange - Préparation des données de test
+    const credentials = {
+      email: 'test@example.com',
+      password: 'password',
+    };
+
+    // Act - Exécution de la méthode à tester
+    // Vérifiez si la méthode login existe dans votre contrôleur
+    // Si elle n'existe pas, utilisez la méthode appropriée ou créez-la
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const result = await authService.validateUser(
+      credentials.email,
+      credentials.password,
+    );
+    const token = await authService.generateToken(result);
+
+    // Assert - Vérification des résultats
+    expect(result).toBeDefined();
+    expect(token).toBe('mock-jwt-token-for-testing-purposes');
+  });
+});

node_app/test/e2e/auth.e2e-spec.ts

@@ -0,0 +1,35 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { INestApplication } from '@nestjs/common';
+import * as request from 'supertest';
+import { AppModule } from '../../src/app.module';
+import { MockAuthService } from '../../src/infrastructure/services/mocks/auth.service.mock';
+
+describe('AuthController (e2e)', () => {
+  let app: INestApplication;
+
+  beforeEach(async () => {
+    const moduleFixture: TestingModule = await Test.createTestingModule({
+      imports: [AppModule],
+    })
+      .overrideProvider('IAuthService')
+      .useClass(MockAuthService)
+      .compile();
+
+    app = moduleFixture.createNestApplication();
+    await app.init();
+  });
+
+  afterEach(async () => {
+    await app.close();
+  });
+
+  it('/api/auth/login (POST)', () => {
+    return request(app.getHttpServer())
+      .post('/api/auth/login')
+      .send({ email: 'test@example.com', password: 'password' })
+      .expect(200)
+      .expect((res) => {
+        expect(res.body.token).toBe('mock-jwt-token-for-testing-purposes');
+      });
+  });
+});