@studyportals/fawkes 8.7.0 → 8.7.1-0

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

@@ -0,0 +1,171 @@
+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 { SpecialProgrammes } from '@/programmes/policies/SpecialProgrammes';
+import { PortalType } from '@studyportals/domain-client';
+import { SpecialProgrammesPresenter } from '@/presenters/SpecialProgrammesPresenter';
+describe('Policy:SpecialProgrammes', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let specialProgrammesPolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            specialProgrammesPolicy = new SpecialProgrammes(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setResultsCount(10);
+            searchDependenciesHelper.setPageNumber(1);
+            searchDependenciesHelper.setPortalType(PortalType.SHORT);
+        });
+        it('Should return true when all conditions are met (Erasmus)', async () => {
+            const specialProgramme = 'erasmus';
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.SPECIAL_PROGRAMMES, [specialProgramme]]]));
+            const result = await specialProgrammesPolicy.shouldIndex();
+            expect(result).toBe(true);
+        });
+        it('Should return true when all conditions are met (Joint)', async () => {
+            const specialProgramme = 'joint';
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.SPECIAL_PROGRAMMES, [specialProgramme]]]));
+            const result = await specialProgrammesPolicy.shouldIndex();
+            expect(result).toBe(true);
+        });
+        it('Should return true when all conditions are met (Executive)', async () => {
+            const specialProgramme = 'executive';
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.SPECIAL_PROGRAMMES, [specialProgramme]]]));
+            const result = await specialProgrammesPolicy.shouldIndex();
+            expect(result).toBe(true);
+        });
+        it('Should return false when multiple special programmes are selected', async () => {
+            const firstSpecialProgramme = 'erasmus';
+            const secondSpecialProgramme = 'joint';
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.SPECIAL_PROGRAMMES, [firstSpecialProgramme, secondSpecialProgramme]]]));
+            const result = await specialProgrammesPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no special programmes are selected', async () => {
+            searchDependenciesHelper.setFilterKeyValues(new Map([]));
+            const result = await specialProgrammesPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            const specialProgramme = 'erasmus';
+            const disciplineId = '54'; // Agriculture & Forestry
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.SPECIAL_PROGRAMMES, [specialProgramme]],
+                [FilterKey.DISCIPLINES, [disciplineId]]
+            ]));
+            const result = await specialProgrammesPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when number of results is less than 7', async () => {
+            const specialProgramme = 'erasmus';
+            searchDependenciesHelper.setResultsCount(6);
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.SPECIAL_PROGRAMMES, [specialProgramme]]]));
+            const result = await specialProgrammesPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when page number is higher than 2', async () => {
+            const specialProgramme = 'erasmus';
+            searchDependenciesHelper.setPageNumber(15);
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.SPECIAL_PROGRAMMES, [specialProgramme]]]));
+            const result = await specialProgrammesPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when portal type is distance learning', async () => {
+            const specialProgramme = 'erasmus';
+            searchDependenciesHelper.setPortalType(PortalType.DISTANCE_LEARNING);
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.SPECIAL_PROGRAMMES, [specialProgramme]]]));
+            const result = await specialProgrammesPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateUrls', () => {
+        let sitemapDependenciesHelper;
+        let specialProgrammesPolicy;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setProgrammeCount(10); // More than 7 programs
+            specialProgrammesPolicy = new SpecialProgrammes(sitemapDependenciesHelper.dependencies);
+            SpecialProgrammesPresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: 'erasmus', path: 'erasmus-mundus' },
+                    { id: 'joint', path: 'joint-programmes' },
+                    { id: 'other', path: 'other-programme' }
+                ])
+            });
+        });
+        afterEach(() => {
+            sitemapDependenciesHelper.resetMocks();
+        });
+        it('Should generate URLs for valid special programmes (Erasmus and Joint)', async () => {
+            // Mock the checkRulesForSitemap to only allow Erasmus and Joint programmes
+            // due to ErasmusOrJointSpecialProgrammesRule
+            const resultMap = new Map();
+            // Set up all possible combinations but only allow Erasmus and Joint
+            for (const programme of ['erasmus', 'joint', 'other']) {
+                const key = `${FilterKey.SPECIAL_PROGRAMMES}:${programme}`;
+                // Only Erasmus and Joint should pass
+                resultMap.set(key, programme === 'erasmus' || programme === 'joint');
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            // Call the method via reflection since it's protected
+            const urls = await specialProgrammesPolicy.generateUrls();
+            // Calculate expected URLs: 2 special programmes (Erasmus and Joint) * 2 pages = 4
+            expect(urls).toHaveLength(2);
+            // Verify Erasmus and Joint are included
+            expect(urls).toContain('erasmus-mundus');
+            expect(urls).toContain('joint-programmes');
+            // Verify other programmes are excluded
+            expect(urls).not.toContain('other-programme');
+        });
+        it('Should exclude all special programmes when all rule checks fail', async () => {
+            // Create a map that returns false for all combinations
+            const resultMap = new Map();
+            for (const programme of ['erasmus', 'joint', 'other']) {
+                const key = `${FilterKey.SPECIAL_PROGRAMMES}:${programme}`;
+                resultMap.set(key, false);
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await specialProgrammesPolicy.generateUrls();
+            // Should include no URLs
+            expect(urls).toHaveLength(0);
+        });
+        it('Should handle empty special programmes fragments', async () => {
+            // Mock the SpecialProgrammesPresenter to return empty fragments
+            SpecialProgrammesPresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue([])
+            });
+            sitemapDependenciesHelper.mockCheckRulesForSitemap();
+            const urls = await specialProgrammesPolicy.generateUrls();
+            // Should return empty array
+            expect(urls).toHaveLength(0);
+        });
+        it('Should handle performance with large number of special programmes', async () => {
+            // Generate larger datasets for testing
+            const largeSpecialProgrammeSet = Array.from({ length: 30 }, (_, index) => ({
+                id: `programme-${index}`,
+                path: `programme-path-${index}`
+            }));
+            // Override mocks with large datasets
+            SpecialProgrammesPresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeSpecialProgrammeSet)
+            });
+            // Mock to only allow combinations where the programme index is even
+            // This simulates the ErasmusOrJointSpecialProgrammesRule
+            const resultMap = new Map();
+            for (let p = 0; p < largeSpecialProgrammeSet.length; p++) {
+                const programmeId = largeSpecialProgrammeSet[p].id;
+                const key = `${FilterKey.SPECIAL_PROGRAMMES}:${programmeId}`;
+                resultMap.set(key, p % 2 === 0); // Only even indices pass
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await specialProgrammesPolicy.generateUrls();
+            // Calculate expected count: 15 special programmes (even indices) * 2 pages = 30
+            expect(urls).toHaveLength(15);
+            // Test specific items
+            expect(urls).toContain('programme-path-0'); // Even index
+            expect(urls).toContain('programme-path-2'); // Even index
+            expect(urls).not.toContain('programme-path-1'); // Odd index
+            expect(urls).not.toContain('programme-path-3'); // Odd index
+        });
+    });
+});

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

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

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

@@ -0,0 +1,360 @@
+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 { TuitionFeeAttendanceDiscipline } from '@/programmes/policies/TuitionFeeAttendanceDiscipline';
+import { PortalType } from '@studyportals/domain-client';
+import { DisciplinePresenter } from '@/presenters/DisciplinePresenter';
+import { AttendancePresenter } from '@/presenters/AttendancePresenter';
+import { TuitionFeePresenter } from '@/presenters/TuitionFeePresenter';
+describe('Policy:TuitionFeeAttendanceDiscipline', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let tuitionFeeAttendanceDisciplinePolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            tuitionFeeAttendanceDisciplinePolicy = new TuitionFeeAttendanceDiscipline(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setResultsCount(7);
+            searchDependenciesHelper.setPageNumber(1);
+            searchDependenciesHelper.setPortalType(PortalType.PHD);
+        });
+        it('Should return true when all conditions are met', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const tuitionFee = '[0,2500]'; // Affordable
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await tuitionFeeAttendanceDisciplinePolicy.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 tuitionFee = '[0,2500]'; // Affordable
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [firstDisciplineId, secondDisciplineId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await tuitionFeeAttendanceDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple tuition fee values are selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const firstTuitionFee = '[0,2500]'; // Affordable
+            const secondTuitionFee = '[0,3000]';
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.TUITION_FEE, [firstTuitionFee, secondTuitionFee]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await tuitionFeeAttendanceDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple attendance values are selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const tuitionFee = '[0,2500]'; // Affordable
+            const firstAttendance = 'online';
+            const secondAttendance = 'blended';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]],
+                [FilterKey.DELIVERY_METHOD, [firstAttendance, secondAttendance]]
+            ]));
+            const result = await tuitionFeeAttendanceDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no disciplines are selected', async () => {
+            const tuitionFee = '[0,2500]'; // Affordable
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.TUITION_FEE, [tuitionFee]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await tuitionFeeAttendanceDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no tuition fee value is selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await tuitionFeeAttendanceDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no attendance value is selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const tuitionFee = '[0,2500]'; // Affordable
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]]
+            ]));
+            const result = await tuitionFeeAttendanceDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const tuitionFee = '[0,2500]'; // Affordable
+            const attendance = 'online';
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]],
+                [FilterKey.DELIVERY_METHOD, [attendance]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            const result = await tuitionFeeAttendanceDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when tuition fee is not [0,2500] (affordable)', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const tuitionFee = '[0,3000]';
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await tuitionFeeAttendanceDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when attendance is not online', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const tuitionFee = '[0,2500]';
+            const attendance = 'face2face';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await tuitionFeeAttendanceDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when number of results is less than 7', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const tuitionFee = '[0,2500]'; // Affordable
+            const attendance = 'online';
+            searchDependenciesHelper.setResultsCount(5);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await tuitionFeeAttendanceDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when page number is higher than 2', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const tuitionFee = '[0,2500]'; // Affordable
+            const attendance = 'online';
+            searchDependenciesHelper.setPageNumber(4);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await tuitionFeeAttendanceDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when portal is distance learning', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const tuitionFee = '[0,2500]'; // Affordable
+            const attendance = 'online';
+            searchDependenciesHelper.setPortalType(PortalType.DISTANCE_LEARNING);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await tuitionFeeAttendanceDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateUrls', () => {
+        let sitemapDependenciesHelper;
+        let tuitionFeeAttendanceDisciplinePolicy;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setProgrammeCount(10); // More than 7 programs
+            tuitionFeeAttendanceDisciplinePolicy = new TuitionFeeAttendanceDiscipline(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' }
+                ])
+            });
+            TuitionFeePresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: '[0,2500]', path: 'affordable' },
+                    { id: '[2501,5000]', path: 'moderate' },
+                    { id: '[5001,10000]', path: 'expensive' }
+                ])
+            });
+            AttendancePresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: 'online', path: 'online' },
+                    { id: 'face2face', path: 'on-campus' },
+                    { id: 'blended', path: 'blended' }
+                ])
+            });
+        });
+        afterEach(() => {
+            sitemapDependenciesHelper.resetMocks();
+        });
+        it('Should generate URLs for valid discipline-tuition fee-attendance combinations with affordable tuition fees and online attendance', async () => {
+            // Mock the checkRulesForSitemap to only allow affordable tuition fee options and online attendance
+            // due to AffordableTuitionFeeRule and OnlineAttendanceRule
+            const resultMap = new Map();
+            // Set up all possible combinations but only allow affordable tuition fee and online attendance
+            for (const discipline of ['54', '12', '356']) {
+                for (const attendance of ['online', 'face2face', 'blended']) {
+                    for (const tuitionFee of ['[0,2500]', '[2501,5000]', '[5001,10000]']) {
+                        const key = `${FilterKey.TUITION_FEE}:${tuitionFee}|${FilterKey.DELIVERY_METHOD}:${attendance}|${FilterKey.DISCIPLINES}:${discipline}`;
+                        // Only affordable tuition fee and online attendance should pass
+                        resultMap.set(key, tuitionFee === '[0,2500]' && attendance === 'online');
+                    }
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            // Call the method via reflection since it's protected
+            const urls = await tuitionFeeAttendanceDisciplinePolicy.generateUrls();
+            // Calculate expected URLs: 3 disciplines * 1 tuition fee option (affordable) * 1 attendance (online) * 2 pages
+            expect(urls).toHaveLength(3);
+            // Verify affordable tuition fee and online attendance combinations
+            expect(urls).toContain('affordable/online/agriculture-forestry');
+            expect(urls).toContain('affordable/online/applied-sciences');
+            expect(urls).toContain('affordable/online/computer-science');
+            // Verify non-online attendance or non-affordable tuition fees are excluded
+            expect(urls).not.toContain('affordable/on-campus/agriculture-forestry');
+            expect(urls).not.toContain('moderate/online/agriculture-forestry');
+        });
+        it('Should exclude specific discipline-tuition fee-attendance combinations based on rules', async () => {
+            // Create a map that returns false for specific combinations
+            const resultMap = new Map();
+            // Only allow affordable tuition fee and online attendance, but exclude computer science
+            for (const discipline of ['54', '12', '356']) {
+                for (const attendance of ['online', 'face2face', 'blended']) {
+                    for (const tuitionFee of ['[0,2500]', '[2501,5000]', '[5001,10000]']) {
+                        const key = `${FilterKey.TUITION_FEE}:${tuitionFee}|${FilterKey.DELIVERY_METHOD}:${attendance}|${FilterKey.DISCIPLINES}:${discipline}`;
+                        // Only affordable tuition fee and online attendance should pass and exclude computer science
+                        resultMap.set(key, tuitionFee === '[0,2500]' && attendance === 'online' && discipline !== '356');
+                    }
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await tuitionFeeAttendanceDisciplinePolicy.generateUrls();
+            // Calculate expected URLs: 2 disciplines (excluding computer science) * 1 tuition fee * 1 attendance * 2 pages
+            // = 2 * 1 * 1 * 2 = 4 URLs
+            expect(urls).toHaveLength(2);
+            // Verify excluded combinations
+            expect(urls).not.toContain('affordable/online/computer-science');
+            // Verify included combinations
+            expect(urls).toContain('affordable/online/agriculture-forestry');
+            expect(urls).toContain('affordable/online/applied-sciences');
+        });
+        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', 'blended']) {
+                    for (const tuitionFee of ['[0,2500]', '[2501,5000]', '[5001,10000]']) {
+                        const key = `${FilterKey.TUITION_FEE}:${tuitionFee}|${FilterKey.DELIVERY_METHOD}:${attendance}|${FilterKey.DISCIPLINES}:${discipline}`;
+                        resultMap.set(key, false);
+                    }
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await tuitionFeeAttendanceDisciplinePolicy.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 tuitionFeeAttendanceDisciplinePolicy.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 tuitionFeeAttendanceDisciplinePolicy.generateUrls();
+            // Should return empty array
+            expect(urls).toHaveLength(0);
+        });
+        it('Should handle empty tuition fee fragments', async () => {
+            // Mock the TuitionFeePresenter to return empty fragments
+            TuitionFeePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue([])
+            });
+            sitemapDependenciesHelper.mockCheckRulesForSitemap();
+            const urls = await tuitionFeeAttendanceDisciplinePolicy.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: 10 }, (_, index) => ({
+                id: `discipline-${index}`,
+                path: `discipline-path-${index}`
+            }));
+            const largeAttendanceSet = Array.from({ length: 3 }, (_, index) => ({
+                id: `attendance-${index}`,
+                path: `attendance-path-${index}`
+            }));
+            const largeTuitionFeeSet = Array.from({ length: 3 }, (_, index) => ({
+                id: `tuition-${index}`,
+                path: `tuition-path-${index}`
+            }));
+            // Override mocks with large datasets
+            DisciplinePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeDisciplineSet)
+            });
+            AttendancePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeAttendanceSet)
+            });
+            TuitionFeePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeTuitionFeeSet)
+            });
+            // Mock to only allow combinations where discipline index is even, attendance index is 0 (online),
+            // and tuition fee index is 0 (affordable)
+            const resultMap = new Map();
+            for (let d = 0; d < largeDisciplineSet.length; d++) {
+                for (let a = 0; a < largeAttendanceSet.length; a++) {
+                    for (let t = 0; t < largeTuitionFeeSet.length; t++) {
+                        const disciplineId = largeDisciplineSet[d].id;
+                        const attendanceId = largeAttendanceSet[a].id;
+                        const tuitionFeeId = largeTuitionFeeSet[t].id;
+                        const key = `${FilterKey.TUITION_FEE}:${tuitionFeeId}|${FilterKey.DELIVERY_METHOD}:${attendanceId}|${FilterKey.DISCIPLINES}:${disciplineId}`;
+                        resultMap.set(key, d % 2 === 0 && a === 0 && t === 0); // Even disciplines, online attendance, affordable tuition
+                    }
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await tuitionFeeAttendanceDisciplinePolicy.generateUrls();
+            // Calculate expected count: 5 disciplines (even indices) * 1 attendance (index 0) * 1 tuition fee (index 0) * 2 pages
+            // = 5 * 1 * 1 * 2 = 10 URLs
+            expect(urls).toHaveLength(5);
+            // Test specific items
+            expect(urls).toContain('tuition-path-0/attendance-path-0/discipline-path-0'); // Even discipline, online, affordable
+            expect(urls).toContain('tuition-path-0/attendance-path-0/discipline-path-2'); // Even discipline, online, affordable
+            expect(urls).not.toContain('tuition-path-0/attendance-path-0/discipline-path-1'); // Odd discipline
+            expect(urls).not.toContain('tuition-path-0/attendance-path-1/discipline-path-0'); // Non-online attendance
+            expect(urls).not.toContain('tuition-path-1/attendance-path-0/discipline-path-0'); // Non-affordable tuition
+        });
+    });
+});

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

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