test: add instrument service text for export records method

Author: david-roper

apps/api/src/instrument-records/__tests__/instrument-records.service.spec.ts

@@ -0,0 +1,77 @@
+import type { Model } from '@douglasneuroinformatics/libnest';
+import { getModelToken } from '@douglasneuroinformatics/libnest';
+import { MockFactory } from '@douglasneuroinformatics/libnest/testing';
+import type { MockedInstance } from '@douglasneuroinformatics/libnest/testing';
+import { NotFoundException } from '@nestjs/common';
+import { Test } from '@nestjs/testing';
+import { beforeEach, describe, expect, it } from 'vitest';
+
+import { GroupsService } from '../../groups/groups.service';
+import { InstrumentsService } from '../../instruments/instruments.service';
+import { SessionsService } from '../../sessions/sessions.service';
+import { SubjectsService } from '../../subjects/subjects.service';
+import { InstrumentMeasuresService } from '../instrument-measures.service';
+import { InstrumentRecordsService } from '../instrument-records.service';
+
+describe('InstrumentRecordsService', () => {
+  let instrumentRecordsService: InstrumentRecordsService;
+  let instrumentRecordModel: MockedInstance<Model<'InstrumentRecord'>>;
+  let _groupsService: MockedInstance<GroupsService>;
+  let _instrumentMeasuresService: MockedInstance<InstrumentMeasuresService>;
+  let _instrumentsService: MockedInstance<InstrumentsService>;
+  let _sessionsService: MockedInstance<SessionsService>;
+  let _subjectsService: MockedInstance<SubjectsService>;
+
+  beforeEach(async () => {
+    const moduleRef = await Test.createTestingModule({
+      providers: [
+        InstrumentRecordsService,
+        MockFactory.createForModelToken(getModelToken('InstrumentRecord')),
+        MockFactory.createForService(GroupsService),
+        MockFactory.createForService(InstrumentMeasuresService),
+        MockFactory.createForService(InstrumentsService),
+        MockFactory.createForService(SessionsService),
+        MockFactory.createForService(SubjectsService)
+      ]
+    }).compile();
+
+    instrumentRecordModel = moduleRef.get(getModelToken('InstrumentRecord'));
+    instrumentRecordsService = moduleRef.get(InstrumentRecordsService);
+    _groupsService = moduleRef.get(GroupsService);
+    _instrumentMeasuresService = moduleRef.get(InstrumentMeasuresService);
+    _instrumentsService = moduleRef.get(InstrumentsService);
+    _sessionsService = moduleRef.get(SessionsService);
+    _subjectsService = moduleRef.get(SubjectsService);
+  });
+
+  describe('findById', () => {
+    it('should throw a NotFoundException if no record is found', async () => {
+      instrumentRecordModel.findFirst.mockResolvedValueOnce(null);
+      await expect(instrumentRecordsService.findById('nonexistent-id')).rejects.toBeInstanceOf(NotFoundException);
+    });
+
+    it('should return the instrument record with the correct shape', async () => {
+      const mockRecord = {
+        data: { test: 'data' },
+        date: new Date(),
+        id: 'test-record-id',
+        instrumentId: 'test-instrument-id',
+        sessionId: 'test-session-id',
+        subjectId: 'test-subject-id'
+      };
+
+      instrumentRecordModel.findFirst.mockResolvedValueOnce(mockRecord);
+
+      const result = await instrumentRecordsService.findById('test-record-id');
+
+      expect(result).toMatchObject({
+        data: { test: 'data' },
+        id: 'test-record-id',
+        instrumentId: 'test-instrument-id',
+        sessionId: 'test-session-id',
+        subjectId: 'test-subject-id'
+      });
+      expect(result.date).toBeInstanceOf(Date);
+    });
+  });
+});