@studyportals/fawkes 8.7.1-0 → 8.7.1

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

@@ -1,179 +0,0 @@
-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 { Duration } from '@/programmes/policies/Duration';
-import { PortalType } from '@studyportals/domain-client';
-import { SitemapDependencies } from '../utils/SitemapDependencies.util.mjs';
-import { DurationPresenter } from '@/presenters/DurationPresenter';
-describe('Policy:Duration', () => {
-    describe('shouldIndex', () => {
-        let searchDependenciesHelper;
-        let durationPolicy;
-        beforeEach(() => {
-            searchDependenciesHelper = new SearchDependencies();
-            durationPolicy = new Duration(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setResultsCount(10);
-            searchDependenciesHelper.setPageNumber(1);
-            searchDependenciesHelper.setPortalType(PortalType.BACHELOR);
-        });
-        it('Should return true when 1 year duration is selected', async () => {
-            const duration = '[360,360]'; // 1 year
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.DURATION, [duration]]
-            ]));
-            const result = await durationPolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Should return true when 2 years duration is selected', async () => {
-            const duration = '[720,720]'; // 2 years
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.DURATION, [duration]]
-            ]));
-            const result = await durationPolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Should return false when multiple durations are selected', async () => {
-            const firstDuration = '[360,360]'; // 1 year
-            const secondDuration = '[720,720]'; // 2 years
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.DURATION, [firstDuration, secondDuration]]
-            ]));
-            const result = await durationPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when no duration is selected', async () => {
-            searchDependenciesHelper.setFilterKeyValues(new Map());
-            const result = await durationPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when other filters are selected', async () => {
-            const duration = '[360,360]'; // 1 year
-            const countryId = '30'; // UK
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.DURATION, [duration]],
-                [FilterKey.COUNTRY, [countryId]]
-            ]));
-            const result = await durationPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when duration filter is not 1 year or 2 years', async () => {
-            const duration = '[-1,359]'; // This will be filtered out in generateUrls, but shouldIndex only checks basic rules
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.DURATION, [duration]]
-            ]));
-            const result = await durationPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when number of results is less than 7', async () => {
-            const duration = '[720,720]'; // 2 years
-            searchDependenciesHelper.setResultsCount(6);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.DURATION, [duration]]
-            ]));
-            const result = await durationPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when page number is higher than 2', async () => {
-            const duration = '[360,360]'; // 1 year
-            searchDependenciesHelper.setPageNumber(4);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.DURATION, [duration]]
-            ]));
-            const result = await durationPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when portal is distance learning', async () => {
-            const duration = '[720,720]'; // 2 years
-            searchDependenciesHelper.setPortalType(PortalType.DISTANCE_LEARNING);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.DURATION, [duration]]
-            ]));
-            const result = await durationPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-    });
-    describe('generateUrls', () => {
-        let sitemapDependenciesHelper;
-        let durationPolicy;
-        beforeEach(() => {
-            sitemapDependenciesHelper = new SitemapDependencies();
-            sitemapDependenciesHelper.setProgrammeCount(10); // More than 7 programs
-            durationPolicy = new Duration(sitemapDependenciesHelper.dependencies);
-            // Mock DurationPresenter with all durations including ones that should be filtered out
-            DurationPresenter.getInstance = vi.fn().mockReturnValue({
-                getFragments: vi.fn().mockReturnValue([
-                    { id: '[360,360]', path: '1-year' }, // Should be included
-                    { id: '[720,720]', path: '2-years' }, // Should be included
-                    { id: '[1080,1080]', path: '3-years' }, // Should be filtered out
-                    { id: '[1440,1440]', path: '4-years' }, // Should be filtered out
-                    { id: '[-1,359]', path: 'less-than-1-year' } // Should be filtered out
-                ])
-            });
-        });
-        afterEach(() => {
-            sitemapDependenciesHelper.resetMocks();
-        });
-        it('Should generate URLs only for 1 year and 2 years durations', async () => {
-            // Mock the checkRulesForSitemap to return true for allowed durations
-            const resultMap = new Map([
-                [`${FilterKey.DURATION}:[360,360]`, true], // 1 year
-                [`${FilterKey.DURATION}:[720,720]`, true], // 2 years
-                [`${FilterKey.DURATION}:[1080,1080]`, true], // Won't be used due to filtering
-                [`${FilterKey.DURATION}:[1440,1440]`, true], // Won't be used due to filtering
-                [`${FilterKey.DURATION}:[-1,359]`, true] // Won't be used due to filtering
-            ]);
-            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
-            const urls = await durationPolicy.generateUrls();
-            // Should only include 1 year and 2 years
-            expect(urls).toHaveLength(2);
-            expect(urls).toContain('1-year');
-            expect(urls).toContain('2-years');
-            // Should exclude other durations
-            expect(urls).not.toContain('3-years');
-            expect(urls).not.toContain('4-years');
-            expect(urls).not.toContain('less-than-1-year');
-        });
-        it('Should exclude URLs when rule checks fail', async () => {
-            const resultMap = new Map([
-                [`${FilterKey.DURATION}:[360,360]`, false], // 1 year fails
-                [`${FilterKey.DURATION}:[720,720]`, true] // 2 years passes
-            ]);
-            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
-            const urls = await durationPolicy.generateUrls();
-            // Should only include 2 years
-            expect(urls).toHaveLength(1);
-            expect(urls).toContain('2-years');
-            expect(urls).not.toContain('1-year');
-        });
-        it('Should handle empty duration fragments', async () => {
-            DurationPresenter.getInstance.mockReturnValueOnce({
-                getFragments: vi.fn().mockReturnValue([])
-            });
-            sitemapDependenciesHelper.mockCheckRulesForSitemap();
-            const urls = await durationPolicy.generateUrls();
-            expect(urls).toHaveLength(0);
-        });
-        it('Should verify filtering logic with exact duration IDs', async () => {
-            // Test that only specific duration IDs are allowed
-            const mockFragments = [
-                { id: '[360,360]', path: '1-year' },
-                { id: '[720,720]', path: '2-years' },
-                { id: '[900,900]', path: 'other-duration' } // Should be filtered out
-            ];
-            DurationPresenter.getInstance.mockReturnValueOnce({
-                getFragments: vi.fn().mockReturnValue(mockFragments)
-            });
-            const resultMap = new Map([
-                [`${FilterKey.DURATION}:[360,360]`, true],
-                [`${FilterKey.DURATION}:[720,720]`, true],
-                [`${FilterKey.DURATION}:[900,900]`, true] // Won't be used
-            ]);
-            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
-            const urls = await durationPolicy.generateUrls();
-            expect(urls).toHaveLength(2);
-            expect(urls).toContain('1-year');
-            expect(urls).toContain('2-years');
-            expect(urls).not.toContain('other-duration');
-        });
-    });
-});

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

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

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

@@ -1,117 +0,0 @@
-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 { Format } from '@/programmes/policies/Format';
-import { PortalType } from '@studyportals/domain-client';
-import { SitemapDependencies } from '../utils/SitemapDependencies.util.mjs';
-import { FormatPresenter } from '@/presenters/FormatPresenter';
-describe('Policy:Format', () => {
-    describe('shouldIndex', () => {
-        let searchDependenciesHelper;
-        let formatPolicy;
-        beforeEach(() => {
-            searchDependenciesHelper = new SearchDependencies();
-            formatPolicy = new Format(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setResultsCount(10);
-            searchDependenciesHelper.setPageNumber(1);
-            searchDependenciesHelper.setPortalType(PortalType.BACHELOR);
-        });
-        it('Should return true when fulltime format is selected', async () => {
-            const format = 'fulltime';
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.ATTENDANCE, [format]]
-            ]));
-            const result = await formatPolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Should return true when parttime format is selected', async () => {
-            const format = 'parttime';
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.ATTENDANCE, [format]]
-            ]));
-            const result = await formatPolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Should return false when multiple formats are selected', async () => {
-            const firstFormat = 'fulltime';
-            const secondFormat = 'parttime';
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.ATTENDANCE, [firstFormat, secondFormat]]
-            ]));
-            const result = await formatPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when no format is selected', async () => {
-            searchDependenciesHelper.setFilterKeyValues(new Map());
-            const result = await formatPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when other filters are selected', async () => {
-            const format = 'fulltime';
-            const countryId = '30'; // UK
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.ATTENDANCE, [format]],
-                [FilterKey.COUNTRY, [countryId]]
-            ]));
-            const result = await formatPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when number of results is less than 7', async () => {
-            const format = 'parttime';
-            searchDependenciesHelper.setResultsCount(6);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.ATTENDANCE, [format]]
-            ]));
-            const result = await formatPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when page number is higher than 2', async () => {
-            const format = 'fulltime';
-            searchDependenciesHelper.setPageNumber(4);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.ATTENDANCE, [format]]
-            ]));
-            const result = await formatPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-        it('Should return false when portal is distance learning', async () => {
-            const format = 'parttime';
-            searchDependenciesHelper.setPortalType(PortalType.DISTANCE_LEARNING);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.ATTENDANCE, [format]]
-            ]));
-            const result = await formatPolicy.shouldIndex();
-            expect(result).toBe(false);
-        });
-    });
-    describe('generateUrls', () => {
-        let sitemapDependenciesHelper;
-        let formatPolicy;
-        beforeEach(() => {
-            sitemapDependenciesHelper = new SitemapDependencies();
-            sitemapDependenciesHelper.setProgrammeCount(10); // More than 7 programs
-            formatPolicy = new Format(sitemapDependenciesHelper.dependencies);
-            // Mock FormatPresenter with all formats including ones that should be filtered out
-            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
-                    { id: 'face2face', path: 'on-campus' } // Should be filtered out
-                ])
-            });
-        });
-        afterEach(() => {
-            sitemapDependenciesHelper.resetMocks();
-        });
-        it('Should handle empty format fragments', async () => {
-            FormatPresenter.getInstance.mockReturnValueOnce({
-                getFragments: vi.fn().mockReturnValue([])
-            });
-            sitemapDependenciesHelper.mockCheckRulesForSitemap();
-            const urls = await formatPolicy.generateUrls();
-            expect(urls).toHaveLength(0);
-        });
-    });
-});

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

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

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

@@ -1,320 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { FilterKey } from '@studyportals/search-filters/server-side';
-import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
-import { PortalType } from '@studyportals/domain-client';
-// Import all policies to validate new rules
-import { Format } from '@/programmes/policies/Format';
-import { Degree } from '@/programmes/policies/Degree';
-import { DegreeFormat } from '@/programmes/policies/DegreeFormat';
-import { AttendanceDegree } from '@/programmes/policies/AttendanceDegree';
-import { Duration } from '@/programmes/policies/Duration';
-import { DegreeDuration } from '@/programmes/policies/DegreeDuration';
-import { AttendanceDuration } from '@/programmes/policies/AttendanceDuration';
-import { AttendanceFormat } from '@/programmes/policies/AttendanceFormat';
-import { AttendanceContinent } from '@/programmes/policies/AttendanceContinent';
-import { ContinentFormat } from '@/programmes/policies/ContinentFormat';
-import { DegreeTuitionFee } from '@/programmes/policies/DegreeTuitionFee';
-import { DegreeContinent } from '@/programmes/policies/DegreeContinent';
-import { TuitionFeeAttendance } from '@/programmes/policies/TuitionFeeAttendance';
-import { DegreeTuitionFeeArea } from '@/programmes/policies/DegreeTuitionFeeArea';
-import { DegreeTuitionFeeContinent } from '@/programmes/policies/DegreeTuitionFeeContinent';
-import { SpecialProgrammes } from '@/programmes/policies/SpecialProgrammes';
-import { DisciplineContinentAttendance } from '@/programmes/policies/DisciplineContinentAttendance';
-import { DisciplineCountryAttendance } from '@/programmes/policies/DisciplineCountryAttendance';
-import { DisciplineCountryFormat } from '@/programmes/policies/DisciplineCountryFormat';
-import { DegreeSpecialProgrammes } from '@/programmes/policies/DegreeSpecialProgrammes';
-import { DegreeAttendanceSpecialProgrammes } from '@/programmes/policies/DegreeAttendanceSpecialProgrammes';
-import { ContinentSpecialProgrammes } from '@/programmes/policies';
-/**
- * Test suite to validate that all new indexing rules from new-rules.md are properly implemented
- * This ensures we match the requirements exactly as specified
- */
-describe('New Rules Validation (from new-rules.md)', () => {
-    let searchDependenciesHelper;
-    beforeEach(() => {
-        searchDependenciesHelper = new SearchDependencies();
-        searchDependenciesHelper.setResultsCount(10);
-        searchDependenciesHelper.setPageNumber(1);
-        searchDependenciesHelper.setPortalType(PortalType.BACHELOR);
-    });
-    describe('Format Rules (Rules 1-2)', () => {
-        it('Rule 1: Full-time (Format) should be indexable', async () => {
-            const formatPolicy = new Format(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.ATTENDANCE, ['fulltime']]]));
-            const result = await formatPolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Rule 2: Part-time (Format) should be indexable', async () => {
-            const formatPolicy = new Format(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.ATTENDANCE, ['parttime']]]));
-            const result = await formatPolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-    });
-    describe('Degree Rules (Rules 3-9)', () => {
-        it('Rule 3: Degree should be indexable', async () => {
-            const degreePolicy = new Degree(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DEGREE_TYPE, ['mba']]]));
-            const result = await degreePolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Rule 4: Part-time + Degree should be indexable', async () => {
-            searchDependenciesHelper.setPortalType(PortalType.MASTER);
-            const degreeFormatPolicy = new DegreeFormat(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.ATTENDANCE, ['parttime']],
-                [FilterKey.DEGREE_TYPE, ['mba']]
-            ]));
-            const result = await degreeFormatPolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Rule 7: Full-time + Degree should be indexable', async () => {
-            searchDependenciesHelper.setPortalType(PortalType.MASTER);
-            const degreeFormatPolicy = new DegreeFormat(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.ATTENDANCE, ['fulltime']],
-                [FilterKey.DEGREE_TYPE, ['msc']]
-            ]));
-            const result = await degreeFormatPolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Rule 8: Tuition Fee + Degree should be indexable', async () => {
-            const degreeTuitionFeePolicy = new DegreeTuitionFee(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.TUITION_FEE, ['[0,2500]']],
-                [FilterKey.DEGREE_TYPE, ['phd']]
-            ]));
-            const result = await degreeTuitionFeePolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Rule 9: Continent + Degree should be indexable', async () => {
-            searchDependenciesHelper.setPortalType(PortalType.MASTER);
-            const degreeContinentPolicy = new DegreeContinent(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.CONTINENT, ['europe']],
-                [FilterKey.DEGREE_TYPE, ['mba']]
-            ]));
-            const result = await degreeContinentPolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-    });
-    describe('Duration Rules (Rules 11-12, 17-22, 28-30)', () => {
-        it('Rule 11: 1 year (Duration) should be indexable', async () => {
-            const durationPolicy = new Duration(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DURATION, ['[360,360]']]]));
-            const result = await durationPolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Rule 17: 2 years (Duration) should be indexable', async () => {
-            const durationPolicy = new Duration(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DURATION, ['[720,720]']]]));
-            const result = await durationPolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Rule 12: Online Learning + 1 year should be indexable', async () => {
-            const attendanceDurationPolicy = new AttendanceDuration(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.DELIVERY_METHOD, ['online']],
-                [FilterKey.DURATION, ['[360,360]']]
-            ]));
-            const result = await attendanceDurationPolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Rule 21: Degree + 2 years should be indexable', async () => {
-            searchDependenciesHelper.setPortalType(PortalType.MASTER);
-            const degreeDurationPolicy = new DegreeDuration(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.DEGREE_TYPE, ['msc']],
-                [FilterKey.DURATION, ['[720,720]']]
-            ]));
-            const result = await degreeDurationPolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Rule 29: Degree + 1 year should be indexable', async () => {
-            searchDependenciesHelper.setPortalType(PortalType.MASTER);
-            const degreeDurationPolicy = new DegreeDuration(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.DEGREE_TYPE, ['mba']],
-                [FilterKey.DURATION, ['[360,360]']]
-            ]));
-            const result = await degreeDurationPolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-    });
-    describe('Attendance Combination Rules (Rules 10, 16, 18-20, 25-27)', () => {
-        it('Rule 10: Tuition Fee + Online Learning should be indexable', async () => {
-            const attendanceTuitionFeePolicy = new TuitionFeeAttendance(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.TUITION_FEE, ['[0,2500]']],
-                [FilterKey.DELIVERY_METHOD, ['online']]
-            ]));
-            const result = await attendanceTuitionFeePolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Rule 16: Part-time + Online Learning should be indexable', async () => {
-            const attendanceFormatPolicy = new AttendanceFormat(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.ATTENDANCE, ['parttime']],
-                [FilterKey.DELIVERY_METHOD, ['online']]
-            ]));
-            const result = await attendanceFormatPolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Rule 18: Blended Learning + Degree should be indexable', async () => {
-            searchDependenciesHelper.setPortalType(PortalType.PHD);
-            const attendanceDegreePolicy = new AttendanceDegree(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.DELIVERY_METHOD, ['blended']],
-                [FilterKey.DEGREE_TYPE, ['phd']]
-            ]));
-            const result = await attendanceDegreePolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Rule 19: Continent + Online Learning should be indexable', async () => {
-            const attendanceContinentPolicy = new AttendanceContinent(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.CONTINENT, ['europe']],
-                [FilterKey.DELIVERY_METHOD, ['online']]
-            ]));
-            const result = await attendanceContinentPolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Rule 20: Continent + Part-time should be indexable', async () => {
-            const continentFormatPolicy = new ContinentFormat(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.CONTINENT, ['europe']],
-                [FilterKey.ATTENDANCE, ['parttime']]
-            ]));
-            const result = await continentFormatPolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Rule 25: Full-time + Online Learning should be indexable', async () => {
-            const attendanceFormatPolicy = new AttendanceFormat(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.ATTENDANCE, ['fulltime']],
-                [FilterKey.DELIVERY_METHOD, ['online']]
-            ]));
-            const result = await attendanceFormatPolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-    });
-    describe('Complex Combination Rules (Rules 13-15, 27-28)', () => {
-        it('Rule 13: Region + Tuition Fee + Degree - Policy exists (DegreeTuitionFeeArea)', async () => {
-            // This test verifies the policy exists and can be instantiated
-            // The actual rule validation may require additional filters based on implementation
-            const degreeTuitionFeeAreaPolicy = new DegreeTuitionFeeArea(searchDependenciesHelper.dependencies);
-            expect(degreeTuitionFeeAreaPolicy).toBeDefined();
-            expect(degreeTuitionFeeAreaPolicy.name).toBe('Degree Area Tuition fee Policy');
-        });
-        it('Rule 15: Continent + Tuition Fee + Degree should be indexable', async () => {
-            searchDependenciesHelper.setPortalType(PortalType.MASTER);
-            const degreeContinentTuitionFeePolicy = new DegreeTuitionFeeContinent(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.CONTINENT, ['europe']],
-                [FilterKey.TUITION_FEE, ['[0,2500]']],
-                [FilterKey.DEGREE_TYPE, ['msc']]
-            ]));
-            const result = await degreeContinentTuitionFeePolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-    });
-    describe('Special Programmes Rules (Rules 22-24, 30, 34-35)', () => {
-        it('Rule 24: Executive Programmes (Special) should be indexable', async () => {
-            const specialProgrammesPolicy = new SpecialProgrammes(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.SPECIAL_PROGRAMMES, ['executive']]]));
-            const result = await specialProgrammesPolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Rule 34: MBA + Executive Programmes should be indexable', async () => {
-            const degreeSpecialProgrammesPolicy = new DegreeSpecialProgrammes(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.DEGREE_TYPE, ['mba']],
-                [FilterKey.SPECIAL_PROGRAMMES, ['executive']]
-            ]));
-            const result = await degreeSpecialProgrammesPolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Rule 35: MBA + Executive Programmes + online - Policy exists (DegreeAttendanceSpecialProgrammes)', async () => {
-            // This test verifies the policy exists and implements the required functionality
-            // The policy filters for MBA + Executive programs and uses OnlineAttendanceRule
-            const degreeAttendanceSpecialProgrammesPolicy = new DegreeAttendanceSpecialProgrammes(searchDependenciesHelper.dependencies);
-            expect(degreeAttendanceSpecialProgrammesPolicy).toBeDefined();
-            expect(degreeAttendanceSpecialProgrammesPolicy.name).toBe('Degree Attendance Special Programmes Policy');
-            expect(degreeAttendanceSpecialProgrammesPolicy.description).toContain('online');
-        });
-    });
-    describe('Discipline Combination Rules (Rules 14, 32-33)', () => {
-        it('Rule 14: Continent + Discipline + Online should be indexable', async () => {
-            const disciplineContinentAttendancePolicy = new DisciplineContinentAttendance(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.CONTINENT, ['europe']],
-                [FilterKey.DISCIPLINES, ['business']],
-                [FilterKey.DELIVERY_METHOD, ['online']]
-            ]));
-            const result = await disciplineContinentAttendancePolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Rule 32: Discipline + Country + Online learning should be indexable', async () => {
-            const disciplineCountryAttendancePolicy = new DisciplineCountryAttendance(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.DISCIPLINES, ['engineering']],
-                [FilterKey.COUNTRY, ['30']], // UK
-                [FilterKey.DELIVERY_METHOD, ['online']]
-            ]));
-            const result = await disciplineCountryAttendancePolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-        it('Rule 33: Discipline + Country + Part-time should be indexable', async () => {
-            const disciplineCountryFormatPolicy = new DisciplineCountryFormat(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.DISCIPLINES, ['medicine']],
-                [FilterKey.COUNTRY, ['56']], // USA
-                [FilterKey.ATTENDANCE, ['parttime']]
-            ]));
-            const result = await disciplineCountryFormatPolicy.shouldIndex();
-            expect(result).toBe(true);
-        });
-    });
-    describe('Verify Policy Behavior', () => {
-        it('Format policy allows any attendance type in shouldIndex (filtering in generateUrls)', async () => {
-            const formatPolicy = new Format(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.ATTENDANCE, ['online']]]) // This passes shouldIndex but gets filtered in generateUrls
-            );
-            const result = await formatPolicy.shouldIndex();
-            expect(result).toBe(true); // Basic validation passes
-        });
-        it('Duration policy allows 1 year duration in shouldIndex (filtering in generateUrls)', async () => {
-            const durationPolicy = new Duration(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DURATION, ['[360,360]']]]) // 1 year - allowed in shouldIndex, filtered in generateUrls
-            );
-            const result = await durationPolicy.shouldIndex();
-            expect(result).toBe(true); // Basic validation passes
-        });
-        it('Duration policy allows 2 years duration in shouldIndex (filtering in generateUrls)', async () => {
-            const durationPolicy = new Duration(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DURATION, ['[720,720]']]]) // 2 years - allowed in shouldIndex, filtered in generateUrls
-            );
-            const result = await durationPolicy.shouldIndex();
-            expect(result).toBe(true); // Basic validation passes
-        });
-        it('AttendanceDegree allows blended in shouldIndex (filtering in generateUrls)', async () => {
-            searchDependenciesHelper.setPortalType(PortalType.MASTER);
-            const attendanceDegreePolicy = new AttendanceDegree(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.DELIVERY_METHOD, ['blended']], // Allowed in shouldIndex, filtered in generateUrls
-                [FilterKey.DEGREE_TYPE, ['mba']]
-            ]));
-            const result = await attendanceDegreePolicy.shouldIndex();
-            expect(result).toBe(true); // Basic validation passes
-        });
-        it('AttendanceDegree allows blended in shouldIndex (filtering in generateUrls)', async () => {
-            const continentSpecialProgrammesPolicy = new ContinentSpecialProgrammes(searchDependenciesHelper.dependencies);
-            searchDependenciesHelper.setFilterKeyValues(new Map([
-                [FilterKey.SPECIAL_PROGRAMMES, ['erasmus']], // Allowed in shouldIndex, filtered in generateUrls
-                [FilterKey.CONTINENT, ['1']]
-            ]));
-            const result = await continentSpecialProgrammesPolicy.shouldIndex();
-            expect(result).toBe(true); // Basic validation passes
-        });
-    });
-});

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

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