From ee9afab6cabdba406ecda3c3af0facac1e479a0d Mon Sep 17 00:00:00 2001
From: Gerald Schmittinger <gerald.schmittinger@ugent.be>
Date: Wed, 16 Apr 2025 00:55:43 +0200
Subject: [PATCH] fix(backend): Testen LearningPathRepository gerepareerd na
 refactoring.

---
 .../content/learning-path-repository.test.ts  | 41 ++++++++-----------
 backend/tests/test-utils/expectations.ts      | 17 ++++++++
 2 files changed, 34 insertions(+), 24 deletions(-)

diff --git a/backend/tests/data/content/learning-path-repository.test.ts b/backend/tests/data/content/learning-path-repository.test.ts
index bdf5377e..370eec2a 100644
--- a/backend/tests/data/content/learning-path-repository.test.ts
+++ b/backend/tests/data/content/learning-path-repository.test.ts
@@ -2,41 +2,34 @@ import { beforeAll, describe, expect, it } from 'vitest';
 import { setupTestApp } from '../../setup-tests.js';
 import { getLearningPathRepository } from '../../../src/data/repositories.js';
 import { LearningPathRepository } from '../../../src/data/content/learning-path-repository.js';
-import example from '../../test-assets/learning-paths/pn-werking-example.js';
 import { LearningPath } from '../../../src/entities/content/learning-path.entity.js';
-import { expectToBeCorrectEntity } from '../../test-utils/expectations.js';
+import {
+    expectToBeCorrectEntity,
+    expectToHaveFoundNothing,
+    expectToHaveFoundPrecisely
+} from '../../test-utils/expectations.js';
 import { Language } from '@dwengo-1/common/util/language';
-
-function expectToHaveFoundPrecisely(expected: LearningPath, result: LearningPath[]): void {
-    expect(result).toHaveProperty('length');
-    expect(result.length).toBe(1);
-    expectToBeCorrectEntity({ entity: result[0] }, { entity: expected });
-}
-
-function expectToHaveFoundNothing(result: LearningPath[]): void {
-    expect(result).toHaveProperty('length');
-    expect(result.length).toBe(0);
-}
+import {testLearningPath01} from "../../test_assets/content/learning-paths.testdata";
+import {mapToLearningPath} from "../../../src/services/learning-paths/learning-path-service";
 
 describe('LearningPathRepository', () => {
     let learningPathRepo: LearningPathRepository;
+    let examplePath: LearningPath;
 
     beforeAll(async () => {
         await setupTestApp();
         learningPathRepo = getLearningPathRepository();
+
+        examplePath = mapToLearningPath(testLearningPath01, []);
     });
 
-    let examplePath: LearningPath;
-
-    it('should be able to add a learning path without throwing an error', async () => {
-        examplePath = example.createLearningPath();
-        await learningPathRepo.insert(examplePath);
-    });
-
-    it('should return the added path when it is queried by hruid and language', async () => {
-        const result = await learningPathRepo.findByHruidAndLanguage(examplePath.hruid, examplePath.language);
+    it('should return a learning path when it is queried by hruid and language', async () => {
+        const result = await learningPathRepo.findByHruidAndLanguage(
+            testLearningPath01.hruid,
+            testLearningPath01.language as Language
+        );
         expect(result).toBeInstanceOf(LearningPath);
-        expectToBeCorrectEntity({ entity: result! }, { entity: examplePath });
+        expectToBeCorrectEntity(result!, examplePath);
     });
 
     it('should return null to a query on a non-existing hruid or language', async () => {
@@ -45,7 +38,7 @@ describe('LearningPathRepository', () => {
     });
 
     it('should return the learning path when we search for a search term occurring in its title', async () => {
-        const result = await learningPathRepo.findByQueryStringAndLanguage(examplePath.title.slice(4, 9), examplePath.language);
+        const result = await learningPathRepo.findByQueryStringAndLanguage(examplePath.title.slice(9, 13), examplePath.language);
         expectToHaveFoundPrecisely(examplePath, result);
     });
 
diff --git a/backend/tests/test-utils/expectations.ts b/backend/tests/test-utils/expectations.ts
index 0ee0eff8..3a2e2283 100644
--- a/backend/tests/test-utils/expectations.ts
+++ b/backend/tests/test-utils/expectations.ts
@@ -141,3 +141,20 @@ export function expectToBeCorrectLearningPath(
         expect(new Set(node.transitions.map((it) => it.next.version))).toEqual(new Set(expectedNode.transitions.map((it) => it.next.version)));
     }
 }
+
+/**
+ * Expect that the given result is a singleton list with exactly the given element.
+ */
+export function expectToHaveFoundPrecisely<T extends object>(expected: T, result: T[]): void {
+    expect(result).toHaveProperty('length');
+    expect(result.length).toBe(1);
+    expectToBeCorrectEntity(result[0], expected);
+}
+
+/**
+ * Expect that the given result is an empty list.
+ */
+export function expectToHaveFoundNothing<T>(result: T[]): void {
+    expect(result).toHaveProperty('length');
+    expect(result.length).toBe(0);
+}