@studyportals/fawkes 8.7.0 → 8.7.1-0

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

@@ -0,0 +1,267 @@
+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 { TuitionFeeDiscipline } from '@/programmes/policies/TuitionFeeDiscipline';
+import { PortalType } from '@studyportals/domain-client';
+import { DisciplinePresenter } from '@/presenters/DisciplinePresenter';
+import { TuitionFeePresenter } from '@/presenters/TuitionFeePresenter';
+describe('Policy:TuitionFeeDiscipline', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let tuitionFeeDisciplinePolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            tuitionFeeDisciplinePolicy = new TuitionFeeDiscipline(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setResultsCount(7);
+            searchDependenciesHelper.setPageNumber(1);
+            searchDependenciesHelper.setPortalType(PortalType.BACHELOR);
+        });
+        it('Should return true when all conditions are met', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const tuitionFee = '[0,2500]'; // Affordable
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]]
+            ]));
+            const result = await tuitionFeeDisciplinePolicy.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
+            const tuitionFee = '[0,2500]'; // Affordable
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [firstDisciplineId, secondDisciplineId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]]
+            ]));
+            const result = await tuitionFeeDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when multiple tuition fee values are selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const firstTuitionFee = '[0,2500]'; // Affordable
+            const secondTuitionFee = '[0,3000]';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.TUITION_FEE, [firstTuitionFee, secondTuitionFee]]
+            ]));
+            const result = await tuitionFeeDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no disciplines are selected', async () => {
+            const tuitionFee = '[0,2500]'; // Affordable
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.TUITION_FEE, [tuitionFee]]]));
+            const result = await tuitionFeeDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when no tuition fee value is selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DISCIPLINES, [disciplineId]]]));
+            const result = await tuitionFeeDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when other filters are selected', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const tuitionFee = '[0,2500]'; // Affordable
+            const countryId = '30'; // UK
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]],
+                [FilterKey.COUNTRY, [countryId]]
+            ]));
+            const result = await tuitionFeeDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when tuition fee is not [0,2500] (affordable)', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const tuitionFee = '[0,3000]';
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]]
+            ]));
+            const result = await tuitionFeeDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when number of results is less than 7', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const tuitionFee = '[0,2500]'; // Affordable
+            searchDependenciesHelper.setResultsCount(5);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]]
+            ]));
+            const result = await tuitionFeeDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when page number is higher than 2', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const tuitionFee = '[0,2500]'; // Affordable
+            searchDependenciesHelper.setPageNumber(3);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]]
+            ]));
+            const result = await tuitionFeeDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when portal type is distance learning', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const tuitionFee = '[0,2500]'; // Affordable
+            searchDependenciesHelper.setPortalType(PortalType.DISTANCE_LEARNING);
+            searchDependenciesHelper.setFilterKeyValues(new Map([
+                [FilterKey.DISCIPLINES, [disciplineId]],
+                [FilterKey.TUITION_FEE, [tuitionFee]]
+            ]));
+            const result = await tuitionFeeDisciplinePolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateUrls', () => {
+        let sitemapDependenciesHelper;
+        let tuitionFeeDisciplinePolicy;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setProgrammeCount(10); // More than 7 programs
+            tuitionFeeDisciplinePolicy = new TuitionFeeDiscipline(sitemapDependenciesHelper.dependencies);
+            DisciplinePresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: '54', path: 'agriculture-forestry' },
+                    { id: '12', path: 'applied-sciences' },
+                    { id: '356', path: 'computer-science' }
+                ])
+            });
+            TuitionFeePresenter.getInstance = vi.fn().mockReturnValue({
+                getFragments: vi.fn().mockReturnValue([
+                    { id: '[0,2500]', path: 'affordable' },
+                    { id: '[2501,5000]', path: 'moderate' },
+                    { id: '[5001,10000]', path: 'expensive' }
+                ])
+            });
+        });
+        afterEach(() => {
+            sitemapDependenciesHelper.resetMocks();
+        });
+        it('Should generate URLs for valid discipline-tuition fee combinations with affordable tuition fees', async () => {
+            // Mock the checkRulesForSitemap to only allow affordable tuition fee options
+            // due to AffordableTuitionFeeRule
+            const resultMap = new Map();
+            // Set up all possible combinations but only allow affordable ones
+            for (const discipline of ['54', '12', '356']) {
+                for (const tuitionFee of ['[0,2500]', '[2501,5000]', '[5001,10000]']) {
+                    const key = `${FilterKey.TUITION_FEE}:${tuitionFee}|${FilterKey.DISCIPLINES}:${discipline}`;
+                    // Only affordable tuition fee should pass
+                    resultMap.set(key, tuitionFee === '[0,2500]');
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            // Call the method via reflection since it's protected
+            const urls = await tuitionFeeDisciplinePolicy.generateUrls();
+            // Calculate expected URLs: 3 disciplines * 1 tuition fee option (affordable) * 2 pages = 6 URLs
+            expect(urls).toHaveLength(3);
+            // Verify affordable tuition fee combinations
+            expect(urls).toContain('affordable/agriculture-forestry');
+            expect(urls).toContain('affordable/applied-sciences');
+            expect(urls).toContain('affordable/computer-science');
+            // Verify expensive tuition fees are excluded
+            expect(urls).not.toContain('moderate/agriculture-forestry');
+            expect(urls).not.toContain('expensive/agriculture-forestry');
+        });
+        it('Should exclude specific discipline-tuition fee combinations based on rules', async () => {
+            // Create a map that returns false for specific combinations
+            const resultMap = new Map();
+            // Only allow affordable tuition fee, but exclude computer science
+            for (const discipline of ['54', '12', '356']) {
+                for (const tuitionFee of ['[0,2500]', '[2501,5000]', '[5001,10000]']) {
+                    const key = `${FilterKey.TUITION_FEE}:${tuitionFee}|${FilterKey.DISCIPLINES}:${discipline}`;
+                    // Only affordable tuition fee should pass and exclude computer science
+                    resultMap.set(key, tuitionFee === '[0,2500]' && discipline !== '356');
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await tuitionFeeDisciplinePolicy.generateUrls();
+            // Calculate expected URLs: 2 disciplines (excluding computer science) * 1 tuition fee option (affordable) * 2 pages = 4 URLs
+            expect(urls).toHaveLength(2);
+            // Verify excluded combinations
+            expect(urls).not.toContain('affordable/computer-science');
+            expect(urls).not.toContain('moderate/computer-science');
+            expect(urls).not.toContain('expensive/computer-science');
+            // Verify included combinations
+            expect(urls).toContain('affordable/agriculture-forestry');
+            expect(urls).toContain('affordable/applied-sciences');
+        });
+        it('Should exclude all URLs when all rule checks fail', async () => {
+            // Create a map that returns false for all combinations
+            const resultMap = new Map();
+            for (const discipline of ['54', '12', '356']) {
+                for (const tuitionFee of ['[0,2500]', '[2501,5000]', '[5001,10000]']) {
+                    const key = `${FilterKey.TUITION_FEE}:${tuitionFee}|${FilterKey.DISCIPLINES}:${discipline}`;
+                    resultMap.set(key, false);
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await tuitionFeeDisciplinePolicy.generateUrls();
+            // Should include no URLs
+            expect(urls).toHaveLength(0);
+        });
+        it('Should handle empty discipline fragments', async () => {
+            // Mock the DisciplinePresenter to return empty fragments
+            DisciplinePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue([])
+            });
+            sitemapDependenciesHelper.mockCheckRulesForSitemap();
+            const urls = await tuitionFeeDisciplinePolicy.generateUrls();
+            // Should return empty array
+            expect(urls).toHaveLength(0);
+        });
+        it('Should handle empty tuition fee fragments', async () => {
+            // Mock the TuitionFeePresenter to return empty fragments
+            TuitionFeePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue([])
+            });
+            sitemapDependenciesHelper.mockCheckRulesForSitemap();
+            const urls = await tuitionFeeDisciplinePolicy.generateUrls();
+            // Should return empty array
+            expect(urls).toHaveLength(0);
+        });
+        it('Should handle performance with large number of combinations', async () => {
+            // Generate larger datasets for testing
+            const largeDisciplineSet = Array.from({ length: 30 }, (_, index) => ({
+                id: `discipline-${index}`,
+                path: `discipline-path-${index}`
+            }));
+            const largeTuitionFeeSet = Array.from({ length: 5 }, (_, index) => ({
+                id: `tuition-${index}`,
+                path: `tuition-path-${index}`
+            }));
+            // Override mocks with large datasets
+            DisciplinePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeDisciplineSet)
+            });
+            TuitionFeePresenter.getInstance.mockReturnValueOnce({
+                getFragments: vi.fn().mockReturnValue(largeTuitionFeeSet)
+            });
+            // Mock to only allow combinations where discipline index is even and tuition fee index is 0
+            // This simulates the AffordableTuitionFeeRule that only allows affordable (lowest) tuition fees
+            const resultMap = new Map();
+            for (let d = 0; d < largeDisciplineSet.length; d++) {
+                for (let t = 0; t < largeTuitionFeeSet.length; t++) {
+                    const disciplineId = largeDisciplineSet[d].id;
+                    const tuitionFeeId = largeTuitionFeeSet[t].id;
+                    const key = `${FilterKey.TUITION_FEE}:${tuitionFeeId}|${FilterKey.DISCIPLINES}:${disciplineId}`;
+                    resultMap.set(key, d % 2 === 0 && t === 0); // Only even disciplines and affordable (index 0) tuition
+                }
+            }
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(resultMap);
+            const urls = await tuitionFeeDisciplinePolicy.generateUrls();
+            // Calculate expected count: 15 disciplines (even indices) * 1 tuition fee (index 0) * 2 pages
+            // = 15 * 1 * 2 = 30 URLs
+            expect(urls).toHaveLength(15);
+            // Test specific items
+            expect(urls).toContain('tuition-path-0/discipline-path-0'); // Even discipline, affordable tuition
+            expect(urls).toContain('tuition-path-0/discipline-path-2'); // Even discipline, affordable tuition
+            expect(urls).not.toContain('tuition-path-0/discipline-path-1'); // Odd discipline
+            expect(urls).not.toContain('tuition-path-1/discipline-path-0'); // Non-affordable tuition
+        });
+    });
+});

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

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

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

@@ -0,0 +1,90 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { FilterKey } 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 { Unfiltered } from '@/programmes/policies/Unfiltered';
+describe('Policy:Unfiltered', () => {
+    describe('shouldIndex', () => {
+        let searchDependenciesHelper;
+        let unfilteredPolicy;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            unfilteredPolicy = new Unfiltered(searchDependenciesHelper.dependencies);
+            searchDependenciesHelper.setPageNumber(1);
+            searchDependenciesHelper.setPortalType(PortalType.MASTER);
+            searchDependenciesHelper.setResultsCount(20);
+        });
+        it.each([PortalType.MASTER, PortalType.BACHELOR, PortalType.PHD, PortalType.SHORT])('Should return true when no filters are selected', async (portalType) => {
+            searchDependenciesHelper.setPortalType(portalType);
+            searchDependenciesHelper.setFilterKeyValues(new Map([]));
+            const result = await unfilteredPolicy.shouldIndex();
+            expect(result).toBe(true);
+        });
+        it.each([
+            [FilterKey.CONTINENT, '1'], // Europe
+            [FilterKey.COUNTRY, '30'], // UK
+            [FilterKey.AREA, '137'], // Western Australia
+            [FilterKey.DISCIPLINES, '54'], // Agriculture & Forestry
+            [FilterKey.DURATION, '[360,360]'], // 1 year
+            [FilterKey.ATTENDANCE, 'fulltime'],
+            [FilterKey.DELIVERY_METHOD, 'online'],
+            [FilterKey.DEGREE_TYPE, 'mba'],
+            [FilterKey.EDUCATIONAL_FORM, 'academic'],
+            [FilterKey.SPECIAL_PROGRAMMES, 'erasmus'],
+            [FilterKey.TUITION_FEE, '[0,2500]'] // Affordable
+        ])('Should return false any filter value is selected', async (key, value) => {
+            searchDependenciesHelper.setFilterKeyValues(new Map([[key, [value]]]));
+            const result = await unfilteredPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when page number is higher than 2', async () => {
+            searchDependenciesHelper.setPageNumber(15);
+            searchDependenciesHelper.setFilterKeyValues(new Map([]));
+            const result = await unfilteredPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when portal type is distance learning', async () => {
+            searchDependenciesHelper.setPortalType(PortalType.DISTANCE_LEARNING);
+            searchDependenciesHelper.setFilterKeyValues(new Map([]));
+            const result = await unfilteredPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+        it('Should return false when result count is less than 7', async () => {
+            searchDependenciesHelper.setResultsCount(4);
+            searchDependenciesHelper.setFilterKeyValues(new Map([]));
+            const result = await unfilteredPolicy.shouldIndex();
+            expect(result).toBe(false);
+        });
+    });
+    describe('generateUrls', () => {
+        let sitemapDependenciesHelper;
+        let unfilteredPolicy;
+        beforeEach(() => {
+            sitemapDependenciesHelper = new SitemapDependencies();
+            sitemapDependenciesHelper.setProgrammeCount(10); // More than 7 programs
+            unfilteredPolicy = new Unfiltered(sitemapDependenciesHelper.dependencies);
+        });
+        afterEach(() => {
+            sitemapDependenciesHelper.resetMocks();
+        });
+        it('Should generate a single empty string URL for the unfiltered page', async () => {
+            // This policy is unique because it always returns a single empty string
+            // representing the base/unfiltered URL of the site
+            const urls = await unfilteredPolicy.generateUrls(); // Note: This method is public in Unfiltered
+            // Verify the result
+            expect(urls).toHaveLength(1);
+            expect(urls[0]).toBe('');
+        });
+        it('Should always return the same result regardless of checkRulesForSitemap', async () => {
+            // Mock to make checkRulesForSitemap return false
+            sitemapDependenciesHelper.mockCheckRulesForSitemap(new Map([['', false]]));
+            // The result should still be the same since this policy doesn't actually use
+            // checkRulesForSitemap in its generateUrls implementation
+            const urls = await unfilteredPolicy.generateUrls();
+            // Verify the result
+            expect(urls).toHaveLength(1);
+            expect(urls[0]).toBe('');
+        });
+    });
+});

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

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

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

@@ -0,0 +1,27 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { AffordableTuitionFeeRule } from '@/programmes/rules/AffordableTuitionFeeRule';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+describe('Rule:AffordableTuitionFeeRule', () => {
+    describe('forSearch', () => {
+        let searchDependenciesHelper;
+        let rule;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            rule = new AffordableTuitionFeeRule();
+            searchDependenciesHelper.setFilterKeyValues(new Map([]));
+        });
+        it('Returns true if affordable tuition fee is affordable', async () => {
+            const tuitionFee = '[0,2500]'; // Affordable
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.TUITION_FEE, [tuitionFee]]]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(true);
+        });
+        it('Returns false if tuition fee is not affordable', async () => {
+            const tuitionFee = '[0,3000]';
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.TUITION_FEE, [tuitionFee]]]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(false);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,121 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { DegreeCountryDisciplineSpecificRule } from '@/programmes/rules/DegreeCountryDisciplineSpecificRule';
+describe('Rule:DegreeCountryDisciplineSpecificRule', () => {
+    describe('forSearch', () => {
+        let searchDependenciesHelper;
+        let rule;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            rule = new DegreeCountryDisciplineSpecificRule();
+            searchDependenciesHelper.setFilterKeyValues(new Map([]));
+        });
+        describe('msc valid countries', () => {
+            it.each([
+                '82', // USA
+                '56', // Canada
+                '11', // Germany
+                '30' // UK
+            ])('Should return true for msc with country %s', async (countryId) => {
+                searchDependenciesHelper.setFilterKeyValues(new Map([
+                    [FilterKey.DEGREE_TYPE, ['msc']],
+                    [FilterKey.COUNTRY, [countryId]],
+                    [FilterKey.DISCIPLINES, ['289']] // Valid discipline for testing
+                ]));
+                const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+                expect(result).toBe(true);
+            });
+            it('Should return false for msc with invalid country', async () => {
+                searchDependenciesHelper.setFilterKeyValues(new Map([
+                    [FilterKey.DEGREE_TYPE, ['msc']],
+                    [FilterKey.COUNTRY, ['999']],
+                    [FilterKey.DISCIPLINES, ['289']] // Valid discipline for testing
+                ]));
+                const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+                expect(result).toBe(false);
+            });
+        });
+        describe('mba valid countries', () => {
+            it.each([
+                '82', // USA
+                '30' // UK
+            ])('Should return true for mba with country %s', async (countryId) => {
+                searchDependenciesHelper.setFilterKeyValues(new Map([
+                    [FilterKey.DEGREE_TYPE, ['mba']],
+                    [FilterKey.COUNTRY, [countryId]],
+                    [FilterKey.DISCIPLINES, ['289']] // Valid discipline for testing
+                ]));
+                const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+                expect(result).toBe(true);
+            });
+            it.each([
+                '56', // Canada (not allowed for MBA)
+                '11', // Germany (not allowed for MBA)
+                '202' // Australia (not allowed for MBA)
+            ])('Should return false for mba with country %s', async (countryId) => {
+                searchDependenciesHelper.setFilterKeyValues(new Map([
+                    [FilterKey.DEGREE_TYPE, ['mba']],
+                    [FilterKey.COUNTRY, [countryId]],
+                    [FilterKey.DISCIPLINES, ['289']] // Valid discipline for testing
+                ]));
+                const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+                expect(result).toBe(false);
+            });
+        });
+        describe('med valid countries', () => {
+            it.each([
+                '202', // Australia
+                '56' // Canada
+            ])('Should return true for med with country %s', async (countryId) => {
+                searchDependenciesHelper.setFilterKeyValues(new Map([
+                    [FilterKey.DEGREE_TYPE, ['med']],
+                    [FilterKey.COUNTRY, [countryId]],
+                    [FilterKey.DISCIPLINES, ['289']] // Valid discipline for testing
+                ]));
+                const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+                expect(result).toBe(true);
+            });
+            it.each([
+                '82', // USA (not allowed for MEd)
+                '30', // UK (not allowed for MEd)
+                '11' // Germany (not allowed for MEd)
+            ])('Should return false for med with country %s', async (countryId) => {
+                searchDependenciesHelper.setFilterKeyValues(new Map([
+                    [FilterKey.DEGREE_TYPE, ['med']],
+                    [FilterKey.COUNTRY, [countryId]],
+                    [FilterKey.DISCIPLINES, ['289']] // Valid discipline for testing
+                ]));
+                const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+                expect(result).toBe(false);
+            });
+        });
+        describe('edge cases', () => {
+            it('Should return false when degree type is missing', async () => {
+                searchDependenciesHelper.setFilterKeyValues(new Map([
+                    [FilterKey.COUNTRY, ['82']],
+                    [FilterKey.DISCIPLINES, ['289']] // Valid discipline for testing
+                ]));
+                const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+                expect(result).toBe(false);
+            });
+            it('Should return false when country is missing', async () => {
+                searchDependenciesHelper.setFilterKeyValues(new Map([
+                    [FilterKey.DEGREE_TYPE, ['msc']],
+                    [FilterKey.DISCIPLINES, ['289']] // Valid discipline for testing
+                ]));
+                const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+                expect(result).toBe(false);
+            });
+            it('Should return false for unknown degree types', async () => {
+                searchDependenciesHelper.setFilterKeyValues(new Map([
+                    [FilterKey.DEGREE_TYPE, ['unknown-degree']],
+                    [FilterKey.COUNTRY, ['82']],
+                    [FilterKey.DISCIPLINES, ['289']] // Valid discipline for testing
+                ]));
+                const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+                expect(result).toBe(false);
+            });
+        });
+    });
+});

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

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