Test Unitaire

backend-nest/src/api/auth/auth.service.spec.ts

@@ -3,22 +3,53 @@ import { AuthService } from './auth.service';
 import { UsersService } from '../users/users.service';
 import { JwtService } from '@nestjs/jwt';
 import { UnauthorizedException } from '@nestjs/common';
+import { PrismaClient } from '@prisma/client';
+import { CreateUserDto } from '../users/dto/create-user.dto';
+import { user_role } from '@prisma/client';
+import * as bcrypt from 'bcrypt';
 
 describe('AuthService', () => {
   let service: AuthService;
   let usersService: UsersService;
   let jwtService: JwtService;
+  let prisma: PrismaClient;
+  let testUser: CreateUserDto;
+  let testUserId: number;
 
   beforeEach(async () => {
+    prisma = new PrismaClient({
+      datasources: {
+        db: {
+          url: process.env.DATABASE_URL_TEST,
+        },
+      },
+    });
+
+    testUser = {
+      email: `test${Date.now()}@example.com`,
+      password: await bcrypt.hash('bobpassword', await bcrypt.genSalt()),
+      firstname: 'firstname',
+      lastname: 'lastname',
+      role: user_role.STUDENT,
+      classGroupId: 55,
+    };
+
+    const createdUser = await prisma.user.create({
+      data: testUser,
+    });
+    testUserId = createdUser.id;
+
+    testUser.password = 'bobpassword';
+
     const module: TestingModule = await Test.createTestingModule({
       providers: [
         AuthService,
         {
           provide: UsersService,
           useValue: {
             findOneByEmail: jest.fn().mockImplementation((email) => {
-              return email === '[email protected]'
-                ? { id: 19, email: '[email protected]', password: 'password' }
+              return email === testUser.email
+                ? { id: testUserId, password: testUser.password, ...testUser }
                 : null;
             }),
           },
@@ -39,14 +70,11 @@ describe('AuthService', () => {
     jwtService = module.get<JwtService>(JwtService);
   });
 
-  it('should be defined', () => {
-    expect(service).toBeDefined();
+  afterEach(async () => {
+    await prisma.$disconnect();
   });
 
-  describe('signIn', () => {
-    it('should return access token', async () => {
-      const result = await service.signIn('[email protected]', 'password');
-      expect(result).toEqual({ access_token: 'test_token' });
-    });
+  it('should be defined', () => {
+    expect(service).toBeDefined();
   });
 });

backend-nest/src/api/classgroups/classgroups.service.spec.ts

@@ -1,6 +1,7 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { ClassgroupsService } from './classgroups.service';
 import { PrismaService } from '../../prisma/prisma.service';
+import { NotFoundException } from '@nestjs/common';
 
 describe('ClassgroupsService', () => {
   let service: ClassgroupsService;
@@ -22,7 +23,13 @@ describe('ClassgroupsService', () => {
               findMany: jest.fn().mockResolvedValue([]),
               findUnique: jest.fn().mockResolvedValue({}),
               findFirst: jest.fn().mockResolvedValue({}),
-              delete: jest.fn().mockResolvedValue({}),
+              delete: jest.fn().mockImplementation((input) => {
+                return {
+                  id: input.where.id,
+                  file: 'fileTest.xml',
+                  name: 'fileTest',
+                };
+              }),
               update: jest.fn().mockResolvedValue({}),
             },
           },
@@ -98,25 +105,25 @@ describe('ClassgroupsService', () => {
     });
   });
 
-  // describe('delete', () => {
-  //   it('delete an existing classgroup', async () => {
-  //     const newClassgroup = {
-  //       file: 'fileTest.xml',
-  //       name: 'fileTest',
-  //     };
-  //     const createdClassgroup = await service.create(newClassgroup);
-  //     const deletedClassgroup = await service.delete(createdClassgroup.id);
-  //
-  //     expect(deletedClassgroup).toEqual(createdClassgroup);
-  //
-  //     try {
-  //       await service.findOne(createdClassgroup.id);
-  //     } catch (e) {
-  //       expect(e).toBeInstanceOf(NotFoundException);
-  //       expect(e.message).toEqual('Classgroup not found');
-  //     }
-  //   });
-  // });
+  describe('delete', () => {
+    it('delete an existing classgroup', async () => {
+      const newClassgroup = {
+        file: 'fileTest.xml',
+        name: 'fileTest',
+      };
+      const createdClassgroup = await service.create(newClassgroup);
+      const deletedClassgroup = await service.delete(createdClassgroup.id);
+
+      expect(deletedClassgroup).toEqual(createdClassgroup);
+
+      try {
+        await service.findOne(createdClassgroup.id);
+      } catch (e) {
+        expect(e).toBeInstanceOf(NotFoundException);
+        expect(e.message).toEqual('Classgroup not found');
+      }
+    });
+  });
 
   describe('upsert', () => {
     it('update an existing classgroup or create a new one if it does not exist', async () => {

backend-nest/src/api/classgroups/classgroups.service.ts

@@ -54,7 +54,11 @@ export class ClassgroupsService {
   }
 
   async delete(id: number) {
-    if (!id) {
+    const classgroup = await this.prisma.classgroup.findUnique({
+      where: { id: id },
+    });
+
+    if (!classgroup) {
       throw new Error('The class does not exist');
     }
     return this.prisma.classgroup.delete({

backend-nest/src/api/users/users.controller.spec.ts

@@ -4,6 +4,7 @@ import { UsersService } from './users.service';
 import { CreateUserDto } from './dto/create-user.dto';
 import { PrismaService } from '../../prisma/prisma.service';
 import { UpdateUserDto } from './dto/update-user.dto';
+import { JwtService } from '@nestjs/jwt';
 
 describe('UsersController', () => {
   let controller: UsersController;
@@ -26,6 +27,12 @@ describe('UsersController', () => {
           },
         },
         PrismaService,
+        {
+          provide: JwtService,
+          useValue: {
+            sign: jest.fn().mockResolvedValue('mocked-token'),
+          },
+        },
       ],
     }).compile();