@studyportals/fawkes 8.7.0 → 8.7.1-0

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

@@ -0,0 +1,273 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { PortalType } from '@studyportals/domain-client';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { SitemapDependencies } from '../utils/SitemapDependencies.util.mjs';
+import { DisciplineDegree } from '@/programmes/policies/DisciplineDegree';
+import { DisciplinePresenter } from '@/presenters/DisciplinePresenter';
+import { DegreePresenter } from '@/presenters/DegreePresenter';
+describe('Policy:DisciplineDegree', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let disciplineDegreePolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            disciplineDegreePolicy = new DisciplineDegree(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setResultsCount(7);
+            searchDependenciesHelper.setPageNumber(1);
+            searchDependenciesHelper.setPortalType(PortalType.BACHELOR);
+        });
+        it('Should return true when all conditions are met', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const degreeType = 'msc';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.DEGREE_TYPE, [degreeType]]
+            ]));
+            const result = await disciplineDegreePolicy.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 degreeType = 'mphil';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [firstDisciplineId, secondDisciplineId]],
+                [FilterKey.DEGREE_TYPE, [degreeType]]
+            ]));
+            const result = await disciplineDegreePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple degrees are selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const firstDegreeType = 'ma';
+            const secondDegreeType = 'meng';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.DEGREE_TYPE, [firstDegreeType, secondDegreeType]]
+            ]));
+            const result = await disciplineDegreePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no disciplines are selected', async () => {
+            const degreeType = 'msc';
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DEGREE_TYPE, [degreeType]]]));
+            const result = await disciplineDegreePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no degree is selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DISCIPLINES, [disciplineId]]]));
+            const result = await disciplineDegreePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const countryId = '30'; // UK
+            const degreeType = 'ma';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.DEGREE_TYPE, [degreeType]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            const result = await disciplineDegreePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when degree is not indexable', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const degreeType = 'adiploma';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.DEGREE_TYPE, [degreeType]]
+            ]));
+            const result = await disciplineDegreePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when number of results is less than 7', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const degreeType = 'msc';
+            searchDependenciesHelper.setResultsCount(6);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.DEGREE_TYPE, [degreeType]]
+            ]));
+            const result = await disciplineDegreePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when page number is higher than 2', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const degreeType = 'msc';
+            searchDependenciesHelper.setPageNumber(8);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.DEGREE_TYPE, [degreeType]]
+            ]));
+            const result = await disciplineDegreePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when portal type is distance learning', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const degreeType = 'msc';
+            searchDependenciesHelper.setPortalType(PortalType.DISTANCE_LEARNING);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.DEGREE_TYPE, [degreeType]]
+            ]));
+            const result = await disciplineDegreePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateUrls', () => {
+        let sitemapDependenciesHelper;
+        let disciplineDegreePolicy;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setProgrammeCount(10); // More than 7 programs
+            disciplineDegreePolicy = new DisciplineDegree(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' }
+                ])
+            });
+            DegreePresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: 'msc', path: 'msc' },
+                    { id: 'mba', path: 'mba' },
+                    { id: 'msc', path: 'masters' },
+                    { id: 'bachelor', path: 'bachelors' },
+                    { id: 'adiploma', path: 'associate-degree' }
+                ])
+            });
+        });
+        afterEach(() => {
+            sitemapDependenciesHelper.resetMocks();
+        });
+        it('Should generate URLs for valid discipline-degree combinations with indexable degrees', async () => {
+            // Mock the checkRulesForSitemap to only allow indexable degrees
+            // due to IndexableDegreeRule
+            const resultMap = new Map();
+            // Set up all possible combinations but only allow indexable degrees
+            for (const discipline of ['54', '12', '356']) {
+                for (const degree of ['msc', 'mba', 'msc', 'bachelor', 'adiploma']) {
+                    const key = `${FilterKey.DISCIPLINES}:${discipline}|${FilterKey.DEGREE_TYPE}:${degree}`;
+                    // Only these degrees should pass (exclude associate degree)
+                    resultMap.set(key, ['msc', 'mba', 'msc', 'bachelor'].includes(degree));
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            // Call the method via reflection since it's protected
+            const urls = await disciplineDegreePolicy.generateUrls();
+            // Calculate expected URLs: 3 disciplines * 4 indexable degrees * 2 pages = 24 URLs
+            expect(urls).toHaveLength(12);
+            // Verify indexable degree combinations
+            expect(urls).toContain('msc/agriculture-forestry');
+            expect(urls).toContain('mba/agriculture-forestry');
+            expect(urls).toContain('masters/agriculture-forestry');
+            expect(urls).toContain('bachelors/agriculture-forestry');
+            expect(urls).toContain('msc/applied-sciences');
+            expect(urls).toContain('msc/computer-science');
+            // Verify non-indexable degrees are excluded
+            expect(urls).not.toContain('associate-degree/agriculture-forestry');
+            expect(urls).not.toContain('associate-degree/applied-sciences');
+            expect(urls).not.toContain('associate-degree/computer-science');
+        });
+        it('Should exclude specific discipline-degree combinations based on rules', async () => {
+            // Create a map that returns false for specific combinations
+            const resultMap = new Map();
+            // Only allow indexable degrees, but exclude computer science
+            for (const discipline of ['54', '12', '356']) {
+                for (const degree of ['msc', 'mba', 'msc', 'bachelor', 'adiploma']) {
+                    const key = `${FilterKey.DISCIPLINES}:${discipline}|${FilterKey.DEGREE_TYPE}:${degree}`;
+                    // Only indexable degrees should pass and exclude computer science
+                    resultMap.set(key, ['msc', 'mba', 'msc', 'bachelor'].includes(degree) && discipline !== '356');
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await disciplineDegreePolicy.generateUrls();
+            // Calculate expected URLs: 2 disciplines (excluding computer science) * 4 indexable degrees * 2 pages = 16 URLs
+            expect(urls).toHaveLength(8);
+            // Verify excluded combinations
+            expect(urls).not.toContain('msc/computer-science');
+            expect(urls).not.toContain('mba/computer-science');
+            expect(urls).not.toContain('bachelors/computer-science');
+            // Verify included combinations
+            expect(urls).toContain('msc/agriculture-forestry');
+            expect(urls).toContain('msc/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 degree of ['msc', 'mba', 'msc', 'bachelor', 'adiploma']) {
+                    const key = `${FilterKey.DISCIPLINES}:${discipline}|${FilterKey.DEGREE_TYPE}:${degree}`;
+                    resultMap.set(key, false);
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await disciplineDegreePolicy.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 disciplineDegreePolicy.generateUrls();
+            // Should return empty array
+            expect(urls).toHaveLength(0);
+        });
+        it('Should handle empty degree fragments', async () => {
+            // Mock the DegreePresenter to return empty fragments
+            DegreePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue([])
+            });
+            sitemapDependenciesHelper.mockCheckRulesForSitemap();
+            const urls = await disciplineDegreePolicy.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 largeDegreeSet = Array.from({ length: 8 }, (_, index) => ({
+                id: `degree-${index}`,
+                path: `degree-path-${index}`
+            }));
+            // Override mocks with large datasets
+            DisciplinePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeDisciplineSet)
+            });
+            DegreePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeDegreeSet)
+            });
+            // Mock to only allow combinations where discipline index is even and degree index is 0-4
+            // This simulates the IndexableDegreeRule that only allows certain degrees
+            const resultMap = new Map();
+            for (let d = 0; d < largeDisciplineSet.length; d++) {
+                for (let deg = 0; deg < largeDegreeSet.length; deg++) {
+                    const disciplineId = largeDisciplineSet[d].id;
+                    const degreeId = largeDegreeSet[deg].id;
+                    const key = `${FilterKey.DISCIPLINES}:${disciplineId}|${FilterKey.DEGREE_TYPE}:${degreeId}`;
+                    resultMap.set(key, d % 2 === 0 && deg <= 4); // Only even disciplines and indexable degrees (0-4)
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await disciplineDegreePolicy.generateUrls();
+            // Calculate expected count: 10 disciplines (even indices) * 5 degrees (indices 0-4) * 2 pages
+            // = 10 * 5 * 2 = 100 URLs
+            expect(urls).toHaveLength(50);
+            // Test specific items
+            expect(urls).toContain('degree-path-0/discipline-path-0'); // Even discipline, indexable degree
+            expect(urls).toContain('degree-path-4/discipline-path-2'); // Even discipline, indexable degree
+            expect(urls).not.toContain('degree-path-0/discipline-path-1'); // Odd discipline
+            expect(urls).not.toContain('degree-path-5/discipline-path-0'); // Non-indexable degree
+        });
+    });
+});

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

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

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

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

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

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