@studyportals/fawkes 8.7.0 → 8.7.1-0

package/dist/tests/programmes/policies/DisciplineAttendance.test.mjs

@@ -0,0 +1,292 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { SitemapDependencies } from '../utils/SitemapDependencies.util.mjs';
+import { DisciplineAttendance } from '@/programmes/policies/DisciplineAttendance';
+import { PortalType } from '@studyportals/domain-client';
+import { DisciplinePresenter } from '@/presenters/DisciplinePresenter';
+import { AttendancePresenter } from '@/presenters/AttendancePresenter';
+// Mock the presenters at the module level
+vi.mock('@/presenters/DisciplinePresenter', () => {
+    return {
+        DisciplinePresenter: {
+            getInstance: vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: '54', path: 'agriculture-forestry' },
+                    { id: '12', path: 'applied-sciences' },
+                    { id: '356', path: 'computer-science' }
+                ])
+            })
+        }
+    };
+});
+vi.mock('@/presenters/AttendancePresenter', () => {
+    return {
+        AttendancePresenter: {
+            getInstance: vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: 'online', path: 'online' },
+                    { id: 'face2face', path: 'on-campus' }
+                ])
+            })
+        }
+    };
+});
+describe('Policy:DisciplineAttendance', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let disciplineAttendancePolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            disciplineAttendancePolicy = new DisciplineAttendance(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setResultsCount(10);
+            searchDependenciesHelper.setPageNumber(1);
+            searchDependenciesHelper.setPortalType(PortalType.MASTER);
+        });
+        it('Should return true when all conditions are met', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await disciplineAttendancePolicy.shouldIndex();
+            expect(result).toBe(true);
+        });
+        it('Should return false when multiple disciplines are selected', async () => {
+            const firstDisciplineId = '54'; // Agriculture & Forestry
+            const secondDisciplineId = '12'; // Applied Sciences & Professions
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [firstDisciplineId, secondDisciplineId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await disciplineAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple attendance values are selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const firstAttendance = 'online';
+            const secondAttendance = 'face2face';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.DELIVERY_METHOD, [firstAttendance, secondAttendance]]
+            ]));
+            const result = await disciplineAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no disciplines are selected', async () => {
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DELIVERY_METHOD, [attendance]]]));
+            const result = await disciplineAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no attendance value is selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DISCIPLINES, [disciplineId]]]));
+            const result = await disciplineAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const attendance = 'online';
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            const result = await disciplineAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false attendance is not online', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const attendance = 'face2face';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await disciplineAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when number of results is less than 7', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const attendance = 'online';
+            searchDependenciesHelper.setResultsCount(2);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await disciplineAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when page number is higher than 2', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const attendance = 'online';
+            searchDependenciesHelper.setPageNumber(4);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await disciplineAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when portal is distance learning', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const attendance = 'online';
+            searchDependenciesHelper.setPortalType(PortalType.DISTANCE_LEARNING);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await disciplineAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateUrls', () => {
+        let sitemapDependenciesHelper;
+        let disciplineAttendancePolicy;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setProgrammeCount(10); // More than 7 programs
+            disciplineAttendancePolicy = new DisciplineAttendance(sitemapDependenciesHelper.dependencies);
+            DisciplinePresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: '54', path: 'agriculture-forestry' },
+                    { id: '12', path: 'applied-sciences' },
+                    { id: '356', path: 'computer-science' }
+                ])
+            });
+            AttendancePresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: 'online', path: 'online' },
+                    { id: 'face2face', path: 'on-campus' }
+                ])
+            });
+        });
+        afterEach(() => {
+            sitemapDependenciesHelper.resetMocks();
+        });
+        it('Should generate URLs for valid discipline-attendance combinations with online attendance', async () => {
+            // Mock the checkRulesForSitemap to filter out non-online attendance options
+            const resultMap = new Map();
+            // Set up all combinations
+            for (const discipline of ['54', '12', '356']) {
+                for (const attendance of ['online', 'face2face']) {
+                    const key = `${FilterKey.DISCIPLINES}:${discipline}|${FilterKey.DELIVERY_METHOD}:${attendance}`;
+                    // Only allow online attendance to pass (due to OnlineAttendanceRule)
+                    resultMap.set(key, attendance === 'online');
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            // Call the method via reflection since it's protected
+            const urls = await disciplineAttendancePolicy.generateUrls();
+            // Calculate expected URLs: 3 disciplines * 1 attendance (online) * 2 pages = 6 URLs
+            expect(urls).toHaveLength(3);
+            // Verify valid combinations with proper path format
+            expect(urls).toContain('online/agriculture-forestry');
+            expect(urls).toContain('online/applied-sciences');
+            expect(urls).toContain('online/computer-science');
+            // Verify on-campus combinations are excluded
+            expect(urls).not.toContain('on-campus/agriculture-forestry');
+            expect(urls).not.toContain('on-campus/applied-sciences');
+            expect(urls).not.toContain('on-campus/computer-science');
+        });
+        it('Should exclude specific discipline combinations based on rules', async () => {
+            // Create a map that returns false for computer science
+            const resultMap = new Map();
+            // Set up all possible combinations
+            for (const discipline of ['54', '12', '356']) {
+                for (const attendance of ['online', 'face2face']) {
+                    const key = `${FilterKey.DISCIPLINES}:${discipline}|${FilterKey.DELIVERY_METHOD}:${attendance}`;
+                    // Only allow agriculture and applied sciences with online attendance
+                    resultMap.set(key, discipline !== '356' && attendance === 'online');
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await disciplineAttendancePolicy.generateUrls();
+            // Calculate expected URLs: 2 disciplines * 1 attendance (online) * 2 pages = 4 URLs
+            expect(urls).toHaveLength(2);
+            // Verify included disciplines
+            expect(urls).toContain('online/agriculture-forestry');
+            expect(urls).toContain('online/applied-sciences');
+            // Verify excluded disciplines
+            expect(urls).not.toContain('online/computer-science');
+            expect(urls).not.toContain('on-campus/agriculture-forestry');
+            expect(urls).not.toContain('on-campus/applied-sciences');
+            expect(urls).not.toContain('on-campus/computer-science');
+        });
+        it('Should exclude all URLs when all rule checks fail', async () => {
+            // Create a map that returns false for all combinations
+            const resultMap = new Map();
+            for (const discipline of ['54', '12', '356']) {
+                for (const attendance of ['online', 'face2face']) {
+                    const key = `${FilterKey.DISCIPLINES}:${discipline}|${FilterKey.DELIVERY_METHOD}:${attendance}`;
+                    resultMap.set(key, false);
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await disciplineAttendancePolicy.generateUrls();
+            // Should include no URLs
+            expect(urls).toHaveLength(0);
+        });
+        it('Should handle empty discipline fragments', async () => {
+            // Mock the DisciplinePresenter to return empty fragments
+            DisciplinePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue([])
+            });
+            sitemapDependenciesHelper.mockCheckRulesForSitemap();
+            const urls = await disciplineAttendancePolicy.generateUrls();
+            // Should return empty array
+            expect(urls).toHaveLength(0);
+        });
+        it('Should handle empty attendance fragments', async () => {
+            // Mock the AttendancePresenter to return empty fragments
+            AttendancePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue([])
+            });
+            sitemapDependenciesHelper.mockCheckRulesForSitemap();
+            const urls = await disciplineAttendancePolicy.generateUrls();
+            // Should return empty array
+            expect(urls).toHaveLength(0);
+        });
+        it('Should handle performance with large number of discipline combinations', async () => {
+            // Generate larger dataset for testing
+            const largeDisciplineSet = Array.from({ length: 30 }, (_, index) => ({
+                id: `discipline-${index}`,
+                path: `discipline-path-${index}`
+            }));
+            const largeAttendanceSet = Array.from({ length: 2 }, (_, index) => ({
+                id: index === 0 ? 'online' : 'face2face',
+                path: index === 0 ? 'online' : 'on-campus'
+            }));
+            // Override mocks with large datasets
+            DisciplinePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeDisciplineSet)
+            });
+            AttendancePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeAttendanceSet)
+            });
+            // Mock to allow only combinations where discipline index is even and attendance is online
+            const resultMap = new Map();
+            for (let d = 0; d < largeDisciplineSet.length; d++) {
+                for (let a = 0; a < largeAttendanceSet.length; a++) {
+                    const disciplineId = largeDisciplineSet[d].id;
+                    const attendanceId = largeAttendanceSet[a].id;
+                    const key = `${FilterKey.DISCIPLINES}:${disciplineId}|${FilterKey.DELIVERY_METHOD}:${attendanceId}`;
+                    resultMap.set(key, d % 2 === 0 && attendanceId === 'online');
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await disciplineAttendancePolicy.generateUrls();
+            // Calculate expected count: 15 disciplines (even indices) * 1 attendance (online) * 2 pages
+            // = 15 * 1 * 2 = 30 URLs
+            expect(urls).toHaveLength(15);
+            // Test specific items
+            expect(urls).toContain('online/discipline-path-0');
+            expect(urls).toContain('online/discipline-path-2');
+            expect(urls).not.toContain('online/discipline-path-1'); // Odd discipline index
+            expect(urls).not.toContain('on-campus/discipline-path-0'); // Face-to-face attendance
+        });
+    });
+});

package/dist/tests/programmes/policies/DisciplineContinent.test.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/tests/programmes/policies/DisciplineContinent.test.mjs

@@ -0,0 +1,253 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { SitemapDependencies } from '../utils/SitemapDependencies.util.mjs';
+import { DisciplineContinent } from '@/programmes/policies/DisciplineContinent';
+import { PortalType } from '@studyportals/domain-client';
+import { DisciplinePresenter } from '@/presenters/DisciplinePresenter';
+import { ContinentPresenter } from '@/presenters/ContinentPresenter';
+describe('Policy:DisciplineContinent', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let disciplineContinentPolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            disciplineContinentPolicy = new DisciplineContinent(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setResultsCount(10);
+            searchDependenciesHelper.setPageNumber(1);
+            searchDependenciesHelper.setPortalType(PortalType.BACHELOR);
+        });
+        it('Should return true when all conditions are met', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const continentId = '1'; // Europe
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.CONTINENT, [continentId]]
+            ]));
+            const result = await disciplineContinentPolicy.shouldIndex();
+            expect(result).toBe(true);
+        });
+        it('Should return false when multiple disciplines are selected', async () => {
+            const firstDisciplineId = '54'; // Agriculture & Forestry
+            const secondDisciplineId = '12'; // Applied Sciences & Professions
+            const continentId = '9'; // Asia
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [firstDisciplineId, secondDisciplineId]],
+                [FilterKey.CONTINENT, [continentId]]
+            ]));
+            const result = await disciplineContinentPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple continents are selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const firstContinentId = '1'; // Europe
+            const secondContinentId = '9'; // Asia
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.CONTINENT, [firstContinentId, secondContinentId]]
+            ]));
+            const result = await disciplineContinentPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no disciplines are selected', async () => {
+            const continentId = '1'; // Europe
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.CONTINENT, [continentId]]]));
+            const result = await disciplineContinentPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no continents are selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DISCIPLINES, [disciplineId]]]));
+            const result = await disciplineContinentPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const continentId = '10'; // Africa
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.CONTINENT, [continentId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await disciplineContinentPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when number of results is less than 7', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const continentId = '1'; // Europe
+            searchDependenciesHelper.setResultsCount(4);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.CONTINENT, [continentId]]
+            ]));
+            const result = await disciplineContinentPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when page number is higher than 2', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const continentId = '1'; // Europe
+            searchDependenciesHelper.setPageNumber(3);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.CONTINENT, [continentId]]
+            ]));
+            const result = await disciplineContinentPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when portal distance learning', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const continentId = '1'; // Europe
+            searchDependenciesHelper.setPortalType(PortalType.DISTANCE_LEARNING);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.CONTINENT, [continentId]]
+            ]));
+            const result = await disciplineContinentPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateUrls', () => {
+        let sitemapDependenciesHelper;
+        let disciplineContinentPolicy;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setProgrammeCount(10); // More than 7 programs
+            disciplineContinentPolicy = new DisciplineContinent(sitemapDependenciesHelper.dependencies);
+            DisciplinePresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: '54', path: 'agriculture-forestry' },
+                    { id: '12', path: 'applied-sciences' },
+                    { id: '152', path: 'computer-science-it' }
+                ])
+            });
+            ContinentPresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: '1', path: 'europe' },
+                    { id: '9', path: 'asia' },
+                    { id: '10', path: 'africa' },
+                    { id: '4', path: 'north-america' }
+                ])
+            });
+        });
+        afterEach(() => {
+            sitemapDependenciesHelper.resetMocks();
+        });
+        it('Should generate URLs for valid discipline-continent combinations', async () => {
+            // Mock the checkRulesForSitemap to control which combinations pass
+            const resultMap = new Map();
+            // Set up all possible combinations
+            for (const discipline of ['54', '12', '152']) {
+                for (const continent of ['1', '9', '10', '4']) {
+                    const key = `${FilterKey.DISCIPLINES}:${discipline}|${FilterKey.CONTINENT}:${continent}`;
+                    // Allow all valid combinations
+                    resultMap.set(key, true);
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            // Call the method via reflection since it's protected
+            const urls = await disciplineContinentPolicy.generateUrls();
+            // Calculate expected URLs: 3 disciplines * 4 continents * 2 pages = 24 URLs
+            expect(urls).toHaveLength(12);
+            // Verify some valid combinations
+            expect(urls).toContain('agriculture-forestry/europe');
+            expect(urls).toContain('agriculture-forestry/asia');
+            expect(urls).toContain('applied-sciences/africa');
+            expect(urls).toContain('computer-science-it/north-america');
+        });
+        it('Should exclude specific discipline-continent combinations based on rules', async () => {
+            // Create a map that returns false for specific combinations
+            const resultMap = new Map();
+            // Only allow Europe continent, exclude Computer Science discipline
+            for (const discipline of ['54', '12', '152']) {
+                for (const continent of ['1', '9', '10', '4']) {
+                    const key = `${FilterKey.DISCIPLINES}:${discipline}|${FilterKey.CONTINENT}:${continent}`;
+                    // Only Europe continent and not Computer Science discipline should pass
+                    resultMap.set(key, continent === '1' && discipline !== '152');
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await disciplineContinentPolicy.generateUrls();
+            // Calculate expected URLs: 2 disciplines (excluding computer science) * 1 continent (Europe) * 2 pages = 4 URLs
+            expect(urls).toHaveLength(2);
+            // Verify included combinations
+            expect(urls).toContain('agriculture-forestry/europe');
+            expect(urls).toContain('applied-sciences/europe');
+            // Verify excluded combinations
+            expect(urls).not.toContain('computer-science/europe');
+            expect(urls).not.toContain('agriculture-forestry/asia');
+        });
+        it('Should exclude all URLs when all rule checks fail', async () => {
+            // Create a map that returns false for all combinations
+            const resultMap = new Map();
+            for (const discipline of ['54', '12', '152']) {
+                for (const continent of ['1', '9', '10', '4']) {
+                    const key = `${FilterKey.DISCIPLINES}:${discipline}|${FilterKey.CONTINENT}:${continent}`;
+                    resultMap.set(key, false);
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap, false);
+            const urls = await disciplineContinentPolicy.generateUrls();
+            // Should include no URLs
+            expect(urls).toHaveLength(0);
+        });
+        it('Should handle empty discipline fragments', async () => {
+            // Mock the DisciplinePresenter to return empty fragments
+            DisciplinePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue([])
+            });
+            sitemapDependenciesHelper.mockCheckRulesForSitemap();
+            const urls = await disciplineContinentPolicy.generateUrls();
+            // Should return empty array
+            expect(urls).toHaveLength(0);
+        });
+        it('Should handle empty continent fragments', async () => {
+            // Mock the ContinentPresenter to return empty fragments
+            ContinentPresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue([])
+            });
+            sitemapDependenciesHelper.mockCheckRulesForSitemap();
+            const urls = await disciplineContinentPolicy.generateUrls();
+            // Should return empty array
+            expect(urls).toHaveLength(0);
+        });
+        it('Should handle performance with large number of combinations', async () => {
+            // Generate larger datasets for testing
+            const largeDisciplineSet = Array.from({ length: 20 }, (_, index) => ({
+                id: `discipline-${index}`,
+                path: `discipline-path-${index}`
+            }));
+            const largeContinentSet = Array.from({ length: 7 }, (_, index) => ({
+                id: `continent-${index}`,
+                path: `continent-path-${index}`
+            }));
+            // Override mocks with large datasets
+            DisciplinePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeDisciplineSet)
+            });
+            ContinentPresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeContinentSet)
+            });
+            // Mock to only allow combinations where discipline index is even and continent index is less than 5
+            const resultMap = new Map();
+            for (let d = 0; d < largeDisciplineSet.length; d++) {
+                for (let c = 0; c < largeContinentSet.length; c++) {
+                    const disciplineId = largeDisciplineSet[d].id;
+                    const continentId = largeContinentSet[c].id;
+                    const key = `${FilterKey.DISCIPLINES}:${disciplineId}|${FilterKey.CONTINENT}:${continentId}`;
+                    resultMap.set(key, d % 2 === 0 && c < 5);
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await disciplineContinentPolicy.generateUrls();
+            // Calculate expected count: 10 disciplines (even indices) * 5 continents (indices 0-4) * 2 pages
+            // = 10 * 5 * 2 = 100 URLs
+            expect(urls).toHaveLength(50);
+            // Test specific items
+            expect(urls).toContain('discipline-path-0/continent-path-0');
+            expect(urls).toContain('discipline-path-2/continent-path-3');
+            expect(urls).not.toContain('discipline-path-1/continent-path-0'); // Odd discipline
+            expect(urls).not.toContain('discipline-path-0/continent-path-5'); // Continent index >= 5
+        });
+    });
+});

package/dist/tests/programmes/policies/DisciplineCountry.test.d.mts

@@ -0,0 +1 @@
+export {};