@studyportals/fawkes 8.7.0 → 8.7.1-0

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

@@ -0,0 +1,293 @@
+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 { TuitionFeeContinent } from '@/programmes/policies/TuitionFeeContinent';
+import { PortalType } from '@studyportals/domain-client';
+import { ContinentPresenter } from '@/presenters/ContinentPresenter';
+import { TuitionFeePresenter } from '@/presenters/TuitionFeePresenter';
+// Mock the ContinentPresenter
+vi.mock('@/presenters/ContinentPresenter', () => {
+    return {
+        ContinentPresenter: {
+            getInstance: vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: '1', path: 'europe' },
+                    { id: '9', path: 'asia' },
+                    { id: '2', path: 'north-america' },
+                    { id: '6', path: 'south-america' },
+                    { id: '4', path: 'africa' }
+                ])
+            })
+        }
+    };
+});
+// Mock the TuitionFeePresenter
+vi.mock('@/presenters/TuitionFeePresenter', () => {
+    return {
+        TuitionFeePresenter: {
+            getInstance: vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: '[0,2500]', path: 'affordable' },
+                    { id: '[2501,5000]', path: 'moderate' },
+                    { id: '[5001,10000]', path: 'expensive' }
+                ])
+            })
+        }
+    };
+});
+describe('Policy:TuitionFeeContinent', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let tuitionFeeContinentPolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            tuitionFeeContinentPolicy = new TuitionFeeContinent(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setResultsCount(10);
+            searchDependenciesHelper.setPageNumber(1);
+            searchDependenciesHelper.setPortalType(PortalType.MASTER);
+        });
+        it('Should return true when all conditions are met', async () => {
+            const continentId = '1'; // Europe
+            const tuitionFee = '[0,2500]'; // Affordable
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.CONTINENT, [continentId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]]
+            ]));
+            const result = await tuitionFeeContinentPolicy.shouldIndex();
+            expect(result).toBe(true);
+        });
+        it('Should return false when multiple continents are selected', async () => {
+            const firstContinentId = '1'; // Europe
+            const secondContinentId = '10'; // Africa
+            const tuitionFee = '[0,2500]'; // Affordable
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.CONTINENT, [firstContinentId, secondContinentId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]]
+            ]));
+            const result = await tuitionFeeContinentPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple tuition fee values are selected', async () => {
+            const continentId = '1'; // Europe
+            const firstTuitionFee = '[0,2500]'; // Affordable
+            const secondTuitionFee = '[2501,5000]';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.CONTINENT, [continentId]],
+                [FilterKey.TUITION_FEE, [firstTuitionFee, secondTuitionFee]]
+            ]));
+            const result = await tuitionFeeContinentPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no continents are selected', async () => {
+            const tuitionFee = '[0,2500]'; // Affordable
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.TUITION_FEE, [tuitionFee]]]));
+            const result = await tuitionFeeContinentPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no tuition fee values are selected', async () => {
+            const continentId = '1'; // Europe
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.CONTINENT, [continentId]]]));
+            const result = await tuitionFeeContinentPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            const continentId = '1'; // Europe
+            const tuitionFee = '[0,2500]'; // Affordable
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.CONTINENT, [continentId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await tuitionFeeContinentPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when number of results is less than 7', async () => {
+            const continentId = '1'; // Europe
+            const tuitionFee = '[0,2500]'; // Affordable
+            const attendance = 'online';
+            searchDependenciesHelper.setResultsCount(6);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.CONTINENT, [continentId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await tuitionFeeContinentPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when page number is higher than 2', async () => {
+            const continentId = '1'; // Europe
+            const tuitionFee = '[0,2500]'; // Affordable
+            searchDependenciesHelper.setPageNumber(5);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.CONTINENT, [continentId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]]
+            ]));
+            const result = await tuitionFeeContinentPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when portal type is distance learning', async () => {
+            const continentId = '1'; // Europe
+            const tuitionFee = '[0,2500]'; // Affordable
+            searchDependenciesHelper.setPortalType(PortalType.DISTANCE_LEARNING);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.CONTINENT, [continentId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]]
+            ]));
+            const result = await tuitionFeeContinentPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateUrls', () => {
+        let sitemapDependenciesHelper;
+        let tuitionFeeContinentPolicy;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setProgrammeCount(10); // More than 7 programs
+            tuitionFeeContinentPolicy = new TuitionFeeContinent(sitemapDependenciesHelper.dependencies);
+            ContinentPresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: '1', path: 'europe' },
+                    { id: '9', path: 'asia' },
+                    { id: '2', path: 'north-america' },
+                    { id: '6', path: 'south-america' },
+                    { id: '4', path: 'africa' }
+                ])
+            });
+            TuitionFeePresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: '[0,2500]', path: 'affordable' },
+                    { id: '[2501,5000]', path: 'moderate' },
+                    { id: '[5001,10000]', path: 'expensive' }
+                ])
+            });
+        });
+        afterEach(() => {
+            sitemapDependenciesHelper.resetMocks();
+        });
+        it('Should generate URLs for valid continent-tuition fee combinations with affordable tuition fees', async () => {
+            // Mock the checkRulesForSitemap to only allow affordable tuition fee options
+            // due to AffordableTuitionFeeRule
+            const resultMap = new Map();
+            // Set up all possible combinations but only allow affordable ones
+            for (const continent of ['1', '9', '2', '6', '4']) {
+                for (const tuitionFee of ['[0,2500]', '[2501,5000]', '[5001,10000]']) {
+                    const key = `${FilterKey.TUITION_FEE}:${tuitionFee}|${FilterKey.CONTINENT}:${continent}`;
+                    // Only affordable tuition fee should pass
+                    resultMap.set(key, tuitionFee === '[0,2500]');
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            // Call the method via reflection since it's protected
+            const urls = await tuitionFeeContinentPolicy.generateUrls();
+            // Calculate expected URLs: 5 continents * 1 tuition fee option (affordable) and page-2 variations = 10 URLs
+            expect(urls).toHaveLength(5);
+            // Verify affordable tuition fee combinations
+            expect(urls).toContain('affordable/europe');
+            expect(urls).toContain('affordable/asia');
+            expect(urls).toContain('affordable/north-america');
+            expect(urls).toContain('affordable/south-america');
+            expect(urls).toContain('affordable/africa');
+            // Verify expensive tuition fees are excluded
+            expect(urls).not.toContain('moderate/europe');
+            expect(urls).not.toContain('expensive/europe');
+        });
+        it('Should exclude specific continent-tuition fee combinations based on rules', async () => {
+            // Create a map that returns false for specific combinations
+            const resultMap = new Map();
+            // Only allow affordable tuition fee, but exclude Europe and Asia
+            for (const continent of ['1', '9', '2', '6', '4']) {
+                for (const tuitionFee of ['[0,2500]', '[2501,5000]', '[5001,10000]']) {
+                    const key = `${FilterKey.TUITION_FEE}:${tuitionFee}|${FilterKey.CONTINENT}:${continent}`;
+                    // Only affordable tuition fee should pass and exclude Europe (1) and Asia (9)
+                    resultMap.set(key, tuitionFee === '[0,2500]' && continent !== '1' && continent !== '9');
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await tuitionFeeContinentPolicy.generateUrls();
+            // Calculate expected URLs: 3 continents (excluding Europe and Asia) * 1 tuition fee option (affordable) and page-2 variations = 6 URLs
+            expect(urls).toHaveLength(3);
+            // Verify excluded combinations
+            expect(urls).not.toContain('affordable/europe');
+            expect(urls).not.toContain('affordable/asia');
+            expect(urls).not.toContain('moderate/europe');
+            // Verify included combinations
+            expect(urls).toContain('affordable/north-america');
+            expect(urls).toContain('affordable/south-america');
+            expect(urls).toContain('affordable/africa');
+        });
+        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 continent of ['1', '9', '2', '6', '4']) {
+                for (const tuitionFee of ['[0,2500]', '[2501,5000]', '[5001,10000]']) {
+                    const key = `${FilterKey.TUITION_FEE}:${tuitionFee}|${FilterKey.CONTINENT}:${continent}`;
+                    resultMap.set(key, false);
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await tuitionFeeContinentPolicy.generateUrls();
+            // Should include no URLs
+            expect(urls).toHaveLength(0);
+        });
+        it('Should handle empty continent fragments', async () => {
+            // Mock the ContinentPresenter to return empty fragments
+            ContinentPresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue([])
+            });
+            sitemapDependenciesHelper.mockCheckRulesForSitemap();
+            const urls = await tuitionFeeContinentPolicy.generateUrls();
+            // Should return empty array
+            expect(urls).toHaveLength(0);
+        });
+        it('Should handle empty tuition fee fragments', async () => {
+            // Mock the TuitionFeePresenter to return empty fragments
+            TuitionFeePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue([])
+            });
+            sitemapDependenciesHelper.mockCheckRulesForSitemap();
+            const urls = await tuitionFeeContinentPolicy.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 largeContinentSet = Array.from({ length: 15 }, (_, index) => ({
+                id: `continent-${index}`,
+                path: `continent-path-${index}`
+            }));
+            const largeTuitionFeeSet = Array.from({ length: 8 }, (_, index) => ({
+                id: `tuition-${index}`,
+                path: `tuition-path-${index}`
+            }));
+            // Override mocks with large datasets
+            ContinentPresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeContinentSet)
+            });
+            TuitionFeePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeTuitionFeeSet)
+            });
+            // Mock to only allow combinations where continent index is even and tuition fee index is 0
+            // This simulates the AffordableTuitionFeeRule that only allows affordable (lowest) tuition fees
+            const resultMap = new Map();
+            for (let c = 0; c < largeContinentSet.length; c++) {
+                for (let t = 0; t < largeTuitionFeeSet.length; t++) {
+                    const continentId = largeContinentSet[c].id;
+                    const tuitionFeeId = largeTuitionFeeSet[t].id;
+                    const key = `${FilterKey.TUITION_FEE}:${tuitionFeeId}|${FilterKey.CONTINENT}:${continentId}`;
+                    resultMap.set(key, c % 2 === 0 && t === 0); // Only even continents and affordable (index 0) tuition
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await tuitionFeeContinentPolicy.generateUrls();
+            // Calculate expected count: 8 continents (even indices) * 1 tuition fee (index 0) * page-2 variations = 16 URLs
+            expect(urls).toHaveLength(8);
+            // Test specific items
+            expect(urls).toContain('tuition-path-0/continent-path-0'); // Even continent, affordable tuition
+            expect(urls).toContain('tuition-path-0/continent-path-2'); // Even continent, affordable tuition
+            expect(urls).not.toContain('tuition-path-0/continent-path-1'); // Odd continent
+            expect(urls).not.toContain('tuition-path-1/continent-path-0'); // Non-affordable tuition
+        });
+    });
+});

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

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

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

@@ -0,0 +1,266 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { SitemapDependencies } from '../utils/SitemapDependencies.util.mjs';
+import { TuitionFeeCountry } from '@/programmes/policies/TuitionFeeCountry';
+import { PortalType } from '@studyportals/domain-client';
+import { CountryPresenter } from '@/presenters/CountryPresenter';
+import { TuitionFeePresenter } from '@/presenters/TuitionFeePresenter';
+describe('Policy:TuitionFeeCountry', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let tuitionFeeCountryPolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            tuitionFeeCountryPolicy = new TuitionFeeCountry(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setResultsCount(10);
+            searchDependenciesHelper.setPageNumber(1);
+            searchDependenciesHelper.setPortalType(PortalType.BACHELOR);
+        });
+        it('Should return true when all conditions are met', async () => {
+            const countryId = '82'; // US
+            const tuitionFee = '[0,2500]'; // Affordable
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]]
+            ]));
+            const result = await tuitionFeeCountryPolicy.shouldIndex();
+            expect(result).toBe(true);
+        });
+        it('Should return false when multiple countries are selected', async () => {
+            const firstCountryId = '30'; // UK
+            const secondCountryId = '21'; // Portugal
+            const tuitionFee = '[0,2500]'; // Affordable
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [firstCountryId, secondCountryId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]]
+            ]));
+            const result = await tuitionFeeCountryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple tuition fee values are selected', async () => {
+            const countryId = '30'; // UK
+            const firstTuitionFee = '[0,2500]'; // Affordable
+            const secondTuitionFee = '[0,3000]';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.TUITION_FEE, [firstTuitionFee, secondTuitionFee]]
+            ]));
+            const result = await tuitionFeeCountryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no tuition fee values are selected', async () => {
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [countryId]]]));
+            const result = await tuitionFeeCountryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no countries are selected', async () => {
+            const tuitionFee = '[0,2500]'; // Affordable
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.TUITION_FEE, [tuitionFee]]]));
+            const result = await tuitionFeeCountryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            const countryId = '30'; // UK
+            const tuitionFee = '[0,2500]'; // Affordable
+            const disciplineId = '54'; // Agriculture & Forestry
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]],
+                [FilterKey.DISCIPLINES, [disciplineId]]
+            ]));
+            const result = await tuitionFeeCountryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when tuition fee is not [0,2500] (affordable)', async () => {
+            const countryId = '30'; // UK
+            const tuitionFee = '[0,3000]';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]]
+            ]));
+            const result = await tuitionFeeCountryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when number of results is less than 7', async () => {
+            const countryId = '30'; // UK
+            const tuitionFee = '[0,2500]'; // Affordable
+            searchDependenciesHelper.setResultsCount(6);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]]
+            ]));
+            const result = await tuitionFeeCountryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when page number is higher than 2', async () => {
+            const countryId = '82'; // US
+            const tuitionFee = '[0,2500]'; // Affordable
+            searchDependenciesHelper.setPageNumber(5);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]]
+            ]));
+            const result = await tuitionFeeCountryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when portal type is distance learning', async () => {
+            const countryId = '82'; // US
+            const tuitionFee = '[0,2500]'; // Affordable
+            searchDependenciesHelper.setPortalType(PortalType.DISTANCE_LEARNING);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]]
+            ]));
+            const result = await tuitionFeeCountryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateUrls', () => {
+        let sitemapDependenciesHelper;
+        let tuitionFeeCountryPolicy;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setProgrammeCount(10); // More than 7 programs
+            tuitionFeeCountryPolicy = new TuitionFeeCountry(sitemapDependenciesHelper.dependencies);
+            CountryPresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: '30', path: 'uk' },
+                    { id: '202', path: 'australia' },
+                    { id: '56', path: 'usa' }
+                ])
+            });
+            TuitionFeePresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: '[0,2500]', path: 'affordable' },
+                    { id: '[2501,5000]', path: 'moderate' },
+                    { id: '[5001,10000]', path: 'expensive' }
+                ])
+            });
+        });
+        afterEach(() => {
+            sitemapDependenciesHelper.resetMocks();
+        });
+        it('Should generate URLs for valid country-tuition fee combinations with affordable tuition fees', async () => {
+            // Mock the checkRulesForSitemap to only allow affordable tuition fee options
+            // due to AffordableTuitionFeeRule
+            const resultMap = new Map();
+            // Set up all possible combinations but only allow affordable ones
+            for (const country of ['30', '202', '56']) {
+                for (const tuitionFee of ['[0,2500]', '[2501,5000]', '[5001,10000]']) {
+                    const key = `${FilterKey.TUITION_FEE}:${tuitionFee}|${FilterKey.COUNTRY}:${country}`;
+                    // Only affordable tuition fee should pass
+                    resultMap.set(key, tuitionFee === '[0,2500]');
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            // Call the method via reflection since it's protected
+            const urls = await tuitionFeeCountryPolicy.generateUrls();
+            // Calculate expected URLs: 3 countries * 1 tuition fee option (affordable) * 1 page = 3 URLs
+            expect(urls).toHaveLength(3);
+            // Verify affordable tuition fee combinations
+            expect(urls).toContain('affordable/uk');
+            expect(urls).toContain('affordable/usa');
+            expect(urls).toContain('affordable/australia');
+            // Verify expensive tuition fees are excluded
+            expect(urls).not.toContain('moderate/uk');
+            expect(urls).not.toContain('expensive/uk');
+        });
+        it('Should exclude specific country-tuition fee combinations based on rules', async () => {
+            // Create a map that returns false for specific combinations
+            const resultMap = new Map();
+            // Only allow affordable tuition fee, but exclude UK
+            for (const country of ['30', '56', '202']) {
+                for (const tuitionFee of ['[0,2500]', '[2501,5000]', '[5001,10000]']) {
+                    const key = `${FilterKey.TUITION_FEE}:${tuitionFee}|${FilterKey.COUNTRY}:${country}`;
+                    // Only affordable tuition fee should pass and exclude UK (30)
+                    resultMap.set(key, tuitionFee === '[0,2500]' && country !== '30');
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap, false);
+            const urls = await tuitionFeeCountryPolicy.generateUrls();
+            // Calculate expected URLs: 2 countries (excluding UK) * 1 tuition fee option * 1 page = 2 URLs
+            expect(urls).toHaveLength(2);
+            // Verify excluded combinations
+            expect(urls).not.toContain('affordable/uk');
+            expect(urls).not.toContain('moderate/uk');
+            // Verify included combinations
+            expect(urls).toContain('affordable/usa');
+            expect(urls).toContain('affordable/australia');
+        });
+        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', '82', '202']) {
+                for (const tuitionFee of ['[0,2500]', '[2501,5000]', '[5001,10000]']) {
+                    const key = `${FilterKey.TUITION_FEE}:${tuitionFee}|${FilterKey.COUNTRY}:${country}`;
+                    resultMap.set(key, false);
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap, false);
+            const urls = await tuitionFeeCountryPolicy.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 tuitionFeeCountryPolicy.generateUrls();
+            // Should return empty array
+            expect(urls).toHaveLength(0);
+        });
+        it('Should handle empty tuition fee fragments', async () => {
+            // Mock the TuitionFeePresenter to return empty fragments
+            TuitionFeePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue([])
+            });
+            sitemapDependenciesHelper.mockCheckRulesForSitemap();
+            const urls = await tuitionFeeCountryPolicy.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 largeCountrySet = Array.from({ length: 30 }, (_, index) => ({
+                id: `country-${index}`,
+                path: `country-path-${index}`
+            }));
+            const largeTuitionFeeSet = Array.from({ length: 5 }, (_, index) => ({
+                id: `tuition-${index}`,
+                path: `tuition-path-${index}`
+            }));
+            // Override mocks with large datasets
+            CountryPresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeCountrySet)
+            });
+            TuitionFeePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeTuitionFeeSet)
+            });
+            // Mock to only allow combinations where country index is even and tuition fee index is 0
+            // This simulates the AffordableTuitionFeeRule that only allows affordable (lowest) tuition fees
+            const resultMap = new Map();
+            for (let c = 0; c < largeCountrySet.length; c++) {
+                for (let t = 0; t < largeTuitionFeeSet.length; t++) {
+                    const countryId = largeCountrySet[c].id;
+                    const tuitionFeeId = largeTuitionFeeSet[t].id;
+                    const key = `${FilterKey.TUITION_FEE}:${tuitionFeeId}|${FilterKey.COUNTRY}:${countryId}`;
+                    resultMap.set(key, c % 2 === 0 && t === 0); // Only even countries and affordable (index 0) tuition
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap, false);
+            const urls = await tuitionFeeCountryPolicy.generateUrls();
+            // Calculate expected count: 15 countries (even indices) * 1 tuition fee (index 0) * 1 page
+            // 15 * 1 * 1 = 15 URLs
+            expect(urls).toHaveLength(15);
+            // Test specific items
+            expect(urls).toContain('tuition-path-0/country-path-0'); // Even country, affordable tuition
+            expect(urls).toContain('tuition-path-0/country-path-2'); // Even country, affordable tuition
+            expect(urls).not.toContain('tuition-path-0/country-path-1'); // Odd country
+            expect(urls).not.toContain('tuition-path-1/country-path-0'); // Non-affordable tuition
+        });
+    });
+});

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

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