diff --git a/backend/tests/service/learning-objects.test.ts b/backend/tests/service/learning-objects.test.ts
deleted file mode 100644
index 130c237e..00000000
--- a/backend/tests/service/learning-objects.test.ts
+++ /dev/null
@@ -1,117 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { LearningObjectMetadata, LearningPath } from '../../src/interfaces/learningPath';
-import { fetchWithLogging } from '../../src/util/apiHelper';
-import { getLearningObjectById, getLearningObjectsFromPath } from '../../src/services/learningObjects';
-import { fetchLearningPaths } from '../../src/services/learningPaths';
-
-// Mock API functions
-vi.mock('../../src/util/apiHelper', () => ({
-    fetchWithLogging: vi.fn(),
-}));
-
-vi.mock('../../src/services/learningPaths', () => ({
-    fetchLearningPaths: vi.fn(),
-}));
-
-describe('getLearningObjectById', () => {
-    const hruid = 'test-object';
-    const language = 'en';
-    const mockMetadata: LearningObjectMetadata = {
-        hruid,
-        _id: '123',
-        uuid: 'uuid-123',
-        version: 1,
-        title: 'Test Object',
-        language,
-        difficulty: 5,
-        estimated_time: 120,
-        available: true,
-        teacher_exclusive: false,
-        educational_goals: [{ source: 'source', id: 'id' }],
-        keywords: ['robotics'],
-        description: 'A test object',
-        target_ages: [10, 12],
-        content_type: 'markdown',
-        content_location: '',
-    };
-
-    it('✅ Should return a filtered learning object when API provides data', async () => {
-        vi.mocked(fetchWithLogging).mockResolvedValueOnce(mockMetadata);
-
-        const result = await getLearningObjectById(hruid, language);
-
-        expect(result).toEqual({
-            key: hruid,
-            _id: '123',
-            uuid: 'uuid-123',
-            version: 1,
-            title: 'Test Object',
-            htmlUrl: expect.stringContaining('/learningObject/getRaw?hruid=test-object&language=en'),
-            language,
-            difficulty: 5,
-            estimatedTime: 120,
-            available: true,
-            teacherExclusive: false,
-            educationalGoals: [{ source: 'source', id: 'id' }],
-            keywords: ['robotics'],
-            description: 'A test object',
-            targetAges: [10, 12],
-            contentType: 'markdown',
-            contentLocation: '',
-        });
-    });
-
-    it('⚠️ Should return null if API returns no metadata', async () => {
-        vi.mocked(fetchWithLogging).mockResolvedValueOnce(null);
-        const result = await getLearningObjectById(hruid, language);
-        expect(result).toBeNull();
-    });
-});
-
-describe('getLearningObjectsFromPath', () => {
-    const hruid = 'test-path';
-    const language = 'en';
-
-    it('✅ Should not give error or warning', async () => {
-        const mockPathResponse: LearningPath[] = [
-            {
-                _id: 'path-1',
-                hruid,
-                language,
-                title: 'Test Path',
-                description: '',
-                num_nodes: 1,
-                num_nodes_left: 0,
-                nodes: [],
-                keywords: '',
-                target_ages: [],
-                min_age: 10,
-                max_age: 12,
-                __order: 1,
-            },
-        ];
-
-        vi.mocked(fetchLearningPaths).mockResolvedValueOnce({
-            success: true,
-            source: 'Test Source',
-            data: mockPathResponse,
-        });
-
-        const result = await getLearningObjectsFromPath(hruid, language);
-        expect(result).toEqual([]);
-    });
-
-    it('⚠️ Should give a warning', async () => {
-        vi.mocked(fetchLearningPaths).mockResolvedValueOnce({ success: false, source: 'Test Source', data: [] });
-
-        const result = await getLearningObjectsFromPath(hruid, language);
-        expect(result).toEqual([]);
-    });
-
-    it('❌ Should give an error', async () => {
-        vi.mocked(fetchLearningPaths).mockRejectedValueOnce(new Error('API Error'));
-
-        const result = await getLearningObjectsFromPath(hruid, language);
-        expect(result).toEqual([]);
-    });
-});
diff --git a/backend/tests/service/learning-paths.test.ts b/backend/tests/service/learning-paths.test.ts
deleted file mode 100644
index c002dbac..00000000
--- a/backend/tests/service/learning-paths.test.ts
+++ /dev/null
@@ -1,90 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { fetchLearningPaths, searchLearningPaths } from '../../src/services/learningPaths';
-import { fetchWithLogging } from '../../src/util/apiHelper';
-import { LearningPathResponse } from '../../src/interfaces/learningPath';
-
-// Mock the fetchWithLogging module using vi
-vi.mock('../../src/util/apiHelper', () => ({
-    fetchWithLogging: vi.fn(),
-}));
-
-describe('fetchLearningPaths', () => {
-    // Mock data and response
-    const mockHruids = ['pn_werking', 'art1'];
-    const language = 'en';
-    const source = 'Test Source';
-    const mockResponse = [{ title: 'Test Path', hruids: mockHruids }];
-
-    it('✅ Should return a successful response when HRUIDs are provided', async () => {
-        // Mock the function to return mockResponse
-        vi.mocked(fetchWithLogging).mockResolvedValue(mockResponse);
-
-        const result: LearningPathResponse = await fetchLearningPaths(mockHruids, language, source);
-
-        expect(result.success).toBe(true);
-        expect(result.data).toEqual(mockResponse);
-        expect(result.source).toBe(source);
-    });
-
-    it('⚠️ Should return an error when no HRUIDs are provided', async () => {
-        vi.mocked(fetchWithLogging).mockResolvedValue(mockResponse);
-
-        const result: LearningPathResponse = await fetchLearningPaths([], language, source);
-
-        expect(result.success).toBe(false);
-        expect(result.data).toBeNull();
-        expect(result.message).toBe(`No HRUIDs provided for ${source}.`);
-    });
-
-    it('⚠️ Should return a failure response when no learning paths are found', async () => {
-        // Mock fetchWithLogging to return an empty array
-        vi.mocked(fetchWithLogging).mockResolvedValue([]);
-
-        const result: LearningPathResponse = await fetchLearningPaths(mockHruids, language, source);
-
-        expect(result.success).toBe(false);
-        expect(result.data).toEqual([]);
-        expect(result.message).toBe(`No learning paths found for ${source}.`);
-    });
-});
-
-describe('searchLearningPaths', () => {
-    const query =
-        'https://dwengo.org/backend/api/learningPath/getPathsFromIdList?pathIdList=%7B%22hruids%22:%5B%22pn_werking%22,%22un_artificiele_intelligentie%22%5D%7D&language=nl';
-    const language = 'nl';
-
-    it('✅ Should return search results when API responds with data', async () => {
-        const mockResults = [
-            {
-                _id: '67b4488c9dadb305c4104618',
-                language: 'nl',
-                hruid: 'pn_werking',
-                title: 'Werken met notebooks',
-                description: 'Een korte inleiding tot Python notebooks. Hoe ga je gemakkelijk en efficiënt met de notebooks aan de slag?',
-                num_nodes: 0,
-                num_nodes_left: 0,
-                nodes: [],
-                keywords: 'Python KIKS Wiskunde STEM AI',
-                target_ages: [14, 15, 16, 17, 18],
-                min_age: 14,
-                max_age: 18,
-                __order: 0,
-            },
-        ];
-
-        // Mock fetchWithLogging to return search results
-        vi.mocked(fetchWithLogging).mockResolvedValue(mockResults);
-
-        const result = await searchLearningPaths(query, language);
-
-        expect(result).toEqual(mockResults);
-    });
-
-    it('⚠️ Should return an empty array when API returns no results', async () => {
-        vi.mocked(fetchWithLogging).mockResolvedValue([]);
-
-        const result = await searchLearningPaths(query, language);
-
-        expect(result).toEqual([]);
-    });
-});