@studyportals/fawkes 8.7.1-0 → 8.7.1

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

@@ -1,291 +0,0 @@
-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 { AttendanceDegree } from '@/programmes/policies/AttendanceDegree';
-import { PortalType } from '@studyportals/domain-client';
-import { AttendancePresenter } from '@/presenters/AttendancePresenter';
-import { DegreePresenter } from '@/presenters/DegreePresenter';
-describe('Policy:AttendanceDegree', () => {
-    describe('shouldIndex', () => {
-        let searchDependenciesHelper;
-        let attendanceDegreePolicy;
-        beforeEach(() => {
-            searchDependenciesHelper = new SearchDependencies();
-            attendanceDegreePolicy = new AttendanceDegree(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setResultsCount(10);
-            searchDependenciesHelper.setPageNumber(1);
-            searchDependenciesHelper.setPortalType(PortalType.PHD);
-        });
-        it('Should return true when all conditions are met', async () => {
-            const attendance = 'online';
-            const degree = 'phd';
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.DELIVERY_METHOD, [attendance]],
-                [FilterKey.DEGREE_TYPE, [degree]]
-            ]));
-            const result = await attendanceDegreePolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Should return false when multiple attendance values are selected', async () => {
-            const firstAttendance = 'online';
-            const secondAttendance = 'blended';
-            const degree = 'phd';
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.DELIVERY_METHOD, [firstAttendance, secondAttendance]],
-                [FilterKey.DEGREE_TYPE, [degree]]
-            ]));
-            const result = await attendanceDegreePolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when multiple degree values are selected', async () => {
-            const attendance = 'online';
-            const firstDegree = 'phd';
-            const secondDegree = 'mba';
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.DEGREE_TYPE, [firstDegree, secondDegree]],
-                [FilterKey.DELIVERY_METHOD, [attendance]]
-            ]));
-            const result = await attendanceDegreePolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when no attendance values are selected', async () => {
-            const degree = 'phd';
-            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DEGREE_TYPE, [degree]]]));
-            const result = await attendanceDegreePolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when no degree values are selected', async () => {
-            const attendance = 'online';
-            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DELIVERY_METHOD, [attendance]]]));
-            const result = await attendanceDegreePolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when other filters are selected', async () => {
-            const attendance = 'online';
-            const degree = 'phd';
-            const countryId = '202'; // Australia
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.DELIVERY_METHOD, [attendance]],
-                [FilterKey.DEGREE_TYPE, [degree]],
-                [FilterKey.COUNTRY, [countryId]]
-            ]));
-            const result = await attendanceDegreePolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return true when attendance is blended (now allowed)', async () => {
-            const attendance = 'blended';
-            const degree = 'mba';
-            searchDependenciesHelper.setPortalType(PortalType.MASTER);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.DELIVERY_METHOD, [attendance]],
-                [FilterKey.DEGREE_TYPE, [degree]]
-            ]));
-            const result = await attendanceDegreePolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Should return true for blended in shouldIndex (filtered in generateUrls)', async () => {
-            const attendance = 'blended';
-            const degree = 'mba';
-            searchDependenciesHelper.setPortalType(PortalType.MASTER);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.DELIVERY_METHOD, [attendance]],
-                [FilterKey.DEGREE_TYPE, [degree]]
-            ]));
-            const result = await attendanceDegreePolicy.shouldIndex();
-            expect(result).toBe(true); // Basic validation passes, but generateUrls filters for online/blended only
-        });
-        it('Should verify new rule: Blended Learning + Degree is indexable', async () => {
-            const attendance = 'blended';
-            const degree = 'phd';
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.DELIVERY_METHOD, [attendance]],
-                [FilterKey.DEGREE_TYPE, [degree]]
-            ]));
-            const result = await attendanceDegreePolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Should return false when degree is not indexable (i.e. Academy Profession)', async () => {
-            const attendance = 'online';
-            const degree = 'ap';
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.DELIVERY_METHOD, [attendance]],
-                [FilterKey.DEGREE_TYPE, [degree]]
-            ]));
-            const result = await attendanceDegreePolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when number of results is less than 7', async () => {
-            const attendance = 'online';
-            const degree = 'phd';
-            searchDependenciesHelper.setResultsCount(6);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.DELIVERY_METHOD, [attendance]],
-                [FilterKey.DEGREE_TYPE, [degree]]
-            ]));
-            const result = await attendanceDegreePolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when page number is higher than 2', async () => {
-            const attendance = 'online';
-            const degree = 'phd';
-            searchDependenciesHelper.setPageNumber(3);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.DELIVERY_METHOD, [attendance]],
-                [FilterKey.DEGREE_TYPE, [degree]]
-            ]));
-            const result = await attendanceDegreePolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when portal is distance learning', async () => {
-            const attendance = 'online';
-            const degree = 'phd';
-            searchDependenciesHelper.setPortalType(PortalType.DISTANCE_LEARNING);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.DELIVERY_METHOD, [attendance]],
-                [FilterKey.DEGREE_TYPE, [degree]]
-            ]));
-            const result = await attendanceDegreePolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-    });
-    describe('generateUrls', () => {
-        let sitemapDependenciesHelper;
-        let attendanceDegreePolicy;
-        beforeEach(() => {
-            sitemapDependenciesHelper = new SitemapDependencies();
-            sitemapDependenciesHelper.setProgrammeCount(10); // More than 7 programs
-            attendanceDegreePolicy = new AttendanceDegree(sitemapDependenciesHelper.dependencies);
-            AttendancePresenter.getInstance = vi.fn().mockReturnValue({
-                getFragments: vi.fn().mockReturnValue([
-                    { id: 'online', path: 'online' },
-                    { id: 'face2face', path: 'on-campus' },
-                    { id: 'blended', path: 'blended' }
-                ])
-            });
-            DegreePresenter.getInstance = vi.fn().mockReturnValue({
-                getFragments: vi.fn().mockReturnValue([
-                    { id: 'mba', path: 'mba' },
-                    { id: 'msc', path: 'msc' },
-                    { id: 'phd', path: 'phd' },
-                    { id: 'ap', path: 'ap' } // Non-indexable degree
-                ])
-            });
-        });
-        afterEach(() => {
-            sitemapDependenciesHelper.resetMocks();
-        });
-        it('Should generate URLs for valid attendance-degree combinations', async () => {
-            // Mock the checkRulesForSitemap to return true for online and blended attendance
-            // with indexable degrees (not AP)
-            const resultMap = new Map([
-                // Online with different degrees
-                [`${FilterKey.DELIVERY_METHOD}:online|${FilterKey.DEGREE_TYPE}:mba`, true],
-                [`${FilterKey.DELIVERY_METHOD}:online|${FilterKey.DEGREE_TYPE}:msc`, true],
-                [`${FilterKey.DELIVERY_METHOD}:online|${FilterKey.DEGREE_TYPE}:phd`, true],
-                [`${FilterKey.DELIVERY_METHOD}:online|${FilterKey.DEGREE_TYPE}:ap`, false], // Non-indexable degree
-                // Face-to-face with any degree (not allowed in generateUrls)
-                [`${FilterKey.DELIVERY_METHOD}:face2face|${FilterKey.DEGREE_TYPE}:mba`, false],
-                [`${FilterKey.DELIVERY_METHOD}:face2face|${FilterKey.DEGREE_TYPE}:msc`, false],
-                [`${FilterKey.DELIVERY_METHOD}:face2face|${FilterKey.DEGREE_TYPE}:phd`, false],
-                [`${FilterKey.DELIVERY_METHOD}:face2face|${FilterKey.DEGREE_TYPE}:ap`, false],
-                // Blended with indexable degrees (now allowed)
-                [`${FilterKey.DELIVERY_METHOD}:blended|${FilterKey.DEGREE_TYPE}:mba`, true],
-                [`${FilterKey.DELIVERY_METHOD}:blended|${FilterKey.DEGREE_TYPE}:msc`, true],
-                [`${FilterKey.DELIVERY_METHOD}:blended|${FilterKey.DEGREE_TYPE}:phd`, true],
-                [`${FilterKey.DELIVERY_METHOD}:blended|${FilterKey.DEGREE_TYPE}:ap`, false] // Non-indexable degree
-            ]);
-            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
-            // Call the method via reflection since it's protected
-            const urls = await attendanceDegreePolicy.generateUrls();
-            // Verify online and blended with indexable degrees were included
-            expect(urls).toHaveLength(6);
-            expect(urls).toContain('mba/online');
-            expect(urls).toContain('msc/online');
-            expect(urls).toContain('phd/online');
-            expect(urls).toContain('mba/blended');
-            expect(urls).toContain('msc/blended');
-            expect(urls).toContain('phd/blended');
-            // These combinations should be excluded
-            expect(urls).not.toContain('ap/online');
-            expect(urls).not.toContain('ap/blended');
-            expect(urls).not.toContain('mba/face2face');
-        });
-        it('Should exclude all URLs when all checks fail', async () => {
-            // Create a map that returns false for all combinations
-            const resultMap = new Map();
-            for (const attendance of ['online', 'face2face', 'blended']) {
-                for (const degree of ['mba', 'msc', 'phd', 'ap']) {
-                    const key = `${FilterKey.DELIVERY_METHOD}:${attendance}|${FilterKey.DEGREE_TYPE}:${degree}`;
-                    resultMap.set(key, false);
-                }
-            }
-            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
-            const urls = await attendanceDegreePolicy.generateUrls();
-            // Should include no URLs
-            expect(urls).toHaveLength(0);
-        });
-        it('Should handle empty attendance fragments', async () => {
-            // Mock the AttendancePresenter to return empty fragments
-            AttendancePresenter.getInstance.mockReturnValueOnce({
-                getFragments: vi.fn().mockReturnValue([])
-            });
-            sitemapDependenciesHelper.mockCheckRulesForSitemap();
-            const urls = await attendanceDegreePolicy.generateUrls();
-            // Should return empty array
-            expect(urls).toHaveLength(0);
-        });
-        it('Should handle empty degree fragments', async () => {
-            // Mock the DegreePresenter to return empty fragments
-            DegreePresenter.getInstance.mockReturnValueOnce({
-                getFragments: vi.fn().mockReturnValue([])
-            });
-            sitemapDependenciesHelper.mockCheckRulesForSitemap();
-            const urls = await attendanceDegreePolicy.generateUrls();
-            // Should return empty array
-            expect(urls).toHaveLength(0);
-        });
-        it('Should handle performance with large number of combinations', async () => {
-            // Generate larger sets for testing - only include allowed attendance types
-            const largeAttendanceSet = [
-                { id: 'online', path: 'online' },
-                { id: 'blended', path: 'blended' },
-                { id: 'face2face', path: 'on-campus' }, // This won't be used by generateUrls
-                { id: 'parttime', path: 'part-time' }, // This won't be used by generateUrls
-                { id: 'fulltime', path: 'full-time' } // This won't be used by generateUrls
-            ];
-            const largeDegreeSet = Array.from({ length: 10 }, (_, index) => ({
-                id: `degree-${index}`,
-                path: `degree-type-${index}`
-            }));
-            // Override mocks with large datasets
-            AttendancePresenter.getInstance.mockReturnValueOnce({
-                getFragments: vi.fn().mockReturnValue(largeAttendanceSet)
-            });
-            DegreePresenter.getInstance.mockReturnValueOnce({
-                getFragments: vi.fn().mockReturnValue(largeDegreeSet)
-            });
-            // Mock to allow only some combinations
-            const resultMap = new Map();
-            for (const attendance of largeAttendanceSet) {
-                for (let d = 0; d < largeDegreeSet.length; d++) {
-                    const degreeId = largeDegreeSet[d].id;
-                    const key = `${FilterKey.DELIVERY_METHOD}:${attendance.id}|${FilterKey.DEGREE_TYPE}:${degreeId}`;
-                    // Only allow online/blended with even indexed degrees
-                    const isAllowedAttendance = attendance.id === 'online' || attendance.id === 'blended';
-                    resultMap.set(key, isAllowedAttendance && d % 2 === 0);
-                }
-            }
-            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
-            const urls = await attendanceDegreePolicy.generateUrls();
-            // Calculate expected count: 2 attendance types (online, blended) * 5 degrees (0,2,4,6,8)
-            // = 2 * 5 = 10 URLs
-            expect(urls).toHaveLength(10);
-            // Test some specific combinations
-            expect(urls).toContain('degree-type-0/online');
-            expect(urls).toContain('degree-type-4/blended');
-            expect(urls).not.toContain('degree-type-0/on-campus'); // Face2face not allowed
-            expect(urls).not.toContain('degree-type-1/online'); // Odd degree index
-        });
-    });
-});

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

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

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

@@ -1,169 +0,0 @@
-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 { Continent } from '@/programmes/policies/Continent';
-import { PortalType } from '@studyportals/domain-client';
-import { ContinentPresenter } from '@/presenters/ContinentPresenter';
-describe('Policy:Continent', () => {
-    describe('shouldIndex', () => {
-        let searchDependenciesHelper;
-        let continentPolicy;
-        beforeEach(() => {
-            searchDependenciesHelper = new SearchDependencies();
-            continentPolicy = new Continent(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setResultsCount(10);
-            searchDependenciesHelper.setPageNumber(1);
-            searchDependenciesHelper.setPortalType(PortalType.SHORT);
-        });
-        it('Should return true when all conditions are met', async () => {
-            const continentId = '1'; // Europe
-            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.CONTINENT, [continentId]]]));
-            const result = await continentPolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Should return false when multiple continents are selected', async () => {
-            const firstContinentId = '1'; // Europe
-            const secondContinentId = '9'; // Asia
-            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.CONTINENT, [firstContinentId, secondContinentId]]]));
-            const result = await continentPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when no continents are selected', async () => {
-            searchDependenciesHelper.setFilterKeyValues(new Map([]));
-            const result = await continentPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when other filters are selected', async () => {
-            const continentId = '1'; // Europe
-            const disciplineId = '54'; // Agriculture & Forestry
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.CONTINENT, [continentId]],
-                [FilterKey.DISCIPLINES, [disciplineId]]
-            ]));
-            const result = await continentPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when number of results is less than 7', async () => {
-            const continentId = '9'; // Asia
-            searchDependenciesHelper.setResultsCount(6);
-            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.CONTINENT, [continentId]]]));
-            const result = await continentPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when page number is higher than 2', async () => {
-            const continentId = '1'; // Europe
-            searchDependenciesHelper.setPageNumber(5);
-            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.CONTINENT, [continentId]]]));
-            const result = await continentPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when portal type is distance learning', async () => {
-            const continentId = '1'; // Europe
-            searchDependenciesHelper.setPortalType(PortalType.DISTANCE_LEARNING);
-            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.CONTINENT, [continentId]]]));
-            const result = await continentPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-    });
-    describe('generateUrls', () => {
-        let sitemapDependenciesHelper;
-        let continentPolicy;
-        beforeEach(() => {
-            sitemapDependenciesHelper = new SitemapDependencies();
-            sitemapDependenciesHelper.setProgrammeCount(10); // More than 7 programs
-            continentPolicy = new Continent(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' }
-                ])
-            });
-        });
-        afterEach(() => {
-            sitemapDependenciesHelper.resetMocks();
-        });
-        it('Should generate URLs for all valid continents', async () => {
-            // Mock the checkRulesForSitemap to return true for all continent combinations
-            sitemapDependenciesHelper.mockCheckRulesForSitemap();
-            // Call the method via reflection since it's protected
-            const urls = await continentPolicy.generateUrls();
-            // Verify all continent fragments were included
-            expect(urls).toHaveLength(5);
-            expect(urls).toContain('europe');
-            expect(urls).toContain('asia');
-            expect(urls).toContain('north-america');
-            expect(urls).toContain('south-america');
-            expect(urls).toContain('africa');
-        });
-        it('Should exclude URLs that fail rule checks', async () => {
-            // Create a map that returns false for Europe and Africa
-            const resultMap = new Map([
-                [`${FilterKey.CONTINENT}:1`, false],
-                [`${FilterKey.CONTINENT}:4`, false]
-            ]);
-            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
-            const urls = await continentPolicy.generateUrls();
-            // Should only include Asia, North America, and South America
-            expect(urls).toHaveLength(3);
-            expect(urls).toContain('asia');
-            expect(urls).toContain('north-america');
-            expect(urls).toContain('south-america');
-            expect(urls).not.toContain('europe');
-            expect(urls).not.toContain('africa');
-        });
-        it('Should exclude all URLs when all checks fail', async () => {
-            // Create a map that returns false for all continents
-            const resultMap = new Map([
-                [`${FilterKey.CONTINENT}:1`, false],
-                [`${FilterKey.CONTINENT}:9`, false],
-                [`${FilterKey.CONTINENT}:2`, false],
-                [`${FilterKey.CONTINENT}:6`, false],
-                [`${FilterKey.CONTINENT}:4`, false]
-            ]);
-            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
-            const urls = await continentPolicy.generateUrls();
-            // Should include no URLs
-            expect(urls).toHaveLength(0);
-        });
-        it('Should handle empty fragments array', async () => {
-            // Mock the ContinentPresenter to return empty fragments
-            ContinentPresenter.getInstance.mockReturnValueOnce({
-                getFragments: vi.fn().mockReturnValue([])
-            });
-            sitemapDependenciesHelper.mockCheckRulesForSitemap();
-            const urls = await continentPolicy.generateUrls();
-            // Should return empty array
-            expect(urls).toHaveLength(0);
-        });
-        it('Should handle performance with a large number of continents', async () => {
-            // For this test, we'll generate a hypothetical larger set of continents
-            // (in reality there are just a few continents)
-            const largeContinentSet = Array.from({ length: 50 }, (_, index) => ({
-                id: `continent-${index}`,
-                path: `continent-path-${index}`
-            }));
-            // Mock the ContinentPresenter to return large set
-            ContinentPresenter.getInstance.mockReturnValueOnce({
-                getFragments: vi.fn().mockReturnValue(largeContinentSet)
-            });
-            // Mock to allow only continents with even indices
-            const resultMap = new Map();
-            for (let i = 0; i < largeContinentSet.length; i++) {
-                const continentId = largeContinentSet[i].id;
-                resultMap.set(`${FilterKey.CONTINENT}:${continentId}`, i % 2 === 0);
-            }
-            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
-            const urls = await continentPolicy.generateUrls();
-            // Should include half of the continents (those with even indices)
-            expect(urls).toHaveLength(25);
-            // Check specific items
-            expect(urls).toContain('continent-path-0'); // Even index
-            expect(urls).not.toContain('continent-path-1'); // Odd index
-            expect(urls).toContain('continent-path-2'); // Even index
-        });
-    });
-});

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

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

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

@@ -1,164 +0,0 @@
-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 { Country } from '@/programmes/policies/Country';
-import { PortalType } from '@studyportals/domain-client';
-import { CountryPresenter } from '@/presenters/CountryPresenter';
-describe('Policy:Country', () => {
-    describe('shouldIndex', () => {
-        let searchDependenciesHelper;
-        let countryPolicy;
-        beforeEach(() => {
-            searchDependenciesHelper = new SearchDependencies();
-            countryPolicy = new Country(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setResultsCount(10);
-            searchDependenciesHelper.setPageNumber(1);
-            searchDependenciesHelper.setPortalType(PortalType.BACHELOR);
-        });
-        it('Should return true when all conditions are met', async () => {
-            const countryId = '21'; // Portugal
-            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [countryId]]]));
-            const result = await countryPolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Should return false when multiple countries are selected', async () => {
-            const firstCountryId = '30'; // UK
-            const secondCountryId = '21'; // Portugal
-            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [firstCountryId, secondCountryId]]]));
-            const result = await countryPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when no countries are selected', async () => {
-            searchDependenciesHelper.setFilterKeyValues(new Map([]));
-            const result = await countryPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when other filters are selected', async () => {
-            const countryId = '82'; // US
-            const disciplineId = '54'; // Agriculture & Forestry
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.COUNTRY, [countryId]],
-                [FilterKey.DISCIPLINES, [disciplineId]]
-            ]));
-            const result = await countryPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when number of results is less than 7', async () => {
-            const countryId = '1'; // Netherlands
-            searchDependenciesHelper.setResultsCount(6);
-            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [countryId]]]));
-            const result = await countryPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when page number is higher than 2', async () => {
-            const countryId = '21'; // Portugal
-            searchDependenciesHelper.setPageNumber(7);
-            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [countryId]]]));
-            const result = await countryPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when portal type is distance learning', async () => {
-            const countryId = '21'; // Portugal
-            searchDependenciesHelper.setPortalType(PortalType.DISTANCE_LEARNING);
-            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [countryId]]]));
-            const result = await countryPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-    });
-    describe('generateUrls', () => {
-        let sitemapDependenciesHelper;
-        let countryPolicy;
-        beforeEach(() => {
-            sitemapDependenciesHelper = new SitemapDependencies();
-            sitemapDependenciesHelper.setProgrammeCount(10); // More than 7 programs
-            countryPolicy = new Country(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' }
-                ])
-            });
-        });
-        afterEach(() => {
-            sitemapDependenciesHelper.resetMocks();
-        });
-        it('Should generate URLs for all valid countries', async () => {
-            // Mock the checkRulesForSitemap to return true for all country combinations
-            sitemapDependenciesHelper.mockCheckRulesForSitemap();
-            // Call the method via reflection since it's protected
-            const urls = await countryPolicy.generateUrls();
-            // Verify all country fragments were included (4 countries * 1 page = 4 URLs)
-            expect(urls).toHaveLength(4);
-            expect(urls).toContain('uk');
-            expect(urls).toContain('portugal');
-            expect(urls).toContain('usa');
-            expect(urls).toContain('netherlands');
-        });
-        it('Should exclude URLs that fail rule checks', async () => {
-            // Create a map that returns false for UK and Netherlands
-            const resultMap = new Map([
-                [`${FilterKey.COUNTRY}:30`, false],
-                [`${FilterKey.COUNTRY}:82`, false]
-            ]);
-            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
-            const urls = await countryPolicy.generateUrls();
-            // Should only include Portugal and USA (2 countries * 1 page = 2 URLs)
-            expect(urls).toHaveLength(2);
-            expect(urls).toContain('portugal');
-            expect(urls).toContain('usa');
-            expect(urls).not.toContain('uk');
-            expect(urls).not.toContain('netherlands');
-        });
-        it('Should exclude all URLs when all checks fail', async () => {
-            // Create a map that returns false for all countries
-            const resultMap = new Map([
-                [`${FilterKey.COUNTRY}:30`, false],
-                [`${FilterKey.COUNTRY}:21`, false],
-                [`${FilterKey.COUNTRY}:56`, false],
-                [`${FilterKey.COUNTRY}:82`, false]
-            ]);
-            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
-            const urls = await countryPolicy.generateUrls();
-            // Should include no URLs
-            expect(urls).toHaveLength(0);
-        });
-        it('Should handle empty fragments array', async () => {
-            // Mock the CountryPresenter to return empty fragments
-            CountryPresenter.getInstance.mockReturnValueOnce({
-                getFragments: vi.fn().mockReturnValue([])
-            });
-            sitemapDependenciesHelper.mockCheckRulesForSitemap();
-            const urls = await countryPolicy.generateUrls();
-            // Should return empty array
-            expect(urls).toHaveLength(0);
-        });
-        it('Should handle performance with a large number of countries', async () => {
-            // Generate a large number of country fragments
-            const largeCountrySet = Array.from({ length: 200 }, (_, index) => ({
-                id: `country-${index}`,
-                path: `country-path-${index}`
-            }));
-            // Mock the CountryPresenter to return large set
-            CountryPresenter.getInstance.mockReturnValueOnce({
-                getFragments: vi.fn().mockReturnValue(largeCountrySet)
-            });
-            // Mock to allow only countries with even indices
-            const resultMap = new Map();
-            for (let i = 0; i < largeCountrySet.length; i++) {
-                const countryId = largeCountrySet[i].id;
-                resultMap.set(`${FilterKey.COUNTRY}:${countryId}`, i % 2 === 0);
-            }
-            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap, false);
-            const urls = await countryPolicy.generateUrls();
-            // Should include half of the countries (those with even indices) * 1 page
-            expect(urls).toHaveLength(100); // 100 countries * 1 page
-            // Check specific items
-            expect(urls).toContain('country-path-0'); // Even index
-            expect(urls).not.toContain('country-path-1'); // Odd index
-            expect(urls).toContain('country-path-2'); // Even index
-        });
-    });
-});

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

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