@studyportals/fawkes 8.7.0 → 8.7.1-0

package/dist/tests/organisations/rules/OnlineAttendanceRule.test.mjs

@@ -0,0 +1,59 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { OnlineAttendanceRule } from '@/common/rules/OnlineAttendanceRule';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+describe('Rule:OnlineAttendance', () => {
+    describe('forSearch', () => {
+        let searchDependenciesHelper;
+        let rule;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            rule = new OnlineAttendanceRule();
+            searchDependenciesHelper.setFilterKeyValues(new Map([]));
+        });
+        it('Returns true if selected attendance is online', async () => {
+            const attendanceId = 'online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DELIVERY_METHOD, [attendanceId]]]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(true);
+        });
+        it('Returns false if selected attendance is not online', async () => {
+            const attendanceId = 'not-online';
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.DELIVERY_METHOD, [attendanceId]]]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(false);
+        });
+    });
+    describe('forSitemapGenerator', () => {
+        let rule;
+        beforeEach(() => {
+            rule = new OnlineAttendanceRule();
+        });
+        it('Returns true if selected attendance is online', async () => {
+            const attendanceId = 'online';
+            const filterKeyValues = new Map([[FilterKey.DELIVERY_METHOD, [attendanceId]]]);
+            const result = await rule.forSitemapGenerator(filterKeyValues);
+            expect(result).toBe(true);
+        });
+        it('Returns false if selected attendance is not online', async () => {
+            const attendanceId = 'not-online';
+            const filterKeyValues = new Map([[FilterKey.DELIVERY_METHOD, [attendanceId]]]);
+            const result = await rule.forSitemapGenerator(filterKeyValues);
+            expect(result).toBe(false);
+        });
+    });
+    describe('forDocumentation', () => {
+        let rule;
+        beforeEach(() => {
+            rule = new OnlineAttendanceRule();
+        });
+        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/organisations/rules/SearchVolumeAreasAttendanceRule.test.d.mts

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

package/dist/tests/organisations/rules/SearchVolumeAreasAttendanceRule.test.mjs

@@ -0,0 +1,59 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { SearchVolumeAreasAttendanceRule } from '@/organisations/rules/SearchVolumeAreasAttendanceRule';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+describe('Rule:SearchVolumeAreasAttendance', () => {
+    describe('forSearch', () => {
+        let searchDependenciesHelper;
+        let rule;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            rule = new SearchVolumeAreasAttendanceRule();
+            searchDependenciesHelper.setFilterKeyValues(new Map([]));
+        });
+        it('Returns true if selected area has search volume', async () => {
+            const areaId = '3592'; // Texas
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.AREA, [areaId]]]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(true);
+        });
+        it('Returns false if selected attendance is not online', async () => {
+            const areaId = '994'; // Scotland
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.AREA, [areaId]]]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(false);
+        });
+    });
+    describe('forSitemapGenerator', () => {
+        let rule;
+        beforeEach(() => {
+            rule = new SearchVolumeAreasAttendanceRule();
+        });
+        it('Returns true if selected area has search volume', async () => {
+            const areaId = '3592'; // Texas
+            const filterKeyValues = new Map([[FilterKey.AREA, [areaId]]]);
+            const result = await rule.forSitemapGenerator(filterKeyValues);
+            expect(result).toBe(true);
+        });
+        it('Returns false if selected attendance is not online', async () => {
+            const areaId = '994'; // Scotland
+            const filterKeyValues = new Map([[FilterKey.AREA, [areaId]]]);
+            const result = await rule.forSitemapGenerator(filterKeyValues);
+            expect(result).toBe(false);
+        });
+    });
+    describe('forDocumentation', () => {
+        let rule;
+        beforeEach(() => {
+            rule = new SearchVolumeAreasAttendanceRule();
+        });
+        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/organisations/rules/SearchVolumeAreasDisciplineRule.test.d.mts

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

package/dist/tests/organisations/rules/SearchVolumeAreasDisciplineRule.test.mjs

@@ -0,0 +1,59 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { SearchVolumeAreasDisciplineRule } from '@/organisations/rules/SearchVolumeAreasDisciplineRule';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+describe('Rule:SearchVolumeAreasDiscipline', () => {
+    describe('forSearch', () => {
+        let searchDependenciesHelper;
+        let rule;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            rule = new SearchVolumeAreasDisciplineRule();
+            searchDependenciesHelper.setFilterKeyValues(new Map([]));
+        });
+        it('Returns true if selected area has search volume', async () => {
+            const areaId = '3592'; // Texas
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.AREA, [areaId]]]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(true);
+        });
+        it('Returns false if selected attendance is not online', async () => {
+            const areaId = '994'; // Scotland
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.AREA, [areaId]]]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(false);
+        });
+    });
+    describe('forSitemapGenerator', () => {
+        let rule;
+        beforeEach(() => {
+            rule = new SearchVolumeAreasDisciplineRule();
+        });
+        it('Returns true if selected area has search volume', async () => {
+            const areaId = '3592'; // Texas
+            const filterKeyValues = new Map([[FilterKey.AREA, [areaId]]]);
+            const result = await rule.forSitemapGenerator(filterKeyValues);
+            expect(result).toBe(true);
+        });
+        it('Returns false if selected attendance is not online', async () => {
+            const areaId = '994'; // Scotland
+            const filterKeyValues = new Map([[FilterKey.AREA, [areaId]]]);
+            const result = await rule.forSitemapGenerator(filterKeyValues);
+            expect(result).toBe(false);
+        });
+    });
+    describe('forDocumentation', () => {
+        let rule;
+        beforeEach(() => {
+            rule = new SearchVolumeAreasDisciplineRule();
+        });
+        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/organisations/rules/SearchVolumeCountriesAttendanceRule.test.d.mts

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

package/dist/tests/organisations/rules/SearchVolumeCountriesAttendanceRule.test.mjs

@@ -0,0 +1,59 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { SearchDependencies } from '../utils/SearchDependencies.util.mjs';
+import { SearchVolumeCountriesAttendanceRule } from '@/organisations/rules/SearchVolumeCountriesAttendanceRule';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+describe('Rule:SearchVolumeCountriesAttendance', () => {
+    describe('forSearch', () => {
+        let searchDependenciesHelper;
+        let rule;
+        beforeEach(() => {
+            searchDependenciesHelper = new SearchDependencies();
+            rule = new SearchVolumeCountriesAttendanceRule();
+            searchDependenciesHelper.setFilterKeyValues(new Map([]));
+        });
+        it('Returns true if selected country is online', async () => {
+            const countryId = '108'; // India
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [countryId]]]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(true);
+        });
+        it('Returns false if selected country is not online', async () => {
+            const countryId = '1'; // Netherlands
+            searchDependenciesHelper.setFilterKeyValues(new Map([[FilterKey.COUNTRY, [countryId]]]));
+            const result = await rule.forSearch(searchDependenciesHelper.dependencies);
+            expect(result).toBe(false);
+        });
+    });
+    describe('forSitemapGenerator', () => {
+        let rule;
+        beforeEach(() => {
+            rule = new SearchVolumeCountriesAttendanceRule();
+        });
+        it('Returns true if  selected country is online', async () => {
+            const countryId = '108'; // India
+            const filterKeyValues = new Map([[FilterKey.COUNTRY, [countryId]]]);
+            const result = await rule.forSitemapGenerator(filterKeyValues);
+            expect(result).toBe(true);
+        });
+        it('Returns false if selected country is not online', async () => {
+            const countryId = '1'; // Netherlands
+            const filterKeyValues = new Map([[FilterKey.COUNTRY, [countryId]]]);
+            const result = await rule.forSitemapGenerator(filterKeyValues);
+            expect(result).toBe(false);
+        });
+    });
+    describe('forDocumentation', () => {
+        let rule;
+        beforeEach(() => {
+            rule = new SearchVolumeCountriesAttendanceRule();
+        });
+        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/organisations/utils/SearchDependencies.util.d.mts

@@ -0,0 +1,20 @@
+import { IOrganisationSearchDependencies } from '@/organisations/types/IOrganisationSearchDependencies';
+import { ISeoInfoBase } from '@/common/ISeoInfoBase';
+import { ISeoFilterState } from '@/common';
+import { DependencyTypes } from '@/enums/DependencyTypes';
+import { FilterKeyValuesMap } from '@/common/FilterKeyValuesMap';
+import { PortalType } from '@studyportals/domain-client';
+import { SortingOptions } from '@/enums/SortingOptions';
+export declare class SearchDependencies {
+    readonly dependencies: IOrganisationSearchDependencies;
+    constructor();
+    get seoInfoBase(): ISeoInfoBase;
+    get filterState(): ISeoFilterState;
+    get dependencyType(): DependencyTypes;
+    setSortingState(option: SortingOptions): void;
+    setRankedResultsCount(count: number): void;
+    setPageNumber(pageNumber: number): void;
+    setNumberOfResults(count: number): void;
+    setPortalType(portalType: PortalType): void;
+    setFilterKeyValues(filterKeyValues: FilterKeyValuesMap): void;
+}

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

@@ -0,0 +1,88 @@
+import { vi } from 'vitest';
+import { DependencyTypes } from '@/enums/DependencyTypes';
+import { PortalType } from '@studyportals/domain-client';
+export class SearchDependencies {
+    dependencies;
+    constructor() {
+        const seoInfoBase = {
+            singleSelectionFor: vi.fn(),
+            selectionOnlyFor: vi.fn(),
+            getFilterOptionValueBy: vi.fn(),
+            getSelectionTypeCount: vi.fn()
+        };
+        const sortingState = {
+            getSelectedOption: vi.fn()
+        };
+        const applicationState = {
+            getRankedResultsCount: vi.fn(),
+            getPageNumber: vi.fn().mockReturnValue(1),
+            getNumberOfResults: vi.fn()
+        };
+        const portalType = PortalType.MASTER;
+        const dependencyType = DependencyTypes.SEARCH;
+        const filterState = {};
+        this.dependencies = {
+            portalType,
+            sortingState,
+            seoInfoBase,
+            filterState,
+            applicationState,
+            dependencyType
+        };
+    }
+    get seoInfoBase() {
+        return this.dependencies.seoInfoBase;
+    }
+    get filterState() {
+        return this.dependencies.filterState;
+    }
+    get dependencyType() {
+        return this.dependencies.dependencyType;
+    }
+    setSortingState(option) {
+        this.dependencies.sortingState.getSelectedOption.mockImplementation(() => {
+            return option;
+        });
+    }
+    setRankedResultsCount(count) {
+        this.dependencies.applicationState.getRankedResultsCount.mockImplementation(() => {
+            return count;
+        });
+    }
+    setPageNumber(pageNumber) {
+        this.dependencies.applicationState.getPageNumber.mockImplementation(() => {
+            return pageNumber;
+        });
+    }
+    setNumberOfResults(count) {
+        this.dependencies.applicationState.getNumberOfResults.mockImplementation(() => {
+            return count;
+        });
+    }
+    setPortalType(portalType) {
+        this.dependencies.portalType = portalType;
+    }
+    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/organisations/utils/SitemapDependencies.util.d.mts

@@ -0,0 +1,18 @@
+import { DependencyTypes } from '@/enums/DependencyTypes';
+import { IOrganisationsSitemapDependencies } from '@/organisations/types/IOrganisationsSitemapDependencies';
+import { IRankingApiClient } from '@/sitemap-generator/IRankingApiClient';
+import { PortalType } from '@studyportals/domain-client';
+import { IOrganisation, IOrganisationsClient, ISearchApiClient } from 'sitemap-generator-seo';
+export declare class SitemapDependencies {
+    readonly dependencies: IOrganisationsSitemapDependencies;
+    constructor();
+    get searchApiClient(): ISearchApiClient;
+    get organisationsClient(): IOrganisationsClient;
+    get rankingApiClient(): IRankingApiClient;
+    get dependencyType(): DependencyTypes;
+    get portalType(): PortalType;
+    setOrganisations(organisations: IOrganisation[]): void;
+    setRankedOrganisationCount(count: number): void;
+    setOrganisationCount(count: number): void;
+    setPortalType(portalType: PortalType): void;
+}

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

@@ -0,0 +1,54 @@
+import { DependencyTypes } from '@/enums/DependencyTypes';
+import { PortalType } from '@studyportals/domain-client';
+import { vi } from 'vitest';
+export class SitemapDependencies {
+    dependencies;
+    constructor() {
+        const searchApiClient = {
+            getOrganisationIds: vi.fn(),
+            getCount: vi.fn()
+        };
+        const organisationsClient = {
+            getOrganisations: vi.fn()
+        };
+        const rankingApiClient = {
+            getRankedOrganisationCount: vi.fn()
+        };
+        const dependencyType = DependencyTypes.SITEMAP_GENERATOR;
+        this.dependencies = {
+            searchApiClient,
+            organisationsClient,
+            rankingApiClient,
+            dependencyType,
+            portalType: PortalType.MASTER
+        };
+    }
+    get searchApiClient() {
+        return this.dependencies.searchApiClient;
+    }
+    get organisationsClient() {
+        return this.dependencies.organisationsClient;
+    }
+    get rankingApiClient() {
+        return this.dependencies.rankingApiClient;
+    }
+    get dependencyType() {
+        return this.dependencies.dependencyType;
+    }
+    get portalType() {
+        return this.dependencies.portalType;
+    }
+    setOrganisations(organisations) {
+        this.dependencies.searchApiClient.getOrganisationIds.mockResolvedValue(organisations.map((org) => org.id));
+        this.dependencies.organisationsClient.getOrganisations.mockResolvedValue(organisations);
+    }
+    setRankedOrganisationCount(count) {
+        this.dependencies.rankingApiClient.getRankedOrganisationCount.mockResolvedValue(count);
+    }
+    setOrganisationCount(count) {
+        this.dependencies.searchApiClient.getCount.mockResolvedValue(count);
+    }
+    setPortalType(portalType) {
+        this.dependencies.portalType = portalType;
+    }
+}

package/dist/tests/presenters/AreaPresenter.test.d.mts

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

package/dist/tests/presenters/AreaPresenter.test.mjs

@@ -0,0 +1,46 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { AreaPresenter } from '@/presenters/AreaPresenter';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+describe('AreaPresenter', () => {
+    beforeEach(() => {
+        // Reset the singleton instance before each test
+        AreaPresenter.instance = undefined;
+    });
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+    it('Should be a singleton', () => {
+        const instance1 = AreaPresenter.getInstance();
+        const instance2 = AreaPresenter.getInstance();
+        expect(instance1).toBe(instance2);
+    });
+    it('Should have the correct filter key', () => {
+        const presenter = AreaPresenter.getInstance();
+        expect(presenter.filterKey).toBe(FilterKey.AREA);
+    });
+    it('Should return area fragments', () => {
+        const presenter = AreaPresenter.getInstance();
+        const fragments = presenter.getFragments();
+        expect(fragments.length).toBeGreaterThan(0);
+        // Check structure of fragments
+        const firstFragment = fragments[0];
+        expect(firstFragment).toHaveProperty('id');
+        expect(firstFragment).toHaveProperty('path');
+        expect(firstFragment).toHaveProperty('countryId');
+        // Verify that all fragments have the required properties
+        fragments.forEach((fragment) => {
+            expect(fragment).toHaveProperty('id');
+            expect(fragment).toHaveProperty('path');
+            expect(fragment).toHaveProperty('countryId');
+            expect(typeof fragment.id).toBe('string');
+            expect(typeof fragment.path).toBe('string');
+            expect(typeof fragment.countryId).toBe('string');
+        });
+    });
+    it('Should return the same fragments on multiple calls', () => {
+        const presenter = AreaPresenter.getInstance();
+        const fragments1 = presenter.getFragments();
+        const fragments2 = presenter.getFragments();
+        expect(fragments1).toBe(fragments2); // Should be the same instance
+    });
+});

package/dist/tests/presenters/AttendancePresenter.test.d.mts

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

package/dist/tests/presenters/AttendancePresenter.test.mjs

@@ -0,0 +1,41 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { AttendancePresenter } from '@/presenters/AttendancePresenter';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+describe('AttendancePresenter', () => {
+    beforeEach(() => {
+        // Reset the singleton instance before each test
+        AttendancePresenter.instance = undefined;
+    });
+    it('Should be a singleton', () => {
+        const instance1 = AttendancePresenter.getInstance();
+        const instance2 = AttendancePresenter.getInstance();
+        expect(instance1).toBe(instance2);
+    });
+    it('Should have the correct filter key', () => {
+        const presenter = AttendancePresenter.getInstance();
+        expect(presenter.filterKey).toBe(FilterKey.DELIVERY_METHOD);
+    });
+    it('Should return the correct fragments', () => {
+        const presenter = AttendancePresenter.getInstance();
+        const fragments = presenter.getFragments();
+        // Should have the online fragment
+        expect(fragments.length).toBeGreaterThan(0);
+        // Should have the online fragment
+        const onlineFragment = fragments.find((f) => f.id === 'online');
+        expect(onlineFragment).toBeDefined();
+        expect(onlineFragment?.path).toBe('online');
+        // Check structure of all fragments
+        fragments.forEach((fragment) => {
+            expect(fragment).toHaveProperty('id');
+            expect(fragment).toHaveProperty('path');
+            expect(typeof fragment.id).toBe('string');
+            expect(typeof fragment.path).toBe('string');
+        });
+    });
+    it('Should return the same fragments on multiple calls', () => {
+        const presenter = AttendancePresenter.getInstance();
+        const fragments1 = presenter.getFragments();
+        const fragments2 = presenter.getFragments();
+        expect(fragments1).toBe(fragments2); // Should be the same instance
+    });
+});

package/dist/tests/presenters/ContinentPresenter.test.d.mts

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

package/dist/tests/presenters/ContinentPresenter.test.mjs

@@ -0,0 +1,44 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ContinentPresenter } from '@/presenters/ContinentPresenter';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+describe('ContinentPresenter', () => {
+    beforeEach(() => {
+        // Reset the singleton instance before each test
+        ContinentPresenter.instance = undefined;
+    });
+    it('Should be a singleton', () => {
+        const instance1 = ContinentPresenter.getInstance();
+        const instance2 = ContinentPresenter.getInstance();
+        expect(instance1).toBe(instance2);
+    });
+    it('Should have the correct filter key', () => {
+        const presenter = ContinentPresenter.getInstance();
+        expect(presenter.filterKey).toBe(FilterKey.CONTINENT);
+    });
+    it('Should return continent fragments', () => {
+        const presenter = ContinentPresenter.getInstance();
+        const fragments = presenter.getFragments();
+        // We expect to have at least a few continents
+        expect(fragments.length).toBeGreaterThan(0);
+        // Check structure of fragments
+        fragments.forEach((fragment) => {
+            expect(fragment).toHaveProperty('id');
+            expect(fragment).toHaveProperty('path');
+            expect(typeof fragment.id).toBe('string');
+            expect(typeof fragment.path).toBe('string');
+        });
+        // We should have common continents like Europe, Asia, etc.
+        const continentIds = fragments.map((f) => f.id);
+        const continentPaths = fragments.map((f) => f.path);
+        // We can't know the exact IDs, but we can check if some paths follow expected patterns
+        // Most continent paths should be lowercase and URL-friendly
+        const hasValidPaths = continentPaths.some((path) => /^[a-z-]+$/.test(path));
+        expect(hasValidPaths).toBe(true);
+    });
+    it('Should return the same fragments on multiple calls', () => {
+        const presenter = ContinentPresenter.getInstance();
+        const fragments1 = presenter.getFragments();
+        const fragments2 = presenter.getFragments();
+        expect(fragments1).toBe(fragments2); // Should be the same instance
+    });
+});

package/dist/tests/presenters/CountryPresenter.test.d.mts

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

package/dist/tests/presenters/CountryPresenter.test.mjs

@@ -0,0 +1,50 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { CountryPresenter } from '@/presenters/CountryPresenter';
+import { FilterKey } from '@studyportals/search-filters/server-side';
+describe('CountryPresenter', () => {
+    beforeEach(() => {
+        // Reset the singleton instance before each test
+        CountryPresenter.instance = undefined;
+    });
+    it('Should be a singleton', () => {
+        const instance1 = CountryPresenter.getInstance();
+        const instance2 = CountryPresenter.getInstance();
+        expect(instance1).toBe(instance2);
+    });
+    it('Should have the correct filter key', () => {
+        const presenter = CountryPresenter.getInstance();
+        expect(presenter.filterKey).toBe(FilterKey.COUNTRY);
+    });
+    it('Should return country fragments', () => {
+        const presenter = CountryPresenter.getInstance();
+        const fragments = presenter.getFragments();
+        // Should have a good number of countries
+        expect(fragments.length).toBeGreaterThan(10);
+        // Check structure of country fragments
+        fragments.forEach((fragment) => {
+            expect(fragment).toHaveProperty('id');
+            expect(fragment).toHaveProperty('path');
+            expect(fragment).toHaveProperty('iso');
+            expect(typeof fragment.id).toBe('string');
+            expect(typeof fragment.path).toBe('string');
+            expect(typeof fragment.iso).toBe('string');
+        });
+        // We should be able to find common countries
+        const commonCountryIds = ['30', '56', '82', '21']; // UK, US, Netherlands, Portugal
+        const foundCountryIds = fragments.map((f) => f.id);
+        // Check if at least some of these common countries are present
+        const hasCommonCountries = commonCountryIds.some((id) => foundCountryIds.includes(id));
+        expect(hasCommonCountries).toBe(true);
+        // Some known paths should exist
+        const paths = fragments.map((f) => f.path);
+        const expectedPaths = ['uk', 'usa', 'netherlands', 'portugal', 'germany', 'france'];
+        const hasExpectedPaths = expectedPaths.some((path) => paths.includes(path));
+        expect(hasExpectedPaths).toBe(true);
+    });
+    it('Should return the same fragments on multiple calls', () => {
+        const presenter = CountryPresenter.getInstance();
+        const fragments1 = presenter.getFragments();
+        const fragments2 = presenter.getFragments();
+        expect(fragments1).toBe(fragments2); // Should be the same instance
+    });
+});

package/dist/tests/presenters/DegreePresenter.test.d.mts

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