fix(backend): Testen AssignmentRepository gerepareerd na refactoring.

backend/tests/data/content/attachment-repository.test.ts

@@ -2,66 +2,60 @@ import { beforeAll, describe, expect, it } from 'vitest';
 import { setupTestApp } from '../../setup-tests.js';
 import { getAttachmentRepository, getLearningObjectRepository } from '../../../src/data/repositories.js';
 import { AttachmentRepository } from '../../../src/data/content/attachment-repository.js';
-import { LearningObjectRepository } from '../../../src/data/content/learning-object-repository.js';
-import example from '../../test-assets/learning-objects/pn-werkingnotebooks/pn-werkingnotebooks-example.js';
 import { LearningObject } from '../../../src/entities/content/learning-object.entity.js';
 import { Attachment } from '../../../src/entities/content/attachment.entity.js';
 import { LearningObjectIdentifier } from '../../../src/entities/content/learning-object-identifier.js';
-
+import {testLearningObjectPnNotebooks} from "../../test_assets/content/learning-objects.testdata";
-const NEWER_TEST_SUFFIX = 'nEweR';
+import {v4 as uuidV4} from "uuid";
-
-async function createTestLearningObjects(learningObjectRepo: LearningObjectRepository): Promise<{
-    older: LearningObject;
-    newer: LearningObject;
-}> {
-    const olderExample = example.createLearningObject();
-    await learningObjectRepo.save(olderExample);
-
-    const newerExample = example.createLearningObject();
-    newerExample.title = 'Newer example';
-    newerExample.version = 100;
-
-    return {
-        older: olderExample,
-        newer: newerExample,
-    };
-}
 
 describe('AttachmentRepository', () => {
     let attachmentRepo: AttachmentRepository;
-    let exampleLearningObjects: { older: LearningObject; newer: LearningObject };
+    let newLearningObject: LearningObject;
     let attachmentsOlderLearningObject: Attachment[];
 
     beforeAll(async () => {
         await setupTestApp();
+
+        attachmentsOlderLearningObject = testLearningObjectPnNotebooks.attachments as Attachment[];
+
         attachmentRepo = getAttachmentRepository();
-        exampleLearningObjects = await createTestLearningObjects(getLearningObjectRepository());
+        const learningObjectRepo = getLearningObjectRepository();
-    });
 
-    it('can add attachments to learning objects without throwing an error', async () => {
+        const newLearningObjectData = structuredClone(testLearningObjectPnNotebooks);
-        attachmentsOlderLearningObject = Object.values(example.createAttachment).map((fn) => fn(exampleLearningObjects.older));
+        newLearningObjectData.title = 'Newer example';
+        newLearningObjectData.version = 101;
+        newLearningObjectData.attachments = [];
+        newLearningObjectData.uuid = uuidV4();
+        newLearningObjectData.content = Buffer.from("Content of the newer example");
 
-        await Promise.all(attachmentsOlderLearningObject.map(async (attachment) => attachmentRepo.save(attachment)));
+        newLearningObject = learningObjectRepo.create(newLearningObjectData);
+        await learningObjectRepo.save(newLearningObject);
     });
 
     let attachmentOnlyNewer: Attachment;
     it('allows us to add attachments with the same name to a different learning object without throwing an error', async () => {
-        attachmentOnlyNewer = Object.values(example.createAttachment)[0](exampleLearningObjects.newer);
+        attachmentOnlyNewer = structuredClone(attachmentsOlderLearningObject[0]);
-        attachmentOnlyNewer.content.write(NEWER_TEST_SUFFIX);
+        attachmentOnlyNewer.learningObject = newLearningObject;
+        attachmentOnlyNewer.content = Buffer.from("New attachment content");
 
-        await attachmentRepo.save(attachmentOnlyNewer);
+        await attachmentRepo.save(attachmentRepo.create(attachmentOnlyNewer));
     });
 
     let olderLearningObjectId: LearningObjectIdentifier;
     it('returns the correct attachment when queried by learningObjectId and attachment name', async () => {
         olderLearningObjectId = {
-            hruid: exampleLearningObjects.older.hruid,
+            hruid: testLearningObjectPnNotebooks.hruid,
-            language: exampleLearningObjects.older.language,
+            language: testLearningObjectPnNotebooks.language,
-            version: exampleLearningObjects.older.version,
+            version: testLearningObjectPnNotebooks.version,
         };
 
-        const result = await attachmentRepo.findByLearningObjectIdAndName(olderLearningObjectId, attachmentsOlderLearningObject[0].name);
+        const result = await attachmentRepo.findByLearningObjectIdAndName(
-        expect(result).toBe(attachmentsOlderLearningObject[0]);
+            olderLearningObjectId,
+            attachmentsOlderLearningObject[0].name
+        );
+        expect(result).not.toBeNull();
+        expect(result!.name).toEqual(attachmentsOlderLearningObject[0].name);
+        expect(result!.content).toEqual(attachmentsOlderLearningObject[0].content);
     });
 
     it('returns null when queried by learningObjectId and non-existing attachment name', async () => {
@@ -71,10 +65,12 @@ describe('AttachmentRepository', () => {
 
     it('returns the newer version of the attachment when only queried by hruid, language and attachment name (but not version)', async () => {
         const result = await attachmentRepo.findByMostRecentVersionOfLearningObjectAndName(
-            exampleLearningObjects.older.hruid,
+            testLearningObjectPnNotebooks.hruid,
-            exampleLearningObjects.older.language,
+            testLearningObjectPnNotebooks.language,
             attachmentOnlyNewer.name
         );
-        expect(result).toBe(attachmentOnlyNewer);
+        expect(result).not.toBeNull();
+        expect(result!.name).toEqual(attachmentOnlyNewer.name);
+        expect(result!.content).toEqual(attachmentOnlyNewer.content);
     });
 });