Merge pull request #1186 from david-roper/subject-service-tests

Subject service tests

Author: joshunrau

apps/api/package.json

@@ -17,7 +17,7 @@
   "dependencies": {
     "@douglasneuroinformatics/libcrypto": "catalog:",
     "@douglasneuroinformatics/libjs": "catalog:",
-    "@douglasneuroinformatics/libnest": "^7.3.2",
+    "@douglasneuroinformatics/libnest": "^7.3.3",
     "@douglasneuroinformatics/libpasswd": "catalog:",
     "@douglasneuroinformatics/libstats": "catalog:",
     "@faker-js/faker": "^9.4.0",

apps/api/src/subjects/__tests__/subjects.service.spec.ts

@@ -1,28 +1,47 @@
-import { CryptoService, getModelToken } from '@douglasneuroinformatics/libnest';
-import type { Model } from '@douglasneuroinformatics/libnest';
+import { CryptoService, getModelToken, PRISMA_CLIENT_TOKEN } from '@douglasneuroinformatics/libnest';
+import type { ExtendedPrismaClient, Model } from '@douglasneuroinformatics/libnest';
 import { MockFactory } from '@douglasneuroinformatics/libnest/testing';
 import type { MockedInstance } from '@douglasneuroinformatics/libnest/testing';
 import { ConflictException, NotFoundException } from '@nestjs/common';
 import { Test } from '@nestjs/testing';
 import { pick } from 'lodash-es';
-import { beforeEach, describe, expect, it } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { SubjectsService } from '../subjects.service';
 
 describe('SubjectsService', () => {
   let subjectsService: SubjectsService;
   let subjectModel: MockedInstance<Model<'Subject'>>;
+  let prismaClient: MockedInstance<ExtendedPrismaClient> & {
+    [key: string]: any;
+  };
 
   beforeEach(async () => {
     const moduleRef = await Test.createTestingModule({
       providers: [
         MockFactory.createForService(CryptoService),
         SubjectsService,
-        MockFactory.createForModelToken(getModelToken('Subject'))
+        MockFactory.createForModelToken(getModelToken('Subject')),
+        {
+          provide: PRISMA_CLIENT_TOKEN,
+          useValue: {
+            $transaction: vi.fn(),
+            instrumentRecord: {
+              deleteMany: vi.fn()
+            },
+            session: {
+              deleteMany: vi.fn()
+            },
+            subject: {
+              deleteMany: vi.fn()
+            }
+          }
+        }
       ]
     }).compile();
     subjectModel = moduleRef.get(getModelToken('Subject'));
     subjectsService = moduleRef.get(SubjectsService);
+    prismaClient = moduleRef.get(PRISMA_CLIENT_TOKEN);
   });
 
   describe('create', () => {
@@ -59,6 +78,28 @@ describe('SubjectsService', () => {
     });
   });
 
+  describe('deleteById', () => {
+    it('should delete the subject via the subject model and not call $transaction, if force is falsy', async () => {
+      subjectModel.findFirst.mockResolvedValueOnce({ id: '123' });
+      await subjectsService.deleteById('123');
+      expect(subjectModel.delete).toHaveBeenCalledOnce();
+      expect(prismaClient.$transaction).not.toHaveBeenCalled();
+    });
+    it('should use $transaction if force is set to true', async () => {
+      subjectModel.findFirst.mockResolvedValueOnce({ id: '123' });
+      await subjectsService.deleteById('123', { force: true });
+      expect(subjectModel.delete).not.toHaveBeenCalled();
+      expect(prismaClient.session.deleteMany).toHaveBeenCalled();
+      expect(prismaClient.instrumentRecord.deleteMany).toHaveBeenCalled();
+      expect(prismaClient.subject.deleteMany).toHaveBeenCalled();
+      expect(prismaClient.$transaction).toHaveBeenCalledOnce();
+    });
+    it('should throw NotFoundException when subject does not exist', async () => {
+      subjectModel.findFirst.mockResolvedValueOnce(null);
+      await expect(subjectsService.deleteById('123')).rejects.toBeInstanceOf(NotFoundException);
+    });
+  });
+
   describe('findById', () => {
     it('should throw a `NotFoundException` if there is no subject with the provided id', async () => {
       subjectModel.findFirst.mockResolvedValueOnce(null);