@studyportals/fawkes 8.7.0 → 8.7.1-0

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

@@ -0,0 +1,105 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { Continent } from '@/organisations/policies/our-picks/Continent';
+import { SearchDependencies } from '../../../organisations/utils/SearchDependencies.util.mjs';
+import { SitemapDependencies } from '../../utils/SitemapDependencies.util.mjs';
+import { SortingOptions } from '@/enums/SortingOptions';
+import { ContinentPresenter } from '@/presenters/ContinentPresenter';
+import { PortalType } from '@studyportals/domain-client';
+describe('Policy:Continent', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let continentPolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            continentPolicy = new Continent(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setSortingState(SortingOptions.OUR_PICKS);
+            searchDependenciesHelper.setNumberOfResults(10);
+        });
+        it('Should return true when all conditions are met', async () => {
+            const continentId = '1'; // Europe
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.CONTINENT, [continentId]]]));
+            const result = await continentPolicy.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 continentId = '1'; // Europe
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.CONTINENT, [continentId]]]));
+            searchDependenciesHelper.setPortalType(portalType);
+            const result = await continentPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when area when University Meta Ranking sorting is selected', async () => {
+            const continentId = '1'; // Europe
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.CONTINENT, [continentId]]]));
+            searchDependenciesHelper.setSortingState(SortingOptions.UNIVERSITY_META_RANKING);
+            const result = await continentPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple continents are selected', async () => {
+            const firstContinentId = '1'; // Europe
+            const secondContinentId = '9'; // Asia
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.CONTINENT, [firstContinentId, secondContinentId]]]));
+            const result = await continentPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no continents are selected', async () => {
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [countryId]]]));
+            const result = await continentPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            const continentId = '1'; // Europe
+            const areaId = '996'; // England
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.AREA, [areaId]],
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.CONTINENT, [continentId]]
+            ]));
+            const result = await continentPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateSitemapUrls', () => {
+        let sitemapDependenciesHelper;
+        let continentPolicy;
+        let continentFragments;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setOrganisationCount(10);
+            continentPolicy = new Continent(sitemapDependenciesHelper.dependencies);
+            vi.spyOn(ContinentPresenter, 'getInstance').mockReturnValue({
+                getFragments: vi.fn(() => continentFragments),
+                generatePaths: vi.fn(() => continentFragments),
+                fragments: continentFragments
+            });
+        });
+        it('Should return path when all conditions are met', async () => {
+            const continentId = '1'; // Europe
+            const continentPath = 'path';
+            continentFragments = [
+                {
+                    id: continentId,
+                    path: continentPath
+                }
+            ];
+            const result = await continentPolicy.generateSitemapUrls();
+            expect(result).toEqual([`${continentPath}`]);
+        });
+        it.each([[PortalType.BACHELOR], [PortalType.PHD], [PortalType.SHORT]])('Should not return path when portal type is %s', async (portalType) => {
+            const continentId = '1'; // Europe
+            const continentPath = 'path';
+            continentFragments = [
+                {
+                    id: continentId,
+                    path: continentPath
+                }
+            ];
+            sitemapDependenciesHelper.setPortalType(portalType);
+            const result = await continentPolicy.generateSitemapUrls();
+            expect(result).toEqual([]);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,109 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { Country } from '@/organisations/policies/our-picks/Country';
+import { SearchDependencies } from '../../../organisations/utils/SearchDependencies.util.mjs';
+import { SitemapDependencies } from '../../utils/SitemapDependencies.util.mjs';
+import { SortingOptions } from '@/enums/SortingOptions';
+import { PortalType } from '@studyportals/domain-client';
+import { CountryPresenter } from '@/presenters/CountryPresenter';
+describe('Policy:Country', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let countryPolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            countryPolicy = new Country(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setSortingState(SortingOptions.OUR_PICKS);
+            searchDependenciesHelper.setNumberOfResults(10);
+        });
+        it('Should return true when all conditions are met', async () => {
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [countryId]]]));
+            const result = await countryPolicy.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 countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [countryId]]]));
+            searchDependenciesHelper.setPortalType(portalType);
+            const result = await countryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when area when University Meta Ranking sorting is selected', async () => {
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [countryId]]]));
+            searchDependenciesHelper.setSortingState(SortingOptions.UNIVERSITY_META_RANKING);
+            const result = await countryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple countries are selected', async () => {
+            const firstCountryId = '30'; // UK
+            const secondCountryId = '82'; // US
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [firstCountryId, secondCountryId]]]));
+            const result = await countryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no countries are selected', async () => {
+            const areaId = '137'; // Western Australia
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.AREA, [areaId]]]));
+            const result = await countryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            const continentId = '1'; // Europe
+            const areaId = '996'; // England
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.AREA, [areaId]],
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.CONTINENT, [continentId]]
+            ]));
+            const result = await countryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateSitemapUrls', () => {
+        let sitemapDependenciesHelper;
+        let countryPolicy;
+        let countryFragments;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setOrganisationCount(10);
+            countryPolicy = new Country(sitemapDependenciesHelper.dependencies);
+            vi.spyOn(CountryPresenter, 'getInstance').mockReturnValue({
+                getFragments: vi.fn(() => countryFragments),
+                generatePaths: vi.fn(() => countryFragments),
+                fragments: countryFragments
+            });
+        });
+        it('Should return path when all conditions are met', async () => {
+            const countryId = '30'; // UK
+            const countryIso = 'GB';
+            const countryPath = 'path';
+            countryFragments = [
+                {
+                    id: countryId,
+                    iso: countryIso,
+                    path: countryPath
+                }
+            ];
+            const result = await countryPolicy.generateSitemapUrls();
+            expect(result).toEqual([`${countryPath}`]);
+        });
+        it.each([[PortalType.BACHELOR], [PortalType.PHD], [PortalType.SHORT]])('Should not return path when portal type is %s', async (portalType) => {
+            const countryId = '30'; // UK
+            const countryIso = 'GB';
+            const countryPath = 'path';
+            countryFragments = [
+                {
+                    id: countryId,
+                    iso: countryIso,
+                    path: countryPath
+                }
+            ];
+            sitemapDependenciesHelper.setPortalType(portalType);
+            const result = await countryPolicy.generateSitemapUrls();
+            expect(result).toEqual([]);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,152 @@
+import { SortingOptions } from "@/enums/SortingOptions";
+import { CountryAreaCity } from "@/organisations/policies";
+import { FilterKey } from "@studyportals/search-filters/server-side";
+import { SearchDependencies } from '../../../organisations/utils/SearchDependencies.util.mjs';
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { CityPresenter } from "@/presenters/CityPresenter";
+import { PortalType } from "@studyportals/domain-client";
+import { SitemapDependencies } from '../../utils/SitemapDependencies.util.mjs';
+describe('Policy:CountryAreaCity', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let countryAreaCityPolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            countryAreaCityPolicy = new CountryAreaCity(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setSortingState(SortingOptions.OUR_PICKS);
+            searchDependenciesHelper.setNumberOfResults(10);
+        });
+        it('Should return true when all conditions are met', async () => {
+            const cityID = '';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, ['30']],
+                [FilterKey.AREA, ['8']],
+                [FilterKey.CITY, ['1']]
+            ]));
+            const result = await countryAreaCityPolicy.shouldIndex();
+            expect(result).toBe(true);
+        });
+        it('Should return false when area is missing', async () => {
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, ['30']],
+                [FilterKey.CITY, ['1']]
+            ]));
+            const result = await countryAreaCityPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple areas are selected', async () => {
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, ['30']],
+                [FilterKey.AREA, ['8', '9']],
+                [FilterKey.CITY, ['1']]
+            ]));
+            const result = await countryAreaCityPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when country is missing', async () => {
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.AREA, ['8']],
+                [FilterKey.CITY, ['1']]
+            ]));
+            const result = await countryAreaCityPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple countries are selected', async () => {
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, ['30', '82']],
+                [FilterKey.AREA, ['8']],
+                [FilterKey.CITY, ['1']]
+            ]));
+            const result = await countryAreaCityPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when city is missing', async () => {
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, ['30']],
+                [FilterKey.AREA, ['8']]
+            ]));
+            const result = await countryAreaCityPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple cities are selected', async () => {
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, ['30']],
+                [FilterKey.AREA, ['8']],
+                [FilterKey.CITY, ['1', '2']]
+            ]));
+            const result = await countryAreaCityPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, ['30']],
+                [FilterKey.AREA, ['8']],
+                [FilterKey.CITY, ['1']],
+                [FilterKey.CONTINENT, ['1']]
+            ]));
+            const result = await countryAreaCityPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateSitemapUrls', () => {
+        let sitemapDependenciesHelper;
+        let countryAreaCityPolicy;
+        let cityFragments;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setOrganisationCount(10);
+            countryAreaCityPolicy = new CountryAreaCity(sitemapDependenciesHelper.dependencies);
+            vi.spyOn(CityPresenter, 'getInstance').mockReturnValue({
+                getFragments: vi.fn(() => cityFragments),
+                generatePaths: vi.fn(() => cityFragments),
+                fragments: cityFragments
+            });
+        });
+        it('Should generate correct sitemap urls', async () => {
+            const countryId = '30';
+            const areaId = '8';
+            const cityId = '1';
+            cityFragments = [
+                {
+                    id: cityId,
+                    areaId: areaId,
+                    countryId: countryId,
+                    path: '/uk/england/city'
+                }
+            ];
+            const result = await countryAreaCityPolicy.generateSitemapUrls();
+            expect(result).toEqual(['/uk/england/city']);
+        });
+        it('Should not generate urls when areaId is empty string', async () => {
+            const countryId = '30';
+            const cityId = '1';
+            const areaId = '';
+            cityFragments = [
+                {
+                    id: cityId,
+                    areaId: areaId,
+                    countryId: countryId,
+                    path: '/uk/england/city'
+                }
+            ];
+            const result = await countryAreaCityPolicy.generateSitemapUrls();
+            expect(result).toEqual([]);
+        });
+        it.each([[PortalType.BACHELOR], [PortalType.PHD], [PortalType.SHORT]])('Should not return path when portal type is %s', async (portalType) => {
+            const countryId = '30';
+            const areaId = '8';
+            const cityId = '1';
+            cityFragments = [
+                {
+                    id: cityId,
+                    areaId: areaId,
+                    countryId: countryId,
+                    path: '/uk/england/city'
+                }
+            ];
+            sitemapDependenciesHelper.setPortalType(portalType);
+            const result = await countryAreaCityPolicy.generateSitemapUrls();
+            expect(result).toEqual([]);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,223 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { SearchDependencies } from '../../../organisations/utils/SearchDependencies.util.mjs';
+import { SitemapDependencies } from '../../utils/SitemapDependencies.util.mjs';
+import { SortingOptions } from '@/enums/SortingOptions';
+import { CountryAttendance } from '@/organisations/policies';
+import { PortalType } from '@studyportals/domain-client';
+import { CountryPresenter } from '@/presenters/CountryPresenter';
+import { AttendancePresenter } from '@/presenters/AttendancePresenter';
+describe('Policy:CountryAttendance', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let countryAttendancePolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            countryAttendancePolicy = new CountryAttendance(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setSortingState(SortingOptions.OUR_PICKS);
+            searchDependenciesHelper.setNumberOfResults(10);
+        });
+        it('Should return true when all conditions are met', async () => {
+            const countryId = '82'; // US
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await countryAttendancePolicy.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 countryId = '82'; // US
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            searchDependenciesHelper.setPortalType(portalType);
+            const result = await countryAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when area when University Meta Ranking sorting is selected', async () => {
+            const countryId = '82'; // US
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            searchDependenciesHelper.setSortingState(SortingOptions.UNIVERSITY_META_RANKING);
+            const result = await countryAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple countries are selected', async () => {
+            const firstCountryId = '30'; // UK
+            const secondCountryId = '82'; // US
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [firstCountryId, secondCountryId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await countryAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no countries are selected', async () => {
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DELIVERY_METHOD, [attendance]]]));
+            const result = await countryAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            const areaId = '996'; // England
+            const countryId = '30'; // UK
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.AREA, [areaId]],
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await countryAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when attendance is not online', async () => {
+            const countryId = '30'; // UK
+            const attendance = 'blended';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await countryAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple attendances are selected', async () => {
+            const countryId = '82'; // US
+            const firstAttendance = 'online';
+            const secondAttendance = 'blended';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DELIVERY_METHOD, [firstAttendance, secondAttendance]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            const result = await countryAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when country has no search volume', async () => {
+            const countryId = '21'; // PT
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DELIVERY_METHOD, [attendance]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            const result = await countryAttendancePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateSitemapUrls', () => {
+        let sitemapDependenciesHelper;
+        let countryAttendancePolicy;
+        let countryFragments;
+        let attendanceFragments;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setOrganisationCount(10);
+            countryAttendancePolicy = new CountryAttendance(sitemapDependenciesHelper.dependencies);
+            vi.spyOn(CountryPresenter, 'getInstance').mockReturnValue({
+                getFragments: vi.fn(() => countryFragments),
+                generatePaths: vi.fn(() => countryFragments),
+                fragments: countryFragments
+            });
+            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 countryId = '82'; // US
+            const countryIso = 'US';
+            const countryPath = 'country-path';
+            const attendance = 'online';
+            const attendancePath = 'attendance-path';
+            countryFragments = [
+                {
+                    id: countryId,
+                    iso: countryIso,
+                    path: countryPath
+                }
+            ];
+            attendanceFragments = [
+                {
+                    id: attendance,
+                    path: attendancePath
+                }
+            ];
+            const result = await countryAttendancePolicy.generateSitemapUrls();
+            expect(result).toEqual([`${attendancePath}/${countryPath}`]);
+        });
+        it.each([[PortalType.BACHELOR], [PortalType.PHD], [PortalType.SHORT]])('Should not return path when portal type is %s', async (portalType) => {
+            const countryId = '82'; // US
+            const countryIso = 'US';
+            const countryPath = 'country-path';
+            const attendance = 'online';
+            const attendancePath = 'attendance-path';
+            countryFragments = [
+                {
+                    id: countryId,
+                    iso: countryIso,
+                    path: countryPath
+                }
+            ];
+            attendanceFragments = [
+                {
+                    id: attendance,
+                    path: attendancePath
+                }
+            ];
+            sitemapDependenciesHelper.setPortalType(portalType);
+            const result = await countryAttendancePolicy.generateSitemapUrls();
+            expect(result).toEqual([]);
+        });
+        it('Should not return path when attendance is not online', async () => {
+            const countryId = '82'; // US
+            const countryIso = 'US';
+            const countryPath = 'country-path';
+            const attendance = 'face-2-face';
+            const attendancePath = 'attendance-path';
+            countryFragments = [
+                {
+                    id: countryId,
+                    iso: countryIso,
+                    path: countryPath
+                }
+            ];
+            attendanceFragments = [
+                {
+                    id: attendance,
+                    path: attendancePath
+                }
+            ];
+            const result = await countryAttendancePolicy.generateSitemapUrls();
+            expect(result).toEqual([]);
+        });
+        it('Should not return path when there is not enough search volume', async () => {
+            const countryId = '21'; // PT
+            const countryIso = 'US';
+            const countryPath = 'country-path';
+            const attendance = 'online';
+            const attendancePath = 'attendance-path';
+            countryFragments = [
+                {
+                    id: countryId,
+                    iso: countryIso,
+                    path: countryPath
+                }
+            ];
+            attendanceFragments = [
+                {
+                    id: attendance,
+                    path: attendancePath
+                }
+            ];
+            const result = await countryAttendancePolicy.generateSitemapUrls();
+            expect(result).toEqual([]);
+        });
+    });
+});

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

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