@studyportals/fawkes 8.7.0 → 8.7.1-0

package/dist/tests/scholarships/policies/DisciplineCountry.test.mjs

@@ -0,0 +1,151 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { DisciplineCountry } from '@/scholarships/policies/DisciplineCountry';
+import { SitemapDependencies } from '../utils/SitemapDependencies.util.mjs';
+import { DisciplinePresenter } from '@/presenters/DisciplinePresenter';
+import { CountryPresenter } from '@/presenters/CountryPresenter';
+describe('Policy:DisciplineCountry', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let disciplineCountryPolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            disciplineCountryPolicy = new DisciplineCountry(searchDependenciesHelper.dependencies);
+        });
+        it('Should return true when all conditions are met', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            const result = await disciplineCountryPolicy.shouldIndex();
+            expect(result).toBe(true);
+        });
+        it('Should return false when multiple disciplines are selected', async () => {
+            const firstDisciplineId = '54'; // Agriculture & Forestry
+            const secondDisciplineId = '12'; // Applied Sciences & Professions
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [firstDisciplineId, secondDisciplineId]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            const result = await disciplineCountryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple countries are selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const firstCountryId = '30'; // UK
+            const secondCountryId = '82'; // USA
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.COUNTRY, [firstCountryId, secondCountryId]]
+            ]));
+            const result = await disciplineCountryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no disciplines are selected', async () => {
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [countryId]]]));
+            const result = await disciplineCountryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no countries are selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DISCIPLINES, [disciplineId]]]));
+            const result = await disciplineCountryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const countryId = '30'; // UK
+            const areaId = '996';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.AREA, [areaId]]
+            ]));
+            const result = await disciplineCountryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when there is not enough search volume', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const countryId = '199'; // Zambia
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DISCIPLINES, [disciplineId]]
+            ]));
+            const result = await disciplineCountryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateSitemapUrls', () => {
+        let sitemapDependenciesHelper;
+        let disciplineCountryPolicy;
+        let disciplineFragments;
+        let countryFragments;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            disciplineCountryPolicy = new DisciplineCountry(sitemapDependenciesHelper.dependencies);
+            vi.spyOn(DisciplinePresenter, 'getInstance').mockReturnValue({
+                getFragments: vi.fn(() => disciplineFragments),
+                generatePaths: vi.fn(() => disciplineFragments),
+                fragments: disciplineFragments
+            });
+            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 disciplineId = '54'; // Agriculture & Forestry
+            const disciplinePath = 'discipline-path';
+            const countryId = '30'; // UK
+            const countryPath = 'country-path';
+            const countryIso = 'iso';
+            disciplineFragments = [
+                {
+                    id: disciplineId,
+                    path: disciplinePath
+                }
+            ];
+            countryFragments = [
+                {
+                    id: countryId,
+                    path: countryPath,
+                    iso: countryIso
+                }
+            ];
+            const result = await disciplineCountryPolicy.generateSitemapUrls();
+            expect(result).toEqual([`${countryPath}/${disciplinePath}`]);
+        });
+        it('Should not return path when there is not enough search volume', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const disciplinePath = 'discipline-path';
+            const countryId = '199'; // Zambia
+            const countryPath = 'country-path';
+            const countryIso = 'iso';
+            disciplineFragments = [
+                {
+                    id: disciplineId,
+                    path: disciplinePath
+                }
+            ];
+            countryFragments = [
+                {
+                    id: countryId,
+                    path: countryPath,
+                    iso: countryIso
+                }
+            ];
+            const result = await disciplineCountryPolicy.generateSitemapUrls();
+            expect(result).toEqual([]);
+        });
+        it('Should return all rules', () => {
+            const rules = disciplineCountryPolicy.getAllRules();
+            expect(rules.length).toBeGreaterThan(1);
+        });
+    });
+});

package/dist/tests/scholarships/policies/Unfiltered.test.d.mts

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

package/dist/tests/scholarships/policies/Unfiltered.test.mjs

@@ -0,0 +1,44 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { Unfiltered } from '@/scholarships/policies/Unfiltered';
+import { SitemapDependencies } from '../utils/SitemapDependencies.util.mjs';
+describe('Policy:Unfiltered', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let unfilteredPolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            unfilteredPolicy = new Unfiltered(searchDependenciesHelper.dependencies);
+        });
+        it('Should return true when no filters are selected', async () => {
+            searchDependenciesHelper.setFilterKeyValues(new Map([]));
+            const result = await unfilteredPolicy.shouldIndex();
+            expect(result).toBe(true);
+        });
+        it('Should return false when at least 1 filter is selected', async () => {
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [countryId]]]));
+            const result = await unfilteredPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateSitemapUrls', () => {
+        let sitemapDependenciesHelper;
+        let unfilteredPolicy;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            unfilteredPolicy = new Unfiltered(sitemapDependenciesHelper.dependencies);
+        });
+        it('Should return path', async () => {
+            const result = await unfilteredPolicy.generateSitemapUrls();
+            expect(result).toEqual(['']);
+        });
+    });
+    it('Should return all rules', () => {
+        const searchDependenciesHelper = new SearchDependencies();
+        const unfilteredPolicy = new Unfiltered(searchDependenciesHelper.dependencies);
+        const rules = unfilteredPolicy.getAllRules();
+        expect(rules[0]).toEqual({});
+    });
+});

package/dist/tests/scholarships/policies/UniversityCountry.test.d.mts

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

package/dist/tests/scholarships/policies/UniversityCountry.test.mjs

@@ -0,0 +1,115 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { UniversityCountry } from '@/scholarships/policies/UniversityCountry';
+import { SitemapDependencies } from '../utils/SitemapDependencies.util.mjs';
+import { CountryPresenter } from '@/presenters/CountryPresenter';
+describe('Policy:UniversityCountry', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let universityCountryPolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            universityCountryPolicy = new UniversityCountry(searchDependenciesHelper.dependencies);
+        });
+        it('Should return true when all conditions are met', async () => {
+            const organisationId = '12819'; // Studyportals
+            const countryId = '1'; // Netherlands
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.ORGANISATIONS, [organisationId]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            const result = await universityCountryPolicy.shouldIndex();
+            expect(result).toBe(true);
+        });
+        it('Should return false when multiple universities are selected', async () => {
+            const firstOrganisationId = '12819'; // Studyportals
+            const secondOrganisationId = '1'; // TU/E
+            const countryId = '1'; // Netherlands
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.ORGANISATIONS, [firstOrganisationId, secondOrganisationId]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            const result = await universityCountryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple countries are selected', async () => {
+            const organisationId = '12819'; // Studyportals
+            const firstCountryId = '1'; // Netherlands
+            const secondCountryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.ORGANISATIONS, [organisationId]],
+                [FilterKey.COUNTRY, [firstCountryId, secondCountryId]]
+            ]));
+            const result = await universityCountryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no organisations are selected', async () => {
+            const countryId = '1'; // Netherlands
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [countryId]]]));
+            const result = await universityCountryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no countries are selected', async () => {
+            const organisationId = '12819'; // Studyportals
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.ORGANISATIONS, [organisationId]]]));
+            const result = await universityCountryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            const organisationId = '12819'; // Studyportals
+            const countryId = '1'; // Netherlands
+            const disciplineId = '54'; // Agriculture & Forestry
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.ORGANISATIONS, [organisationId]],
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DISCIPLINES, [disciplineId]]
+            ]));
+            const result = await universityCountryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateSitemapUrls', () => {
+        let sitemapDependenciesHelper;
+        let universityCountryPolicy;
+        let countryFragments;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            universityCountryPolicy = new UniversityCountry(sitemapDependenciesHelper.dependencies);
+            vi.spyOn(CountryPresenter, 'getInstance').mockReturnValue({
+                getFragments: vi.fn(() => countryFragments),
+                generatePaths: vi.fn(() => countryFragments),
+                countryFragments
+            });
+        });
+        it('Should return path when all conditions are met', async () => {
+            const countryId = '30'; // UK
+            const countryPath = 'country-path';
+            const countryIso = 'ISO';
+            const organisationId = 12819;
+            const organisationName = 'Studyportals';
+            const organisationPath = 'organisation-path';
+            sitemapDependenciesHelper.setOrganisations([
+                {
+                    id: organisationId,
+                    name: organisationName,
+                    virtualPath: organisationPath,
+                    countryIsoCodes: [countryIso]
+                }
+            ]);
+            countryFragments = [
+                {
+                    id: countryId,
+                    path: countryPath,
+                    iso: countryIso
+                }
+            ];
+            const result = await universityCountryPolicy.generateSitemapUrls();
+            expect(result).toEqual([`${countryPath}/${organisationPath}`]);
+        });
+        it('Should return all rules', () => {
+            const rules = universityCountryPolicy.getAllRules();
+            expect(rules.length).toBeGreaterThan(1);
+        });
+    });
+});

package/dist/tests/scholarships/rules/ExceptAustaliaAreasRule.test.d.mts

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

package/dist/tests/scholarships/rules/ExceptAustaliaAreasRule.test.mjs

@@ -0,0 +1,64 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { ExceptAustraliaAreasRule } from '@/scholarships/rules/ExceptAustaliaAreasRule';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+describe('Rule:ExceptAustaliaAreas', () => {
+    describe('forSearch', () => {
+        let searchDependenciesHelper;
+        let rule;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            rule = new ExceptAustraliaAreasRule();
+        });
+        it('Returns true if area is not in Australia', async () => {
+            const areaId = '996'; // England
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.AREA, [areaId]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(true);
+        });
+        it('Returns false if area is in Australia', async () => {
+            const areaId = '137'; // Western Australia
+            const countryId = '202'; // Australia
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.AREA, [areaId]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(false);
+        });
+    });
+    describe('forSitemapGenerator', () => {
+        let rule;
+        beforeEach(() => {
+            rule = new ExceptAustraliaAreasRule();
+        });
+        it('Returns true if country is not Australia', async () => {
+            const countryId = '30'; // UK
+            const result = await rule.forSitemapGenerator(new Map([[FilterKey.COUNTRY, [countryId]]]));
+            expect(result).toBe(true);
+        });
+        it('Returns false if country is Australia', async () => {
+            const countryId = '202'; // Australia
+            const result = await rule.forSitemapGenerator(new Map([[FilterKey.COUNTRY, [countryId]]]));
+            expect(result).toBe(false);
+        });
+    });
+    describe('forDocumentation', () => {
+        let rule;
+        beforeEach(() => {
+            rule = new ExceptAustraliaAreasRule();
+        });
+        it('Returns description', () => {
+            const result = rule.getName();
+            expect(typeof result).toBe('string');
+        });
+        it('Returns name', () => {
+            const result = rule.getDescription();
+            expect(typeof result).toBe('string');
+        });
+    });
+});

package/dist/tests/scholarships/rules/SearchVolumeAreasRule.test.d.mts

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

package/dist/tests/scholarships/rules/SearchVolumeAreasRule.test.mjs

@@ -0,0 +1,62 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { SearchVolumeAreasRule } from '@/scholarships/rules/SearchVolumeAreasRule';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+describe('Rule:SearchVolumeAreas', () => {
+    describe('forSearch', () => {
+        let searchDependenciesHelper;
+        let rule;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            rule = new SearchVolumeAreasRule();
+        });
+        it('Returns true if area has enough search volume', async () => {
+            const areaId = '996'; // England
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.AREA, [areaId]]]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(true);
+        });
+        it('Returns false if area does not have enough search volume', async () => {
+            const areaId = '995'; // N. Ireland
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.AREA, [areaId]]]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(false);
+        });
+    });
+    describe('forSitemapGenerator', () => {
+        let rule;
+        beforeEach(() => {
+            rule = new SearchVolumeAreasRule();
+        });
+        it('Returns true if area has enough search volume', async () => {
+            const areaId = '996'; // England
+            const result = await rule.forSitemapGenerator(new Map([[FilterKey.AREA, [areaId]]]));
+            expect(result).toBe(true);
+        });
+        it('Returns false if area does not have enough search volume', async () => {
+            const areaId = '995'; // N. Ireland
+            const result = await rule.forSitemapGenerator(new Map([[FilterKey.AREA, [areaId]]]));
+            expect(result).toBe(false);
+        });
+        it('Returns false if multiple areas are selected', async () => {
+            const firstAreaId = '993'; // Wales
+            const secondAreaId = '996'; // England
+            const result = await rule.forSitemapGenerator(new Map([[FilterKey.AREA, [firstAreaId, secondAreaId]]]));
+            expect(result).toBe(false);
+        });
+    });
+    describe('forDocumentation', () => {
+        let rule;
+        beforeEach(() => {
+            rule = new SearchVolumeAreasRule();
+        });
+        it('Returns description', () => {
+            const result = rule.getName();
+            expect(typeof result).toBe('string');
+        });
+        it('Returns name', () => {
+            const result = rule.getDescription();
+            expect(typeof result).toBe('string');
+        });
+    });
+});

package/dist/tests/scholarships/rules/SearchVolumeCountriesDisciplinesRule.test.d.mts

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

package/dist/tests/scholarships/rules/SearchVolumeCountriesDisciplinesRule.test.mjs

@@ -0,0 +1,114 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { SearchVolumeCountriesDisciplinesRule } from '@/scholarships/rules/SearchVolumeCountriesDisciplinesRule';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+describe('Rule:SearchVolumeAreas', () => {
+    describe('forSearch', () => {
+        let searchDependenciesHelper;
+        let rule;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            rule = new SearchVolumeCountriesDisciplinesRule();
+        });
+        it('Returns true if combination has search volume', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(true);
+        });
+        it('Returns false if combination does not have search volume', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const countryId = '199'; // Zambia
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(false);
+        });
+        it('Returns false if no countries are selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DISCIPLINES, [disciplineId]]]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(false);
+        });
+        it('Returns false if no disciplines are selected', async () => {
+            const countryId = '30'; // UK
+            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 SearchVolumeCountriesDisciplinesRule();
+        });
+        it('Returns true if combination has search volume', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const countryId = '30'; // UK
+            const result = await rule.forSitemapGenerator(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            expect(result).toBe(true);
+        });
+        it('Returns false if combination does not have search volume', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const countryId = '199'; // Zambia
+            const result = await rule.forSitemapGenerator(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            expect(result).toBe(false);
+        });
+        it('Returns false if multiple countries are selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const firstCountryId = '30'; // UK
+            const secondCountryId = '82'; // USA
+            const result = await rule.forSitemapGenerator(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.COUNTRY, [firstCountryId, secondCountryId]]
+            ]));
+            expect(result).toBe(false);
+        });
+        it('Returns false if multiple disciplines are selected', async () => {
+            const firstDisciplineId = '54'; // Agriculture & Forestry
+            const secondDisciplineId = '12'; // Applied Sciences & Professions
+            const countryId = '30'; // UK
+            const result = await rule.forSitemapGenerator(new Map([
+                [FilterKey.DISCIPLINES, [firstDisciplineId, secondDisciplineId]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            expect(result).toBe(false);
+        });
+        it('Returns false if no countries are selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const result = await rule.forSitemapGenerator(new Map([[FilterKey.DISCIPLINES, [disciplineId]]]));
+            expect(result).toBe(false);
+        });
+        it('Returns false if no disciplines are selected', async () => {
+            const countryId = '30'; // UK
+            const result = await rule.forSitemapGenerator(new Map([[FilterKey.COUNTRY, [countryId]]]));
+            expect(result).toBe(false);
+        });
+    });
+    describe('forDocumentation', () => {
+        let rule;
+        beforeEach(() => {
+            rule = new SearchVolumeCountriesDisciplinesRule();
+        });
+        it('Returns description', () => {
+            const result = rule.getName();
+            expect(typeof result).toBe('string');
+        });
+        it('Returns name', () => {
+            const result = rule.getDescription();
+            expect(typeof result).toBe('string');
+        });
+    });
+});

package/dist/tests/scholarships/rules/SearchVolumeCountriesRule.test.d.mts

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

package/dist/tests/scholarships/rules/SearchVolumeCountriesRule.test.mjs

@@ -0,0 +1,62 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { SearchVolumeCountriesRule } from '@/scholarships/rules/SearchVolumeCountriesRule';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+describe('Rule:SearchVolumeAreas', () => {
+    describe('forSearch', () => {
+        let searchDependenciesHelper;
+        let rule;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            rule = new SearchVolumeCountriesRule();
+        });
+        it('Returns true if country has enough search volume', async () => {
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [countryId]]]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(true);
+        });
+        it('Returns false if country does not have enough search volume', async () => {
+            const countryId = '122'; // Macao
+            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 SearchVolumeCountriesRule();
+        });
+        it('Returns true if country has enough search volume', async () => {
+            const countryId = '30'; // UK
+            const result = await rule.forSitemapGenerator(new Map([[FilterKey.COUNTRY, [countryId]]]));
+            expect(result).toBe(true);
+        });
+        it('Returns false if country does not have enough search volume', async () => {
+            const countryId = '122'; // Macao
+            const result = await rule.forSitemapGenerator(new Map([[FilterKey.COUNTRY, [countryId]]]));
+            expect(result).toBe(false);
+        });
+        it('Returns false if multiple countries are selected', async () => {
+            const firstCountryId = '30'; // UK
+            const secondCountryId = '82'; // USA
+            const result = await rule.forSitemapGenerator(new Map([[FilterKey.COUNTRY, [firstCountryId, secondCountryId]]]));
+            expect(result).toBe(false);
+        });
+    });
+    describe('forDocumentation', () => {
+        let rule;
+        beforeEach(() => {
+            rule = new SearchVolumeCountriesRule();
+        });
+        it('Returns description', () => {
+            const result = rule.getName();
+            expect(typeof result).toBe('string');
+        });
+        it('Returns name', () => {
+            const result = rule.getDescription();
+            expect(typeof result).toBe('string');
+        });
+    });
+});

package/dist/tests/scholarships/rules/SearchVolumeDisciplinesRule.test.d.mts

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