@studyportals/fawkes 8.7.0 → 8.7.1-0

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

@@ -0,0 +1,179 @@
+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

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

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

@@ -0,0 +1,117 @@
+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

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

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

@@ -0,0 +1,320 @@
+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

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