@studyportals/fawkes 8.7.0 → 8.7.1-0

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

@@ -0,0 +1,260 @@
+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 { CountryEducationalForm } from '@/programmes/policies/CountryEducationalForm';
+import { PortalType } from '@studyportals/domain-client';
+import { SitemapDependencies } from '../utils/SitemapDependencies.util.mjs';
+import { CountryPresenter } from '@/presenters/CountryPresenter';
+import { EducationalFormPresenter } from '@/presenters/EducationalFormPresenter';
+describe('Policy:CountryEducationalForm', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let countryEducationalFormPolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            countryEducationalFormPolicy = new CountryEducationalForm(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setResultsCount(10);
+            searchDependenciesHelper.setPageNumber(1);
+            searchDependenciesHelper.setPortalType(PortalType.SHORT);
+        });
+        it('Should return true when all conditions are met', async () => {
+            const countryId = '30'; // UK
+            const educationalForm = 'academic';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.EDUCATIONAL_FORM, [educationalForm]]
+            ]));
+            const result = await countryEducationalFormPolicy.shouldIndex();
+            expect(result).toBe(true);
+        });
+        it('Should return false when multiple countries are selected', async () => {
+            const firstCountryId = '30'; // UK
+            const secondCountryId = '21'; // Portugal
+            const educationalForm = 'academic';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [firstCountryId, secondCountryId]],
+                [FilterKey.EDUCATIONAL_FORM, [educationalForm]]
+            ]));
+            const result = await countryEducationalFormPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple educational form values are selected', async () => {
+            const countryId = '30'; // UK
+            const firstEducationalForm = 'academic';
+            const secondEducationalForm = 'semester';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DURATION, [firstEducationalForm, secondEducationalForm]]
+            ]));
+            const result = await countryEducationalFormPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no educational form values are selected', async () => {
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [countryId]]]));
+            const result = await countryEducationalFormPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no countries are selected', async () => {
+            const educationalForm = 'academic';
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.EDUCATIONAL_FORM, [educationalForm]]]));
+            const result = await countryEducationalFormPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            const countryId = '30'; // UK
+            const educationalForm = 'academic';
+            const disciplineId = '54'; // Agriculture & Forestry
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.EDUCATIONAL_FORM, [educationalForm]],
+                [FilterKey.DISCIPLINES, [disciplineId]]
+            ]));
+            const result = await countryEducationalFormPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when educational form is not indexable (i.e. Winter School)', async () => {
+            const countryId = '30'; // UK
+            const educationalForm = 'winter_school';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.EDUCATIONAL_FORM, [educationalForm]]
+            ]));
+            const result = await countryEducationalFormPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when number of results is less than 7', async () => {
+            const countryId = '30'; // UK
+            const educationalForm = 'academic';
+            searchDependenciesHelper.setResultsCount(6);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.EDUCATIONAL_FORM, [educationalForm]]
+            ]));
+            const result = await countryEducationalFormPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when page number is higher than 2', async () => {
+            const countryId = '30'; // UK
+            const educationalForm = 'academic';
+            searchDependenciesHelper.setPageNumber(3);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.EDUCATIONAL_FORM, [educationalForm]]
+            ]));
+            const result = await countryEducationalFormPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when portal is distance learning', async () => {
+            const countryId = '30'; // UK
+            const educationalForm = 'academic';
+            searchDependenciesHelper.setPortalType(PortalType.DISTANCE_LEARNING);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.EDUCATIONAL_FORM, [educationalForm]]
+            ]));
+            const result = await countryEducationalFormPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateUrls', () => {
+        let sitemapDependenciesHelper;
+        let countryEducationalFormPolicy;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setProgrammeCount(10); // More than 7 programs
+            countryEducationalFormPolicy = new CountryEducationalForm(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' }
+                ])
+            });
+            EducationalFormPresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: 'academic', path: 'academic-programmes' },
+                    { id: 'semester', path: 'semester-programmes' },
+                    { id: 'winter_school', path: 'winter-school-programmes' },
+                    { id: 'summer_school', path: 'summer-school-programmes' }
+                ])
+            });
+        });
+        afterEach(() => {
+            sitemapDependenciesHelper.resetMocks();
+        });
+        it('Should generate URLs for all valid country-form combinations', async () => {
+            // Mock the checkRulesForSitemap to exclude winter_school
+            const resultMap = new Map();
+            // Set rules to exclude winter_school (as per shouldIndex test)
+            for (const countryId of ['30', '21', '56', '82']) {
+                for (const formId of ['academic', 'semester', 'winter_school', 'summer_school']) {
+                    const key = `${FilterKey.COUNTRY}:${countryId}|${FilterKey.EDUCATIONAL_FORM}:${formId}`;
+                    resultMap.set(key, formId !== 'winter_school');
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            // Call the method via reflection since it's protected
+            const urls = await countryEducationalFormPolicy.generateUrls();
+            // Verify winter_school is excluded (3 forms * 4 countries * 2 pages = 24 URLs)
+            expect(urls).toHaveLength(12);
+            expect(urls).toContain('uk/academic-programmes');
+            expect(urls).toContain('uk/semester-programmes');
+            expect(urls).toContain('uk/summer-school-programmes');
+            expect(urls).toContain('portugal/academic-programmes');
+            expect(urls).toContain('usa/academic-programmes');
+            expect(urls).toContain('netherlands/academic-programmes');
+            expect(urls).not.toContain('uk/winter-school-programmes');
+            expect(urls).not.toContain('portugal/winter-school-programmes');
+        });
+        it('Should exclude certain country-form combinations', async () => {
+            // Mock to exclude UK combinations
+            const resultMap = new Map();
+            // Set up rules to exclude UK for all forms
+            for (const countryId of ['30', '21', '56', '82']) {
+                for (const formId of ['academic', 'semester', 'winter_school', 'summer_school']) {
+                    const key = `${FilterKey.COUNTRY}:${countryId}|${FilterKey.EDUCATIONAL_FORM}:${formId}`;
+                    // Exclude UK (30) and winter_school
+                    resultMap.set(key, countryId !== '30' && formId !== 'winter_school');
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await countryEducationalFormPolicy.generateUrls();
+            // Should include others but not UK (3 forms * 3 countries * 2 pages = 18 URLs)
+            expect(urls).toHaveLength(9);
+            expect(urls).toContain('portugal/academic-programmes');
+            expect(urls).toContain('usa/academic-programmes');
+            expect(urls).toContain('netherlands/academic-programmes');
+            expect(urls).not.toContain('uk/academic-programmes');
+            expect(urls).not.toContain('uk/semester-programmes');
+            expect(urls).not.toContain('portugal/winter-school-programmes');
+        });
+        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 formId of ['academic', 'semester', 'winter_school', 'summer_school']) {
+                    const key = `${FilterKey.COUNTRY}:${countryId}|${FilterKey.EDUCATIONAL_FORM}:${formId}`;
+                    resultMap.set(key, false);
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap, false);
+            const urls = await countryEducationalFormPolicy.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 countryEducationalFormPolicy.generateUrls();
+            // Should return empty array
+            expect(urls).toHaveLength(0);
+        });
+        it('Should handle large number of combinations efficiently', async () => {
+            // Generate a larger set of countries (10) and educational forms (5)
+            const largeCountrySet = Array.from({ length: 10 }, (_, index) => ({
+                id: `${1000 + index}`,
+                path: `country-${1000 + index}`
+            }));
+            const largeFormSet = Array.from({ length: 5 }, (_, index) => ({
+                id: `form-${index}`,
+                path: `educational-form-${index}`
+            }));
+            // Mock the presenters to return large sets
+            CountryPresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeCountrySet)
+            });
+            EducationalFormPresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeFormSet)
+            });
+            // Mock to allow only specific combinations
+            // Only allow countries divisible by 2, and forms with odd indices
+            const resultMap = new Map();
+            for (let c = 0; c < largeCountrySet.length; c++) {
+                for (let f = 0; f < largeFormSet.length; f++) {
+                    const countryId = largeCountrySet[c].id;
+                    const formId = largeFormSet[f].id;
+                    const key = `${FilterKey.COUNTRY}:${countryId}|${FilterKey.EDUCATIONAL_FORM}:${formId}`;
+                    // Only include countries where index is divisible by 2, and form indices that are odd
+                    resultMap.set(key, c % 2 === 0 && f % 2 === 1);
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await countryEducationalFormPolicy.generateUrls();
+            // Should generate 5 countries (10/2) * 2 forms (5/2 rounded down + ignore index 0) * 2 pages = 20 URLs
+            expect(urls).toHaveLength(10);
+            // Test some specific combinations
+            expect(urls).toContain('country-1000/educational-form-1'); // First valid country, first valid form
+            expect(urls).toContain('country-1000/educational-form-3'); // First valid country, second valid form
+            expect(urls).toContain('country-1002/educational-form-1'); // Another valid country, first valid form
+            expect(urls).not.toContain('country-1001/educational-form-1'); // Invalid country (not divisible by 2)
+            expect(urls).not.toContain('country-1000/educational-form-0'); // Invalid form (not odd index)
+            expect(urls).not.toContain('country-1000/educational-form-2'); // Invalid form (not odd index)
+        });
+    });
+});

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

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

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

@@ -0,0 +1,253 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { CountryFormat } from '@/programmes/policies/CountryFormat';
+import { PortalType } from '@studyportals/domain-client';
+import { SitemapDependencies } from '../utils/SitemapDependencies.util.mjs';
+import { CountryPresenter } from '@/presenters/CountryPresenter';
+import { FormatPresenter } from '@/presenters/FormatPresenter';
+describe('Policy:CountryFormat', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let countryFormatPolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            countryFormatPolicy = new CountryFormat(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setResultsCount(10);
+            searchDependenciesHelper.setPageNumber(1);
+            searchDependenciesHelper.setPortalType(PortalType.MASTER);
+        });
+        it('Should return true when all conditions are met', async () => {
+            const countryId = '82'; // US
+            const format = 'parttime';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.ATTENDANCE, [format]]
+            ]));
+            const result = await countryFormatPolicy.shouldIndex();
+            expect(result).toBe(true);
+        });
+        it('Should return false when multiple countries are selected', async () => {
+            const firstCountryId = '30'; // UK
+            const secondCountryId = '21'; // Portugal
+            const format = 'parttime';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [firstCountryId, secondCountryId]],
+                [FilterKey.ATTENDANCE, [format]]
+            ]));
+            const result = await countryFormatPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple format values are selected', async () => {
+            const countryId = '30'; // UK
+            const firstFormat = 'parttime';
+            const secondFormat = 'fulltime';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.ATTENDANCE, [firstFormat, secondFormat]]
+            ]));
+            const result = await countryFormatPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no format values are selected', async () => {
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [countryId]]]));
+            const result = await countryFormatPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no countries are selected', async () => {
+            const format = 'parttime';
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.EDUCATIONAL_FORM, [format]]]));
+            const result = await countryFormatPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            const countryId = '30'; // UK
+            const format = 'parttime';
+            const disciplineId = '54'; // Agriculture & Forestry
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.ATTENDANCE, [format]],
+                [FilterKey.DISCIPLINES, [disciplineId]]
+            ]));
+            const result = await countryFormatPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when format is not part-time', async () => {
+            const countryId = '30'; // UK
+            const format = 'fulltime';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.ATTENDANCE, [format]]
+            ]));
+            const result = await countryFormatPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when number of results is less than 7', async () => {
+            const countryId = '30'; // UK
+            const format = 'parttime';
+            searchDependenciesHelper.setResultsCount(6);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.ATTENDANCE, [format]]
+            ]));
+            const result = await countryFormatPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when page number is higher than 2', async () => {
+            const countryId = '82'; // US
+            const format = 'parttime';
+            searchDependenciesHelper.setPageNumber(5);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.ATTENDANCE, [format]]
+            ]));
+            const result = await countryFormatPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when portal is distance learning', async () => {
+            const countryId = '82'; // US
+            const format = 'parttime';
+            searchDependenciesHelper.setPortalType(PortalType.DISTANCE_LEARNING);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.ATTENDANCE, [format]]
+            ]));
+            const result = await countryFormatPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateUrls', () => {
+        let sitemapDependenciesHelper;
+        let countryFormatPolicy;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setProgrammeCount(10); // More than 7 programs
+            countryFormatPolicy = new CountryFormat(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' }
+                ])
+            });
+            FormatPresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: 'parttime', path: 'part-time-programmes' },
+                    { id: 'fulltime', path: 'full-time-programmes' }
+                ])
+            });
+        });
+        afterEach(() => {
+            sitemapDependenciesHelper.resetMocks();
+        });
+        it('Should generate URLs for all valid country-format combinations', async () => {
+            // Mock the checkRulesForSitemap to only allow part-time format
+            const resultMap = new Map();
+            // Set rules to only allow part-time format (as per shouldIndex test)
+            for (const countryId of ['30', '21', '56', '82']) {
+                for (const formatId of ['parttime', 'fulltime']) {
+                    const key = `${FilterKey.ATTENDANCE}:${formatId}|${FilterKey.COUNTRY}:${countryId}`;
+                    resultMap.set(key, formatId === 'parttime');
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            // Call the method via reflection since it's protected
+            const urls = await countryFormatPolicy.generateUrls();
+            // Verify only part-time and full-time format is included (2 format * 4 countries * 1 pages = 8 URLs)
+            expect(urls).toHaveLength(8);
+            expect(urls).toContain('part-time-programmes/uk');
+            expect(urls).toContain('part-time-programmes/portugal');
+            expect(urls).toContain('part-time-programmes/usa');
+            expect(urls).toContain('part-time-programmes/netherlands');
+            expect(urls).toContain('full-time-programmes/uk');
+            expect(urls).toContain('full-time-programmes/portugal');
+        });
+        it('Should exclude certain country-format combinations', async () => {
+            // Mock to exclude UK combinations
+            const resultMap = new Map();
+            // Set up rules to exclude UK for all formats
+            for (const countryId of ['30', '21', '56', '82']) {
+                for (const formatId of ['parttime', 'fulltime']) {
+                    const key = `${FilterKey.COUNTRY}:${countryId}|${FilterKey.ATTENDANCE}:${formatId}`;
+                    // Exclude UK (30) and only allow part-time for others
+                    resultMap.set(key, countryId !== '30' && formatId === 'parttime');
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await countryFormatPolicy.generateUrls();
+            // Should include others but not UK (1 format * 3 countries * 2 pages = 6 URLs)
+            expect(urls).toHaveLength(3);
+            expect(urls).toContain('part-time-programmes/portugal');
+            expect(urls).toContain('part-time-programmes/usa');
+            expect(urls).toContain('part-time-programmes/netherlands');
+            expect(urls).not.toContain('part-time-programmes/uk');
+            expect(urls).not.toContain('full-time-programmes/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 formatId of ['parttime', 'fulltime']) {
+                    const key = `${FilterKey.ATTENDANCE}:${formatId}|${FilterKey.COUNTRY}:${countryId}`;
+                    resultMap.set(key, false);
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap, false);
+            const urls = await countryFormatPolicy.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 countryFormatPolicy.generateUrls();
+            // Should return empty array
+            expect(urls).toHaveLength(0);
+        });
+        it('Should handle large number of combinations efficiently', async () => {
+            // Generate a larger set of countries (20) and format types (3)
+            const largeCountrySet = Array.from({ length: 20 }, (_, index) => ({
+                id: `${1000 + index}`,
+                path: `country-${1000 + index}`
+            }));
+            const largeFormatSet = Array.from({ length: 3 }, (_, index) => ({
+                id: `format-${index}`,
+                path: `format-type-${index}`
+            }));
+            // Mock the presenters to return large sets
+            CountryPresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeCountrySet)
+            });
+            FormatPresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeFormatSet)
+            });
+            // Mock to allow only specific combinations
+            // Only allow countries divisible by 3, and format index 0 (part-time equivalent)
+            const resultMap = new Map();
+            for (let c = 0; c < largeCountrySet.length; c++) {
+                for (let f = 0; f < largeFormatSet.length; f++) {
+                    const countryId = largeCountrySet[c].id;
+                    const formatId = largeFormatSet[f].id;
+                    const key = `${FilterKey.COUNTRY}:${countryId}|${FilterKey.ATTENDANCE}:${formatId}`;
+                    // Only include countries where index is divisible by 3, and format index 0
+                    resultMap.set(key, c % 3 === 0 && f === 0);
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await countryFormatPolicy.generateUrls();
+            // Should generate 7 countries (20/3 rounded up) * 1 format type * 2 pages = 14 URLs
+            expect(urls).toHaveLength(7);
+            // Test some specific combinations
+            expect(urls).toContain('format-type-0/country-1000'); // First valid country, allowed format
+            expect(urls).toContain('format-type-0/country-1003'); // Another valid country, allowed format
+            expect(urls).not.toContain('format-type-0/country-1001'); // Invalid country (not divisible by 3)
+            expect(urls).not.toContain('format-type-1/country-1000'); // Valid country, but invalid format
+        });
+    });
+});

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

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