@studyportals/fawkes 8.7.0 → 8.7.1-0

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

@@ -0,0 +1,244 @@
+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 { DisciplineCountry } from '@/programmes/policies/DisciplineCountry';
+import { PortalType } from '@studyportals/domain-client';
+import { DisciplinePresenter } from '@/presenters/DisciplinePresenter';
+import { CountryPresenter } from '@/presenters/CountryPresenter';
+describe('Policy:DisciplineCountry', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let disciplineCountryPolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            disciplineCountryPolicy = new DisciplineCountry(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setResultsCount(10);
+            searchDependenciesHelper.setPageNumber(1);
+            searchDependenciesHelper.setPortalType(PortalType.PHD);
+        });
+        it('Should return true when all conditions are met', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            const result = await disciplineCountryPolicy.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 countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [firstDisciplineId, secondDisciplineId]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            const result = await disciplineCountryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple countries are selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const firstCountryId = '30'; // UK
+            const secondCountryId = '82'; // USA
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.COUNTRY, [firstCountryId, secondCountryId]]
+            ]));
+            const result = await disciplineCountryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no disciplines are selected', async () => {
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [countryId]]]));
+            const result = await disciplineCountryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no countries are selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DISCIPLINES, [disciplineId]]]));
+            const result = await disciplineCountryPolicy.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 areaId = '996';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.AREA, [areaId]]
+            ]));
+            const result = await disciplineCountryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when number of results is less than 7', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setResultsCount(6);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            const result = await disciplineCountryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when page number is higher than 2', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setPageNumber(5);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            const result = await disciplineCountryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when portal type is distance learning', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setPortalType(PortalType.DISTANCE_LEARNING);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            const result = await disciplineCountryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateUrls', () => {
+        let sitemapDependenciesHelper;
+        let disciplineCountryPolicy;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setProgrammeCount(10); // More than 7 programs
+            disciplineCountryPolicy = new DisciplineCountry(sitemapDependenciesHelper.dependencies);
+            DisciplinePresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: '54', path: 'agriculture-forestry' },
+                    { id: '12', path: 'applied-sciences' },
+                    { id: '152', path: 'computer-science-it' }
+                ])
+            });
+            CountryPresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: '30', path: 'uk' },
+                    { id: '202', path: 'australia' },
+                    { id: '56', path: 'usa' }
+                ])
+            });
+        });
+        afterEach(() => {
+            sitemapDependenciesHelper.resetMocks();
+        });
+        it('Should generate URLs for all valid discipline-country combinations', async () => {
+            // Mock the checkRulesForSitemap to return true for all combinations
+            sitemapDependenciesHelper.mockCheckRulesForSitemap();
+            // Call the method via reflection since it's protected
+            const urls = await disciplineCountryPolicy.generateUrls();
+            // The total number of URLs should be the product of the number of disciplines and countries
+            // 3 disciplines × 3 countries x 2 pages = 18 URLs
+            expect(urls).toHaveLength(9);
+            // Verify some specific combinations
+            expect(urls).toContain('agriculture-forestry/uk');
+            expect(urls).toContain('computer-science-it/australia');
+            expect(urls).toContain('applied-sciences/usa');
+        });
+        it('Should exclude specific discipline-country combinations based on rules', async () => {
+            // Create a map that returns false for specific combinations
+            const resultMap = new Map([
+                // Exclude agriculture from UK
+                [`${FilterKey.DISCIPLINES}:54|${FilterKey.COUNTRY}:30`, false],
+                // Exclude applied sciences from Australia
+                [`${FilterKey.DISCIPLINES}:12|${FilterKey.COUNTRY}:202`, false],
+                // Exclude computer science from USA
+                [`${FilterKey.DISCIPLINES}:152|${FilterKey.COUNTRY}:56`, false]
+            ]);
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await disciplineCountryPolicy.generateUrls();
+            // Should include all combinations except the excluded ones, so 9 - 3 * 2 = 12
+            expect(urls).toHaveLength(6);
+            // Verify excluded combinations
+            expect(urls).not.toContain('agriculture-forestry/uk');
+            expect(urls).not.toContain('applied-sciences/australia');
+            expect(urls).not.toContain('computer-science-it/usa');
+            // Verify included combinations
+            expect(urls).toContain('agriculture-forestry/australia');
+            expect(urls).toContain('applied-sciences/uk');
+            expect(urls).toContain('computer-science-it/uk');
+        });
+        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', '152']) {
+                for (const country of ['30', '202', '56']) {
+                    const key = `${FilterKey.DISCIPLINES}:${discipline}|${FilterKey.COUNTRY}:${country}`;
+                    resultMap.set(key, false);
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await disciplineCountryPolicy.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 disciplineCountryPolicy.generateUrls();
+            // Should return empty array
+            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 disciplineCountryPolicy.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 largeCountrySet = Array.from({ length: 15 }, (_, index) => ({
+                id: `country-${index}`,
+                path: `country-path-${index}`
+            }));
+            // Override mocks with large datasets
+            DisciplinePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeDisciplineSet)
+            });
+            CountryPresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeCountrySet)
+            });
+            // Mock to allow only combinations where both discipline and country indices are even
+            const resultMap = new Map();
+            for (let d = 0; d < largeDisciplineSet.length; d++) {
+                for (let c = 0; c < largeCountrySet.length; c++) {
+                    const disciplineId = largeDisciplineSet[d].id;
+                    const countryId = largeCountrySet[c].id;
+                    const key = `${FilterKey.DISCIPLINES}:${disciplineId}|${FilterKey.COUNTRY}:${countryId}`;
+                    resultMap.set(key, d % 2 === 0 && c % 2 === 0);
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await disciplineCountryPolicy.generateUrls();
+            // Calculate expected count: 10 disciplines (even indices) * 8 countries (even indices) * 2 pages
+            // = 10 * 8 * 2 = 160 URLs
+            expect(urls).toHaveLength(80);
+            // Test specific items
+            expect(urls).toContain('discipline-path-0/country-path-0'); // Both even indices
+            expect(urls).toContain('discipline-path-2/country-path-4'); // Both even indices
+            expect(urls).not.toContain('discipline-path-1/country-path-0'); // Odd discipline index
+            expect(urls).not.toContain('discipline-path-0/country-path-1'); // Odd country index
+        });
+    });
+});

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

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

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

@@ -0,0 +1,345 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { PortalType } from '@studyportals/domain-client';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { SitemapDependencies } from '../utils/SitemapDependencies.util.mjs';
+import { DisciplineCountryEducationalForm } from '@/programmes/policies/DisciplineCountryEducationalForm';
+import { DisciplinePresenter } from '@/presenters/DisciplinePresenter';
+import { CountryPresenter } from '@/presenters/CountryPresenter';
+import { EducationalFormPresenter } from '@/presenters/EducationalFormPresenter';
+describe('Policy:DisciplineCountryEducationalForm', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let disciplineCountryEducationalForm;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            disciplineCountryEducationalForm = new DisciplineCountryEducationalForm(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setResultsCount(7);
+            searchDependenciesHelper.setPageNumber(1);
+            searchDependenciesHelper.setPortalType(PortalType.SHORT);
+        });
+        it('Should return true when all conditions are met', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const countryId = '30'; // UK
+            const educationalForm = 'academic';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.EDUCATIONAL_FORM, [educationalForm]]
+            ]));
+            const result = await disciplineCountryEducationalForm.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 countryId = '30'; // UK
+            const educationalForm = 'academic';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [firstDisciplineId, secondDisciplineId]],
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.EDUCATIONAL_FORM, [educationalForm]]
+            ]));
+            const result = await disciplineCountryEducationalForm.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple countries are selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const firstCountryId = '30'; // UK
+            const secondCountryId = '82'; // US
+            const educationalForm = 'semester';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.COUNTRY, [firstCountryId, secondCountryId]],
+                [FilterKey.EDUCATIONAL_FORM, [educationalForm]]
+            ]));
+            const result = await disciplineCountryEducationalForm.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple educational form values are selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const countryId = '30'; // UK
+            const firstEducationalForm = 'academic';
+            const secondEducationaForm = 'semester';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.EDUCATIONAL_FORM, [firstEducationalForm, secondEducationaForm]]
+            ]));
+            const result = await disciplineCountryEducationalForm.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no disciplines are selected', async () => {
+            const countryId = '30'; // UK
+            const educationalForm = 'academic';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.EDUCATIONAL_FORM, [educationalForm]]
+            ]));
+            const result = await disciplineCountryEducationalForm.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no country is selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const educationalForm = 'academic';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.EDUCATIONAL_FORM, [educationalForm]]
+            ]));
+            const result = await disciplineCountryEducationalForm.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no educational form value is selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const countryId = '82'; // US
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            const result = await disciplineCountryEducationalForm.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 = '82'; // US
+            const tuitionFee = '[0,2500]'; // Affordable
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]],
+                [FilterKey.EDUCATIONAL_FORM, [educationalForm]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            const result = await disciplineCountryEducationalForm.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 countryId = '30'; // UK
+            const educationalForm = 'winter_school';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.EDUCATIONAL_FORM, [educationalForm]]
+            ]));
+            const result = await disciplineCountryEducationalForm.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when number of results is less than 7', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const countryId = '30'; // UK
+            const educationalForm = 'semester';
+            searchDependenciesHelper.setResultsCount(5);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.EDUCATIONAL_FORM, [educationalForm]]
+            ]));
+            const result = await disciplineCountryEducationalForm.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when page number is higher than 2', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const countryId = '30'; // UK
+            const educationalForm = 'academic';
+            searchDependenciesHelper.setPageNumber(15);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.EDUCATIONAL_FORM, [educationalForm]]
+            ]));
+            const result = await disciplineCountryEducationalForm.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when portal is distance learning', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const countryId = '30'; // UK
+            const educationalForm = 'academic';
+            searchDependenciesHelper.setPortalType(PortalType.DISTANCE_LEARNING);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.EDUCATIONAL_FORM, [educationalForm]]
+            ]));
+            const result = await disciplineCountryEducationalForm.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateUrls', () => {
+        let sitemapDependenciesHelper;
+        let disciplineCountryEducationalForm;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setProgrammeCount(10); // More than 7 programs
+            disciplineCountryEducationalForm = new DisciplineCountryEducationalForm(sitemapDependenciesHelper.dependencies);
+            DisciplinePresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: '54', path: 'agriculture-forestry' },
+                    { id: '12', path: 'applied-sciences' }
+                ])
+            });
+            CountryPresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: '30', path: 'uk' },
+                    { id: '56', path: 'usa' }
+                ])
+            });
+            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-school' }
+                ])
+            });
+        });
+        afterEach(() => {
+            sitemapDependenciesHelper.resetMocks();
+        });
+        it('Should generate URLs for valid discipline-country-educational form combinations', async () => {
+            const resultMap = new Map();
+            for (const discipline of ['54', '12']) {
+                for (const country of ['30', '56']) {
+                    for (const form of ['academic', 'summer_school', 'semester', 'skill', 'winter_school']) {
+                        const key = `${FilterKey.DISCIPLINES}:${discipline}|${FilterKey.COUNTRY}:${country}|${FilterKey.EDUCATIONAL_FORM}:${form}`;
+                        // Only these forms should pass (exclude winter_school)
+                        resultMap.set(key, ['academic', 'summer_school', 'semester', 'skill'].includes(form));
+                    }
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap, false);
+            // Call the method via reflection since it's protected
+            const urls = await disciplineCountryEducationalForm.generateUrls();
+            // Calculate expected URLs: 2 disciplines * 2 countries * 4 indexable forms * 2 pages = 32 URLs
+            expect(urls).toHaveLength(16);
+            // Verify some valid combinations
+            expect(urls).toContain('agriculture-forestry/academic/uk');
+            expect(urls).toContain('agriculture-forestry/summer-courses/uk');
+            expect(urls).toContain('applied-sciences/academic/usa');
+            // Verify non-indexable forms are excluded
+            expect(urls).not.toContain('agriculture-forestry/winter-courses/uk');
+            expect(urls).not.toContain('applied-sciences/winter-courses/usa');
+        });
+        it('Should exclude specific discipline-country-educational form combinations based on rules', async () => {
+            // Create a map that returns false for specific combinations
+            const resultMap = new Map();
+            // Only allow academic form with UK but not with USA
+            for (const discipline of ['54', '12']) {
+                for (const country of ['30', '82']) {
+                    for (const form of ['academic', 'summer_school', 'semester', 'skill', 'winter_school']) {
+                        const key = `${FilterKey.DISCIPLINES}:${discipline}|${FilterKey.COUNTRY}:${country}|${FilterKey.EDUCATIONAL_FORM}:${form}`;
+                        // Only academic form with UK should pass
+                        resultMap.set(key, form === 'academic' && country === '30');
+                    }
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap, false);
+            const urls = await disciplineCountryEducationalForm.generateUrls();
+            // Calculate expected URLs: 2 disciplines * 1 country (UK) * 1 form (academic) * 2 pages = 4 URLs
+            expect(urls).toHaveLength(2);
+            // Verify included combinations
+            expect(urls).toContain('agriculture-forestry/academic/uk');
+            expect(urls).toContain('applied-sciences/academic/uk');
+            // Verify excluded combinations
+            expect(urls).not.toContain('agriculture-forestry/academic/usa');
+            expect(urls).not.toContain('applied-sciences/summer-courses/uk');
+        });
+        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']) {
+                for (const country of ['30', '82']) {
+                    for (const form of ['academic', 'summer_school', 'semester', 'skill', 'winter_school']) {
+                        const key = `${FilterKey.DISCIPLINES}:${discipline}|${FilterKey.COUNTRY}:${country}|${FilterKey.EDUCATIONAL_FORM}:${form}`;
+                        resultMap.set(key, false);
+                    }
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap, false);
+            const urls = await disciplineCountryEducationalForm.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 disciplineCountryEducationalForm.generateUrls();
+            // Should return empty array
+            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 disciplineCountryEducationalForm.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 disciplineCountryEducationalForm.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: 5 }, (_, index) => ({
+                id: `discipline-${index}`,
+                path: `discipline-path-${index}`
+            }));
+            const largeCountrySet = Array.from({ length: 5 }, (_, index) => ({
+                id: `country-${index}`,
+                path: `country-path-${index}`
+            }));
+            const largeEducationalFormSet = Array.from({ length: 5 }, (_, index) => ({
+                id: `form-${index}`,
+                path: `form-path-${index}`
+            }));
+            // Override mocks with large datasets
+            DisciplinePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeDisciplineSet)
+            });
+            CountryPresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeCountrySet)
+            });
+            EducationalFormPresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeEducationalFormSet)
+            });
+            // Mock to only allow combinations where discipline index is even,
+            // country index is less than 3, and educational form index is 0-2
+            const resultMap = new Map();
+            for (let d = 0; d < largeDisciplineSet.length; d++) {
+                for (let c = 0; c < largeCountrySet.length; c++) {
+                    for (let f = 0; f < largeEducationalFormSet.length; f++) {
+                        const disciplineId = largeDisciplineSet[d].id;
+                        const countryId = largeCountrySet[c].id;
+                        const formId = largeEducationalFormSet[f].id;
+                        const key = `${FilterKey.DISCIPLINES}:${disciplineId}|${FilterKey.COUNTRY}:${countryId}|${FilterKey.EDUCATIONAL_FORM}:${formId}`;
+                        resultMap.set(key, d % 2 === 0 && c < 3 && f <= 2);
+                    }
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await disciplineCountryEducationalForm.generateUrls();
+            // Calculate expected count: 3 disciplines (even indices) * 3 countries (0-2) * 3 forms (0-2) * 2 pages
+            // = 3 * 3 * 3 * 2 = 54 URLs
+            expect(urls).toHaveLength(27);
+            // Test specific items
+            expect(urls).toContain('discipline-path-0/form-path-0/country-path-0');
+            expect(urls).toContain('discipline-path-2/form-path-1/country-path-1');
+            expect(urls).not.toContain('discipline-path-1/form-path-0/country-path-0'); // Odd discipline
+            expect(urls).not.toContain('discipline-path-0/form-path-0/country-path-3'); // Country index >= 3
+            expect(urls).not.toContain('discipline-path-0/form-path-3/country-path-0'); // Form index > 2
+        });
+    });
+});

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

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