@studyportals/fawkes 8.7.0 → 8.7.1-0

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

@@ -0,0 +1,302 @@
+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 { DisciplineEducationalForm } from '@/programmes/policies/DisciplineEducationalForm';
+import { PortalType } from '@studyportals/domain-client';
+import { DisciplinePresenter } from '@/presenters/DisciplinePresenter';
+import { EducationalFormPresenter } from '@/presenters/EducationalFormPresenter';
+describe('Policy:DisciplineEducationalForm', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let disciplineEducationalFormPolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            disciplineEducationalFormPolicy = new DisciplineEducationalForm(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setResultsCount(7);
+            searchDependenciesHelper.setPageNumber(1);
+            searchDependenciesHelper.setPortalType(PortalType.SHORT);
+        });
+        it('Should return true when all conditions are met (academic)', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const educationalForm = 'academic';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.EDUCATIONAL_FORM, [educationalForm]]
+            ]));
+            const result = await disciplineEducationalFormPolicy.shouldIndex();
+            expect(result).toBe(true);
+        });
+        it('Should return true when all conditions are met (Summer School)', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const educationalForm = 'summer_school';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.EDUCATIONAL_FORM, [educationalForm]]
+            ]));
+            const result = await disciplineEducationalFormPolicy.shouldIndex();
+            expect(result).toBe(true);
+        });
+        it('Should return true when all conditions are met (Semester)', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const educationalForm = 'semester';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.EDUCATIONAL_FORM, [educationalForm]]
+            ]));
+            const result = await disciplineEducationalFormPolicy.shouldIndex();
+            expect(result).toBe(true);
+        });
+        it('Should return true when all conditions are met (Skill)', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const educationalForm = 'skill';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.EDUCATIONAL_FORM, [educationalForm]]
+            ]));
+            const result = await disciplineEducationalFormPolicy.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 educationalForm = 'academic';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [firstDisciplineId, secondDisciplineId]],
+                [FilterKey.EDUCATIONAL_FORM, [educationalForm]]
+            ]));
+            const result = await disciplineEducationalFormPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple educational form values are selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const firstEducationalForm = 'academic';
+            const secondEducationaForm = 'skill';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.EDUCATIONAL_FORM, [firstEducationalForm, secondEducationaForm]]
+            ]));
+            const result = await disciplineEducationalFormPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no disciplines are selected', async () => {
+            const educationalForm = 'academic';
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.EDUCATIONAL_FORM, [educationalForm]]]));
+            const result = await disciplineEducationalFormPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no educational form value is selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DISCIPLINES, [disciplineId]]]));
+            const result = await disciplineEducationalFormPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const educationalForm = 'academic';
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.EDUCATIONAL_FORM, [educationalForm]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            const result = await disciplineEducationalFormPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when educational form is not indexable (i.e. Winter School)', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const educationalForm = 'winter_school';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.EDUCATIONAL_FORM, [educationalForm]]
+            ]));
+            const result = await disciplineEducationalFormPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when number of results is less than 7', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const educationalForm = 'academic';
+            searchDependenciesHelper.setResultsCount(5);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.EDUCATIONAL_FORM, [educationalForm]]
+            ]));
+            const result = await disciplineEducationalFormPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when page number is higher than 2', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const educationalForm = 'academic';
+            searchDependenciesHelper.setPageNumber(13);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.EDUCATIONAL_FORM, [educationalForm]]
+            ]));
+            const result = await disciplineEducationalFormPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false portal type is distance learning', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const educationalForm = 'academic';
+            searchDependenciesHelper.setPortalType(PortalType.DISTANCE_LEARNING);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.EDUCATIONAL_FORM, [educationalForm]]
+            ]));
+            const result = await disciplineEducationalFormPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateUrls', () => {
+        let sitemapDependenciesHelper;
+        let disciplineEducationalFormPolicy;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setProgrammeCount(10); // More than 7 programs
+            disciplineEducationalFormPolicy = new DisciplineEducationalForm(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' }
+                ])
+            });
+            EducationalFormPresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: 'academic', path: 'academic' },
+                    { id: 'summer_school', path: 'summer-courses' },
+                    { id: 'semester', path: 'semester' },
+                    { id: 'skill', path: 'professional-courses' },
+                    { id: 'winter_school', path: 'winter-courses' }
+                ])
+            });
+        });
+        afterEach(() => {
+            sitemapDependenciesHelper.resetMocks();
+        });
+        it('Should generate URLs for valid discipline-educational form combinations with indexable educational forms', async () => {
+            // Mock the checkRulesForSitemap to only allow indexable educational forms
+            // due to IndexableEducationalFormRule
+            const resultMap = new Map();
+            // Set up all possible combinations but only allow indexable educational forms
+            for (const discipline of ['54', '12', '356']) {
+                for (const form of ['academic', 'summer_school', 'semester', 'skill', 'winter_school']) {
+                    const key = `${FilterKey.DISCIPLINES}:${discipline}|${FilterKey.EDUCATIONAL_FORM}:${form}`;
+                    // Only these educational forms should pass (exclude winter_school)
+                    resultMap.set(key, ['academic', 'summer_school', 'semester', 'skill'].includes(form));
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            // Call the method via reflection since it's protected
+            const urls = await disciplineEducationalFormPolicy.generateUrls();
+            // Calculate expected URLs: 3 disciplines * 4 indexable educational forms * 2 pages = 24 URLs
+            expect(urls).toHaveLength(12);
+            // Verify indexable educational form combinations
+            expect(urls).toContain('agriculture-forestry/academic');
+            expect(urls).toContain('agriculture-forestry/summer-courses');
+            expect(urls).toContain('agriculture-forestry/semester');
+            expect(urls).toContain('agriculture-forestry/professional-courses');
+            expect(urls).toContain('applied-sciences/academic');
+            expect(urls).toContain('computer-science/academic');
+            // Verify non-indexable educational forms are excluded
+            expect(urls).not.toContain('agriculture-forestry/winter-courses');
+            expect(urls).not.toContain('applied-sciences/winter-courses');
+            expect(urls).not.toContain('computer-science/winter-courses');
+        });
+        it('Should exclude specific discipline-educational form combinations based on rules', async () => {
+            // Create a map that returns false for specific combinations
+            const resultMap = new Map();
+            // Only allow indexable forms, but exclude computer science
+            for (const discipline of ['54', '12', '356']) {
+                for (const form of ['academic', 'summer_school', 'semester', 'skill', 'winter_school']) {
+                    const key = `${FilterKey.DISCIPLINES}:${discipline}|${FilterKey.EDUCATIONAL_FORM}:${form}`;
+                    // Only indexable forms should pass and exclude computer science
+                    resultMap.set(key, ['academic', 'summer_school', 'semester', 'skill'].includes(form) && discipline !== '356');
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await disciplineEducationalFormPolicy.generateUrls();
+            // Calculate expected URLs: 2 disciplines (excluding computer science) * 4 indexable forms * 2 pages = 16 URLs
+            expect(urls).toHaveLength(8);
+            // Verify excluded combinations
+            expect(urls).not.toContain('computer-science/academic');
+            expect(urls).not.toContain('computer-science/summer-courses');
+            // Verify included combinations
+            expect(urls).toContain('agriculture-forestry/academic');
+            expect(urls).toContain('applied-sciences/academic');
+        });
+        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 form of ['academic', 'summer_school', 'semester', 'skill', 'winter_school']) {
+                    const key = `${FilterKey.DISCIPLINES}:${discipline}|${FilterKey.EDUCATIONAL_FORM}:${form}`;
+                    resultMap.set(key, false);
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await disciplineEducationalFormPolicy.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 disciplineEducationalFormPolicy.generateUrls();
+            // Should return empty array
+            expect(urls).toHaveLength(0);
+        });
+        it('Should handle empty educational form fragments', async () => {
+            // Mock the EducationalFormPresenter to return empty fragments
+            EducationalFormPresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue([])
+            });
+            sitemapDependenciesHelper.mockCheckRulesForSitemap();
+            const urls = await disciplineEducationalFormPolicy.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 largeEducationalFormSet = Array.from({ length: 6 }, (_, index) => ({
+                id: `form-${index}`,
+                path: `form-path-${index}`
+            }));
+            // Override mocks with large datasets
+            DisciplinePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeDisciplineSet)
+            });
+            EducationalFormPresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeEducationalFormSet)
+            });
+            // Mock to only allow combinations where discipline index is even and educational form index is 0-3
+            // This simulates the IndexableEducationalFormRule that only allows certain educational forms
+            const resultMap = new Map();
+            for (let d = 0; d < largeDisciplineSet.length; d++) {
+                for (let f = 0; f < largeEducationalFormSet.length; f++) {
+                    const disciplineId = largeDisciplineSet[d].id;
+                    const formId = largeEducationalFormSet[f].id;
+                    const key = `${FilterKey.DISCIPLINES}:${disciplineId}|${FilterKey.EDUCATIONAL_FORM}:${formId}`;
+                    resultMap.set(key, d % 2 === 0 && f <= 3); // Only even disciplines and indexable forms (0-3)
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await disciplineEducationalFormPolicy.generateUrls();
+            // Calculate expected count: 10 disciplines (even indices) * 4 educational forms (indices 0-3) * 2 pages
+            // = 10 * 4 * 2 = 80 URLs
+            expect(urls).toHaveLength(40);
+            // Test specific items
+            expect(urls).toContain('discipline-path-0/form-path-0'); // Even discipline, indexable form
+            expect(urls).toContain('discipline-path-2/form-path-3'); // Even discipline, indexable form
+            expect(urls).not.toContain('discipline-path-1/form-path-0'); // Odd discipline
+            expect(urls).not.toContain('discipline-path-0/form-path-4'); // Non-indexable form
+        });
+    });
+});

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

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

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

@@ -0,0 +1,266 @@
+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 { DisciplineFormat } from '@/programmes/policies/DisciplineFormat';
+import { PortalType } from '@studyportals/domain-client';
+import { DisciplinePresenter } from '@/presenters/DisciplinePresenter';
+import { FormatPresenter } from '@/presenters/FormatPresenter';
+describe('Policy:DisciplineFormat', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let disciplineFormatPolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            disciplineFormatPolicy = new DisciplineFormat(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setResultsCount(7);
+            searchDependenciesHelper.setPageNumber(1);
+            searchDependenciesHelper.setPortalType(PortalType.MASTER);
+        });
+        it('Should return true when all conditions are met', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const format = 'parttime';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.ATTENDANCE, [format]]
+            ]));
+            const result = await disciplineFormatPolicy.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 format = 'parttime';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [firstDisciplineId, secondDisciplineId]],
+                [FilterKey.ATTENDANCE, [format]]
+            ]));
+            const result = await disciplineFormatPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple format values are selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const firstFormat = 'parttime';
+            const secondFormat = 'fulltime';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.ATTENDANCE, [firstFormat, secondFormat]]
+            ]));
+            const result = await disciplineFormatPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no disciplines are selected', async () => {
+            const format = 'parttime';
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.ATTENDANCE, [format]]]));
+            const result = await disciplineFormatPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no format value is selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DISCIPLINES, [disciplineId]]]));
+            const result = await disciplineFormatPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const format = 'parttime';
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.ATTENDANCE, [format]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            const result = await disciplineFormatPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when format is not part-time', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const format = 'fulltime';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.ATTENDANCE, [format]]
+            ]));
+            const result = await disciplineFormatPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when number of results is less than 7', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const format = 'parttime';
+            searchDependenciesHelper.setResultsCount(5);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.ATTENDANCE, [format]]
+            ]));
+            const result = await disciplineFormatPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when page number is higher than 2', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const format = 'parttime';
+            searchDependenciesHelper.setPageNumber(16);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.ATTENDANCE, [format]]
+            ]));
+            const result = await disciplineFormatPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when portal is distance learning', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const format = 'parttime';
+            searchDependenciesHelper.setPortalType(PortalType.DISTANCE_LEARNING);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.ATTENDANCE, [format]]
+            ]));
+            const result = await disciplineFormatPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateUrls', () => {
+        let sitemapDependenciesHelper;
+        let disciplineFormatPolicy;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setProgrammeCount(10); // More than 7 programs
+            disciplineFormatPolicy = new DisciplineFormat(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' }
+                ])
+            });
+            FormatPresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: 'parttime', path: 'part-time' },
+                    { id: 'fulltime', path: 'full-time' }
+                ])
+            });
+        });
+        afterEach(() => {
+            sitemapDependenciesHelper.resetMocks();
+        });
+        it('Should generate URLs for valid discipline-format combinations with part-time format', async () => {
+            // Mock the checkRulesForSitemap to only allow part-time format options
+            // due to PartTimeFormatRule
+            const resultMap = new Map();
+            // Set up all possible combinations but only allow part-time format
+            for (const discipline of ['54', '12', '356']) {
+                for (const format of ['parttime', 'fulltime']) {
+                    const key = `${FilterKey.DISCIPLINES}:${discipline}|${FilterKey.ATTENDANCE}:${format}`;
+                    // Only part-time format should pass
+                    resultMap.set(key, format === 'parttime');
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            // Call the method via reflection since it's protected
+            const urls = await disciplineFormatPolicy.generateUrls();
+            // Calculate expected URLs: 3 disciplines * 1 format option (part-time) * 2 page size = 6 URLs
+            expect(urls).toHaveLength(3);
+            // Verify part-time format combinations
+            expect(urls).toContain('part-time/agriculture-forestry');
+            expect(urls).toContain('part-time/applied-sciences');
+            expect(urls).toContain('part-time/computer-science');
+            // Verify full-time format is excluded
+            expect(urls).not.toContain('full-time/agriculture-forestry');
+            expect(urls).not.toContain('full-time/applied-sciences');
+            expect(urls).not.toContain('full-time/computer-science');
+        });
+        it('Should exclude specific discipline-format combinations based on rules', async () => {
+            // Create a map that returns false for specific combinations
+            const resultMap = new Map();
+            // Only allow part-time format, but exclude computer science
+            for (const discipline of ['54', '12', '356']) {
+                for (const format of ['parttime', 'fulltime']) {
+                    const key = `${FilterKey.DISCIPLINES}:${discipline}|${FilterKey.ATTENDANCE}:${format}`;
+                    // Only part-time format should pass and exclude computer science
+                    resultMap.set(key, format === 'parttime' && discipline !== '356');
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await disciplineFormatPolicy.generateUrls();
+            // Calculate expected URLs: 2 disciplines (excluding computer science) * 1 format option * 2 page number = 4 URLs
+            expect(urls).toHaveLength(2);
+            // Verify excluded combinations
+            expect(urls).not.toContain('part-time/computer-science');
+            expect(urls).not.toContain('full-time/computer-science');
+            // Verify included combinations
+            expect(urls).toContain('part-time/agriculture-forestry');
+            expect(urls).toContain('part-time/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 format of ['parttime', 'fulltime']) {
+                    const key = `${FilterKey.DISCIPLINES}:${discipline}|${FilterKey.ATTENDANCE}:${format}`;
+                    resultMap.set(key, false);
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await disciplineFormatPolicy.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 disciplineFormatPolicy.generateUrls();
+            // Should return empty array
+            expect(urls).toHaveLength(0);
+        });
+        it('Should handle empty format fragments', async () => {
+            // Mock the FormatPresenter to return empty fragments
+            FormatPresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue([])
+            });
+            sitemapDependenciesHelper.mockCheckRulesForSitemap();
+            const urls = await disciplineFormatPolicy.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: 30 }, (_, index) => ({
+                id: `discipline-${index}`,
+                path: `discipline-path-${index}`
+            }));
+            const largeFormatSet = Array.from({ length: 3 }, (_, index) => ({
+                id: `format-${index}`,
+                path: `format-path-${index}`
+            }));
+            // Override mocks with large datasets
+            DisciplinePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeDisciplineSet)
+            });
+            FormatPresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeFormatSet)
+            });
+            // Mock to only allow combinations where discipline index is even and format index is 0
+            // This simulates the PartTimeFormatRule that only allows part-time (first) format
+            const resultMap = new Map();
+            for (let d = 0; d < largeDisciplineSet.length; d++) {
+                for (let f = 0; f < largeFormatSet.length; f++) {
+                    const disciplineId = largeDisciplineSet[d].id;
+                    const formatId = largeFormatSet[f].id;
+                    const key = `${FilterKey.DISCIPLINES}:${disciplineId}|${FilterKey.ATTENDANCE}:${formatId}`;
+                    resultMap.set(key, d % 2 === 0 && f === 0); // Only even disciplines and part-time (index 0) format
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await disciplineFormatPolicy.generateUrls();
+            // Calculate expected count: 15 disciplines (even indices) * 1 format (index 0) * 2 page size
+            // = 15 * 1 * 2 = 30  URLs
+            expect(urls).toHaveLength(15);
+            // Test specific items
+            expect(urls).toContain('format-path-0/discipline-path-0'); // Even discipline, part-time format
+            expect(urls).toContain('format-path-0/discipline-path-2'); // Even discipline, part-time format
+            expect(urls).not.toContain('format-path-0/discipline-path-1'); // Odd discipline
+            expect(urls).not.toContain('format-path-1/discipline-path-0'); // Non-part-time format
+        });
+    });
+});

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

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