@studyportals/fawkes 8.7.0 → 8.7.1-0

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

@@ -0,0 +1,234 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { CountryDuration } from '@/programmes/policies/CountryDuration';
+import { PortalType } from '@studyportals/domain-client';
+import { SitemapDependencies } from '../utils/SitemapDependencies.util.mjs';
+import { CountryPresenter } from '@/presenters/CountryPresenter';
+import { DurationPresenter } from '@/presenters/DurationPresenter';
+describe('Policy:CountryDuration', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let countryDurationPolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            countryDurationPolicy = new CountryDuration(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setResultsCount(10);
+            searchDependenciesHelper.setPageNumber(1);
+            searchDependenciesHelper.setPortalType(PortalType.BACHELOR);
+        });
+        it('Should return true when all conditions are met', async () => {
+            const countryId = '30'; // UK
+            const duration = '[360,360]'; // 1 year
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DURATION, [duration]]
+            ]));
+            const result = await countryDurationPolicy.shouldIndex();
+            expect(result).toBe(true);
+        });
+        it('Should return false when multiple countries are selected', async () => {
+            const firstCountryId = '30'; // UK
+            const secondCountryId = '21'; // Portugal
+            const duration = '[360,360]'; // 1 year
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [firstCountryId, secondCountryId]],
+                [FilterKey.DURATION, [duration]]
+            ]));
+            const result = await countryDurationPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple duration values are selected', async () => {
+            const countryId = '30'; // UK
+            const firstDuration = '[360,360]'; // 1 year
+            const secondDuration = '[720,720]'; // 2 years
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DURATION, [firstDuration, secondDuration]]
+            ]));
+            const result = await countryDurationPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no duration values are selected', async () => {
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [countryId]]]));
+            const result = await countryDurationPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no countries are selected', async () => {
+            const duration = '[360,360]'; // 1 year
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DURATION, [duration]]]));
+            const result = await countryDurationPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            const countryId = '30'; // UK
+            const duration = '[360,360]'; // 1 year
+            const disciplineId = '54'; // Agriculture & Forestry
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DURATION, [duration]],
+                [FilterKey.DISCIPLINES, [disciplineId]]
+            ]));
+            const result = await countryDurationPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when duration is not indexable (i.e. 2 years)', async () => {
+            const countryId = '30'; // UK
+            const duration = '[720,720]'; // 2 years
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DURATION, [duration]]
+            ]));
+            const result = await countryDurationPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when number of results is less than 7', async () => {
+            const countryId = '30'; // UK
+            const duration = '[360,360]'; // 1 year
+            searchDependenciesHelper.setResultsCount(6);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DURATION, [duration]]
+            ]));
+            const result = await countryDurationPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when page number is higher than 2', async () => {
+            const countryId = '30'; // UK
+            const duration = '[360,360]'; // 1 year
+            searchDependenciesHelper.setPageNumber(4);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DURATION, [duration]]
+            ]));
+            const result = await countryDurationPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when portal is distance learning', async () => {
+            const countryId = '30'; // UK
+            const duration = '[360,360]'; // 1 year
+            searchDependenciesHelper.setPortalType(PortalType.DISTANCE_LEARNING);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DURATION, [duration]]
+            ]));
+            const result = await countryDurationPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateUrls', () => {
+        let sitemapDependenciesHelper;
+        let countryDurationPolicy;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setProgrammeCount(10); // More than 7 programs
+            countryDurationPolicy = new CountryDuration(sitemapDependenciesHelper.dependencies);
+            CountryPresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: '30', path: 'uk' },
+                    { id: '202', path: 'australia' },
+                    { id: '56', path: 'usa' }
+                ])
+            });
+            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' } // Non-indexable duration
+                ])
+            });
+        });
+        afterEach(() => {
+            sitemapDependenciesHelper.resetMocks();
+        });
+        it('Should generate URLs for valid country-duration combinations', async () => {
+            // Mock the checkRulesForSitemap to filter out non-indexable durations for all countries
+            const resultMap = new Map();
+            // Set up all possible combinations - only [360,360] (1-year) is allowed by the policy
+            for (const country of ['30', '202', '56']) {
+                for (const duration of ['[360,360]', '[720,720]', '[1080,1080]', '[1440,1440]', '[-1,719]']) {
+                    const key = `${FilterKey.COUNTRY}:${country}|${FilterKey.DURATION}:${duration}`;
+                    // Only [360,360] should be allowed by the policy's allowedDurationIds
+                    resultMap.set(key, duration === '[360,360]');
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            // Call the method via reflection since it's protected
+            const urls = await countryDurationPolicy.generateUrls();
+            // Calculate expected URLs: 3 countries * 1 duration ([360,360] only) * 1 page = 3 URLs
+            expect(urls).toHaveLength(3);
+            // Verify paths structure
+            expect(urls).toContain('1-year/uk');
+            expect(urls).toContain('1-year/australia');
+            expect(urls).toContain('1-year/usa');
+            // Verify other durations are excluded
+            expect(urls).not.toContain('2-years/uk');
+            expect(urls).not.toContain('3-years/uk');
+            expect(urls).not.toContain('4-years/uk');
+            expect(urls).not.toContain('less-than-2-years/uk');
+        });
+        it('Should exclude specific country-duration combinations based on rules', async () => {
+            // Create a map that returns false for specific combinations
+            const resultMap = new Map();
+            // Only [360,360] is allowed by policy, but we can exclude specific countries
+            for (const country of ['30', '202', '56']) {
+                for (const duration of ['[360,360]', '[720,720]', '[1080,1080]', '[1440,1440]', '[-1,719]']) {
+                    const key = `${FilterKey.COUNTRY}:${country}|${FilterKey.DURATION}:${duration}`;
+                    // Only [360,360] is allowed and exclude UK (30) for testing
+                    const shouldPass = duration === '[360,360]' && country !== '30';
+                    resultMap.set(key, shouldPass);
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await countryDurationPolicy.generateUrls();
+            // Calculate expected URLs: 2 countries (excluding UK) * 1 duration ([360,360]) = 2 URLs
+            expect(urls).toHaveLength(2);
+            // Verify excluded combinations
+            expect(urls).not.toContain('1-year/uk');
+            expect(urls).not.toContain('2-years/australia');
+            expect(urls).not.toContain('3-years/usa');
+            expect(urls).not.toContain('less-than-2-years/uk');
+            // Verify included combinations
+            expect(urls).toContain('1-year/australia');
+            expect(urls).toContain('1-year/usa');
+        });
+        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 country of ['30', '202', '56']) {
+                // Include [360,360] since that's what the policy actually uses
+                for (const duration of ['[360,360]', '[720,720]', '[1080,1080]', '[1440,1440]', '[-1,719]']) {
+                    const key = `${FilterKey.COUNTRY}:${country}|${FilterKey.DURATION}:${duration}`;
+                    resultMap.set(key, false);
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await countryDurationPolicy.generateUrls();
+            // Should include no URLs
+            expect(urls).toHaveLength(0);
+        });
+        it('Should handle empty country fragments', async () => {
+            // Mock the CountryPresenter to return empty fragments
+            CountryPresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue([])
+            });
+            sitemapDependenciesHelper.mockCheckRulesForSitemap();
+            const urls = await countryDurationPolicy.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 countryDurationPolicy.generateUrls();
+            // Should return empty array
+            expect(urls).toHaveLength(0);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,304 @@
+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 { CountryDurationDegree } from '@/programmes/policies/CountryDurationDegree';
+import { PortalType } from '@studyportals/domain-client';
+import { SitemapDependencies } from '../utils/SitemapDependencies.util.mjs';
+import { CountryPresenter } from '@/presenters/CountryPresenter';
+import { DegreePresenter } from '@/presenters/DegreePresenter';
+import { DurationPresenter } from '@/presenters/DurationPresenter';
+describe('Policy:CountryDurationDegree', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let countryDurationDegreePolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            countryDurationDegreePolicy = new CountryDurationDegree(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setResultsCount(10);
+            searchDependenciesHelper.setPageNumber(1);
+            searchDependenciesHelper.setPortalType(PortalType.PHD);
+        });
+        it('Should return true when all conditions are met (degree is MBA)', async () => {
+            const countryId = '30'; // UK
+            const duration = '[360,360]'; // 1 year
+            const degree = 'mba';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DURATION, [duration]],
+                [FilterKey.DEGREE_TYPE, [degree]]
+            ]));
+            const result = await countryDurationDegreePolicy.shouldIndex();
+            expect(result).toBe(true);
+        });
+        it('Should return true when all conditions are met (degree is MSC)', async () => {
+            const countryId = '30'; // UK
+            const duration = '[360,360]'; // 1 year
+            const degree = 'msc';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DURATION, [duration]],
+                [FilterKey.DEGREE_TYPE, [degree]]
+            ]));
+            const result = await countryDurationDegreePolicy.shouldIndex();
+            expect(result).toBe(true);
+        });
+        it('Should return false when multiple countries are selected', async () => {
+            const firstCountryId = '30'; // UK
+            const secondCountryId = '21'; // Portugal
+            const duration = '[360,360]'; // 1 year
+            const degree = 'mba';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [firstCountryId, secondCountryId]],
+                [FilterKey.DURATION, [duration]],
+                [FilterKey.DEGREE_TYPE, [degree]]
+            ]));
+            const result = await countryDurationDegreePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when degree is not MBA or MSC', async () => {
+            const countryId = '30'; // UK
+            const duration = '[360,360]'; // 1 year
+            const degree = 'phd';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DURATION, [duration]],
+                [FilterKey.DEGREE_TYPE, [degree]]
+            ]));
+            const result = await countryDurationDegreePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when duration is not one year', async () => {
+            const countryId = '30'; // UK
+            const duration = '[720,720]'; // 2 years
+            const degree = 'mba';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DURATION, [duration]],
+                [FilterKey.DEGREE_TYPE, [degree]]
+            ]));
+            const result = await countryDurationDegreePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            const countryId = '30'; // UK
+            const duration = '[360,360]'; // 1 year
+            const degree = 'mba';
+            const disciplineId = '12'; // Applied Sciences & Professions
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DURATION, [duration]],
+                [FilterKey.DEGREE_TYPE, [degree]],
+                [FilterKey.DISCIPLINES, [disciplineId]]
+            ]));
+            const result = await countryDurationDegreePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when number of results is less than 7', async () => {
+            const countryId = '30'; // UK
+            const duration = '[360,360]'; // 1 year
+            const degree = 'mba';
+            searchDependenciesHelper.setResultsCount(6);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DURATION, [duration]],
+                [FilterKey.DEGREE_TYPE, [degree]]
+            ]));
+            const result = await countryDurationDegreePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when page number is higher than 2', async () => {
+            const countryId = '30'; // UK
+            const duration = '[360,360]'; // 1 year
+            const degree = 'mba';
+            searchDependenciesHelper.setPageNumber(5);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DURATION, [duration]],
+                [FilterKey.DEGREE_TYPE, [degree]]
+            ]));
+            const result = await countryDurationDegreePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when portal is distance learning', async () => {
+            const countryId = '30'; // UK
+            const duration = '[360,360]'; // 1 year
+            const degree = 'mba';
+            searchDependenciesHelper.setPortalType(PortalType.DISTANCE_LEARNING);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DURATION, [duration]],
+                [FilterKey.DEGREE_TYPE, [degree]]
+            ]));
+            const result = await countryDurationDegreePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateUrls', () => {
+        let sitemapDependenciesHelper;
+        let countryDurationDegreePolicy;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setProgrammeCount(10); // More than 7 programs
+            countryDurationDegreePolicy = new CountryDurationDegree(sitemapDependenciesHelper.dependencies);
+            CountryPresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: '30', path: 'uk' },
+                    { id: '21', path: 'portugal' },
+                    { id: '56', path: 'usa' },
+                    { id: '82', path: 'netherlands' }
+                ])
+            });
+            DegreePresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: 'mba', path: 'mba' },
+                    { id: 'msc', path: 'msc' },
+                    { id: 'phd', path: 'phd' }
+                ])
+            });
+            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' }
+                ])
+            });
+        });
+        afterEach(() => {
+            sitemapDependenciesHelper.resetMocks();
+        });
+        it('Should generate URLs for all valid degree-duration-country combinations', async () => {
+            // Mock the checkRulesForSitemap to only allow 1-year duration and MBA or MSC degrees
+            const resultMap = new Map();
+            // Set rules: only allow 1-year duration and MBA or MSC degrees
+            for (const countryId of ['30', '21', '56', '82']) {
+                for (const durationId of ['[360,360]', '[720,720]', '[1080,1080]']) {
+                    for (const degreeId of ['mba', 'msc', 'phd']) {
+                        const key = `${FilterKey.COUNTRY}:${countryId}|${FilterKey.DURATION}:${durationId}|${FilterKey.DEGREE_TYPE}:${degreeId}`;
+                        resultMap.set(key, durationId === '[360,360]' && (degreeId === 'mba' || degreeId === 'msc'));
+                    }
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            // Call the method via reflection since it's protected
+            const urls = await countryDurationDegreePolicy.generateUrls();
+            // Verify only 1-year MBA/MSC combinations were included (2 degrees * 4 countries * 2 pages = 16 URLs)
+            expect(urls).toHaveLength(8);
+            expect(urls).toContain('mba/1-year/uk');
+            expect(urls).toContain('mba/1-year/portugal');
+            expect(urls).toContain('mba/1-year/usa');
+            expect(urls).toContain('mba/1-year/netherlands');
+            expect(urls).toContain('msc/1-year/uk');
+            expect(urls).toContain('msc/1-year/portugal');
+            expect(urls).toContain('msc/1-year/usa');
+            expect(urls).toContain('msc/1-year/netherlands');
+            expect(urls).not.toContain('mba/2-years/uk');
+            expect(urls).not.toContain('msc/2-years/uk');
+            expect(urls).not.toContain('phd/1-year/uk');
+            expect(urls).not.toContain('mba/2-years/uk');
+        });
+        it('Should exclude certain degree-duration-country combinations', async () => {
+            // Mock to exclude UK combinations
+            const resultMap = new Map();
+            // Set up rules to exclude UK for all durations and degrees
+            for (const countryId of ['30', '21', '56', '82']) {
+                for (const durationId of ['[360,360]', '[720,720]', '[1080,1080]']) {
+                    for (const degreeId of ['mba', 'msc', 'phd']) {
+                        const key = `${FilterKey.COUNTRY}:${countryId}|${FilterKey.DURATION}:${durationId}|${FilterKey.DEGREE_TYPE}:${degreeId}`;
+                        // Exclude UK (30) and only allow 1-year MBA/MSC for others
+                        resultMap.set(key, countryId !== '30' && durationId === '[360,360]' && (degreeId === 'mba' || degreeId === 'msc'));
+                    }
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await countryDurationDegreePolicy.generateUrls();
+            // Should include others but not UK (2 degrees * 3 countries = 6 URLs)
+            expect(urls).toHaveLength(6);
+            expect(urls).toContain('mba/1-year/portugal');
+            expect(urls).toContain('mba/1-year/usa');
+            expect(urls).toContain('mba/1-year/netherlands');
+            expect(urls).toContain('msc/1-year/portugal');
+            expect(urls).toContain('msc/1-year/usa');
+            expect(urls).toContain('msc/1-year/netherlands');
+            expect(urls).not.toContain('mba/1-year/uk');
+            expect(urls).not.toContain('msc/1-year/uk');
+        });
+        it('Should exclude all URLs when all checks fail', async () => {
+            // Create a map that returns false for all combinations
+            const resultMap = new Map();
+            // Set all combinations to fail
+            for (const countryId of ['30', '21', '56', '82']) {
+                for (const durationId of ['[360,360]', '[720,720]', '[1080,1080]']) {
+                    for (const degreeId of ['mba', 'msc', 'phd']) {
+                        const key = `${FilterKey.COUNTRY}:${countryId}|${FilterKey.DURATION}:${durationId}|${FilterKey.DEGREE_TYPE}:${degreeId}`;
+                        resultMap.set(key, false);
+                    }
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap, false);
+            const urls = await countryDurationDegreePolicy.generateUrls();
+            // Should include no URLs
+            expect(urls).toHaveLength(0);
+        });
+        it('Should handle empty fragments arrays', async () => {
+            // Mock the CountryPresenter to return empty fragments
+            CountryPresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue([])
+            });
+            sitemapDependenciesHelper.mockCheckRulesForSitemap();
+            const urls = await countryDurationDegreePolicy.generateUrls();
+            // Should return empty array
+            expect(urls).toHaveLength(0);
+        });
+        it('Should handle large number of combinations efficiently', async () => {
+            // Generate a smaller set of countries (10), durations (3) and degree types (3)
+            const largeCountrySet = Array.from({ length: 10 }, (_, index) => ({
+                id: `${1000 + index}`,
+                path: `country-${1000 + index}`
+            }));
+            const largeDurationSet = Array.from({ length: 3 }, (_, index) => ({
+                id: `duration-${index}`,
+                path: `duration-type-${index}`
+            }));
+            const largeDegreeSet = Array.from({ length: 3 }, (_, index) => ({
+                id: `degree-${index}`,
+                path: `degree-type-${index}`
+            }));
+            // Mock the presenters to return large sets
+            CountryPresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeCountrySet)
+            });
+            DurationPresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeDurationSet)
+            });
+            DegreePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeDegreeSet)
+            });
+            // Mock to allow only specific combinations
+            // Only allow countries divisible by 2, duration index 0, and degree index 0 or 1
+            const resultMap = new Map();
+            for (let c = 0; c < largeCountrySet.length; c++) {
+                for (let d = 0; d < largeDurationSet.length; d++) {
+                    for (let g = 0; g < largeDegreeSet.length; g++) {
+                        const countryId = largeCountrySet[c].id;
+                        const durationId = largeDurationSet[d].id;
+                        const degreeId = largeDegreeSet[g].id;
+                        const key = `${FilterKey.COUNTRY}:${countryId}|${FilterKey.DURATION}:${durationId}|${FilterKey.DEGREE_TYPE}:${degreeId}`;
+                        // Only include countries where index is divisible by 2, duration index 0, and degree index 0 or 1
+                        resultMap.set(key, c % 2 === 0 && d === 0 && (g === 0 || g === 1));
+                    }
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await countryDurationDegreePolicy.generateUrls();
+            // Should generate 5 countries (10/2) * 1 duration type * 2 degree types * 2 pages = 20 URLs
+            expect(urls).toHaveLength(10);
+            // Test some specific combinations
+            expect(urls).toContain('degree-type-0/duration-type-0/country-1000'); // First valid country, first degree
+            expect(urls).toContain('degree-type-1/duration-type-0/country-1000'); // First valid country, second degree
+            expect(urls).toContain('degree-type-0/duration-type-0/country-1002'); // Another valid country, first degree
+            expect(urls).not.toContain('degree-type-0/duration-type-0/country-1001'); // Invalid country (not divisible by 2)
+            expect(urls).not.toContain('degree-type-2/duration-type-0/country-1000'); // Invalid degree
+            expect(urls).not.toContain('degree-type-0/duration-type-1/country-1000'); // Invalid duration
+        });
+    });
+});

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

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