@studyportals/fawkes 8.7.0 → 8.7.1-0

package/dist/tests/scholarships/rules/SearchVolumeDisciplinesRule.test.mjs

@@ -0,0 +1,62 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { SearchVolumeDisciplinesRule } from '@/scholarships/rules/SearchVolumeDisciplinesRule';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+describe('Rule:SearchVolumeAreas', () => {
+    describe('forSearch', () => {
+        let searchDependenciesHelper;
+        let rule;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            rule = new SearchVolumeDisciplinesRule();
+        });
+        it('Returns true if discipline has search volume', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DISCIPLINES, [disciplineId]]]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(true);
+        });
+        it('Returns false if discipline does not have search volume', async () => {
+            const disciplineId = '243'; // Master in Management
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DISCIPLINES, [disciplineId]]]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(false);
+        });
+    });
+    describe('forSitemapGenerator', () => {
+        let rule;
+        beforeEach(() => {
+            rule = new SearchVolumeDisciplinesRule();
+        });
+        it('Returns true if discipline has search volume', async () => {
+            const disciplineId = '54'; // Agriculture & Forestry
+            const result = await rule.forSitemapGenerator(new Map([[FilterKey.DISCIPLINES, [disciplineId]]]));
+            expect(result).toBe(true);
+        });
+        it('Returns false if discipline does not have search volume', async () => {
+            const disciplineId = '243'; // Master in Management
+            const result = await rule.forSitemapGenerator(new Map([[FilterKey.DISCIPLINES, [disciplineId]]]));
+            expect(result).toBe(false);
+        });
+        it('Returns false if multiple disciplines are selected', async () => {
+            const firstCountryId = '30'; // UK
+            const secondCountryId = '82'; // USA
+            const result = await rule.forSitemapGenerator(new Map([[FilterKey.DISCIPLINES, [firstCountryId, secondCountryId]]]));
+            expect(result).toBe(false);
+        });
+    });
+    describe('forDocumentation', () => {
+        let rule;
+        beforeEach(() => {
+            rule = new SearchVolumeDisciplinesRule();
+        });
+        it('Returns description', () => {
+            const result = rule.getName();
+            expect(typeof result).toBe('string');
+        });
+        it('Returns name', () => {
+            const result = rule.getDescription();
+            expect(typeof result).toBe('string');
+        });
+    });
+});

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

@@ -0,0 +1,16 @@
+import { FilterKeyValuesMap } from '@/common/FilterKeyValuesMap';
+import { ISearchApplicationState } from '@/common/ISearchApplicationState';
+import { ISearchDependencies } from '@/common/ISearchDependencies';
+import { DependencyTypes } from '@/enums/DependencyTypes';
+import { ISeoFilterState, ISeoInfoBase } from 'scholarships-seo';
+export declare class SearchDependencies {
+    dependencies: ISearchDependencies;
+    constructor();
+    get seoInfoBase(): ISeoInfoBase;
+    get filterState(): ISeoFilterState;
+    get applicationState(): ISearchApplicationState;
+    get dependencyType(): DependencyTypes;
+    setPageNumber(pageNumber: number): void;
+    setNumberOfResults(count: number): void;
+    setFilterKeyValues(filterKeyValues: FilterKeyValuesMap): void;
+}

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

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

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

@@ -0,0 +1,11 @@
+import { IScholarshipSitemapDependencies } from '@/scholarships/types/IScholarshipSitemapDependencies';
+import { DependencyTypes } from '@/enums/DependencyTypes';
+import { IOrganisation, IOrganisationsClient, ISearchApiClient } from 'sitemap-generator-seo';
+export declare class SitemapDependencies {
+    readonly dependencies: IScholarshipSitemapDependencies;
+    constructor();
+    get searchApiClient(): ISearchApiClient;
+    get organisationsClient(): IOrganisationsClient;
+    get dependencyType(): DependencyTypes;
+    setOrganisations(organisations: IOrganisation[]): void;
+}

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

@@ -0,0 +1,33 @@
+import { DependencyTypes } from '@/enums/DependencyTypes';
+import { vi } from 'vitest';
+export class SitemapDependencies {
+    dependencies;
+    constructor() {
+        const searchApiClient = {
+            getOrganisationIds: vi.fn(),
+            getCount: vi.fn()
+        };
+        const organisationsClient = {
+            getOrganisations: vi.fn()
+        };
+        const dependencyType = DependencyTypes.SITEMAP_GENERATOR;
+        this.dependencies = {
+            searchApiClient,
+            organisationsClient,
+            dependencyType
+        };
+    }
+    get searchApiClient() {
+        return this.dependencies.searchApiClient;
+    }
+    get organisationsClient() {
+        return this.dependencies.organisationsClient;
+    }
+    get dependencyType() {
+        return this.dependencies.dependencyType;
+    }
+    setOrganisations(organisations) {
+        this.dependencies.searchApiClient.getOrganisationIds.mockResolvedValue(organisations.map((org) => org.id));
+        this.dependencies.organisationsClient.getOrganisations.mockResolvedValue(organisations);
+    }
+}

package/dist/tests/sitemap-generator/BaseSitemapUrlGeneratorManager.test.d.mts

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

package/dist/tests/sitemap-generator/BaseSitemapUrlGeneratorManager.test.mjs

@@ -0,0 +1,82 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { BaseSitemapUrlGeneratorManager } from '@/sitemap-generator/BaseSitemapUrlGeneratorManager';
+import { FilterCombinations } from '@/enums/FilterCombinations';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+// Create a concrete implementation of the abstract class for testing
+class TestSitemapUrlGeneratorManager extends BaseSitemapUrlGeneratorManager {
+    policies;
+    presenters = new Map();
+    constructor(policies = []) {
+        super();
+        this.policies = policies;
+    }
+}
+describe('BaseSitemapUrlGeneratorManager', () => {
+    let mockPolicy1;
+    let mockPolicy2;
+    let manager;
+    beforeEach(() => {
+        // Create mock policies
+        mockPolicy1 = {
+            filterCombination: FilterCombinations.UNFILTERED,
+            generateSitemapUrls: vi.fn().mockResolvedValue(['url1', 'url2']),
+            getAllRules: vi.fn().mockReturnValue([])
+        };
+        mockPolicy2 = {
+            filterCombination: FilterCombinations.COUNTRY,
+            generateSitemapUrls: vi.fn().mockResolvedValue(['url3', 'url4', 'url5']),
+            getAllRules: vi.fn().mockReturnValue([])
+        };
+        // Create manager with mock policies
+        manager = new TestSitemapUrlGeneratorManager([mockPolicy1, mockPolicy2]);
+    });
+    it('Should generate URLs for all policies', async () => {
+        const urlMap = await manager.generateUrls();
+        // Should call generateSitemapUrls on each policy
+        expect(mockPolicy1.generateSitemapUrls).toHaveBeenCalledTimes(1);
+        expect(mockPolicy2.generateSitemapUrls).toHaveBeenCalledTimes(1);
+        // Should return a map with the correct URLs for each policy
+        expect(urlMap.size).toBe(2);
+        expect(urlMap.get(FilterCombinations.UNFILTERED)).toEqual(['url1', 'url2']);
+        expect(urlMap.get(FilterCombinations.COUNTRY)).toEqual(['url3', 'url4', 'url5']);
+    });
+    it('Should return empty results if no policies are defined', async () => {
+        const emptyManager = new TestSitemapUrlGeneratorManager([]);
+        const urlMap = await emptyManager.generateUrls();
+        expect(urlMap.size).toBe(0);
+    });
+    it('Should get filter key value counts', () => {
+        const counts = manager.getFilterKeyValueCounts();
+        // Initially should be empty as setFilterKeyValueCounts hasn't been called
+        expect(counts.size).toBe(0);
+    });
+    it('Should set filter key value counts from presenters', () => {
+        // Create mock presenters
+        const mockPresenter1 = {
+            filterKey: FilterKey.COUNTRY,
+            getFragments: vi.fn().mockReturnValue([
+                { id: '1', path: 'path1' },
+                { id: '2', path: 'path2' }
+            ])
+        };
+        const mockPresenter2 = {
+            filterKey: FilterKey.DISCIPLINES,
+            getFragments: vi.fn().mockReturnValue([{ id: '3', path: 'path3' }])
+        };
+        // Add presenters to the manager
+        manager.presenters.set(FilterKey.COUNTRY, mockPresenter1);
+        manager.presenters.set(FilterKey.DISCIPLINES, mockPresenter2);
+        // Call the protected method via casting
+        manager.setFilterKeyValueCounts();
+        // Check that counts were set correctly
+        const counts = manager.getFilterKeyValueCounts();
+        expect(counts.size).toBe(2);
+        expect(counts.get(FilterKey.COUNTRY)).toBe(2);
+        expect(counts.get(FilterKey.DISCIPLINES)).toBe(1);
+    });
+    it('Should return the policies', () => {
+        const policies = manager.getPolicies();
+        expect(policies).toBe(manager.policies);
+        expect(policies).toEqual([mockPolicy1, mockPolicy2]);
+    });
+});

package/dist/tests/sitemap-generator/OrganisationsSitemapUrlGeneratorManager.test.d.mts

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

package/dist/tests/sitemap-generator/OrganisationsSitemapUrlGeneratorManager.test.mjs

@@ -0,0 +1,85 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { OrganisationsSitemapUrlGeneratorManager } from '@/sitemap-generator/OrganisationsSitemapUrlGeneratorManager';
+import { PortalType } from '@studyportals/domain-client';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+describe('OrganisationsSitemapUrlGeneratorManager', () => {
+    let searchApiClient;
+    let organisationsClient;
+    let rankingApiClient;
+    let manager;
+    beforeEach(() => {
+        // Create mock dependencies
+        searchApiClient = {
+            getOrganisationIds: vi.fn(),
+            getCount: vi.fn()
+        };
+        organisationsClient = {
+            getOrganisations: vi.fn()
+        };
+        rankingApiClient = {
+            getRankedOrganisationCount: vi.fn()
+        };
+        // Create the manager
+        manager = new OrganisationsSitemapUrlGeneratorManager(PortalType.MASTER, searchApiClient, organisationsClient, rankingApiClient);
+    });
+    it('Should initialize with all policies', () => {
+        // The manager should have initialized with all the policy classes
+        expect(manager.policies.length).toBeGreaterThan(0);
+        // Check a few specific policy types to ensure they're included
+        const policyClassNames = manager.policies.map((p) => p.constructor.name);
+        // Core policies that should be included
+        expect(policyClassNames).toContain('Area');
+        expect(policyClassNames).toContain('Attendance');
+        expect(policyClassNames).toContain('Country');
+        expect(policyClassNames).toContain('Unfiltered');
+        // Some ranked policies
+        expect(policyClassNames).toContain('RankedCountry');
+        expect(policyClassNames).toContain('RankedDiscipline');
+        expect(policyClassNames).toContain('RankedUnfiltered');
+    });
+    it('Should initialize with all presenters', () => {
+        // The manager should have all required presenters
+        expect(manager.presenters.size).toBeGreaterThan(0);
+        // Check that all expected filter keys have presenters
+        const expectedFilterKeys = [FilterKey.AREA, FilterKey.DELIVERY_METHOD, FilterKey.CONTINENT, FilterKey.COUNTRY, FilterKey.DISCIPLINES];
+        expectedFilterKeys.forEach((filterKey) => {
+            expect(manager.presenters.has(filterKey)).toBe(true);
+            expect(manager.presenters.get(filterKey)).toBeDefined();
+        });
+    });
+    it('Should use singleton presenters', () => {
+        // Get some presenters from the manager
+        const areaPresenter = manager.presenters.get(FilterKey.AREA);
+        const countryPresenter = manager.presenters.get(FilterKey.COUNTRY);
+        // Create a new manager
+        const newManager = new OrganisationsSitemapUrlGeneratorManager(PortalType.PHD, searchApiClient, organisationsClient, rankingApiClient);
+        // The presenters should be the same instances (singletons)
+        expect(newManager.presenters.get(FilterKey.AREA)).toBe(areaPresenter);
+        expect(newManager.presenters.get(FilterKey.COUNTRY)).toBe(countryPresenter);
+    });
+    it('Should set filter key value counts during initialization', () => {
+        // The manager should have filter key value counts set
+        const counts = manager.getFilterKeyValueCounts();
+        // There should be counts for all presenter filter keys
+        expect(counts.size).toBeGreaterThan(0);
+        expect(counts.size).toBe(manager.presenters.size);
+        // All counts should be numbers greater than or equal to 0
+        Array.from(counts.values()).forEach((count) => {
+            expect(typeof count).toBe('number');
+            expect(count).toBeGreaterThanOrEqual(0);
+        });
+    });
+    it('Should pass the correct portal type to policies', () => {
+        // The portal type should be passed to all policies
+        expect(manager.portalType).toBe(PortalType.MASTER);
+        // Change portal type and check that it's reflected
+        const phdManager = new OrganisationsSitemapUrlGeneratorManager(PortalType.PHD, searchApiClient, organisationsClient, rankingApiClient);
+        expect(phdManager.portalType).toBe(PortalType.PHD);
+    });
+    it('Should inherit from BaseSitemapUrlGeneratorManager', () => {
+        // Verify it extends the base class by checking for inherited methods
+        expect(manager.generateUrls).toBeDefined();
+        expect(manager.getFilterKeyValueCounts).toBeDefined();
+        expect(manager.getPolicies).toBeDefined();
+    });
+});

package/dist/tests/sitemap-generator/ProgrammesSitemapUrlGeneratorManager.test.d.mts

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

package/dist/tests/sitemap-generator/ProgrammesSitemapUrlGeneratorManager.test.mjs

@@ -0,0 +1,77 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ProgrammesSitemapUrlGeneratorManager } from '@/sitemap-generator/ProgrammesSitemapUrlGeneratorManager';
+import { PortalType } from '@studyportals/domain-client';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+describe('ProgrammesSitemapUrlGeneratorManager', () => {
+    let searchApiClient;
+    let manager;
+    beforeEach(() => {
+        // Create mock dependencies
+        searchApiClient = {
+            getOrganisationIds: vi.fn(),
+            getCount: vi.fn()
+        };
+        // Create the manager
+        manager = new ProgrammesSitemapUrlGeneratorManager(PortalType.MASTER, searchApiClient);
+    });
+    // it('Should initialize with all policies', () => {
+    // 	// The manager should have initialized with all the policy classes
+    // 	expect(manager.policies.length).toBeGreaterThan(0);
+    // 	// Check a few specific policy types to ensure they're included
+    // 	const policyClassNames = manager.policies.map((p) => p.constructor.name);
+    // 	// Core policies that should be included
+    // 	expect(policyClassNames).toContain('Area');
+    // 	expect(policyClassNames).toContain('Attendance');
+    // 	expect(policyClassNames).toContain('Country');
+    // 	expect(policyClassNames).toContain('Discipline');
+    // 	expect(policyClassNames).toContain('Unfiltered');
+    // 	// Some combined policies
+    // 	expect(policyClassNames).toContain('CountryAttendance');
+    // 	expect(policyClassNames).toContain('DisciplineCountry');
+    // });
+    it('Should initialize with all presenters', () => {
+        // The manager should have all required presenters
+        expect(manager.presenters.size).toBeGreaterThan(0);
+        // Check that all expected filter keys have presenters
+        const expectedFilterKeys = [
+            FilterKey.AREA,
+            FilterKey.DELIVERY_METHOD,
+            FilterKey.DEGREE_TYPE,
+            FilterKey.CONTINENT,
+            FilterKey.TUITION_FEE,
+            FilterKey.COUNTRY,
+            FilterKey.DISCIPLINES,
+            FilterKey.SPECIAL_PROGRAMMES,
+            FilterKey.DURATION,
+            FilterKey.EDUCATIONAL_FORM,
+            FilterKey.ATTENDANCE
+        ];
+        expectedFilterKeys.forEach((filterKey) => {
+            expect(manager.presenters.has(filterKey)).toBe(true);
+            expect(manager.presenters.get(filterKey)).toBeDefined();
+        });
+    });
+    it('Should use singleton presenters', () => {
+        // Get some presenters from the manager
+        const areaPresenter = manager.presenters.get(FilterKey.AREA);
+        const countryPresenter = manager.presenters.get(FilterKey.COUNTRY);
+        // Create a new manager
+        const newManager = new ProgrammesSitemapUrlGeneratorManager(PortalType.PHD, searchApiClient);
+        // The presenters should be the same instances (singletons)
+        expect(newManager.presenters.get(FilterKey.AREA)).toBe(areaPresenter);
+        expect(newManager.presenters.get(FilterKey.COUNTRY)).toBe(countryPresenter);
+    });
+    it('Should pass the correct portal type to policies', () => {
+        // The portal type should be passed to all policies
+        expect(manager.portalType).toBe(PortalType.MASTER);
+        // Change portal type and check that it's reflected
+        const phdManager = new ProgrammesSitemapUrlGeneratorManager(PortalType.PHD, searchApiClient);
+        expect(phdManager.portalType).toBe(PortalType.PHD);
+    });
+    it('Should inherit from BaseSitemapUrlGeneratorManager', () => {
+        // Verify it extends the base class by checking for inherited methods
+        expect(manager.generateUrls).toBeDefined();
+        expect(manager.getFilterKeyValueCounts).toBeDefined();
+        expect(manager.getPolicies).toBeDefined();
+    });
+});

package/dist/tests/sitemap-generator/ScholarshipsSitemapUrlGeneratorManager.test.d.mts

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

package/dist/tests/sitemap-generator/ScholarshipsSitemapUrlGeneratorManager.test.mjs

@@ -0,0 +1,60 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ScholarshipsSitemapUrlGeneratorManager } from '@/sitemap-generator/ScholarshipsSitemapUrlGeneratorManager';
+describe('ScholarshipsSitemapUrlGeneratorManager', () => {
+    let searchApiClient;
+    let organisationsClient;
+    let manager;
+    beforeEach(() => {
+        // Create mock dependencies
+        searchApiClient = {
+            getOrganisationIds: vi.fn(),
+            getCount: vi.fn()
+        };
+        organisationsClient = {
+            getOrganisations: vi.fn()
+        };
+        // Create the manager
+        manager = new ScholarshipsSitemapUrlGeneratorManager(searchApiClient, organisationsClient);
+    });
+    it('Should initialize with all policies', () => {
+        // The manager should have initialized with all the policy classes
+        expect(manager.policies.length).toBeGreaterThan(0);
+        // Check a few specific policy types to ensure they're included
+        const policyClassNames = manager.policies.map((p) => p.constructor.name);
+        // Core policies that should be included
+        expect(policyClassNames).toContain('Area');
+        expect(policyClassNames).toContain('Country');
+        expect(policyClassNames).toContain('Discipline');
+        expect(policyClassNames).toContain('Unfiltered');
+        // Some combined policies
+        expect(policyClassNames).toContain('DisciplineCountry');
+        expect(policyClassNames).toContain('UniversityCountry');
+    });
+    it('Should have empty presenters map', () => {
+        // The ScholarshipsSitemapUrlGeneratorManager doesn't initialize any presenters
+        expect(manager.presenters.size).toBe(0);
+    });
+    it('Should inherit from BaseSitemapUrlGeneratorManager', () => {
+        // Verify it extends the base class by checking for inherited methods
+        expect(manager.generateUrls).toBeDefined();
+        expect(manager.getFilterKeyValueCounts).toBeDefined();
+        expect(manager.getPolicies).toBeDefined();
+    });
+    it('Should pass dependencies to policies', async () => {
+        // Mock the generateSitemapUrls method of the first policy
+        const firstPolicy = manager.policies[0];
+        const originalGenerateSitemapUrls = firstPolicy.generateSitemapUrls;
+        firstPolicy.generateSitemapUrls = vi.fn().mockResolvedValue(['test-url']);
+        // Generate URLs
+        const urlMap = await manager.generateUrls();
+        // The policy's generateSitemapUrls should be called
+        expect(firstPolicy.generateSitemapUrls).toHaveBeenCalledTimes(1);
+        // Restore the original method
+        firstPolicy.generateSitemapUrls = originalGenerateSitemapUrls;
+    });
+    it('Should not call setFilterKeyValueCounts since presenters are empty', () => {
+        // The filter key value counts should be empty
+        const counts = manager.getFilterKeyValueCounts();
+        expect(counts.size).toBe(0);
+    });
+});

package/dist/tests/structured-data/OrganisationStructuredDataFactory.test.d.mts

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