@studyportals/fawkes 8.7.0 → 8.7.1-0

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

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

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

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

@@ -0,0 +1,251 @@
+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 { CountryAttendance } from '@/programmes/policies/CountryAttendance';
+import { PortalType } from '@studyportals/domain-client';
+import { CountryPresenter } from '@/presenters/CountryPresenter';
+import { AttendancePresenter } from '@/presenters/AttendancePresenter';
+describe('Policy:CountryAttendance', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let countryAttendancePolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            countryAttendancePolicy = new CountryAttendance(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setResultsCount(10);
+            searchDependenciesHelper.setPageNumber(1);
+            searchDependenciesHelper.setPortalType(PortalType.PHD);
+        });
+        it('Should return true when all conditions are met', async () => {
+            const countryId = '30'; // UK
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await countryAttendancePolicy.shouldIndex();
+            expect(result).toBe(true);
+        });
+        it('Should return false when multiple countries are selected', async () => {
+            const firstCountryId = '30'; // UK
+            const secondCountryId = '21'; // Portugal
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [firstCountryId, secondCountryId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await countryAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple attendance values are selected', async () => {
+            const countryId = '30'; // UK
+            const firstAttendance = 'online';
+            const secondAttendance = 'face2face';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DELIVERY_METHOD, [firstAttendance, secondAttendance]]
+            ]));
+            const result = await countryAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no attendance values are selected', async () => {
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [countryId]]]));
+            const result = await countryAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no countries are selected', async () => {
+            const degree = 'phd';
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DEGREE_TYPE, [degree]]]));
+            const result = await countryAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            const countryId = '30'; // UK
+            const attendance = 'online';
+            const disciplineId = '54'; // Agriculture & Forestry
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]],
+                [FilterKey.DISCIPLINES, [disciplineId]]
+            ]));
+            const result = await countryAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when attendance is not online', async () => {
+            const countryId = '30'; // UK
+            const attendance = 'blended';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await countryAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when number of results is less than 7', async () => {
+            const countryId = '30'; // UK
+            const degree = 'phd';
+            searchDependenciesHelper.setResultsCount(6);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DELIVERY_METHOD, [degree]]
+            ]));
+            const result = await countryAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when page number is higher than 2', async () => {
+            const countryId = '30'; // UK
+            const attendance = 'online';
+            searchDependenciesHelper.setPageNumber(3);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await countryAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when portal is distance learning', async () => {
+            const countryId = '30'; // UK
+            const attendance = 'online';
+            searchDependenciesHelper.setPortalType(PortalType.DISTANCE_LEARNING);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await countryAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateUrls', () => {
+        let sitemapDependenciesHelper;
+        let countryAttendancePolicy;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setProgrammeCount(10); // More than 7 programs
+            countryAttendancePolicy = new CountryAttendance(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' }
+                ])
+            });
+            AttendancePresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: 'online', path: 'online' },
+                    { id: 'face2face', path: 'on-campus' },
+                    { id: 'blended', path: 'blended' }
+                ])
+            });
+        });
+        afterEach(() => {
+            sitemapDependenciesHelper.resetMocks();
+        });
+        it('Should generate URLs for all valid country-attendance combinations', async () => {
+            // Mock the checkRulesForSitemap to only allow online attendance (due to OnlineAttendanceRule)
+            const resultMap = new Map();
+            // Allow only online attendance (the rule check should pass only for online)
+            for (const countryId of ['30', '21', '56', '82']) {
+                for (const attendanceId of ['online', 'face2face', 'blended']) {
+                    const key = `${FilterKey.COUNTRY}:${countryId}|${FilterKey.DELIVERY_METHOD}:${attendanceId}`;
+                    resultMap.set(key, attendanceId === 'online');
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            // Call the method via reflection since it's protected
+            const urls = await countryAttendancePolicy.generateUrls();
+            // Verify only online attendance URLs were included
+            expect(urls).toHaveLength(4);
+            expect(urls).toContain('online/uk');
+            expect(urls).toContain('online/portugal');
+            expect(urls).toContain('online/netherlands');
+            expect(urls).toContain('online/usa');
+            expect(urls).not.toContain('on-campus/uk');
+            expect(urls).not.toContain('blended/uk');
+        });
+        it('Should exclude certain country-attendance combinations', async () => {
+            // Mock to exclude Australia
+            const resultMap = new Map();
+            // Set up rules to exclude Australia for all attendance modes
+            for (const countryId of ['30', '21', '56', '82']) {
+                for (const attendanceId of ['online', 'face2face', 'blended']) {
+                    const key = `${FilterKey.COUNTRY}:${countryId}|${FilterKey.DELIVERY_METHOD}:${attendanceId}`;
+                    // Exclude UK (30) and only allow online for others
+                    resultMap.set(key, countryId !== '30' && attendanceId === 'online');
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await countryAttendancePolicy.generateUrls();
+            // Should only include Portgual, Netherlands and US
+            expect(urls).toHaveLength(3);
+            expect(urls).toContain('online/portugal');
+            expect(urls).toContain('online/usa');
+            expect(urls).not.toContain('online/uk');
+        });
+        it('Should exclude all URLs when all checks fail', async () => {
+            // Create a map that returns false for all combinations
+            const resultMap = new Map();
+            // Set all combinations to fail
+            for (const countryId of ['30', '21', '56', '82']) {
+                for (const attendanceId of ['online', 'face2face', 'blended']) {
+                    const key = `${FilterKey.COUNTRY}:${countryId}|${FilterKey.DELIVERY_METHOD}:${attendanceId}`;
+                    resultMap.set(key, false);
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap, false);
+            const urls = await countryAttendancePolicy.generateUrls();
+            // Should include no URLs
+            expect(urls).toHaveLength(0);
+        });
+        it('Should handle empty fragments arrays', async () => {
+            // Mock the CountryPresenter to return empty fragments
+            CountryPresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue([])
+            });
+            sitemapDependenciesHelper.mockCheckRulesForSitemap();
+            const urls = await countryAttendancePolicy.generateUrls();
+            // Should return empty array
+            expect(urls).toHaveLength(0);
+        });
+        it('Should handle large number of combinations efficiently', async () => {
+            // Generate a large number of countries (50) and attendance modes (5)
+            const largeCountrySet = Array.from({ length: 50 }, (_, index) => ({
+                id: `${1000 + index}`,
+                path: `country-${1000 + index}`
+            }));
+            const largeAttendanceSet = Array.from({ length: 5 }, (_, index) => ({
+                id: `attendance-${index}`,
+                path: `attendance-type-${index}`
+            }));
+            // Mock the presenters to return large sets
+            CountryPresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeCountrySet)
+            });
+            AttendancePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeAttendanceSet)
+            });
+            // Mock to allow only specific combinations (countries divisible by 3, attendance index 0 or 2)
+            const resultMap = new Map();
+            for (let c = 0; c < largeCountrySet.length; c++) {
+                for (let a = 0; a < largeAttendanceSet.length; a++) {
+                    const countryId = largeCountrySet[c].id;
+                    const attendanceId = largeAttendanceSet[a].id;
+                    const key = `${FilterKey.COUNTRY}:${countryId}|${FilterKey.DELIVERY_METHOD}:${attendanceId}`;
+                    // Only include countries where index is divisible by 3, and attendance indices 0 or 2
+                    resultMap.set(key, c % 3 === 0 && (a === 0 || a === 2));
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await countryAttendancePolicy.generateUrls();
+            // Should generate 17 countries (50/3 rounded up) * 2 attendance types
+            expect(urls).toHaveLength(34);
+            // Test some specific combinations
+            expect(urls).toContain('attendance-type-0/country-1000'); // First country, first attendance
+            expect(urls).toContain('attendance-type-2/country-1000'); // First country, third attendance
+            expect(urls).not.toContain('attendance-type-1/country-1000'); // First country, second attendance (filtered)
+            expect(urls).not.toContain('attendance-type-0/country-1001'); // Second country (filtered)
+        });
+    });
+});

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

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