@studyportals/fawkes 8.7.1-0 → 8.7.1

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

@@ -1,253 +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 { CountryFormat } from '@/programmes/policies/CountryFormat';
-import { PortalType } from '@studyportals/domain-client';
-import { SitemapDependencies } from '../utils/SitemapDependencies.util.mjs';
-import { CountryPresenter } from '@/presenters/CountryPresenter';
-import { FormatPresenter } from '@/presenters/FormatPresenter';
-describe('Policy:CountryFormat', () => {
-    describe('shouldIndex', () => {
-        let searchDependenciesHelper;
-        let countryFormatPolicy;
-        beforeEach(() => {
-            searchDependenciesHelper = new SearchDependencies();
-            countryFormatPolicy = new CountryFormat(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setResultsCount(10);
-            searchDependenciesHelper.setPageNumber(1);
-            searchDependenciesHelper.setPortalType(PortalType.MASTER);
-        });
-        it('Should return true when all conditions are met', async () => {
-            const countryId = '82'; // US
-            const format = 'parttime';
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.COUNTRY, [countryId]],
-                [FilterKey.ATTENDANCE, [format]]
-            ]));
-            const result = await countryFormatPolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Should return false when multiple countries are selected', async () => {
-            const firstCountryId = '30'; // UK
-            const secondCountryId = '21'; // Portugal
-            const format = 'parttime';
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.COUNTRY, [firstCountryId, secondCountryId]],
-                [FilterKey.ATTENDANCE, [format]]
-            ]));
-            const result = await countryFormatPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when multiple format values are selected', async () => {
-            const countryId = '30'; // UK
-            const firstFormat = 'parttime';
-            const secondFormat = 'fulltime';
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.COUNTRY, [countryId]],
-                [FilterKey.ATTENDANCE, [firstFormat, secondFormat]]
-            ]));
-            const result = await countryFormatPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when no format values are selected', async () => {
-            const countryId = '30'; // UK
-            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [countryId]]]));
-            const result = await countryFormatPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when no countries are selected', async () => {
-            const format = 'parttime';
-            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.EDUCATIONAL_FORM, [format]]]));
-            const result = await countryFormatPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when other filters are selected', async () => {
-            const countryId = '30'; // UK
-            const format = 'parttime';
-            const disciplineId = '54'; // Agriculture & Forestry
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.COUNTRY, [countryId]],
-                [FilterKey.ATTENDANCE, [format]],
-                [FilterKey.DISCIPLINES, [disciplineId]]
-            ]));
-            const result = await countryFormatPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when format is not part-time', async () => {
-            const countryId = '30'; // UK
-            const format = 'fulltime';
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.COUNTRY, [countryId]],
-                [FilterKey.ATTENDANCE, [format]]
-            ]));
-            const result = await countryFormatPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when number of results is less than 7', async () => {
-            const countryId = '30'; // UK
-            const format = 'parttime';
-            searchDependenciesHelper.setResultsCount(6);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.COUNTRY, [countryId]],
-                [FilterKey.ATTENDANCE, [format]]
-            ]));
-            const result = await countryFormatPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when page number is higher than 2', async () => {
-            const countryId = '82'; // US
-            const format = 'parttime';
-            searchDependenciesHelper.setPageNumber(5);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.COUNTRY, [countryId]],
-                [FilterKey.ATTENDANCE, [format]]
-            ]));
-            const result = await countryFormatPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when portal is distance learning', async () => {
-            const countryId = '82'; // US
-            const format = 'parttime';
-            searchDependenciesHelper.setPortalType(PortalType.DISTANCE_LEARNING);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.COUNTRY, [countryId]],
-                [FilterKey.ATTENDANCE, [format]]
-            ]));
-            const result = await countryFormatPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-    });
-    describe('generateUrls', () => {
-        let sitemapDependenciesHelper;
-        let countryFormatPolicy;
-        beforeEach(() => {
-            sitemapDependenciesHelper = new SitemapDependencies();
-            sitemapDependenciesHelper.setProgrammeCount(10); // More than 7 programs
-            countryFormatPolicy = new CountryFormat(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' }
-                ])
-            });
-            FormatPresenter.getInstance = vi.fn().mockReturnValue({
-                getFragments: vi.fn().mockReturnValue([
-                    { id: 'parttime', path: 'part-time-programmes' },
-                    { id: 'fulltime', path: 'full-time-programmes' }
-                ])
-            });
-        });
-        afterEach(() => {
-            sitemapDependenciesHelper.resetMocks();
-        });
-        it('Should generate URLs for all valid country-format combinations', async () => {
-            // Mock the checkRulesForSitemap to only allow part-time format
-            const resultMap = new Map();
-            // Set rules to only allow part-time format (as per shouldIndex test)
-            for (const countryId of ['30', '21', '56', '82']) {
-                for (const formatId of ['parttime', 'fulltime']) {
-                    const key = `${FilterKey.ATTENDANCE}:${formatId}|${FilterKey.COUNTRY}:${countryId}`;
-                    resultMap.set(key, formatId === 'parttime');
-                }
-            }
-            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
-            // Call the method via reflection since it's protected
-            const urls = await countryFormatPolicy.generateUrls();
-            // Verify only part-time and full-time format is included (2 format * 4 countries * 1 pages = 8 URLs)
-            expect(urls).toHaveLength(8);
-            expect(urls).toContain('part-time-programmes/uk');
-            expect(urls).toContain('part-time-programmes/portugal');
-            expect(urls).toContain('part-time-programmes/usa');
-            expect(urls).toContain('part-time-programmes/netherlands');
-            expect(urls).toContain('full-time-programmes/uk');
-            expect(urls).toContain('full-time-programmes/portugal');
-        });
-        it('Should exclude certain country-format combinations', async () => {
-            // Mock to exclude UK combinations
-            const resultMap = new Map();
-            // Set up rules to exclude UK for all formats
-            for (const countryId of ['30', '21', '56', '82']) {
-                for (const formatId of ['parttime', 'fulltime']) {
-                    const key = `${FilterKey.COUNTRY}:${countryId}|${FilterKey.ATTENDANCE}:${formatId}`;
-                    // Exclude UK (30) and only allow part-time for others
-                    resultMap.set(key, countryId !== '30' && formatId === 'parttime');
-                }
-            }
-            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
-            const urls = await countryFormatPolicy.generateUrls();
-            // Should include others but not UK (1 format * 3 countries * 2 pages = 6 URLs)
-            expect(urls).toHaveLength(3);
-            expect(urls).toContain('part-time-programmes/portugal');
-            expect(urls).toContain('part-time-programmes/usa');
-            expect(urls).toContain('part-time-programmes/netherlands');
-            expect(urls).not.toContain('part-time-programmes/uk');
-            expect(urls).not.toContain('full-time-programmes/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 formatId of ['parttime', 'fulltime']) {
-                    const key = `${FilterKey.ATTENDANCE}:${formatId}|${FilterKey.COUNTRY}:${countryId}`;
-                    resultMap.set(key, false);
-                }
-            }
-            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap, false);
-            const urls = await countryFormatPolicy.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 countryFormatPolicy.generateUrls();
-            // Should return empty array
-            expect(urls).toHaveLength(0);
-        });
-        it('Should handle large number of combinations efficiently', async () => {
-            // Generate a larger set of countries (20) and format types (3)
-            const largeCountrySet = Array.from({ length: 20 }, (_, index) => ({
-                id: `${1000 + index}`,
-                path: `country-${1000 + index}`
-            }));
-            const largeFormatSet = Array.from({ length: 3 }, (_, index) => ({
-                id: `format-${index}`,
-                path: `format-type-${index}`
-            }));
-            // Mock the presenters to return large sets
-            CountryPresenter.getInstance.mockReturnValueOnce({
-                getFragments: vi.fn().mockReturnValue(largeCountrySet)
-            });
-            FormatPresenter.getInstance.mockReturnValueOnce({
-                getFragments: vi.fn().mockReturnValue(largeFormatSet)
-            });
-            // Mock to allow only specific combinations
-            // Only allow countries divisible by 3, and format index 0 (part-time equivalent)
-            const resultMap = new Map();
-            for (let c = 0; c < largeCountrySet.length; c++) {
-                for (let f = 0; f < largeFormatSet.length; f++) {
-                    const countryId = largeCountrySet[c].id;
-                    const formatId = largeFormatSet[f].id;
-                    const key = `${FilterKey.COUNTRY}:${countryId}|${FilterKey.ATTENDANCE}:${formatId}`;
-                    // Only include countries where index is divisible by 3, and format index 0
-                    resultMap.set(key, c % 3 === 0 && f === 0);
-                }
-            }
-            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
-            const urls = await countryFormatPolicy.generateUrls();
-            // Should generate 7 countries (20/3 rounded up) * 1 format type * 2 pages = 14 URLs
-            expect(urls).toHaveLength(7);
-            // Test some specific combinations
-            expect(urls).toContain('format-type-0/country-1000'); // First valid country, allowed format
-            expect(urls).toContain('format-type-0/country-1003'); // Another valid country, allowed format
-            expect(urls).not.toContain('format-type-0/country-1001'); // Invalid country (not divisible by 3)
-            expect(urls).not.toContain('format-type-1/country-1000'); // Valid country, but invalid format
-        });
-    });
-});

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

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

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

@@ -1,179 +0,0 @@
-import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
-import { FilterKey } from '@studyportals/search-filters/server-side';
-import { PortalType } from '@studyportals/domain-client';
-import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
-import { SitemapDependencies } from '../utils/SitemapDependencies.util.mjs';
-import { DegreeAttendanceDiscipline } from '@/programmes/policies/DegreeAttendanceDiscipline';
-import { DegreePresenter } from '@/presenters/DegreePresenter';
-import { AttendancePresenter } from '@/presenters/AttendancePresenter';
-import { DisciplinePresenter } from '@/presenters/DisciplinePresenter';
-describe('Policy:DegreeAttendanceDiscipline', () => {
-    describe('shouldIndex', () => {
-        let searchDependenciesHelper;
-        let degreeAttendanceDisciplinePolicy;
-        beforeEach(() => {
-            searchDependenciesHelper = new SearchDependencies();
-            degreeAttendanceDisciplinePolicy = new DegreeAttendanceDiscipline(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setResultsCount(7);
-            searchDependenciesHelper.setPageNumber(1);
-            searchDependenciesHelper.setPortalType(PortalType.MASTER);
-        });
-        describe('valid degree combinations', () => {
-            it.each([
-                'msc',
-                'ma',
-                'mba'
-            ])('Should return true for %s with online attendance and any discipline', async (degreeType) => {
-                searchDependenciesHelper.setFilterKeyValues(new Map([
-                    [FilterKey.DEGREE_TYPE, [degreeType]],
-                    [FilterKey.DELIVERY_METHOD, ['online']],
-                    [FilterKey.DISCIPLINES, ['54']] // Any discipline
-                ]));
-                const result = await degreeAttendanceDisciplinePolicy.shouldIndex();
-                expect(result).toBe(true);
-            });
-        });
-        describe('invalid combinations', () => {
-            it('Should return false for valid degrees with non-online attendance', async () => {
-                searchDependenciesHelper.setFilterKeyValues(new Map([
-                    [FilterKey.DEGREE_TYPE, ['msc']],
-                    [FilterKey.DELIVERY_METHOD, ['on-campus']], // Non-online
-                    [FilterKey.DISCIPLINES, ['54']]
-                ]));
-                const result = await degreeAttendanceDisciplinePolicy.shouldIndex();
-                expect(result).toBe(false);
-            });
-            it('Should return false for unsupported degree types', async () => {
-                searchDependenciesHelper.setFilterKeyValues(new Map([
-                    [FilterKey.DEGREE_TYPE, ['llm']], // Not supported by this policy
-                    [FilterKey.DELIVERY_METHOD, ['online']],
-                    [FilterKey.DISCIPLINES, ['54']]
-                ]));
-                const result = await degreeAttendanceDisciplinePolicy.shouldIndex();
-                expect(result).toBe(false);
-            });
-        });
-        describe('filter validation', () => {
-            it('Should return false when multiple degrees are selected', async () => {
-                searchDependenciesHelper.setFilterKeyValues(new Map([
-                    [FilterKey.DEGREE_TYPE, ['msc', 'ma']],
-                    [FilterKey.DELIVERY_METHOD, ['online']],
-                    [FilterKey.DISCIPLINES, ['54']]
-                ]));
-                const result = await degreeAttendanceDisciplinePolicy.shouldIndex();
-                expect(result).toBe(false);
-            });
-            it('Should return false when multiple attendance methods are selected', async () => {
-                searchDependenciesHelper.setFilterKeyValues(new Map([
-                    [FilterKey.DEGREE_TYPE, ['msc']],
-                    [FilterKey.DELIVERY_METHOD, ['online', 'on-campus']],
-                    [FilterKey.DISCIPLINES, ['54']]
-                ]));
-                const result = await degreeAttendanceDisciplinePolicy.shouldIndex();
-                expect(result).toBe(false);
-            });
-            it('Should return false when multiple disciplines are selected', async () => {
-                searchDependenciesHelper.setFilterKeyValues(new Map([
-                    [FilterKey.DEGREE_TYPE, ['msc']],
-                    [FilterKey.DELIVERY_METHOD, ['online']],
-                    [FilterKey.DISCIPLINES, ['54', '12']]
-                ]));
-                const result = await degreeAttendanceDisciplinePolicy.shouldIndex();
-                expect(result).toBe(false);
-            });
-            it('Should return false when other filters are selected', async () => {
-                searchDependenciesHelper.setFilterKeyValues(new Map([
-                    [FilterKey.DEGREE_TYPE, ['msc']],
-                    [FilterKey.DELIVERY_METHOD, ['online']],
-                    [FilterKey.DISCIPLINES, ['54']],
-                    [FilterKey.COUNTRY, ['82']] // Extra filter
-                ]));
-                const result = await degreeAttendanceDisciplinePolicy.shouldIndex();
-                expect(result).toBe(false);
-            });
-        });
-        it('Should return false when number of results is less than 7', async () => {
-            searchDependenciesHelper.setResultsCount(6);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.DEGREE_TYPE, ['msc']],
-                [FilterKey.DELIVERY_METHOD, ['online']],
-                [FilterKey.DISCIPLINES, ['54']]
-            ]));
-            const result = await degreeAttendanceDisciplinePolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-    });
-    describe('generateUrls', () => {
-        let sitemapDependenciesHelper;
-        let degreeAttendanceDisciplinePolicy;
-        beforeEach(() => {
-            sitemapDependenciesHelper = new SitemapDependencies();
-            sitemapDependenciesHelper.setProgrammeCount(10);
-            degreeAttendanceDisciplinePolicy = new DegreeAttendanceDiscipline(sitemapDependenciesHelper.dependencies);
-            DegreePresenter.getInstance = vi.fn().mockReturnValue({
-                getFragments: vi.fn().mockReturnValue([
-                    { id: 'msc', path: 'masters' },
-                    { id: 'ma', path: 'ma' },
-                    { id: 'mba', path: 'mba' },
-                    { id: 'llm', path: 'llm' } // Not supported by this policy
-                ])
-            });
-            AttendancePresenter.getInstance = vi.fn().mockReturnValue({
-                getFragments: vi.fn().mockReturnValue([
-                    { id: 'online', path: 'online' },
-                    { id: 'on-campus', path: 'on-campus' }
-                ])
-            });
-            DisciplinePresenter.getInstance = vi.fn().mockReturnValue({
-                getFragments: vi.fn().mockReturnValue([
-                    { id: '54', path: 'agriculture-forestry' },
-                    { id: '12', path: 'applied-sciences' },
-                    { id: '356', path: 'computer-science' }
-                ])
-            });
-        });
-        afterEach(() => {
-            sitemapDependenciesHelper.resetMocks();
-        });
-        it('Should generate URLs for supported degrees with online attendance and all disciplines', async () => {
-            const resultMap = new Map();
-            // Supported degrees: MSc, MA, MBA
-            const supportedDegrees = ['msc', 'ma', 'mba'];
-            const disciplines = ['54', '12', '356'];
-            for (const degree of supportedDegrees) {
-                for (const discipline of disciplines) {
-                    const key = `${FilterKey.DEGREE_TYPE}:${degree}|${FilterKey.DELIVERY_METHOD}:online|${FilterKey.DISCIPLINES}:${discipline}`;
-                    resultMap.set(key, true);
-                }
-            }
-            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
-            const urls = await degreeAttendanceDisciplinePolicy.generateUrls();
-            // 3 degrees * 3 disciplines * 2 pages = 18 URLs
-            expect(urls.length).toBeGreaterThan(0);
-            expect(urls).toContain('masters/online/agriculture-forestry');
-            expect(urls).toContain('ma/online/applied-sciences');
-            expect(urls).toContain('mba/online/computer-science');
-        });
-        it('Should exclude unsupported degrees', async () => {
-            const resultMap = new Map();
-            // Only allow supported degrees
-            const supportedDegrees = ['msc', 'ma', 'mba'];
-            const allDegrees = ['msc', 'ma', 'mba', 'llm'];
-            const disciplines = ['54', '12', '356'];
-            for (const degree of allDegrees) {
-                for (const discipline of disciplines) {
-                    const key = `${FilterKey.DEGREE_TYPE}:${degree}|${FilterKey.DELIVERY_METHOD}:online|${FilterKey.DISCIPLINES}:${discipline}`;
-                    // Only allow supported degrees
-                    resultMap.set(key, supportedDegrees.includes(degree));
-                }
-            }
-            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
-            const urls = await degreeAttendanceDisciplinePolicy.generateUrls();
-            // Should include supported degrees
-            expect(urls).toContain('masters/online/agriculture-forestry');
-            expect(urls).toContain('mba/online/computer-science');
-            // Should not include unsupported degrees
-            expect(urls).not.toContain('llm/online/agriculture-forestry');
-        });
-    });
-});

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

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