@studyportals/fawkes 8.7.1-0 → 8.7.1

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

@@ -1,262 +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 { CountryDegree } from '@/programmes/policies/CountryDegree';
-import { PortalType } from '@studyportals/domain-client';
-import { CountryPresenter } from '@/presenters/CountryPresenter';
-import { DegreePresenter } from '@/presenters/DegreePresenter';
-describe('Policy:CountryDegree', () => {
-    describe('shouldIndex', () => {
-        let searchDependenciesHelper;
-        let countryDegreePolicy;
-        beforeEach(() => {
-            searchDependenciesHelper = new SearchDependencies();
-            countryDegreePolicy = new CountryDegree(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setResultsCount(10);
-            searchDependenciesHelper.setPageNumber(1);
-            searchDependenciesHelper.setPortalType(PortalType.MASTER);
-        });
-        it('Should return true when all conditions are met', async () => {
-            const countryId = '30'; // UK
-            const degree = 'phd';
-            searchDependenciesHelper.setPortalType(PortalType.PHD);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.COUNTRY, [countryId]],
-                [FilterKey.DEGREE_TYPE, [degree]]
-            ]));
-            const result = await countryDegreePolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Should return false when multiple countries are selected', async () => {
-            const firstCountryId = '30'; // UK
-            const secondCountryId = '21'; // Portugal
-            const degree = 'mba';
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.COUNTRY, [firstCountryId, secondCountryId]],
-                [FilterKey.DEGREE_TYPE, [degree]]
-            ]));
-            const result = await countryDegreePolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when multiple degree values are selected', async () => {
-            const countryId = '30'; // UK
-            const firstDegree = 'phd';
-            const secondDegree = 'mba';
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.COUNTRY, [countryId]],
-                [FilterKey.DEGREE_TYPE, [firstDegree, secondDegree]]
-            ]));
-            const result = await countryDegreePolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when no degree values are selected', async () => {
-            const countryId = '30'; // UK
-            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [countryId]]]));
-            const result = await countryDegreePolicy.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 countryDegreePolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when other filters are selected', async () => {
-            const countryId = '30'; // UK
-            const degree = 'phd';
-            const disciplineId = '54'; // Agriculture & Forestry
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.COUNTRY, [countryId]],
-                [FilterKey.DEGREE_TYPE, [degree]],
-                [FilterKey.DISCIPLINES, [disciplineId]]
-            ]));
-            const result = await countryDegreePolicy.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.DEGREE_TYPE, [degree]]
-            ]));
-            const result = await countryDegreePolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when page number is higher than 2', async () => {
-            const countryId = '30'; // UK
-            const degree = 'phd';
-            searchDependenciesHelper.setPageNumber(3);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.COUNTRY, [countryId]],
-                [FilterKey.DEGREE_TYPE, [degree]]
-            ]));
-            const result = await countryDegreePolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when portal is distance learning', async () => {
-            const countryId = '30'; // UK
-            const degree = 'phd';
-            searchDependenciesHelper.setPortalType(PortalType.DISTANCE_LEARNING);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.COUNTRY, [countryId]],
-                [FilterKey.DEGREE_TYPE, [degree]]
-            ]));
-            const result = await countryDegreePolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-    });
-    describe('generateUrls', () => {
-        let sitemapDependenciesHelper;
-        let countryDegreePolicy;
-        beforeEach(() => {
-            sitemapDependenciesHelper = new SitemapDependencies();
-            sitemapDependenciesHelper.setProgrammeCount(10); // More than 7 programs
-            countryDegreePolicy = new CountryDegree(sitemapDependenciesHelper.dependencies);
-            CountryPresenter.getInstance = vi.fn().mockReturnValue({
-                getFragments: vi.fn().mockReturnValue([
-                    { id: '30', path: 'uk' },
-                    { id: '202', path: 'australia' },
-                    { id: '56', path: 'usa' }
-                ])
-            });
-            DegreePresenter.getInstance = vi.fn().mockReturnValue({
-                getFragments: vi.fn().mockReturnValue([
-                    { id: 'mba', path: 'mba' },
-                    { id: 'msc', path: 'msc' },
-                    { id: 'phd', path: 'phd' },
-                    { id: 'adiploma', path: 'adiploma' } // Non-indexable degree
-                ])
-            });
-        });
-        afterEach(() => {
-            sitemapDependenciesHelper.resetMocks();
-        });
-        it('Should generate URLs for valid country-degree combinations', async () => {
-            // Mock the checkRulesForSitemap to filter out adiploma for all countries
-            // due to IndexableDegreeRule
-            const resultMap = new Map();
-            // Set up all possible combinations
-            for (const country of ['30', '202', '56']) {
-                for (const degree of ['mba', 'msc', 'phd', 'adiploma']) {
-                    const key = `${FilterKey.COUNTRY}:${country}|${FilterKey.DEGREE_TYPE}:${degree}`;
-                    // adiploma should be filtered out by IndexableDegreeRule
-                    resultMap.set(key, degree !== 'adiploma');
-                }
-            }
-            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
-            // Call the method via reflection since it's protected
-            const urls = await countryDegreePolicy.generateUrls();
-            // Calculate expected URLs: 3 countries * 3 degrees (excluding adiploma) * 1 page = 9 URLs
-            expect(urls).toHaveLength(9);
-            // Verify paths structure
-            expect(urls).toContain('mba/uk');
-            expect(urls).toContain('msc/australia');
-            expect(urls).toContain('phd/usa');
-            // Verify adiploma is excluded
-            expect(urls).not.toContain('adiploma/uk');
-            expect(urls).not.toContain('adiploma/australia');
-            expect(urls).not.toContain('adiploma/usa');
-        });
-        it('Should exclude specific country-degree combinations based on rules', async () => {
-            // Create a map that returns false for specific combinations
-            const resultMap = new Map();
-            // Set UK with mba and USA with phd to fail, along with all adiploma combinations
-            for (const country of ['30', '202', '56']) {
-                for (const degree of ['mba', 'msc', 'phd', 'adiploma']) {
-                    const key = `${FilterKey.COUNTRY}:${country}|${FilterKey.DEGREE_TYPE}:${degree}`;
-                    const shouldPass = degree !== 'adiploma' && // All adiploma should fail
-                        !(country === '30' && degree === 'mba') && // UK with MBA should fail
-                        !(country === '56' && degree === 'phd'); // USA with PhD should fail
-                    resultMap.set(key, shouldPass);
-                }
-            }
-            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
-            const urls = await countryDegreePolicy.generateUrls();
-            // Calculate expected URLs: 9 total combinations - 2 specific exclusions - 3 adiploma exclusions * 1 page = 7 URLs
-            expect(urls).toHaveLength(7);
-            // Verify excluded combinations
-            expect(urls).not.toContain('mba/uk');
-            expect(urls).not.toContain('phd/usa');
-            expect(urls).not.toContain('adiploma/uk');
-            // Verify included combinations
-            expect(urls).toContain('msc/uk');
-            expect(urls).toContain('phd/uk');
-            expect(urls).toContain('mba/usa');
-        });
-        it('Should exclude all URLs when all rule checks fail', async () => {
-            // Create a map that returns false for all combinations
-            const resultMap = new Map();
-            for (const country of ['30', '202', '56']) {
-                for (const degree of ['mba', 'msc', 'phd', 'adiploma']) {
-                    const key = `${FilterKey.COUNTRY}:${country}|${FilterKey.DEGREE_TYPE}:${degree}`;
-                    resultMap.set(key, false);
-                }
-            }
-            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
-            const urls = await countryDegreePolicy.generateUrls();
-            // Should include no URLs
-            expect(urls).toHaveLength(0);
-        });
-        it('Should handle empty country fragments', async () => {
-            // Mock the CountryPresenter to return empty fragments
-            CountryPresenter.getInstance.mockReturnValueOnce({
-                getFragments: vi.fn().mockReturnValue([])
-            });
-            sitemapDependenciesHelper.mockCheckRulesForSitemap();
-            const urls = await countryDegreePolicy.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 countryDegreePolicy.generateUrls();
-            // Should return empty array
-            expect(urls).toHaveLength(0);
-        });
-        it('Should handle performance with large number of combinations', async () => {
-            // Generate larger datasets for testing
-            const largeCountrySet = Array.from({ length: 20 }, (_, index) => ({
-                id: `country-${index}`,
-                path: `country-path-${index}`
-            }));
-            const largeDegreeSet = Array.from({ length: 10 }, (_, index) => ({
-                id: `degree-${index}`,
-                path: `degree-path-${index}`
-            }));
-            // Override mocks with large datasets
-            CountryPresenter.getInstance.mockReturnValueOnce({
-                getFragments: vi.fn().mockReturnValue(largeCountrySet)
-            });
-            DegreePresenter.getInstance.mockReturnValueOnce({
-                getFragments: vi.fn().mockReturnValue(largeDegreeSet)
-            });
-            // Mock to allow only combinations where both country and degree indices are even
-            const resultMap = new Map();
-            for (let c = 0; c < largeCountrySet.length; c++) {
-                for (let d = 0; d < largeDegreeSet.length; d++) {
-                    const countryId = largeCountrySet[c].id;
-                    const degreeId = largeDegreeSet[d].id;
-                    const key = `${FilterKey.COUNTRY}:${countryId}|${FilterKey.DEGREE_TYPE}:${degreeId}`;
-                    resultMap.set(key, c % 2 === 0 && d % 2 === 0);
-                }
-            }
-            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap, false);
-            const urls = await countryDegreePolicy.generateUrls();
-            // Calculate expected count: 10 countries (even indices) * 5 degrees (even indices)
-            // 10 * 5 = 50 URLs
-            expect(urls).toHaveLength(50);
-            // Test specific items
-            expect(urls).toContain('degree-path-0/country-path-0'); // Both even indices
-            expect(urls).toContain('degree-path-2/country-path-4'); // Both even indices
-            expect(urls).not.toContain('degree-path-1/country-path-0'); // Odd degree index
-            expect(urls).not.toContain('degree-path-0/country-path-1'); // Odd country index
-        });
-    });
-});

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

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

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

@@ -1,234 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { FilterKey } from '@studyportals/search-filters/server-side';
-import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
-import { CountryDuration } from '@/programmes/policies/CountryDuration';
-import { PortalType } from '@studyportals/domain-client';
-import { SitemapDependencies } from '../utils/SitemapDependencies.util.mjs';
-import { CountryPresenter } from '@/presenters/CountryPresenter';
-import { DurationPresenter } from '@/presenters/DurationPresenter';
-describe('Policy:CountryDuration', () => {
-    describe('shouldIndex', () => {
-        let searchDependenciesHelper;
-        let countryDurationPolicy;
-        beforeEach(() => {
-            searchDependenciesHelper = new SearchDependencies();
-            countryDurationPolicy = new CountryDuration(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setResultsCount(10);
-            searchDependenciesHelper.setPageNumber(1);
-            searchDependenciesHelper.setPortalType(PortalType.BACHELOR);
-        });
-        it('Should return true when all conditions are met', async () => {
-            const countryId = '30'; // UK
-            const duration = '[360,360]'; // 1 year
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.COUNTRY, [countryId]],
-                [FilterKey.DURATION, [duration]]
-            ]));
-            const result = await countryDurationPolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Should return false when multiple countries are selected', async () => {
-            const firstCountryId = '30'; // UK
-            const secondCountryId = '21'; // Portugal
-            const duration = '[360,360]'; // 1 year
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.COUNTRY, [firstCountryId, secondCountryId]],
-                [FilterKey.DURATION, [duration]]
-            ]));
-            const result = await countryDurationPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when multiple duration values are selected', async () => {
-            const countryId = '30'; // UK
-            const firstDuration = '[360,360]'; // 1 year
-            const secondDuration = '[720,720]'; // 2 years
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.COUNTRY, [countryId]],
-                [FilterKey.DURATION, [firstDuration, secondDuration]]
-            ]));
-            const result = await countryDurationPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when no duration values are selected', async () => {
-            const countryId = '30'; // UK
-            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [countryId]]]));
-            const result = await countryDurationPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when no countries are selected', async () => {
-            const duration = '[360,360]'; // 1 year
-            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DURATION, [duration]]]));
-            const result = await countryDurationPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when other filters are selected', async () => {
-            const countryId = '30'; // UK
-            const duration = '[360,360]'; // 1 year
-            const disciplineId = '54'; // Agriculture & Forestry
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.COUNTRY, [countryId]],
-                [FilterKey.DURATION, [duration]],
-                [FilterKey.DISCIPLINES, [disciplineId]]
-            ]));
-            const result = await countryDurationPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when duration is not indexable (i.e. 2 years)', async () => {
-            const countryId = '30'; // UK
-            const duration = '[720,720]'; // 2 years
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.COUNTRY, [countryId]],
-                [FilterKey.DURATION, [duration]]
-            ]));
-            const result = await countryDurationPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when number of results is less than 7', async () => {
-            const countryId = '30'; // UK
-            const duration = '[360,360]'; // 1 year
-            searchDependenciesHelper.setResultsCount(6);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.COUNTRY, [countryId]],
-                [FilterKey.DURATION, [duration]]
-            ]));
-            const result = await countryDurationPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when page number is higher than 2', async () => {
-            const countryId = '30'; // UK
-            const duration = '[360,360]'; // 1 year
-            searchDependenciesHelper.setPageNumber(4);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.COUNTRY, [countryId]],
-                [FilterKey.DURATION, [duration]]
-            ]));
-            const result = await countryDurationPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when portal is distance learning', async () => {
-            const countryId = '30'; // UK
-            const duration = '[360,360]'; // 1 year
-            searchDependenciesHelper.setPortalType(PortalType.DISTANCE_LEARNING);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.COUNTRY, [countryId]],
-                [FilterKey.DURATION, [duration]]
-            ]));
-            const result = await countryDurationPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-    });
-    describe('generateUrls', () => {
-        let sitemapDependenciesHelper;
-        let countryDurationPolicy;
-        beforeEach(() => {
-            sitemapDependenciesHelper = new SitemapDependencies();
-            sitemapDependenciesHelper.setProgrammeCount(10); // More than 7 programs
-            countryDurationPolicy = new CountryDuration(sitemapDependenciesHelper.dependencies);
-            CountryPresenter.getInstance = vi.fn().mockReturnValue({
-                getFragments: vi.fn().mockReturnValue([
-                    { id: '30', path: 'uk' },
-                    { id: '202', path: 'australia' },
-                    { id: '56', path: 'usa' }
-                ])
-            });
-            DurationPresenter.getInstance = vi.fn().mockReturnValue({
-                getFragments: vi.fn().mockReturnValue([
-                    { id: '[360,360]', path: '1-year' },
-                    { id: '[720,720]', path: '2-years' },
-                    { id: '[1080,1080]', path: '3-years' },
-                    { id: '[1440,1440]', path: '4-years' },
-                    { id: '[-1,719]', path: 'less-than-2-years' } // Non-indexable duration
-                ])
-            });
-        });
-        afterEach(() => {
-            sitemapDependenciesHelper.resetMocks();
-        });
-        it('Should generate URLs for valid country-duration combinations', async () => {
-            // Mock the checkRulesForSitemap to filter out non-indexable durations for all countries
-            const resultMap = new Map();
-            // Set up all possible combinations - only [360,360] (1-year) is allowed by the policy
-            for (const country of ['30', '202', '56']) {
-                for (const duration of ['[360,360]', '[720,720]', '[1080,1080]', '[1440,1440]', '[-1,719]']) {
-                    const key = `${FilterKey.COUNTRY}:${country}|${FilterKey.DURATION}:${duration}`;
-                    // Only [360,360] should be allowed by the policy's allowedDurationIds
-                    resultMap.set(key, duration === '[360,360]');
-                }
-            }
-            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
-            // Call the method via reflection since it's protected
-            const urls = await countryDurationPolicy.generateUrls();
-            // Calculate expected URLs: 3 countries * 1 duration ([360,360] only) * 1 page = 3 URLs
-            expect(urls).toHaveLength(3);
-            // Verify paths structure
-            expect(urls).toContain('1-year/uk');
-            expect(urls).toContain('1-year/australia');
-            expect(urls).toContain('1-year/usa');
-            // Verify other durations are excluded
-            expect(urls).not.toContain('2-years/uk');
-            expect(urls).not.toContain('3-years/uk');
-            expect(urls).not.toContain('4-years/uk');
-            expect(urls).not.toContain('less-than-2-years/uk');
-        });
-        it('Should exclude specific country-duration combinations based on rules', async () => {
-            // Create a map that returns false for specific combinations
-            const resultMap = new Map();
-            // Only [360,360] is allowed by policy, but we can exclude specific countries
-            for (const country of ['30', '202', '56']) {
-                for (const duration of ['[360,360]', '[720,720]', '[1080,1080]', '[1440,1440]', '[-1,719]']) {
-                    const key = `${FilterKey.COUNTRY}:${country}|${FilterKey.DURATION}:${duration}`;
-                    // Only [360,360] is allowed and exclude UK (30) for testing
-                    const shouldPass = duration === '[360,360]' && country !== '30';
-                    resultMap.set(key, shouldPass);
-                }
-            }
-            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
-            const urls = await countryDurationPolicy.generateUrls();
-            // Calculate expected URLs: 2 countries (excluding UK) * 1 duration ([360,360]) = 2 URLs
-            expect(urls).toHaveLength(2);
-            // Verify excluded combinations
-            expect(urls).not.toContain('1-year/uk');
-            expect(urls).not.toContain('2-years/australia');
-            expect(urls).not.toContain('3-years/usa');
-            expect(urls).not.toContain('less-than-2-years/uk');
-            // Verify included combinations
-            expect(urls).toContain('1-year/australia');
-            expect(urls).toContain('1-year/usa');
-        });
-        it('Should exclude all URLs when all rule checks fail', async () => {
-            // Create a map that returns false for all combinations
-            const resultMap = new Map();
-            for (const country of ['30', '202', '56']) {
-                // Include [360,360] since that's what the policy actually uses
-                for (const duration of ['[360,360]', '[720,720]', '[1080,1080]', '[1440,1440]', '[-1,719]']) {
-                    const key = `${FilterKey.COUNTRY}:${country}|${FilterKey.DURATION}:${duration}`;
-                    resultMap.set(key, false);
-                }
-            }
-            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
-            const urls = await countryDurationPolicy.generateUrls();
-            // Should include no URLs
-            expect(urls).toHaveLength(0);
-        });
-        it('Should handle empty country fragments', async () => {
-            // Mock the CountryPresenter to return empty fragments
-            CountryPresenter.getInstance.mockReturnValueOnce({
-                getFragments: vi.fn().mockReturnValue([])
-            });
-            sitemapDependenciesHelper.mockCheckRulesForSitemap();
-            const urls = await countryDurationPolicy.generateUrls();
-            // Should return empty array
-            expect(urls).toHaveLength(0);
-        });
-        it('Should handle empty duration fragments', async () => {
-            // Mock the DurationPresenter to return empty fragments
-            DurationPresenter.getInstance.mockReturnValueOnce({
-                getFragments: vi.fn().mockReturnValue([])
-            });
-            sitemapDependenciesHelper.mockCheckRulesForSitemap();
-            const urls = await countryDurationPolicy.generateUrls();
-            // Should return empty array
-            expect(urls).toHaveLength(0);
-        });
-    });
-});

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

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