@studyportals/fawkes 8.7.0 → 8.7.1-0

package/dist/tests/programmes/rules/OneYearDurationRule.test..mjs

@@ -0,0 +1,40 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { OneYearDurationRule } from '@/programmes/rules/OneYearDurationRule';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+describe('Rule:OneYearDurationRule', () => {
+    describe('forSearch', () => {
+        let searchDependenciesHelper;
+        let rule;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            rule = new OneYearDurationRule();
+            searchDependenciesHelper.setFilterKeyValues(new Map([]));
+        });
+        it('Should return true when duration is [360,360] (1 year)', async () => {
+            const duration = '[360,360]'; // 1 year
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DURATION, [duration]]]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(true);
+        });
+        it.each([
+            '[-1,29]',
+            '[30,90]',
+            '[91,-1]',
+            '[-1,359]',
+            '[540,540]',
+            '[-1,719]',
+            '[721,-1]',
+            '[900,900]',
+            '[1260,1260]',
+            '[1441,-1]',
+            '[720,720]',
+            '[1080,1080]',
+            '[1440,1440]'
+        ])('Should return false when duration is "%s"', async (duration) => {
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DURATION, [duration]]]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(false);
+        });
+    });
+});

package/dist/tests/programmes/rules/OnlineAttendanceRule.test.d.mts

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

package/dist/tests/programmes/rules/OnlineAttendanceRule.test.mjs

@@ -0,0 +1,69 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { OnlineAttendanceRule } from '@/common/rules/OnlineAttendanceRule';
+describe('Rule:OnlineAttendanceRule', () => {
+    describe('forSearch', () => {
+        let searchDependenciesHelper;
+        let rule;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            rule = new OnlineAttendanceRule();
+            searchDependenciesHelper.setFilterKeyValues(new Map([]));
+        });
+        it('Should return true when attendance is online', async () => {
+            const attendance = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DELIVERY_METHOD, [attendance]]]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(true);
+        });
+        it.each(['face2face', 'blended'])('Should return false when attendance is %s', async (attendance) => {
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DELIVERY_METHOD, [attendance]]]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(false);
+        });
+    });
+    describe('forSitemapGenerator', () => {
+        let rule;
+        beforeEach(() => {
+            rule = new OnlineAttendanceRule();
+        });
+        it('Should return true when attendance is online', async () => {
+            const attendance = 'online';
+            const filterKeyValues = new Map([[FilterKey.DELIVERY_METHOD, [attendance]]]);
+            const result = await rule.forSitemapGenerator(filterKeyValues);
+            expect(result).toBe(true);
+        });
+        it.each(['face2face', 'blended'])('Should return false when attendance is %s', async (attendance) => {
+            const filterKeyValues = new Map([[FilterKey.DELIVERY_METHOD, [attendance]]]);
+            const result = await rule.forSitemapGenerator(filterKeyValues);
+            expect(result).toBe(false);
+        });
+        it('Should return false when no attendance is specified', async () => {
+            const filterKeyValues = new Map();
+            const result = await rule.forSitemapGenerator(filterKeyValues);
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple attendance values are specified', async () => {
+            const filterKeyValues = new Map([[FilterKey.DELIVERY_METHOD, ['online', 'face2face']]]);
+            const result = await rule.forSitemapGenerator(filterKeyValues);
+            expect(result).toBe(false);
+        });
+    });
+    describe('forDocumentation', () => {
+        let rule;
+        beforeEach(() => {
+            rule = new OnlineAttendanceRule();
+        });
+        it('Should return a name', () => {
+            const result = rule.getName();
+            expect(typeof result).toBe('string');
+            expect(result).toBe('OnlineAttendanceRule');
+        });
+        it('Should return a description', () => {
+            const result = rule.getDescription();
+            expect(typeof result).toBe('string');
+            expect(result.length).toBeGreaterThan(0);
+        });
+    });
+});

package/dist/tests/programmes/rules/PartTimeFormatRule.test.d.mts

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

package/dist/tests/programmes/rules/PartTimeFormatRule.test.mjs

@@ -0,0 +1,27 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { PartTimeFormatRule } from '@/programmes/rules/PartTimeFormatRule';
+describe('Rule:PartTimeFormatRule', () => {
+    describe('forSearch', () => {
+        let searchDependenciesHelper;
+        let rule;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            rule = new PartTimeFormatRule();
+            searchDependenciesHelper.setFilterKeyValues(new Map([]));
+        });
+        it('Should return true when format is part-time', async () => {
+            const format = 'parttime';
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.ATTENDANCE, [format]]]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(true);
+        });
+        it('Should return false when format is fulltime', async () => {
+            const format = 'fulltime';
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.ATTENDANCE, [format]]]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(false);
+        });
+    });
+});

package/dist/tests/programmes/utils/SearchDependencies.util.d.mts

@@ -0,0 +1,16 @@
+import { FilterKeyValuesMap } from '@/common/FilterKeyValuesMap';
+import { DependencyTypes } from '@/enums/DependencyTypes';
+import { IProgrammeSearchDependencies } from '@/programmes/types/IProgrammeSearchDependencies';
+import { PortalType } from '@studyportals/domain-client';
+import { ISeoFilterState, ISeoInfoBase } from 'scholarships-seo';
+export declare class SearchDependencies {
+    dependencies: IProgrammeSearchDependencies;
+    constructor();
+    get seoInfoBase(): ISeoInfoBase;
+    get filterState(): ISeoFilterState;
+    get dependencyType(): DependencyTypes;
+    setPortalType(portalType: PortalType): void;
+    setResultsCount(count: number): void;
+    setPageNumber(pageNumber: number): void;
+    setFilterKeyValues(filterKeyValues: FilterKeyValuesMap): void;
+}

package/dist/tests/programmes/utils/SearchDependencies.util.mjs

@@ -0,0 +1,73 @@
+import { DependencyTypes } from '@/enums/DependencyTypes';
+import { PortalType } from '@studyportals/domain-client';
+import { vi } from 'vitest';
+export class SearchDependencies {
+    dependencies;
+    constructor() {
+        const seoInfoBase = {
+            singleSelectionFor: vi.fn(),
+            selectionOnlyFor: vi.fn(),
+            getFilterOptionValueBy: vi.fn(),
+            getSelectionTypeCount: vi.fn()
+        };
+        const applicationState = {
+            getNumberOfResults: vi.fn(),
+            getPageNumber: vi.fn().mockReturnValue(1)
+        };
+        const filterState = {};
+        const portalType = PortalType.MASTER;
+        const dependencyType = DependencyTypes.SEARCH;
+        this.dependencies = {
+            portalType,
+            seoInfoBase,
+            filterState,
+            applicationState,
+            dependencyType
+        };
+    }
+    get seoInfoBase() {
+        return this.dependencies.seoInfoBase;
+    }
+    get filterState() {
+        return this.dependencies.filterState;
+    }
+    get dependencyType() {
+        return this.dependencies.dependencyType;
+    }
+    setPortalType(portalType) {
+        this.dependencies.portalType = portalType;
+    }
+    setResultsCount(count) {
+        this.dependencies.applicationState.getNumberOfResults.mockImplementation(() => {
+            return count;
+        });
+    }
+    setPageNumber(pageNumber) {
+        this.dependencies.applicationState.getPageNumber.mockImplementation(() => {
+            return pageNumber;
+        });
+    }
+    setFilterKeyValues(filterKeyValues) {
+        const filterKeys = Array.from(filterKeyValues.keys());
+        this.dependencies.seoInfoBase.singleSelectionFor.mockImplementation((key) => {
+            if (filterKeys.includes(key)) {
+                return filterKeyValues.get(key).length === 1;
+            }
+            return false;
+        });
+        this.dependencies.seoInfoBase.selectionOnlyFor.mockImplementation((keys) => {
+            if (keys.every((key) => filterKeys.includes(key)) && filterKeys.every((filterKey) => keys.includes(filterKey)))
+                return true;
+            return false;
+        });
+        this.dependencies.seoInfoBase.getFilterOptionValueBy.mockImplementation((key) => {
+            const values = filterKeyValues.get(key);
+            if (!values || values.length === 0)
+                return null;
+            return values[0];
+        });
+        this.dependencies.seoInfoBase.getSelectionTypeCount.mockImplementation(() => {
+            return filterKeys.length;
+        });
+    }
+}

package/dist/tests/programmes/utils/SitemapDependencies.util.d.mts

@@ -0,0 +1,15 @@
+import { DependencyTypes } from '@/enums/DependencyTypes';
+import { IProgrammeSitemapDependencies } from '@/programmes/types/IProgrammeSitemapDependencies';
+import { PortalType } from '@studyportals/domain-client';
+import { ISearchApiClient } from 'sitemap-generator-seo';
+export declare class SitemapDependencies {
+    readonly dependencies: IProgrammeSitemapDependencies;
+    constructor();
+    get searchApiClient(): ISearchApiClient;
+    get dependencyType(): DependencyTypes;
+    get portalType(): PortalType;
+    setProgrammeCount(count: number): void;
+    setPortalType(portalType: PortalType): void;
+    mockCheckRulesForSitemap(resultMap?: Map<string, boolean>, defaultResult?: boolean): void;
+    resetMocks(): void;
+}

package/dist/tests/programmes/utils/SitemapDependencies.util.mjs

@@ -0,0 +1,49 @@
+import { DependencyTypes } from '@/enums/DependencyTypes';
+import { PortalType } from '@studyportals/domain-client';
+import { vi } from 'vitest';
+import { ProgrammesBaseIndexabilityPolicy } from '@/programmes/ProgrammesBaseIndexabilityPolicy';
+export class SitemapDependencies {
+    dependencies;
+    constructor() {
+        const searchApiClient = {
+            getCount: vi.fn(),
+            getOrganisationIds: vi.fn()
+        };
+        const organisationsClient = {
+            getOrganisations: vi.fn(),
+            getOrganisationIds: vi.fn(),
+        };
+        const dependencyType = DependencyTypes.SITEMAP_GENERATOR;
+        this.dependencies = {
+            searchApiClient,
+            dependencyType,
+            portalType: PortalType.MASTER
+        };
+    }
+    get searchApiClient() {
+        return this.dependencies.searchApiClient;
+    }
+    get dependencyType() {
+        return this.dependencies.dependencyType;
+    }
+    get portalType() {
+        return this.dependencies.portalType;
+    }
+    setProgrammeCount(count) {
+        this.dependencies.searchApiClient.getCount.mockResolvedValue(count);
+    }
+    setPortalType(portalType) {
+        this.dependencies.portalType = portalType;
+    }
+    mockCheckRulesForSitemap(resultMap = new Map(), defaultResult = true) {
+        vi.spyOn(ProgrammesBaseIndexabilityPolicy.prototype, 'checkRulesForSitemapWithPageNumber').mockImplementation(async function (filterKeyValues, pageNumber) {
+            const key = Array.from(filterKeyValues.entries())
+                .map(([k, v]) => `${k}:${v.join(',')}`)
+                .join('|');
+            return resultMap.has(key) ? resultMap.get(key) : defaultResult;
+        });
+    }
+    resetMocks() {
+        vi.restoreAllMocks();
+    }
+}

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

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

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

@@ -0,0 +1,121 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { Area } from '@/scholarships/policies/Area';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { SitemapDependencies } from '../utils/SitemapDependencies.util.mjs';
+import { AreaPresenter } from '@/presenters/AreaPresenter';
+describe('Policy:Area', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let areaPolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            areaPolicy = new Area(searchDependenciesHelper.dependencies);
+        });
+        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('Should return false when area is part of Australia', async () => {
+            const areaId = '137'; // Western Australia
+            const countryId = '202'; // Australia
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.AREA, [areaId]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            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 area does not have enough search volume', async () => {
+            const areaId = '995'; // N. Ireland
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.AREA, [areaId]],
+                [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();
+            areaPolicy = new Area(sitemapDependenciesHelper.dependencies);
+            vi.spyOn(AreaPresenter, 'getInstance').mockReturnValue({
+                getFragments: vi.fn(() => fragments),
+                generatePaths: vi.fn(() => fragments),
+                fragments
+            });
+        });
+        it('Should return path for area 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('Should not return path for area when area is part of Australia', async () => {
+            const areaId = '137'; // Western Australia
+            const countryId = '202'; // Australia
+            const path = '/path';
+            fragments = [
+                {
+                    id: areaId,
+                    countryId: countryId,
+                    path
+                }
+            ];
+            const result = await areaPolicy.generateSitemapUrls();
+            expect(result).toEqual([]);
+        });
+        it('Should return all rules', () => {
+            const rules = areaPolicy.getAllRules();
+            expect(rules.length).toBeGreaterThan(1);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,97 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { Country } from '@/scholarships/policies/Country';
+import { SitemapDependencies } from '../utils/SitemapDependencies.util.mjs';
+import { CountryPresenter } from '@/presenters/CountryPresenter';
+describe('Policy:Country', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let countryPolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            countryPolicy = new Country(searchDependenciesHelper.dependencies);
+        });
+        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('Should return false when multiple countries are selected', async () => {
+            const firstCountryId = '30'; // UK
+            const secondCountryId = '82'; // USA
+            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 disciplineId = '1';
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DISCIPLINES, [disciplineId]]]));
+            const result = await countryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when country does not have search volume', async () => {
+            const countryId = '122'; // Macao
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [countryId]]]));
+            const result = await countryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            const countryId = '30'; // UK
+            const disciplineId = '1';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.COUNTRY, [countryId]],
+                [FilterKey.DISCIPLINES, [disciplineId]]
+            ]));
+            const result = await countryPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateSitemapUrls', () => {
+        let sitemapDependenciesHelper;
+        let countryPolicy;
+        let fragments;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            countryPolicy = new Country(sitemapDependenciesHelper.dependencies);
+            vi.spyOn(CountryPresenter, 'getInstance').mockReturnValue({
+                getFragments: vi.fn(() => fragments),
+                generatePaths: vi.fn(() => fragments),
+                fragments
+            });
+        });
+        it('Should return path for country when all conditions are met', async () => {
+            const countryId = '30'; // UK
+            const path = '/path';
+            const iso = 'iso';
+            fragments = [
+                {
+                    id: countryId,
+                    path,
+                    iso
+                }
+            ];
+            const result = await countryPolicy.generateSitemapUrls();
+            expect(result).toEqual([path]);
+        });
+        it('Should not return path for country when country does not have search volume', async () => {
+            const countryId = '122'; // Macao
+            const path = '/path';
+            const iso = 'iso';
+            fragments = [
+                {
+                    id: countryId,
+                    path,
+                    iso
+                }
+            ];
+            const result = await countryPolicy.generateSitemapUrls();
+            expect(result).toEqual([]);
+        });
+        it('Should return all rules', () => {
+            const rules = countryPolicy.getAllRules();
+            expect(rules.length).toBeGreaterThan(1);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,93 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { Discipline } from '@/scholarships/policies/Discipline';
+import { SitemapDependencies } from '../utils/SitemapDependencies.util.mjs';
+import { DisciplinePresenter } from '@/presenters/DisciplinePresenter';
+describe('Policy:Discipline', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let disciplinePolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            disciplinePolicy = new Discipline(searchDependenciesHelper.dependencies);
+        });
+        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 disciplinePolicy.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
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DISCIPLINES, [firstDisciplineId, secondDisciplineId]]]));
+            const result = await disciplinePolicy.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 disciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when discipline does not have search volume', async () => {
+            const disciplineId = '243'; // Master in Management
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DISCIPLINES, [disciplineId]]]));
+            const result = await disciplinePolicy.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 disciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateSitemapUrls', () => {
+        let sitemapDependenciesHelper;
+        let disciplinePolicy;
+        let fragments;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            disciplinePolicy = new Discipline(sitemapDependenciesHelper.dependencies);
+            vi.spyOn(DisciplinePresenter, 'getInstance').mockReturnValue({
+                getFragments: vi.fn(() => fragments),
+                generatePaths: vi.fn(() => fragments),
+                fragments
+            });
+        });
+        it('Should return path for discipline when all conditions are met', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const path = '/path';
+            fragments = [
+                {
+                    id: disciplineId,
+                    path
+                }
+            ];
+            const result = await disciplinePolicy.generateSitemapUrls();
+            expect(result).toEqual([path]);
+        });
+        it('Should not return path for discipline when discipline does not have search volume', async () => {
+            const disciplineId = '243'; // Master in Management
+            const path = '/path';
+            fragments = [
+                {
+                    id: disciplineId,
+                    path
+                }
+            ];
+            const result = await disciplinePolicy.generateSitemapUrls();
+            expect(result).toEqual([]);
+        });
+        it('Should return all rules', () => {
+            const rules = disciplinePolicy.getAllRules();
+            expect(rules.length).toBeGreaterThan(1);
+        });
+    });
+});

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

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