@studyportals/fawkes 8.7.0 → 8.7.1-0

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

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

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

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

@@ -0,0 +1,267 @@
+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 { DegreeCountryAttendance } from '@/programmes/policies/DegreeCountryAttendance';
+import { DegreePresenter } from '@/presenters/DegreePresenter';
+import { CountryPresenter } from '@/presenters/CountryPresenter';
+import { AttendancePresenter } from '@/presenters/AttendancePresenter';
+describe('Policy:DegreeCountryAttendance', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let degreeCountryAttendancePolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            degreeCountryAttendancePolicy = new DegreeCountryAttendance(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setResultsCount(7);
+            searchDependenciesHelper.setPageNumber(1);
+            searchDependenciesHelper.setPortalType(PortalType.MASTER);
+        });
+        describe('MBA with online attendance', () => {
+            it('Should return true for MBA with any country and online attendance', async () => {
+                searchDependenciesHelper.setFilterKeyValues(new Map([
+                    [FilterKey.DEGREE_TYPE, ['mba']],
+                    [FilterKey.COUNTRY, ['999']], // Any country
+                    [FilterKey.DELIVERY_METHOD, ['online']]
+                ]));
+                const result = await degreeCountryAttendancePolicy.shouldIndex();
+                expect(result).toBe(true);
+            });
+            it('Should return false for MBA with non-online attendance', async () => {
+                searchDependenciesHelper.setFilterKeyValues(new Map([
+                    [FilterKey.DEGREE_TYPE, ['mba']],
+                    [FilterKey.COUNTRY, ['82']], // USA
+                    [FilterKey.DELIVERY_METHOD, ['on-campus']] // Non-online
+                ]));
+                const result = await degreeCountryAttendancePolicy.shouldIndex();
+                expect(result).toBe(false);
+            });
+        });
+        describe('Master of Laws with online attendance', () => {
+            it.each([
+                '82', // USA
+                '30', // UK
+                '56', // Canada
+                '108' // India
+            ])('Should return true for LLM with country %s and online attendance', async (countryId) => {
+                searchDependenciesHelper.setFilterKeyValues(new Map([
+                    [FilterKey.DEGREE_TYPE, ['llm']],
+                    [FilterKey.COUNTRY, [countryId]],
+                    [FilterKey.DELIVERY_METHOD, ['online']]
+                ]));
+                const result = await degreeCountryAttendancePolicy.shouldIndex();
+                expect(result).toBe(true);
+            });
+            it.each([
+                '11', // Germany (not allowed for LLM)
+                '202', // Australia (not allowed for LLM)
+                '999' // Invalid country
+            ])('Should return false for LLM with invalid country %s', async (countryId) => {
+                searchDependenciesHelper.setFilterKeyValues(new Map([
+                    [FilterKey.DEGREE_TYPE, ['llm']],
+                    [FilterKey.COUNTRY, [countryId]],
+                    [FilterKey.DELIVERY_METHOD, ['online']]
+                ]));
+                const result = await degreeCountryAttendancePolicy.shouldIndex();
+                expect(result).toBe(false);
+            });
+        });
+        describe('Master of Philosophy with online attendance', () => {
+            it.each([
+                '82', // USA
+                '30', // UK
+                '108' // India
+            ])('Should return true for MPhil with country %s and online attendance', async (countryId) => {
+                searchDependenciesHelper.setFilterKeyValues(new Map([
+                    [FilterKey.DEGREE_TYPE, ['mphil']],
+                    [FilterKey.COUNTRY, [countryId]],
+                    [FilterKey.DELIVERY_METHOD, ['online']]
+                ]));
+                const result = await degreeCountryAttendancePolicy.shouldIndex();
+                expect(result).toBe(true);
+            });
+            it.each([
+                '56', // Canada (not allowed for MPhil)
+                '11', // Germany (not allowed for MPhil)
+                '202', // Australia (not allowed for MPhil)
+                '999' // Invalid country
+            ])('Should return false for MPhil with invalid country %s', async (countryId) => {
+                searchDependenciesHelper.setFilterKeyValues(new Map([
+                    [FilterKey.DEGREE_TYPE, ['mphil']],
+                    [FilterKey.COUNTRY, [countryId]],
+                    [FilterKey.DELIVERY_METHOD, ['online']]
+                ]));
+                const result = await degreeCountryAttendancePolicy.shouldIndex();
+                expect(result).toBe(false);
+            });
+        });
+        describe('unsupported degrees', () => {
+            it('Should return false for unsupported degree types', async () => {
+                searchDependenciesHelper.setFilterKeyValues(new Map([
+                    [FilterKey.DEGREE_TYPE, ['master-of-science']], // Not supported by this policy
+                    [FilterKey.COUNTRY, ['82']],
+                    [FilterKey.DELIVERY_METHOD, ['online']]
+                ]));
+                const result = await degreeCountryAttendancePolicy.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, ['mba', 'llm']],
+                    [FilterKey.COUNTRY, ['82']],
+                    [FilterKey.DELIVERY_METHOD, ['online']]
+                ]));
+                const result = await degreeCountryAttendancePolicy.shouldIndex();
+                expect(result).toBe(false);
+            });
+            it('Should return false when multiple countries are selected', async () => {
+                searchDependenciesHelper.setFilterKeyValues(new Map([
+                    [FilterKey.DEGREE_TYPE, ['mba']],
+                    [FilterKey.COUNTRY, ['82', '30']],
+                    [FilterKey.DELIVERY_METHOD, ['online']]
+                ]));
+                const result = await degreeCountryAttendancePolicy.shouldIndex();
+                expect(result).toBe(false);
+            });
+            it('Should return false when other filters are selected', async () => {
+                searchDependenciesHelper.setFilterKeyValues(new Map([
+                    [FilterKey.DEGREE_TYPE, ['mba']],
+                    [FilterKey.COUNTRY, ['82']],
+                    [FilterKey.DELIVERY_METHOD, ['online']],
+                    [FilterKey.DISCIPLINES, ['54']] // Extra filter
+                ]));
+                const result = await degreeCountryAttendancePolicy.shouldIndex();
+                expect(result).toBe(false);
+            });
+        });
+    });
+    describe('generateUrls', () => {
+        let sitemapDependenciesHelper;
+        let degreeCountryAttendancePolicy;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setProgrammeCount(10);
+            degreeCountryAttendancePolicy = new DegreeCountryAttendance(sitemapDependenciesHelper.dependencies);
+            DegreePresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: 'mba', path: 'mba' },
+                    { id: 'llm', path: 'llm' },
+                    { id: 'mphil', path: 'mphil' },
+                    { id: 'master-of-science', path: 'masters' } // Not supported
+                ])
+            });
+            CountryPresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: '82', path: 'usa' },
+                    { id: '30', path: 'uk' },
+                    { id: '56', path: 'canada' },
+                    { id: '108', path: 'india' },
+                    { id: '11', path: 'germany' },
+                    { id: '202', path: 'australia' }
+                ])
+            });
+            AttendancePresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: 'online', path: 'online' },
+                    { id: 'on-campus', path: 'on-campus' }
+                ])
+            });
+        });
+        afterEach(() => {
+            sitemapDependenciesHelper.resetMocks();
+        });
+        it('Should generate URLs for MBA with all countries and online attendance', async () => {
+            const resultMap = new Map();
+            // MBA accepts all countries
+            const allCountries = ['82', '30', '56', '108', '11', '202'];
+            for (const country of allCountries) {
+                const key = `${FilterKey.DEGREE_TYPE}:mba|${FilterKey.COUNTRY}:${country}|${FilterKey.DELIVERY_METHOD}:online`;
+                resultMap.set(key, true);
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await degreeCountryAttendancePolicy.generateUrls();
+            // MBA: 6 countries * 2 pages = 12 URLs
+            expect(urls.length).toBeGreaterThan(0);
+            expect(urls).toContain('mba/online/usa');
+            expect(urls).toContain('mba/online/uk');
+            expect(urls).toContain('mba/online/canada');
+            expect(urls).toContain('mba/online/india');
+            expect(urls).toContain('mba/online/germany');
+            expect(urls).toContain('mba/online/australia');
+        });
+        it('Should generate URLs for LLM with specific countries and online attendance', async () => {
+            const resultMap = new Map();
+            // LLM accepts only specific countries: USA, UK, Canada, India
+            const llmCountries = ['82', '30', '56', '108'];
+            for (const country of llmCountries) {
+                const key = `${FilterKey.DEGREE_TYPE}:llm|${FilterKey.COUNTRY}:${country}|${FilterKey.DELIVERY_METHOD}:online`;
+                resultMap.set(key, true);
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await degreeCountryAttendancePolicy.generateUrls();
+            // LLM: 4 allowed countries * 2 pages = 8 URLs
+            expect(urls).toContain('llm/online/usa');
+            expect(urls).toContain('llm/online/uk');
+            expect(urls).toContain('llm/online/canada');
+            expect(urls).toContain('llm/online/india');
+            // Should not include invalid countries for LLM
+            expect(urls).not.toContain('llm/online/germany');
+            expect(urls).not.toContain('llm/online/australia');
+        });
+        it('Should generate URLs for MPhil with specific countries and online attendance', async () => {
+            const resultMap = new Map();
+            // MPhil accepts only specific countries: USA, UK, India
+            const mphilCountries = ['82', '30', '108'];
+            for (const country of mphilCountries) {
+                const key = `${FilterKey.DEGREE_TYPE}:mphil|${FilterKey.COUNTRY}:${country}|${FilterKey.DELIVERY_METHOD}:online`;
+                resultMap.set(key, true);
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await degreeCountryAttendancePolicy.generateUrls();
+            // MPhil: 3 allowed countries * 2 pages = 6 URLs
+            expect(urls).toContain('mphil/online/usa');
+            expect(urls).toContain('mphil/online/uk');
+            expect(urls).toContain('mphil/online/india');
+            // Should not include invalid countries for MPhil
+            expect(urls).not.toContain('mphil/online/canada');
+            expect(urls).not.toContain('mphil/online/germany');
+            expect(urls).not.toContain('mphil/online/australia');
+        });
+        it('Should handle missing online attendance gracefully', async () => {
+            // Mock AttendancePresenter to not return online attendance
+            AttendancePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: 'on-campus', path: 'on-campus' }
+                ])
+            });
+            sitemapDependenciesHelper.mockCheckRulesForSitemap();
+            const urls = await degreeCountryAttendancePolicy.generateUrls();
+            // Should return empty array when no online attendance is available
+            expect(urls).toHaveLength(0);
+        });
+        it('Should exclude unsupported degrees', async () => {
+            const resultMap = new Map();
+            // Only MBA, LLM, and MPhil should be supported
+            const allDegrees = ['mba', 'llm', 'mphil', 'master-of-science'];
+            const supportedDegrees = ['mba', 'llm', 'mphil'];
+            const countries = ['82', '30'];
+            for (const degree of allDegrees) {
+                for (const country of countries) {
+                    const key = `${FilterKey.DEGREE_TYPE}:${degree}|${FilterKey.COUNTRY}:${country}|${FilterKey.DELIVERY_METHOD}:online`;
+                    resultMap.set(key, supportedDegrees.includes(degree));
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await degreeCountryAttendancePolicy.generateUrls();
+            // Should include supported degrees
+            expect(urls).toContain('mba/online/usa');
+            expect(urls).toContain('llm/online/uk');
+            expect(urls).toContain('mphil/online/usa');
+            // Should not include unsupported degrees
+            expect(urls).not.toContain('masters/online/usa');
+        });
+    });
+});

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

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