@studyportals/fawkes 8.7.0 → 8.7.1-0

package/dist/tests/common/rules/NoFiltersSelectedRule.test.mjs

@@ -0,0 +1,40 @@
+import { NoFiltersSelectedRule } from '@/common/rules/NoFiltersSelectedRule';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { SearchDependencies } from '../../organisations/utils/SearchDependencies.util.mjs';
+import { beforeEach, describe, expect, it } from 'vitest';
+describe('Rule:NoFiltersSelected', () => {
+    describe('forSearch', () => {
+        let searchDependenciesHelper;
+        let rule;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            rule = new NoFiltersSelectedRule();
+        });
+        it('Returns true if no filters are selected', async () => {
+            searchDependenciesHelper.setFilterKeyValues(new Map([]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(true);
+        });
+        it('Returns false if at least one filter is selected', async () => {
+            const countryId = '999'; // Dummy country
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [countryId]]]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(false);
+        });
+    });
+    describe('forSitemapGenerator', () => {
+        let rule;
+        beforeEach(() => {
+            rule = new NoFiltersSelectedRule();
+        });
+        it('Returns true if no filters are selected', async () => {
+            const result = await rule.forSitemapGenerator(new Map([]));
+            expect(result).toBe(true);
+        });
+        it('Returns false at least one filter is selected', async () => {
+            const countryId = '999'; // Dummy country
+            const result = await rule.forSitemapGenerator(new Map([[FilterKey.COUNTRY, [countryId]]]));
+            expect(result).toBe(false);
+        });
+    });
+});

package/dist/tests/common/rules/OnlyFiltersSelectedRule.test.d.mts

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

package/dist/tests/common/rules/OnlyFiltersSelectedRule.test.mjs

@@ -0,0 +1,70 @@
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { SearchDependencies } from '../../organisations/utils/SearchDependencies.util.mjs';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { OnlyFiltersSelectedRule } from '@/common/rules/OnlyFiltersSelectedRule';
+const expectedFilterKeys = [FilterKey.COUNTRY, FilterKey.AREA];
+describe('Rule:OnlyFiltersSelected', () => {
+    describe('forSearch', () => {
+        let searchDependenciesHelper;
+        let rule;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            rule = new OnlyFiltersSelectedRule(expectedFilterKeys);
+        });
+        it('Returns true if exactly the expected filters are selected', async () => {
+            const dummyId = '999';
+            const filterKeyValues = new Map();
+            for (const filterKey of expectedFilterKeys) {
+                filterKeyValues.set(filterKey, [dummyId]);
+            }
+            searchDependenciesHelper.setFilterKeyValues(filterKeyValues);
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(true);
+        });
+        it('Returns false if not all expected filters are selected', async () => {
+            searchDependenciesHelper.setFilterKeyValues(new Map([]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(false);
+        });
+        it('Returns false if extra filters are selected', async () => {
+            const dummyId = '999';
+            const filterKeyValues = new Map();
+            for (const filterKey of expectedFilterKeys) {
+                filterKeyValues.set(filterKey, [dummyId]);
+            }
+            filterKeyValues.set(FilterKey.DELIVERY_METHOD, [dummyId]);
+            searchDependenciesHelper.setFilterKeyValues(filterKeyValues);
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(false);
+        });
+    });
+    describe('forSitemapGenerator', () => {
+        let rule;
+        beforeEach(() => {
+            rule = new OnlyFiltersSelectedRule(expectedFilterKeys);
+        });
+        it('Returns true if exactly the expected filters are selected', async () => {
+            const dummyId = '999';
+            const filterKeyValues = new Map();
+            for (const filterKey of expectedFilterKeys) {
+                filterKeyValues.set(filterKey, [dummyId]);
+            }
+            const result = await rule.forSitemapGenerator(filterKeyValues);
+            expect(result).toBe(true);
+        });
+        it('Returns false if not all expected filters are selected', async () => {
+            const result = await rule.forSitemapGenerator(new Map([]));
+            expect(result).toBe(false);
+        });
+        it('Returns false if extra filters are selected', async () => {
+            const dummyId = '999';
+            const filterKeyValues = new Map();
+            for (const filterKey of expectedFilterKeys) {
+                filterKeyValues.set(filterKey, [dummyId]);
+            }
+            filterKeyValues.set(FilterKey.DELIVERY_METHOD, [dummyId]);
+            const result = await rule.forSitemapGenerator(filterKeyValues);
+            expect(result).toBe(false);
+        });
+    });
+});

package/dist/tests/common/rules/SingleValueSelectedForFilterRule.test.d.mts

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

package/dist/tests/common/rules/SingleValueSelectedForFilterRule.test.mjs

@@ -0,0 +1,54 @@
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { SearchDependencies } from '../../organisations/utils/SearchDependencies.util.mjs';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { SingleValueSelectedForFilterRule } from '@/common/rules/SingleValueSelectedForFilterRule';
+const expectedFilterKey = FilterKey.COUNTRY;
+describe('Rule:SingleValueSelectedForFilter', () => {
+    describe('forSearch', () => {
+        let searchDependenciesHelper;
+        let rule;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            rule = new SingleValueSelectedForFilterRule(expectedFilterKey);
+        });
+        it('Returns true if one value is selected', async () => {
+            const dummyId = '999';
+            searchDependenciesHelper.setFilterKeyValues(new Map([[expectedFilterKey, [dummyId]]]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(true);
+        });
+        it('Returns false if no value is selected', async () => {
+            searchDependenciesHelper.setFilterKeyValues(new Map([]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(false);
+        });
+        it('Returns false if multiple values are selected', async () => {
+            const firstDummyId = '1';
+            const secondDummyId = '2';
+            searchDependenciesHelper.setFilterKeyValues(new Map([[expectedFilterKey, [firstDummyId, secondDummyId]]]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(false);
+        });
+    });
+    describe('forSitemapGenerator', () => {
+        let rule;
+        beforeEach(() => {
+            rule = new SingleValueSelectedForFilterRule(expectedFilterKey);
+        });
+        it('Returns true if one value is selected', async () => {
+            const dummyId = '999';
+            const result = await rule.forSitemapGenerator(new Map([[expectedFilterKey, [dummyId]]]));
+            expect(result).toBe(true);
+        });
+        it('Returns false if no value is selected', async () => {
+            const result = await rule.forSitemapGenerator(new Map([]));
+            expect(result).toBe(false);
+        });
+        it('Returns false if multiple values are selected', async () => {
+            const firstDummyId = '1';
+            const secondDummyId = '2';
+            const result = await rule.forSitemapGenerator(new Map([[expectedFilterKey, [firstDummyId, secondDummyId]]]));
+            expect(result).toBe(false);
+        });
+    });
+});

package/dist/tests/organisations/policies/our-picks/Area.test.d.mts

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

package/dist/tests/organisations/policies/our-picks/Area.test.mjs

@@ -0,0 +1,125 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { Area } from '@/organisations/policies/our-picks/Area';
+import { SearchDependencies } from '../../utils/SearchDependencies.util.mjs';
+import { SortingOptions } from '@/enums/SortingOptions';
+import { SitemapDependencies } from '../../utils/SitemapDependencies.util.mjs';
+import { AreaPresenter } from '@/presenters/AreaPresenter';
+import { PortalType } from '@studyportals/domain-client';
+describe('Policy:Area', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let areaPolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            areaPolicy = new Area(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setSortingState(SortingOptions.OUR_PICKS);
+            searchDependenciesHelper.setNumberOfResults(10);
+        });
+        it('Should return true when all conditions are met', async () => {
+            const areaId = '996'; // England
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.AREA, [areaId]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            const result = await areaPolicy.shouldIndex();
+            expect(result).toBe(true);
+        });
+        it.each([[PortalType.BACHELOR], [PortalType.PHD], [PortalType.SHORT]])('Should return false when the selected portal type is %s', async (portalType) => {
+            const areaId = '996'; // England
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.AREA, [areaId]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            searchDependenciesHelper.setPortalType(portalType);
+            const result = await areaPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when University Meta Ranking sorting is selected', async () => {
+            const areaId = '996'; // England
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.AREA, [areaId]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            searchDependenciesHelper.setSortingState(SortingOptions.UNIVERSITY_META_RANKING);
+            const result = await areaPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple areas are selected', async () => {
+            const firstAreaId = '996'; // England
+            const secondAreaId = '994'; // Scotland
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.AREA, [firstAreaId, secondAreaId]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            const result = await areaPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no areas are selected', async () => {
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [countryId]]]));
+            const result = await areaPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            const areaId = '996'; // England
+            const countryId = '30'; // UK
+            const disciplineId = '1';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.AREA, [areaId]],
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DISCIPLINES, [disciplineId]]
+            ]));
+            const result = await areaPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateSitemapUrls', () => {
+        let sitemapDependenciesHelper;
+        let areaPolicy;
+        let fragments;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setOrganisationCount(10);
+            areaPolicy = new Area(sitemapDependenciesHelper.dependencies);
+            vi.spyOn(AreaPresenter, 'getInstance').mockReturnValue({
+                getFragments: vi.fn(() => fragments),
+                generatePaths: vi.fn(() => fragments),
+                fragments
+            });
+        });
+        it('Should return path when all conditions are met', async () => {
+            const areaId = '996'; // England
+            const countryId = '30'; // UK
+            const path = 'path';
+            fragments = [
+                {
+                    id: areaId,
+                    countryId: countryId,
+                    path
+                }
+            ];
+            const result = await areaPolicy.generateSitemapUrls();
+            expect(result).toEqual([path]);
+        });
+        it.each([[PortalType.BACHELOR], [PortalType.PHD], [PortalType.SHORT]])('Should not return path when portal type is %s', async (portalType) => {
+            const areaId = '996'; // England
+            const countryId = '30'; // UK
+            const path = 'path';
+            sitemapDependenciesHelper.setPortalType(portalType);
+            fragments = [
+                {
+                    id: areaId,
+                    countryId: countryId,
+                    path
+                }
+            ];
+            const result = await areaPolicy.generateSitemapUrls();
+            expect(result).toEqual([]);
+        });
+    });
+});

package/dist/tests/organisations/policies/our-picks/AreaAttendance.test.d.mts

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

package/dist/tests/organisations/policies/our-picks/AreaAttendance.test.mjs

@@ -0,0 +1,238 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { AreaAttendance } from '@/organisations/policies/our-picks/AreaAttendance';
+import { SearchDependencies } from '../../../organisations/utils/SearchDependencies.util.mjs';
+import { SortingOptions } from '@/enums/SortingOptions';
+import { SitemapDependencies } from '../../utils/SitemapDependencies.util.mjs';
+import { AreaPresenter } from '@/presenters/AreaPresenter';
+import { AttendancePresenter } from '@/presenters/AttendancePresenter';
+import { PortalType } from '@studyportals/domain-client';
+describe('Policy:AreaAttendance', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let areaAttendancePolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            areaAttendancePolicy = new AreaAttendance(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setSortingState(SortingOptions.OUR_PICKS);
+            searchDependenciesHelper.setNumberOfResults(10);
+        });
+        it('Should return true when all conditions are met', async () => {
+            const areaId = '3582'; // Georgia
+            const countryId = '82'; // US
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.AREA, [areaId]],
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await areaAttendancePolicy.shouldIndex();
+            expect(result).toBe(true);
+        });
+        it.each([[PortalType.BACHELOR], [PortalType.PHD], [PortalType.SHORT]])('Should return false when the selected portal type is %s', async (portalType) => {
+            const areaId = '3582'; // Georgia
+            const countryId = '82'; // US
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.AREA, [areaId]],
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            searchDependenciesHelper.setPortalType(portalType);
+            const result = await areaAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when area when University Meta Ranking sorting is selected', async () => {
+            const areaId = '3582'; // Georgia
+            const countryId = '82'; // US
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.AREA, [areaId]],
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            searchDependenciesHelper.setSortingState(SortingOptions.UNIVERSITY_META_RANKING);
+            const result = await areaAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple areas are selected', async () => {
+            const firstAreaId = '996'; // England
+            const secondAreaId = '994'; // Scotland
+            const countryId = '30'; // UK
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.AREA, [firstAreaId, secondAreaId]],
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await areaAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no areas are selected', async () => {
+            const countryId = '30'; // UK
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await areaAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            const areaId = '996'; // England
+            const countryId = '30'; // UK
+            const disciplineId = '1';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.AREA, [areaId]],
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DISCIPLINES, [disciplineId]]
+            ]));
+            const result = await areaAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when attendance is not online', async () => {
+            const areaId = '996'; // England
+            const countryId = '30'; // UK
+            const attendance = 'other';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.AREA, [areaId]],
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await areaAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when attendance is not selected', async () => {
+            const areaId = '3582'; // Georgia
+            const countryId = '82'; // US
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.AREA, [areaId]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            const result = await areaAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when area has no search volume', async () => {
+            const areaId = '137'; // Western Australia
+            const countryId = '202'; // Australia
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.AREA, [areaId]],
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await areaAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateSitemapUrls', () => {
+        let sitemapDependenciesHelper;
+        let areaAttendancePolicy;
+        let areaFragments;
+        let attendanceFragments;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setOrganisationCount(10);
+            areaAttendancePolicy = new AreaAttendance(sitemapDependenciesHelper.dependencies);
+            vi.spyOn(AreaPresenter, 'getInstance').mockReturnValue({
+                getFragments: vi.fn(() => areaFragments),
+                generatePaths: vi.fn(() => areaFragments),
+                fragments: areaFragments
+            });
+            vi.spyOn(AttendancePresenter, 'getInstance').mockReturnValue({
+                getFragments: vi.fn(() => attendanceFragments),
+                generatePaths: vi.fn(() => attendanceFragments),
+                fragments: attendanceFragments
+            });
+        });
+        it('Should return path when all conditions are met', async () => {
+            const areaId = '3582'; // Georgia
+            const countryId = '82'; // US
+            const areaPath = 'area-path';
+            const attendance = 'online';
+            const attendancePath = 'attendance-path';
+            areaFragments = [
+                {
+                    id: areaId,
+                    path: areaPath,
+                    countryId
+                }
+            ];
+            attendanceFragments = [
+                {
+                    id: attendance,
+                    path: attendancePath
+                }
+            ];
+            const result = await areaAttendancePolicy.generateSitemapUrls();
+            expect(result).toEqual([`${attendancePath}/${areaPath}`]);
+        });
+        it.each([[PortalType.BACHELOR], [PortalType.PHD], [PortalType.SHORT]])('Should not return path when portal type is %s', async (portalType) => {
+            const areaId = '3582'; // Georgia
+            const countryId = '82'; // US
+            const areaPath = 'area-path';
+            const attendance = 'online';
+            const attendancePath = 'attendance-path';
+            areaFragments = [
+                {
+                    id: areaId,
+                    path: areaPath,
+                    countryId
+                }
+            ];
+            attendanceFragments = [
+                {
+                    id: attendance,
+                    path: attendancePath
+                }
+            ];
+            sitemapDependenciesHelper.setPortalType(portalType);
+            const result = await areaAttendancePolicy.generateSitemapUrls();
+            expect(result).toEqual([]);
+        });
+        it('Should not return path when attendance is not online', async () => {
+            const areaId = '137'; // Western Australia
+            const countryId = '202'; // Australia
+            const areaPath = 'area-path';
+            const attendance = 'face-2-face';
+            const attendancePath = 'attendance-path';
+            areaFragments = [
+                {
+                    id: areaId,
+                    path: areaPath,
+                    countryId
+                }
+            ];
+            attendanceFragments = [
+                {
+                    id: attendance,
+                    path: attendancePath
+                }
+            ];
+            const result = await areaAttendancePolicy.generateSitemapUrls();
+            expect(result).toEqual([]);
+        });
+        it('Should not return path when there is not enough search volume', async () => {
+            const areaId = '137'; // Western Australia
+            const countryId = '202'; // Australia
+            const areaPath = 'area-path';
+            const attendance = 'online';
+            const attendancePath = 'attendance-path';
+            areaFragments = [
+                {
+                    id: areaId,
+                    path: areaPath,
+                    countryId
+                }
+            ];
+            attendanceFragments = [
+                {
+                    id: attendance,
+                    path: attendancePath
+                }
+            ];
+            const result = await areaAttendancePolicy.generateSitemapUrls();
+            expect(result).toEqual([]);
+        });
+    });
+});

package/dist/tests/organisations/policies/our-picks/Attendance.test.d.mts

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

package/dist/tests/organisations/policies/our-picks/Attendance.test.mjs

@@ -0,0 +1,119 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { Attendance } from '@/organisations/policies/our-picks/Attendance';
+import { SearchDependencies } from '../../../organisations/utils/SearchDependencies.util.mjs';
+import { SortingOptions } from '@/enums/SortingOptions';
+import { PortalType } from '@studyportals/domain-client';
+import { SitemapDependencies } from '../../utils/SitemapDependencies.util.mjs';
+import { AttendancePresenter } from '@/presenters/AttendancePresenter';
+describe('Policy:Attendance', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let attendancePolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            attendancePolicy = new Attendance(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setSortingState(SortingOptions.OUR_PICKS);
+            searchDependenciesHelper.setNumberOfResults(10);
+        });
+        it('Should return true when all conditions are met', async () => {
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DELIVERY_METHOD, [attendance]]]));
+            const result = await attendancePolicy.shouldIndex();
+            expect(result).toBe(true);
+        });
+        it.each([[PortalType.BACHELOR], [PortalType.PHD], [PortalType.SHORT]])('Should return false when the selected portal type is %s', async (portalType) => {
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DELIVERY_METHOD, [attendance]]]));
+            searchDependenciesHelper.setPortalType(portalType);
+            const result = await attendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when area when University Meta Ranking sorting is selected', async () => {
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DELIVERY_METHOD, [attendance]]]));
+            searchDependenciesHelper.setSortingState(SortingOptions.UNIVERSITY_META_RANKING);
+            const result = await attendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple attendances are selected', async () => {
+            const attendance = 'online';
+            const otherAttendance = 'blended';
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DELIVERY_METHOD, [attendance, otherAttendance]]]));
+            const result = await attendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no attendances are selected', async () => {
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [countryId]]]));
+            const result = await attendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            const attendance = 'online';
+            const areaId = '996'; // England
+            const countryId = '30'; // UK
+            const disciplineId = '1';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DELIVERY_METHOD, [attendance]],
+                [FilterKey.AREA, [areaId]],
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DISCIPLINES, [disciplineId]]
+            ]));
+            const result = await attendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateSitemapUrls', () => {
+        let sitemapDependenciesHelper;
+        let attendancePolicy;
+        let attendanceFragments;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setOrganisationCount(10);
+            attendancePolicy = new Attendance(sitemapDependenciesHelper.dependencies);
+            vi.spyOn(AttendancePresenter, 'getInstance').mockReturnValue({
+                getFragments: vi.fn(() => attendanceFragments),
+                generatePaths: vi.fn(() => attendanceFragments),
+                fragments: attendanceFragments
+            });
+        });
+        it('Should return path when all conditions are met', async () => {
+            const attendance = 'online';
+            const attendancePath = 'attendance-path';
+            attendanceFragments = [
+                {
+                    id: attendance,
+                    path: attendancePath
+                }
+            ];
+            const result = await attendancePolicy.generateSitemapUrls();
+            expect(result).toEqual([`${attendancePath}`]);
+        });
+        it.each([[PortalType.BACHELOR], [PortalType.PHD], [PortalType.SHORT]])('Should not return path when portal type is %s', async (portalType) => {
+            const attendance = 'online';
+            const attendancePath = 'attendance-path';
+            attendanceFragments = [
+                {
+                    id: attendance,
+                    path: attendancePath
+                }
+            ];
+            sitemapDependenciesHelper.setPortalType(portalType);
+            const result = await attendancePolicy.generateSitemapUrls();
+            expect(result).toEqual([]);
+        });
+        it('Should not return path when attendance is not online', async () => {
+            const attendance = 'face-2-face';
+            const attendancePath = 'attendance-path';
+            attendanceFragments = [
+                {
+                    id: attendance,
+                    path: attendancePath
+                }
+            ];
+            const result = await attendancePolicy.generateSitemapUrls();
+            expect(result).toEqual([]);
+        });
+    });
+});

package/dist/tests/organisations/policies/our-picks/Continent.test.d.mts

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