@studyportals/fawkes 8.7.0 → 8.7.1-0

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

@@ -0,0 +1,173 @@
+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 { Attendance } from '@/programmes/policies/Attendance';
+import { PortalType } from '@studyportals/domain-client';
+import { AttendancePresenter } from '@/presenters/AttendancePresenter';
+describe('Policy:Attendance', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let attendancePolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            attendancePolicy = new Attendance(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setResultsCount(10);
+            searchDependenciesHelper.setPageNumber(1);
+            searchDependenciesHelper.setPortalType(PortalType.BACHELOR);
+        });
+        it('Should return true when all conditions are met', async () => {
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DELIVERY_METHOD, [attendance]]]));
+            const result = await attendancePolicy.shouldIndex();
+            expect(result).toBe(true);
+        });
+        it('Should return false when multiple attendance values are selected', async () => {
+            const firstAttendance = 'online';
+            const secondAttendance = 'blended';
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DELIVERY_METHOD, [firstAttendance, secondAttendance]]]));
+            const result = await attendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no attendance values are selected', async () => {
+            searchDependenciesHelper.setFilterKeyValues(new Map([]));
+            const result = await attendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            const attendance = 'online';
+            const countryId = '202'; // Australia
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DELIVERY_METHOD, [attendance]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            const result = await attendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when attendance is not online', async () => {
+            const attendance = 'blended';
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DELIVERY_METHOD, [attendance]]]));
+            const result = await attendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when number of results is less than 7', async () => {
+            const attendance = 'online';
+            searchDependenciesHelper.setResultsCount(6);
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DELIVERY_METHOD, [attendance]]]));
+            const result = await attendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when page number is higher than 2', async () => {
+            const attendance = 'online';
+            searchDependenciesHelper.setPageNumber(3);
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DELIVERY_METHOD, [attendance]]]));
+            const result = await attendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when portal is distance learning', async () => {
+            const attendance = 'online';
+            searchDependenciesHelper.setPortalType(PortalType.DISTANCE_LEARNING);
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DELIVERY_METHOD, [attendance]]]));
+            const result = await attendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateUrls', () => {
+        let sitemapDependenciesHelper;
+        let attendancePolicy;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setProgrammeCount(10); // More than 7 programs
+            attendancePolicy = new Attendance(sitemapDependenciesHelper.dependencies);
+            AttendancePresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: 'online', path: 'online-programmes' },
+                    { id: 'face2face', path: 'on-campus-programmes' },
+                    { id: 'blended', path: 'blended-programmes' }
+                ])
+            });
+        });
+        afterEach(() => {
+            sitemapDependenciesHelper.resetMocks();
+        });
+        it('Should generate URLs for online attendance only', async () => {
+            // Mock the checkRulesForSitemap to return true only for online attendance due to OnlineAttendanceRule
+            const resultMap = new Map([
+                [`${FilterKey.DELIVERY_METHOD}:online`, true],
+                [`${FilterKey.DELIVERY_METHOD}:face2face`, false],
+                [`${FilterKey.DELIVERY_METHOD}:blended`, false]
+            ]);
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            // Call the method via reflection since it's protected
+            const urls = await attendancePolicy.generateUrls();
+            // Verify only online attendance was included
+            expect(urls).toHaveLength(1);
+            expect(urls).toContain('online-programmes');
+            expect(urls).not.toContain('on-campus-programmes');
+            expect(urls).not.toContain('blended-programmes');
+        });
+        it('Should exclude all URLs when all checks fail', async () => {
+            // Create a map that returns false for all attendance types
+            const resultMap = new Map([
+                [`${FilterKey.DELIVERY_METHOD}:online`, false],
+                [`${FilterKey.DELIVERY_METHOD}:face2face`, false],
+                [`${FilterKey.DELIVERY_METHOD}:blended`, false]
+            ]);
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await attendancePolicy.generateUrls();
+            // Should include no URLs
+            expect(urls).toHaveLength(0);
+        });
+        it('Should handle empty fragments array', async () => {
+            // Mock the AttendancePresenter to return empty fragments
+            AttendancePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue([])
+            });
+            sitemapDependenciesHelper.mockCheckRulesForSitemap();
+            const urls = await attendancePolicy.generateUrls();
+            // Should return empty array
+            expect(urls).toHaveLength(0);
+        });
+        it('Should handle multiple attendance types if rule allows', async () => {
+            // This is a hypothetical scenario where the rule might allow multiple attendance types
+            // (in production, OnlineAttendanceRule would only allow online)
+            const resultMap = new Map([
+                [`${FilterKey.DELIVERY_METHOD}:online`, true],
+                [`${FilterKey.DELIVERY_METHOD}:face2face`, true],
+                [`${FilterKey.DELIVERY_METHOD}:blended`, false]
+            ]);
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await attendancePolicy.generateUrls();
+            // Should include online and on-campus
+            expect(urls).toHaveLength(2);
+            expect(urls).toContain('online-programmes');
+            expect(urls).toContain('on-campus-programmes');
+            expect(urls).not.toContain('blended-programmes');
+        });
+        it('Should handle performance with a larger set of attendance types', async () => {
+            // Generate more attendance types for testing
+            const largeAttendanceSet = Array.from({ length: 10 }, (_, index) => ({
+                id: `attendance-${index}`,
+                path: `attendance-type-${index}`
+            }));
+            // Mock the AttendancePresenter to return large set
+            AttendancePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeAttendanceSet)
+            });
+            // Mock to only allow attendance types with even indices
+            const resultMap = new Map();
+            for (let i = 0; i < largeAttendanceSet.length; i++) {
+                const attendanceId = largeAttendanceSet[i].id;
+                resultMap.set(`${FilterKey.DELIVERY_METHOD}:${attendanceId}`, i % 2 === 0);
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await attendancePolicy.generateUrls();
+            // Should include half of the attendance types (those with even indices)
+            expect(urls).toHaveLength(5);
+            // Check specific items
+            expect(urls).toContain('attendance-type-0'); // Even index
+            expect(urls).not.toContain('attendance-type-1'); // Odd index
+            expect(urls).toContain('attendance-type-2'); // Even index
+        });
+    });
+});

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

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

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

@@ -0,0 +1,291 @@
+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

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

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

@@ -0,0 +1,169 @@
+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

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