@studyportals/fawkes 8.7.0 → 8.7.1-0

package/dist/tests/organisations/policies/ranked/RankedCountryDiscipline.test.mjs

@@ -0,0 +1,197 @@
+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 { RankedCountryDiscipline } from '@/organisations/policies';
+import { PortalType } from '@studyportals/domain-client';
+import { DisciplinePresenter } from '@/presenters/DisciplinePresenter';
+import { CountryPresenter } from '@/presenters/CountryPresenter';
+describe('Policy:RankedCountryDiscipline', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let rankedCountryDisciplinePolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            rankedCountryDisciplinePolicy = new RankedCountryDiscipline(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setSortingState(SortingOptions.UNIVERSITY_META_RANKING);
+            searchDependenciesHelper.setRankedResultsCount(10);
+        });
+        it('Should return true when all conditions are met', async () => {
+            const countryId = '30'; // UK
+            const disciplineId = '54'; // Agriculture & Forestry
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DISCIPLINES, [disciplineId]]
+            ]));
+            const result = await rankedCountryDisciplinePolicy.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
+            const disciplineId = '54'; // Agriculture & Forestry
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DISCIPLINES, [disciplineId]]
+            ]));
+            searchDependenciesHelper.setPortalType(portalType);
+            const result = await rankedCountryDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when area when Our Picks sorting is selected', async () => {
+            searchDependenciesHelper.setSortingState(SortingOptions.OUR_PICKS);
+            const result = await rankedCountryDisciplinePolicy.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 = '21'; // PT
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.COUNTRY, [firstCountryId, secondCountryId]]
+            ]));
+            const result = await rankedCountryDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple disciplines are selected', async () => {
+            const countryId = '30'; // UK
+            const firstDisciplineId = '54'; // Agreiculture & Forestry
+            const secondDisciplineId = '12'; // Applied Sciences & Professions
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DISCIPLINES, [firstDisciplineId, secondDisciplineId]]
+            ]));
+            const result = await rankedCountryDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no countries are selected', async () => {
+            const disciplineId = '54'; // Agreiculture & Forestry
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DISCIPLINES, [disciplineId]]]));
+            const result = await rankedCountryDisciplinePolicy.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 rankedCountryDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            const countryId = '30'; // UK
+            const disciplineId = '12'; // Applied Sciences & Professions
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.DELIVERY_METHOD, [attendance]]
+            ]));
+            const result = await rankedCountryDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when there are less then 2 ranked results', async () => {
+            const rankedResultsCount = 1;
+            const countryId = '30'; // UK
+            const disciplineId = '12'; // Applied Sciences & Professions
+            searchDependenciesHelper.setRankedResultsCount(rankedResultsCount);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DISCIPLINES, [disciplineId]]
+            ]));
+            const result = await rankedCountryDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateSitemapUrls', () => {
+        const pathPrefix = 'rankings/';
+        const enoughRankedOrganisations = 10;
+        const noRankedOrganisations = 0;
+        let sitemapDependenciesHelper;
+        let rankedCountryDisciplinePolicy;
+        let countryFragments;
+        let disciplineFragments;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            rankedCountryDisciplinePolicy = new RankedCountryDiscipline(sitemapDependenciesHelper.dependencies);
+            vi.spyOn(CountryPresenter, 'getInstance').mockReturnValue({
+                getFragments: vi.fn(() => countryFragments),
+                generatePaths: vi.fn(() => countryFragments),
+                fragments: countryFragments
+            });
+            vi.spyOn(DisciplinePresenter, 'getInstance').mockReturnValue({
+                getFragments: vi.fn(() => disciplineFragments),
+                generatePaths: vi.fn(() => disciplineFragments),
+                fragments: disciplineFragments
+            });
+            sitemapDependenciesHelper.setRankedOrganisationCount(enoughRankedOrganisations);
+        });
+        it('Should return path when all conditions are met', async () => {
+            const countryId = '30'; // UK
+            const countryIso = 'UK';
+            const countryPath = 'country-path';
+            const disciplineId = '54'; // Agriculture & Forestry
+            const disciplinePath = 'discipline-path';
+            countryFragments = [
+                {
+                    id: countryId,
+                    iso: countryIso,
+                    path: countryPath
+                }
+            ];
+            disciplineFragments = [
+                {
+                    id: disciplineId,
+                    path: disciplinePath
+                }
+            ];
+            const result = await rankedCountryDisciplinePolicy.generateSitemapUrls();
+            expect(result).toEqual([`${pathPrefix}${countryPath}/${disciplinePath}`]);
+        });
+        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 = 'UK';
+            const countryPath = 'country-path';
+            const disciplineId = '54'; // Agriculture & Forestry
+            const disciplinePath = 'discipline-path';
+            countryFragments = [
+                {
+                    id: countryId,
+                    iso: countryIso,
+                    path: countryPath
+                }
+            ];
+            disciplineFragments = [
+                {
+                    id: disciplineId,
+                    path: disciplinePath
+                }
+            ];
+            sitemapDependenciesHelper.setPortalType(portalType);
+            const result = await rankedCountryDisciplinePolicy.generateSitemapUrls();
+            expect(result).toEqual([]);
+        });
+        it('Should not return path when there is no ranked organisation', async () => {
+            const countryId = '30'; // UK
+            const countryIso = 'UK';
+            const countryPath = 'country-path';
+            const disciplineId = '54'; // Agriculture & Forestry
+            const disciplinePath = 'discipline-path';
+            countryFragments = [
+                {
+                    id: countryId,
+                    iso: countryIso,
+                    path: countryPath
+                }
+            ];
+            disciplineFragments = [
+                {
+                    id: disciplineId,
+                    path: disciplinePath
+                }
+            ];
+            sitemapDependenciesHelper.setRankedOrganisationCount(noRankedOrganisations);
+            const result = await rankedCountryDisciplinePolicy.generateSitemapUrls();
+            expect(result).toEqual([]);
+        });
+    });
+});

package/dist/tests/organisations/policies/ranked/RankedDiscipline.test.d.mts

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

package/dist/tests/organisations/policies/ranked/RankedDiscipline.test.mjs

@@ -0,0 +1,124 @@
+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 { RankedDiscipline } from '@/organisations/policies';
+import { PortalType } from '@studyportals/domain-client';
+import { DisciplinePresenter } from '@/presenters/DisciplinePresenter';
+describe('Policy:RankedDiscipline', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let rankedDisciplinePolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            rankedDisciplinePolicy = new RankedDiscipline(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setSortingState(SortingOptions.UNIVERSITY_META_RANKING);
+            searchDependenciesHelper.setRankedResultsCount(10);
+        });
+        it('Should return true when all conditions are met', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DISCIPLINES, [disciplineId]]]));
+            const result = await rankedDisciplinePolicy.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 disciplineId = '54'; // Agriculture & Forestry
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DISCIPLINES, [disciplineId]]]));
+            searchDependenciesHelper.setPortalType(portalType);
+            const result = await rankedDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when area when Our Picks sorting is selected', async () => {
+            searchDependenciesHelper.setSortingState(SortingOptions.OUR_PICKS);
+            const result = await rankedDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple disciplines are selected', async () => {
+            const firstDisciplineId = '54'; // Agriculture & Forestry
+            const secondDisciplineId = '12'; // Applied Sciences & Professions
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DISCIPLINES, [firstDisciplineId, secondDisciplineId]]]));
+            const result = await rankedDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no disciplines are selected', async () => {
+            searchDependenciesHelper.setFilterKeyValues(new Map([]));
+            const result = await rankedDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DISCIPLINES, [disciplineId]]
+            ]));
+            const result = await rankedDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when there are less then 2 ranked results', async () => {
+            const rankedResultsCount = 1;
+            const disciplineId = '54'; // Agriculture & Forestry
+            searchDependenciesHelper.setRankedResultsCount(rankedResultsCount);
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DISCIPLINES, [disciplineId]]]));
+            const result = await rankedDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateSitemapUrls', () => {
+        const pathPrefix = 'rankings/';
+        const enoughRankedOrganisations = 10;
+        const noRankedOrganisations = 0;
+        let sitemapDependenciesHelper;
+        let rankedDisciplinePolicy;
+        let disciplineFragments;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            rankedDisciplinePolicy = new RankedDiscipline(sitemapDependenciesHelper.dependencies);
+            vi.spyOn(DisciplinePresenter, 'getInstance').mockReturnValue({
+                getFragments: vi.fn(() => disciplineFragments),
+                generatePaths: vi.fn(() => disciplineFragments),
+                fragments: disciplineFragments
+            });
+            sitemapDependenciesHelper.setRankedOrganisationCount(enoughRankedOrganisations);
+        });
+        it('Should return path when all conditions are met', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const disciplinePath = 'discipline-path';
+            disciplineFragments = [
+                {
+                    id: disciplineId,
+                    path: disciplinePath
+                }
+            ];
+            const result = await rankedDisciplinePolicy.generateSitemapUrls();
+            expect(result).toEqual([`${pathPrefix}${disciplinePath}`]);
+        });
+        it.each([[PortalType.BACHELOR], [PortalType.PHD], [PortalType.SHORT]])('Should not return path when portal type is %s', async (portalType) => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const disciplinePath = 'discipline-path';
+            disciplineFragments = [
+                {
+                    id: disciplineId,
+                    path: disciplinePath
+                }
+            ];
+            sitemapDependenciesHelper.setPortalType(portalType);
+            const result = await rankedDisciplinePolicy.generateSitemapUrls();
+            expect(result).toEqual([]);
+        });
+        it('Should not return path when there is no ranked organisation', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const disciplinePath = 'discipline-path';
+            disciplineFragments = [
+                {
+                    id: disciplineId,
+                    path: disciplinePath
+                }
+            ];
+            sitemapDependenciesHelper.setRankedOrganisationCount(noRankedOrganisations);
+            const result = await rankedDisciplinePolicy.generateSitemapUrls();
+            expect(result).toEqual([]);
+        });
+    });
+});

package/dist/tests/organisations/policies/ranked/RankedUnfiltered.test.d.mts

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

package/dist/tests/organisations/policies/ranked/RankedUnfiltered.test.mjs

@@ -0,0 +1,75 @@
+import { describe, it, expect, beforeEach } 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 { RankedUnfiltered } from '@/organisations/policies';
+import { PortalType } from '@studyportals/domain-client';
+describe('Policy:RankedUnfiltered', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let rankedUnfilteredPolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            rankedUnfilteredPolicy = new RankedUnfiltered(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setSortingState(SortingOptions.UNIVERSITY_META_RANKING);
+            searchDependenciesHelper.setRankedResultsCount(10);
+        });
+        it('Should return true when all conditions are met', async () => {
+            searchDependenciesHelper.setFilterKeyValues(new Map([]));
+            const result = await rankedUnfilteredPolicy.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) => {
+            searchDependenciesHelper.setFilterKeyValues(new Map([]));
+            searchDependenciesHelper.setPortalType(portalType);
+            const result = await rankedUnfilteredPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when area when Our Picks sorting is selected', async () => {
+            searchDependenciesHelper.setSortingState(SortingOptions.OUR_PICKS);
+            const result = await rankedUnfilteredPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when any filter is selected', async () => {
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [countryId]]]));
+            const result = await rankedUnfilteredPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when there are less then 2 ranked results', async () => {
+            const rankedResultsCount = 1;
+            searchDependenciesHelper.setRankedResultsCount(rankedResultsCount);
+            searchDependenciesHelper.setFilterKeyValues(new Map([]));
+            const result = await rankedUnfilteredPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateSitemapUrls', () => {
+        const pathPrefix = 'rankings/';
+        const enoughRankedOrganisations = 10;
+        const noRankedOrganisations = 0;
+        let sitemapDependenciesHelper;
+        let rankedUnfilteredPolicy;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            rankedUnfilteredPolicy = new RankedUnfiltered(sitemapDependenciesHelper.dependencies);
+            sitemapDependenciesHelper.setRankedOrganisationCount(enoughRankedOrganisations);
+        });
+        it('Should return path when all conditions are met', async () => {
+            const result = await rankedUnfilteredPolicy.generateSitemapUrls();
+            const expectedPath = "rankings";
+            expect(result).toEqual([expectedPath]);
+        });
+        it.each([[PortalType.BACHELOR], [PortalType.PHD], [PortalType.SHORT]])('Should not return path when portal type is %s', async (portalType) => {
+            sitemapDependenciesHelper.setPortalType(portalType);
+            const result = await rankedUnfilteredPolicy.generateSitemapUrls();
+            expect(result).toEqual([]);
+        });
+        it('Should not return path when there is no ranked organisation', async () => {
+            sitemapDependenciesHelper.setRankedOrganisationCount(noRankedOrganisations);
+            const result = await rankedUnfilteredPolicy.generateSitemapUrls();
+            expect(result).toEqual([]);
+        });
+    });
+});

package/dist/tests/organisations/rules/ContinentIsEuropeRule.test.d.mts

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

package/dist/tests/organisations/rules/ContinentIsEuropeRule.test.mjs

@@ -0,0 +1,59 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { ContinentIsEuropeRule } from '@/organisations/rules/ContinentIsEuropeRule';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+describe('Rule:ContinentIsEurope', () => {
+    describe('forSearch', () => {
+        let searchDependenciesHelper;
+        let rule;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            rule = new ContinentIsEuropeRule();
+            searchDependenciesHelper.setFilterKeyValues(new Map([]));
+        });
+        it('Returns true if selected continent is Europe', async () => {
+            const continentId = '1'; // Europe
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.CONTINENT, [continentId]]]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(true);
+        });
+        it('Returns false if selected continent is not Europe', async () => {
+            const continentId = '9'; // Asia
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.CONTINENT, [continentId]]]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(false);
+        });
+    });
+    describe('forSitemapGenerator', () => {
+        let rule;
+        beforeEach(() => {
+            rule = new ContinentIsEuropeRule();
+        });
+        it('Returns true if  selected continent is Europe', async () => {
+            const continentId = '1'; // Europe
+            const filterKeyValues = new Map([[FilterKey.CONTINENT, [continentId]]]);
+            const result = await rule.forSitemapGenerator(filterKeyValues);
+            expect(result).toBe(true);
+        });
+        it('Returns false if selected continent is not Europe', async () => {
+            const continentId = '9'; // Asia
+            const filterKeyValues = new Map([[FilterKey.CONTINENT, [continentId]]]);
+            const result = await rule.forSitemapGenerator(filterKeyValues);
+            expect(result).toBe(false);
+        });
+    });
+    describe('forDocumentation', () => {
+        let rule;
+        beforeEach(() => {
+            rule = new ContinentIsEuropeRule();
+        });
+        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/organisations/rules/MinimumAmountOfRankedResultsRule.test.d.mts

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

package/dist/tests/organisations/rules/MinimumAmountOfRankedResultsRule.test.mjs

@@ -0,0 +1,77 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { SitemapDependencies } from '../utils/SitemapDependencies.util.mjs';
+import { MinimumAmountOfRankedResultsRule } from '@/organisations/rules/MinimumAmountOfRankedResultsRule';
+import { DependencyMissingError } from '@/errors/DependencyMissingError';
+describe('Rule:MinimumAmountOfRankedResultsRule', () => {
+    describe('forSearch', () => {
+        let searchDependenciesHelper;
+        let rule;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            rule = new MinimumAmountOfRankedResultsRule();
+            searchDependenciesHelper.setFilterKeyValues(new Map([]));
+        });
+        it('Returns true if ranked result count is at least 7', async () => {
+            const rankedResultsCount = 7;
+            searchDependenciesHelper.setRankedResultsCount(rankedResultsCount);
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(true);
+        });
+        it('Returns false if result count is less than 7', async () => {
+            const rankedResultsCount = 4;
+            searchDependenciesHelper.setRankedResultsCount(rankedResultsCount);
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(false);
+        });
+    });
+    describe('forSitemapGenerator', () => {
+        let sitemapDependenciesHelper;
+        let rule;
+        const filterKeyValues = new Map([]);
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            rule = new MinimumAmountOfRankedResultsRule(sitemapDependenciesHelper.dependencies.rankingApiClient);
+        });
+        it('Returns true if ranked organisation count is at least 7', async () => {
+            const rankedOrganisationCount = 7;
+            sitemapDependenciesHelper.setRankedOrganisationCount(rankedOrganisationCount);
+            const result = await rule.forSitemapGenerator(filterKeyValues);
+            expect(result).toBe(true);
+        });
+        it('Returns false if ranked organisation count is less than 7', async () => {
+            const rankedOrganisationCount = 3;
+            sitemapDependenciesHelper.setRankedOrganisationCount(rankedOrganisationCount);
+            const result = await rule.forSitemapGenerator(filterKeyValues);
+            expect(result).toBe(false);
+        });
+        it('Throws error if RankingApiClient is not provided', async () => {
+            rule = new MinimumAmountOfRankedResultsRule();
+            let result = false;
+            let caughtError;
+            try {
+                result = await rule.forSitemapGenerator(filterKeyValues);
+            }
+            catch (error) {
+                caughtError = error;
+            }
+            expect(result).toBe(false);
+            expect(caughtError).toBeInstanceOf(Error);
+            expect(caughtError).toBeInstanceOf(DependencyMissingError);
+        });
+    });
+    describe('forDocumentation', () => {
+        let rule;
+        beforeEach(() => {
+            rule = new MinimumAmountOfRankedResultsRule();
+        });
+        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/organisations/rules/MinimumAmountOfResultsRule.test.d.mts

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

package/dist/tests/organisations/rules/MinimumAmountOfResultsRule.test.mjs

@@ -0,0 +1,77 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { SitemapDependencies } from '../utils/SitemapDependencies.util.mjs';
+import { MinimumAmountOfResultsRule } from '@/organisations/rules/MinimumAmountOfResultsRule';
+import { DependencyMissingError } from '@/errors/DependencyMissingError';
+describe('Rule:MinimumAmountOfResultsRule', () => {
+    describe('forSearch', () => {
+        let searchDependenciesHelper;
+        let rule;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            rule = new MinimumAmountOfResultsRule();
+            searchDependenciesHelper.setFilterKeyValues(new Map([]));
+        });
+        it('Returns true if result count is at least 7', async () => {
+            const resultCount = 7;
+            searchDependenciesHelper.setNumberOfResults(resultCount);
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(true);
+        });
+        it('Returns false if result count is less than 7', async () => {
+            const resultCount = 4;
+            searchDependenciesHelper.setNumberOfResults(resultCount);
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(false);
+        });
+    });
+    describe('forSitemapGenerator', () => {
+        let sitemapDependenciesHelper;
+        let rule;
+        const filterKeyValues = new Map([]);
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            rule = new MinimumAmountOfResultsRule(sitemapDependenciesHelper.dependencies.searchApiClient);
+        });
+        it('Returns true if ranked organisation count is at least 7', async () => {
+            const organisationCount = 7;
+            sitemapDependenciesHelper.setOrganisationCount(organisationCount);
+            const result = await rule.forSitemapGenerator(filterKeyValues);
+            expect(result).toBe(true);
+        });
+        it('Returns false if ranked organisation count is less than 7', async () => {
+            const organisationCount = 3;
+            sitemapDependenciesHelper.setOrganisationCount(organisationCount);
+            const result = await rule.forSitemapGenerator(filterKeyValues);
+            expect(result).toBe(false);
+        });
+        it('Throws error if RankingApiClient is not provided', async () => {
+            rule = new MinimumAmountOfResultsRule();
+            let result = false;
+            let caughtError;
+            try {
+                result = await rule.forSitemapGenerator(filterKeyValues);
+            }
+            catch (error) {
+                caughtError = error;
+            }
+            expect(result).toBe(false);
+            expect(caughtError).toBeInstanceOf(Error);
+            expect(caughtError).toBeInstanceOf(DependencyMissingError);
+        });
+    });
+    describe('forDocumentation', () => {
+        let rule;
+        beforeEach(() => {
+            rule = new MinimumAmountOfResultsRule();
+        });
+        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/organisations/rules/OnlineAttendanceRule.test.d.mts

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