testing: added tests for finding users without approve

Author: SharpDevOps10

.github/actions/install/action.yml

@@ -5,7 +5,7 @@ runs:
   using: composite
   steps:
     - name: Use Node.js 20.x
-      uses: actions/setup-node@v3
+      uses: actions/setup-node@v4
       with:
         node-version: '20.x'
     - name: Install dependencies

.github/workflows/build.yml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: Install Node and dependencies
         uses: ./.github/actions/install
       - name: Start PostgreSQL Database

src/users/users.service.spec.ts

@@ -4,20 +4,102 @@ import { UsersRepository } from '../repositories/users.repository';
 import { MailModule } from '../mail/mail.module';
 import { PrismaModule } from '../prisma/prisma.module';
 import { AuthModule } from '../auth/auth.module';
+import { PrismaService } from '../prisma/prisma.service';
+import { Request } from 'express';
+import { ForbiddenException } from '@nestjs/common';
 
 describe('UsersService', () => {
-  let service: UsersService;
+  let usersService: UsersService;
+  let prismaService: PrismaService;
 
-  beforeEach(async () => {
+  beforeAll(async () => {
     const module: TestingModule = await Test.createTestingModule({
       providers: [UsersService, UsersRepository],
       imports: [MailModule, PrismaModule, AuthModule],
     }).compile();
 
-    service = module.get<UsersService>(UsersService);
+    usersService = module.get<UsersService>(UsersService);
+    prismaService = module.get<PrismaService>(PrismaService);
+
+  });
+
+  afterAll(async () => {
+    await prismaService.$disconnect();
   });
 
-  it('should be defined', () => {
-    expect(service).toBeDefined();
+  beforeEach(async () => {
+    await prismaService.queue.deleteMany();
+    await prismaService.user.deleteMany();
+  });
+
+  describe('getNotApprovedUsers', () => {
+    it('should return a list of not approved users if the requester is an admin', async () => {
+      const admin = await prismaService.user.create({
+        data: {
+          email: '[email protected]',
+          password: '123456',
+          firstName: 'John',
+          lastName: 'Doe',
+          admin: true,
+          approved: true,
+        },
+      });
+
+
+      await prismaService.user.createMany({
+        data: [
+          {
+            email: '[email protected]',
+            password: '123456',
+            firstName: 'John',
+            lastName: 'Doe',
+            admin: false,
+            approved: false,
+          },
+          {
+            email: '[email protected]',
+            password: '123456',
+            firstName: 'Andrew',
+            lastName: 'Doe',
+            admin: false,
+            approved: false,
+          },
+        ],
+      });
+
+      const notApprovedUsers = await prismaService.user.findMany({
+        where: { approved: false },
+      });
+
+      const req = {
+        user: {
+          userId: admin.id,
+        },
+      } as unknown as Request;
+
+      const result = await usersService.getNotApprovedUsers(req);
+      expect(result).toStrictEqual(notApprovedUsers);
+    });
+
+    it('should throw ForbiddenException if the requester is not an admin', async () => {
+      const user = await prismaService.user.create({
+        data: {
+          email: '[email protected]',
+          password: 'anon1234',
+          firstName: 'Alex',
+          lastName: 'Bond',
+          admin: false,
+          approved: true,
+        },
+      });
+
+      const req = {
+        user: {
+          userId: user.id,
+        },
+      } as unknown as Request;
+
+      await expect(usersService.getNotApprovedUsers(req)).rejects.toThrow(ForbiddenException);
+    });
   });
 });