@studyportals/fawkes 8.7.0 → 8.7.1-0

package/dist/tests/programmes/policies/DegreeCountryTuitionFee.test.mjs

@@ -0,0 +1,217 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { DegreeTypeFilterOptionValue, FilterKey, TuitionFeeFilterOptionValue } from '@studyportals/search-filters/server-side';
+import { PortalType } from '@studyportals/domain-client';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { SitemapDependencies } from '../utils/SitemapDependencies.util.mjs';
+import { DegreeCountryTuitionFee } from '@/programmes/policies/DegreeCountryTuitionFee';
+import { DegreePresenter } from '@/presenters/DegreePresenter';
+import { CountryPresenter } from '@/presenters/CountryPresenter';
+import { TuitionFeePresenter } from '@/presenters/TuitionFeePresenter';
+describe('Policy:DegreeCountryTuitionFee', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let degreeCountryTuitionFeePolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            degreeCountryTuitionFeePolicy = new DegreeCountryTuitionFee(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setResultsCount(7);
+            searchDependenciesHelper.setPageNumber(1);
+            searchDependenciesHelper.setPortalType(PortalType.MASTER);
+        });
+        describe('MBA with affordable tuition', () => {
+            it('Should return true for MBA with any country and affordable tuition', async () => {
+                searchDependenciesHelper.setFilterKeyValues(new Map([
+                    [FilterKey.DEGREE_TYPE, ['mba']],
+                    [FilterKey.COUNTRY, ['999']], // Any country
+                    [FilterKey.TUITION_FEE, [TuitionFeeFilterOptionValue.ZERO_TO_TWO_THOUSAND_FIVE_HUNDRED]]
+                ]));
+                const result = await degreeCountryTuitionFeePolicy.shouldIndex();
+                expect(result).toBe(true);
+            });
+            it('Should return false for MBA with expensive tuition', async () => {
+                searchDependenciesHelper.setFilterKeyValues(new Map([
+                    [FilterKey.DEGREE_TYPE, ['mba']],
+                    [FilterKey.COUNTRY, ['82']], // USA
+                    [FilterKey.TUITION_FEE, ['10000-15000']] // Expensive tuition
+                ]));
+                const result = await degreeCountryTuitionFeePolicy.shouldIndex();
+                expect(result).toBe(false);
+            });
+        });
+        describe('Master of Laws with affordable tuition', () => {
+            it.each([
+                '82', // USA
+                '30', // UK
+                '56', // Canada
+                '108' // India
+            ])('Should return true for LLM with country %s and affordable tuition', async (countryId) => {
+                searchDependenciesHelper.setFilterKeyValues(new Map([
+                    [FilterKey.DEGREE_TYPE, [DegreeTypeFilterOptionValue.LLM]],
+                    [FilterKey.COUNTRY, [countryId]],
+                    [FilterKey.TUITION_FEE, [TuitionFeeFilterOptionValue.ZERO_TO_TWO_THOUSAND_FIVE_HUNDRED]]
+                ]));
+                const result = await degreeCountryTuitionFeePolicy.shouldIndex();
+                expect(result).toBe(true);
+            });
+            it.each([
+                '11', // Germany (not allowed for LLM)
+                '202', // Australia (not allowed for LLM)
+                '999' // Invalid country
+            ])('Should return false for LLM with invalid country %s', async (countryId) => {
+                searchDependenciesHelper.setFilterKeyValues(new Map([
+                    [FilterKey.DEGREE_TYPE, ['llm']],
+                    [FilterKey.COUNTRY, [countryId]],
+                    [FilterKey.TUITION_FEE, [TuitionFeeFilterOptionValue.ZERO_TO_TWO_THOUSAND_FIVE_HUNDRED]]
+                ]));
+                const result = await degreeCountryTuitionFeePolicy.shouldIndex();
+                expect(result).toBe(false);
+            });
+        });
+        describe('unsupported degrees', () => {
+            it('Should return false for unsupported degree types', async () => {
+                searchDependenciesHelper.setFilterKeyValues(new Map([
+                    [FilterKey.DEGREE_TYPE, ['msc']], // Not supported by this policy
+                    [FilterKey.COUNTRY, ['82']],
+                    [FilterKey.TUITION_FEE, [TuitionFeeFilterOptionValue.ZERO_TO_TWO_THOUSAND_FIVE_HUNDRED]]
+                ]));
+                const result = await degreeCountryTuitionFeePolicy.shouldIndex();
+                expect(result).toBe(false);
+            });
+        });
+        describe('filter validation', () => {
+            it('Should return false when multiple degrees are selected', async () => {
+                searchDependenciesHelper.setFilterKeyValues(new Map([
+                    [FilterKey.DEGREE_TYPE, ['mba', 'llm']],
+                    [FilterKey.COUNTRY, ['82']],
+                    [FilterKey.TUITION_FEE, [TuitionFeeFilterOptionValue.ZERO_TO_TWO_THOUSAND_FIVE_HUNDRED]]
+                ]));
+                const result = await degreeCountryTuitionFeePolicy.shouldIndex();
+                expect(result).toBe(false);
+            });
+            it('Should return false when multiple countries are selected', async () => {
+                searchDependenciesHelper.setFilterKeyValues(new Map([
+                    [FilterKey.DEGREE_TYPE, ['mba']],
+                    [FilterKey.COUNTRY, ['82', '30']],
+                    [FilterKey.TUITION_FEE, [TuitionFeeFilterOptionValue.ZERO_TO_TWO_THOUSAND_FIVE_HUNDRED]]
+                ]));
+                const result = await degreeCountryTuitionFeePolicy.shouldIndex();
+                expect(result).toBe(false);
+            });
+            it('Should return false when other filters are selected', async () => {
+                searchDependenciesHelper.setFilterKeyValues(new Map([
+                    [FilterKey.DEGREE_TYPE, ['mba']],
+                    [FilterKey.COUNTRY, ['82']],
+                    [FilterKey.TUITION_FEE, [TuitionFeeFilterOptionValue.ZERO_TO_TWO_THOUSAND_FIVE_HUNDRED]],
+                    [FilterKey.DISCIPLINES, ['54']] // Extra filter
+                ]));
+                const result = await degreeCountryTuitionFeePolicy.shouldIndex();
+                expect(result).toBe(false);
+            });
+        });
+    });
+    describe('generateUrls', () => {
+        let sitemapDependenciesHelper;
+        let degreeCountryTuitionFeePolicy;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setProgrammeCount(10);
+            degreeCountryTuitionFeePolicy = new DegreeCountryTuitionFee(sitemapDependenciesHelper.dependencies);
+            DegreePresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: 'mba', path: 'mba' },
+                    { id: 'llm', path: 'llm' },
+                    { id: 'msc', path: 'masters' } // Not supported
+                ])
+            });
+            CountryPresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: '82', path: 'usa' },
+                    { id: '30', path: 'uk' },
+                    { id: '56', path: 'canada' },
+                    { id: '108', path: 'india' },
+                    { id: '11', path: 'germany' },
+                    { id: '202', path: 'australia' }
+                ])
+            });
+            TuitionFeePresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: TuitionFeeFilterOptionValue.ZERO_TO_TWO_THOUSAND_FIVE_HUNDRED, path: 'affordable' },
+                    { id: '10000-15000', path: 'expensive' }
+                ])
+            });
+        });
+        afterEach(() => {
+            sitemapDependenciesHelper.resetMocks();
+        });
+        it('Should generate URLs for MBA with all countries and affordable tuition', async () => {
+            const resultMap = new Map();
+            // MBA accepts all countries
+            const allCountries = ['82', '30', '32', '108', '11', '202'];
+            for (const country of allCountries) {
+                const key = `${FilterKey.DEGREE_TYPE}:mba|${FilterKey.COUNTRY}:${country}|${FilterKey.TUITION_FEE}:${TuitionFeeFilterOptionValue.ZERO_TO_TWO_THOUSAND_FIVE_HUNDRED}`;
+                resultMap.set(key, true);
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await degreeCountryTuitionFeePolicy.generateUrls();
+            // MBA: 6 countries * 2 pages = 12 URLs
+            expect(urls.length).toBeGreaterThan(0);
+            expect(urls).toContain('mba/affordable/usa');
+            expect(urls).toContain('mba/affordable/uk');
+            expect(urls).toContain('mba/affordable/canada');
+            expect(urls).toContain('mba/affordable/india');
+            expect(urls).toContain('mba/affordable/germany');
+            expect(urls).toContain('mba/affordable/australia');
+        });
+        it('Should generate URLs for LLM with specific countries and affordable tuition', async () => {
+            const resultMap = new Map();
+            // LLM accepts only specific countries: USA, UK, Canada, India
+            const llmCountries = ['82', '30', '56', '108'];
+            for (const country of llmCountries) {
+                const key = `${FilterKey.DEGREE_TYPE}:llm|${FilterKey.COUNTRY}:${country}|${FilterKey.TUITION_FEE}:${TuitionFeeFilterOptionValue.ZERO_TO_TWO_THOUSAND_FIVE_HUNDRED}`;
+                resultMap.set(key, true);
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await degreeCountryTuitionFeePolicy.generateUrls();
+            // LLM: 4 allowed countries * 2 pages = 8 URLs
+            expect(urls).toContain('llm/affordable/usa');
+            expect(urls).toContain('llm/affordable/uk');
+            expect(urls).toContain('llm/affordable/canada');
+            expect(urls).toContain('llm/affordable/india');
+            // Should not include invalid countries for LLM
+            expect(urls).not.toContain('llm/affordable/germany');
+            expect(urls).not.toContain('llm/affordable/australia');
+        });
+        it('Should handle missing affordable tuition gracefully', async () => {
+            // Mock TuitionFeePresenter to not return affordable tuition
+            TuitionFeePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: '10000-15000', path: 'expensive' }
+                ])
+            });
+            sitemapDependenciesHelper.mockCheckRulesForSitemap();
+            const urls = await degreeCountryTuitionFeePolicy.generateUrls();
+            // Should return empty array when no affordable tuition is available
+            expect(urls).toHaveLength(0);
+        });
+        it('Should exclude unsupported degrees', async () => {
+            const resultMap = new Map();
+            // Only MBA and LLM should be supported
+            const allDegrees = ['mba', 'llm', 'msc'];
+            const supportedDegrees = ['mba', 'llm'];
+            const countries = ['82', '30'];
+            for (const degree of allDegrees) {
+                for (const country of countries) {
+                    const key = `${FilterKey.DEGREE_TYPE}:${degree}|${FilterKey.COUNTRY}:${country}|${FilterKey.TUITION_FEE}:${TuitionFeeFilterOptionValue.ZERO_TO_TWO_THOUSAND_FIVE_HUNDRED}`;
+                    resultMap.set(key, supportedDegrees.includes(degree));
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await degreeCountryTuitionFeePolicy.generateUrls();
+            // Should include supported degrees
+            expect(urls).toContain('mba/affordable/usa');
+            expect(urls).toContain('llm/affordable/uk');
+            // Should not include unsupported degrees
+            expect(urls).not.toContain('masters/affordable/usa');
+        });
+    });
+});

package/dist/tests/programmes/policies/DegreeFormat.test.d.mts

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

package/dist/tests/programmes/policies/DegreeFormat.test.mjs

@@ -0,0 +1,221 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { DegreeFormat } from '@/programmes/policies/DegreeFormat';
+import { PortalType } from '@studyportals/domain-client';
+import { SitemapDependencies } from '../utils/SitemapDependencies.util.mjs';
+import { DegreePresenter } from '@/presenters/DegreePresenter';
+import { FormatPresenter } from '@/presenters/FormatPresenter';
+describe('Policy:DegreeFormat', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let degreeFormatPolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            degreeFormatPolicy = new DegreeFormat(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setResultsCount(10);
+            searchDependenciesHelper.setPageNumber(1);
+            searchDependenciesHelper.setPortalType(PortalType.BACHELOR);
+        });
+        it('Should return true when all conditions are met (fulltime + degree)', async () => {
+            const format = 'fulltime';
+            const degree = 'mba';
+            searchDependenciesHelper.setPortalType(PortalType.MASTER);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.ATTENDANCE, [format]],
+                [FilterKey.DEGREE_TYPE, [degree]]
+            ]));
+            const result = await degreeFormatPolicy.shouldIndex();
+            expect(result).toBe(true);
+        });
+        it('Should return true when all conditions are met (parttime + degree)', async () => {
+            const format = 'parttime';
+            const degree = 'msc';
+            searchDependenciesHelper.setPortalType(PortalType.MASTER);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.ATTENDANCE, [format]],
+                [FilterKey.DEGREE_TYPE, [degree]]
+            ]));
+            const result = await degreeFormatPolicy.shouldIndex();
+            expect(result).toBe(true);
+        });
+        it('Should return false when multiple formats are selected', async () => {
+            const firstFormat = 'fulltime';
+            const secondFormat = 'parttime';
+            const degree = 'mba';
+            searchDependenciesHelper.setPortalType(PortalType.MASTER);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.ATTENDANCE, [firstFormat, secondFormat]],
+                [FilterKey.DEGREE_TYPE, [degree]]
+            ]));
+            const result = await degreeFormatPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple degrees are selected', async () => {
+            const format = 'fulltime';
+            const firstDegree = 'mba';
+            const secondDegree = 'msc';
+            searchDependenciesHelper.setPortalType(PortalType.MASTER);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.ATTENDANCE, [format]],
+                [FilterKey.DEGREE_TYPE, [firstDegree, secondDegree]]
+            ]));
+            const result = await degreeFormatPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no format is selected', async () => {
+            const degree = 'mba';
+            searchDependenciesHelper.setPortalType(PortalType.MASTER);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DEGREE_TYPE, [degree]]
+            ]));
+            const result = await degreeFormatPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no degree is selected', async () => {
+            const format = 'parttime';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.ATTENDANCE, [format]]
+            ]));
+            const result = await degreeFormatPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            const format = 'fulltime';
+            const degree = 'mba';
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setPortalType(PortalType.MASTER);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.ATTENDANCE, [format]],
+                [FilterKey.DEGREE_TYPE, [degree]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            const result = await degreeFormatPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when degree is not indexable', async () => {
+            const format = 'parttime';
+            const degree = 'ap'; // Academy Profession - not indexable
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.ATTENDANCE, [format]],
+                [FilterKey.DEGREE_TYPE, [degree]]
+            ]));
+            const result = await degreeFormatPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when number of results is less than 7', async () => {
+            const format = 'fulltime';
+            const degree = 'mba';
+            searchDependenciesHelper.setResultsCount(6);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.ATTENDANCE, [format]],
+                [FilterKey.DEGREE_TYPE, [degree]]
+            ]));
+            const result = await degreeFormatPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateUrls', () => {
+        let sitemapDependenciesHelper;
+        let degreeFormatPolicy;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setProgrammeCount(10);
+            degreeFormatPolicy = new DegreeFormat(sitemapDependenciesHelper.dependencies);
+            // Mock FormatPresenter - only fulltime and parttime should be used
+            FormatPresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: 'fulltime', path: 'full-time' },
+                    { id: 'parttime', path: 'part-time' },
+                    { id: 'online', path: 'online' }, // Should be filtered out
+                    { id: 'blended', path: 'blended' } // Should be filtered out
+                ])
+            });
+            DegreePresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: 'mba', path: 'master-of-business-administration' },
+                    { id: 'msc', path: 'master-of-science' },
+                    { id: 'phd', path: 'doctor-of-philosophy' }
+                ])
+            });
+        });
+        afterEach(() => {
+            sitemapDependenciesHelper.resetMocks();
+        });
+        it('Should generate URLs only for fulltime/parttime formats with degrees', async () => {
+            // Mock rules to return true for indexable combinations
+            const resultMap = new Map([
+                // Fulltime combinations
+                [`${FilterKey.ATTENDANCE}:fulltime|${FilterKey.DEGREE_TYPE}:mba`, true],
+                [`${FilterKey.ATTENDANCE}:fulltime|${FilterKey.DEGREE_TYPE}:msc`, true],
+                [`${FilterKey.ATTENDANCE}:fulltime|${FilterKey.DEGREE_TYPE}:phd`, true],
+                // Parttime combinations
+                [`${FilterKey.ATTENDANCE}:parttime|${FilterKey.DEGREE_TYPE}:mba`, true],
+                [`${FilterKey.ATTENDANCE}:parttime|${FilterKey.DEGREE_TYPE}:msc`, true],
+                [`${FilterKey.ATTENDANCE}:parttime|${FilterKey.DEGREE_TYPE}:phd`, true]
+            ]);
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await degreeFormatPolicy.generateUrls();
+            // Should include 2 formats * 3 degrees = 6 URLs
+            expect(urls).toHaveLength(6);
+            // Verify specific combinations
+            expect(urls).toContain('master-of-business-administration/full-time');
+            expect(urls).toContain('master-of-business-administration/part-time');
+            expect(urls).toContain('master-of-science/full-time');
+            expect(urls).toContain('master-of-science/part-time');
+            expect(urls).toContain('doctor-of-philosophy/full-time');
+            expect(urls).toContain('doctor-of-philosophy/part-time');
+            // Should not contain online or blended formats
+            expect(urls).not.toContain('master-of-business-administration/online');
+            expect(urls).not.toContain('master-of-business-administration/blended');
+        });
+        it('Should exclude non-indexable degrees', async () => {
+            // Add non-indexable degree to mock
+            DegreePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: 'mba', path: 'master-of-business-administration' },
+                    { id: 'ap', path: 'academy-profession' } // Non-indexable
+                ])
+            });
+            const resultMap = new Map([
+                [`${FilterKey.ATTENDANCE}:fulltime|${FilterKey.DEGREE_TYPE}:mba`, true],
+                [`${FilterKey.ATTENDANCE}:parttime|${FilterKey.DEGREE_TYPE}:mba`, true],
+                [`${FilterKey.ATTENDANCE}:fulltime|${FilterKey.DEGREE_TYPE}:ap`, false], // Non-indexable
+                [`${FilterKey.ATTENDANCE}:parttime|${FilterKey.DEGREE_TYPE}:ap`, false] // Non-indexable
+            ]);
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await degreeFormatPolicy.generateUrls();
+            expect(urls).toHaveLength(2); // Only MBA combinations
+            expect(urls).toContain('master-of-business-administration/full-time');
+            expect(urls).toContain('master-of-business-administration/part-time');
+            expect(urls).not.toContain('academy-profession/full-time');
+            expect(urls).not.toContain('academy-profession/part-time');
+        });
+        it('Should handle rule failures', async () => {
+            const resultMap = new Map([
+                [`${FilterKey.ATTENDANCE}:fulltime|${FilterKey.DEGREE_TYPE}:mba`, true],
+                [`${FilterKey.ATTENDANCE}:parttime|${FilterKey.DEGREE_TYPE}:mba`, false], // Fails
+                [`${FilterKey.ATTENDANCE}:fulltime|${FilterKey.DEGREE_TYPE}:msc`, false], // Fails
+                [`${FilterKey.ATTENDANCE}:parttime|${FilterKey.DEGREE_TYPE}:msc`, true],
+                [`${FilterKey.ATTENDANCE}:fulltime|${FilterKey.DEGREE_TYPE}:phd`, true],
+                [`${FilterKey.ATTENDANCE}:parttime|${FilterKey.DEGREE_TYPE}:phd`, true]
+            ]);
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await degreeFormatPolicy.generateUrls();
+            expect(urls).toHaveLength(4); // mba/fulltime, msc/parttime, phd/fulltime, phd/parttime
+            expect(urls).toContain('master-of-business-administration/full-time');
+            expect(urls).toContain('master-of-science/part-time');
+            expect(urls).toContain('doctor-of-philosophy/full-time');
+            expect(urls).toContain('doctor-of-philosophy/part-time');
+            expect(urls).not.toContain('master-of-business-administration/part-time');
+            expect(urls).not.toContain('master-of-science/full-time');
+        });
+        it('Should handle empty fragments', async () => {
+            FormatPresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue([])
+            });
+            const urls = await degreeFormatPolicy.generateUrls();
+            expect(urls).toHaveLength(0);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,159 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { SitemapDependencies } from '../utils/SitemapDependencies.util.mjs';
+import { Discipline } from '@/programmes/policies/Discipline';
+import { PortalType } from '@studyportals/domain-client';
+import { DisciplinePresenter } from '@/presenters/DisciplinePresenter';
+describe('Policy:Discipline', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let disciplinePolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            disciplinePolicy = new Discipline(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setResultsCount(10);
+            searchDependenciesHelper.setPageNumber(1);
+            searchDependenciesHelper.setPortalType(PortalType.PHD);
+        });
+        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 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);
+        });
+        it('Should return false when number of results is less than 7', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            searchDependenciesHelper.setResultsCount(6);
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DISCIPLINES, [disciplineId]]]));
+            const result = await disciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when page number is higher than 2', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            searchDependenciesHelper.setPageNumber(3);
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DISCIPLINES, [disciplineId]]]));
+            const result = await disciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when portal type is distance learning', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            searchDependenciesHelper.setPortalType(PortalType.DISTANCE_LEARNING);
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DISCIPLINES, [disciplineId]]]));
+            const result = await disciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateUrls', () => {
+        let sitemapDependenciesHelper;
+        let disciplinePolicy;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setProgrammeCount(10); // More than 7 programs
+            disciplinePolicy = new Discipline(sitemapDependenciesHelper.dependencies);
+            DisciplinePresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: '54', path: 'agriculture-forestry' },
+                    { id: '12', path: 'applied-sciences' },
+                    { id: '152', path: 'computer-science-it' }
+                ])
+            });
+        });
+        afterEach(() => {
+            sitemapDependenciesHelper.resetMocks();
+        });
+        it('Should generate URLs for all valid disciplines', async () => {
+            // Mock the checkRulesForSitemap to return true for all filter combinations
+            sitemapDependenciesHelper.mockCheckRulesForSitemap();
+            // Call the method via reflection since it's protected
+            const urls = await disciplinePolicy.generateUrls();
+            // Verify all discipline fragments were included
+            expect(urls).toHaveLength(3);
+            expect(urls).toContain('agriculture-forestry');
+            expect(urls).toContain('applied-sciences');
+            expect(urls).toContain('computer-science-it');
+        });
+        it('Should exclude URLs that fail rule checks', async () => {
+            // Create a map that returns false for Computer Science
+            const resultMap = new Map([[`${FilterKey.DISCIPLINES}:152`, false]]);
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await disciplinePolicy.generateUrls();
+            // Should only include Agriculture and Applied Sciences, not Computer Science
+            expect(urls).toHaveLength(2);
+            expect(urls).toContain('agriculture-forestry');
+            expect(urls).toContain('applied-sciences');
+            expect(urls).not.toContain('computer-science-it');
+        });
+        it('Should exclude all URLs when all checks fail', async () => {
+            // Create a map that returns false for all disciplines
+            const resultMap = new Map([
+                [`${FilterKey.DISCIPLINES}:54`, false],
+                [`${FilterKey.DISCIPLINES}:12`, false],
+                [`${FilterKey.DISCIPLINES}:152`, false]
+            ]);
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await disciplinePolicy.generateUrls();
+            // Should include no URLs
+            expect(urls).toHaveLength(0);
+        });
+        it('Should handle empty fragments array', async () => {
+            // Mock the DisciplinePresenter to return empty fragments
+            DisciplinePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue([])
+            });
+            sitemapDependenciesHelper.mockCheckRulesForSitemap();
+            const urls = await disciplinePolicy.generateUrls();
+            // Should return empty array
+            expect(urls).toHaveLength(0);
+        });
+        it('Should test the performance with a large number of fragments', async () => {
+            // Generate a large number of discipline fragments
+            const largeFragmentSet = Array.from({ length: 100 }, (_, index) => ({
+                id: `${1000 + index}`,
+                path: `discipline-${1000 + index}`
+            }));
+            // Mock the DisciplinePresenter to return large fragment set
+            DisciplinePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeFragmentSet)
+            });
+            // Make half of them fail the rule check
+            const resultMap = new Map();
+            for (let i = 0; i < largeFragmentSet.length; i++) {
+                if (i % 2 === 0) {
+                    resultMap.set(`${FilterKey.DISCIPLINES}:${largeFragmentSet[i].id}`, false);
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await disciplinePolicy.generateUrls();
+            // Should include half of the disciplines
+            expect(urls).toHaveLength(50);
+            // Check a few specific items
+            expect(urls).not.toContain('discipline-1004'); // Should be filtered out (index 0)
+            expect(urls).toContain('discipline-1003'); // Should be included (index 1)
+            expect(urls).not.toContain('discipline-1002'); // Should be filtered out (index 2)
+        });
+    });
+});

package/dist/tests/programmes/policies/DisciplineAttendance.test.d.mts

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