@studyportals/fawkes 8.7.0 → 8.7.1-0

package/dist/tests/structured-data/ProgrammeStructuredDataFactory.test.mjs

@@ -0,0 +1,562 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import Validator from '@adobe/structured-data-validator';
+import { ProgrammeStructuredDataFactory } from '@/structured-data/ProgrammeStructuredDataFactory';
+describe('ProgrammeStructuredDataFactory', () => {
+    let factory;
+    let mockCurrencyService;
+    let mockProgrammeCards;
+    let mockFaqItems;
+    let mockBreadcrumbs;
+    let validator;
+    beforeEach(async () => {
+        // Fetch the current schema.org schema and create validator instance
+        const schemaOrgJson = await (await fetch('https://schema.org/version/latest/schemaorg-current-https.jsonld')).json();
+        validator = new Validator(schemaOrgJson);
+        // Mock the currency conversion service
+        mockCurrencyService = {
+            convert: vi.fn().mockResolvedValue(25000) // Mock conversion to USD
+        };
+        factory = new ProgrammeStructuredDataFactory(mockCurrencyService);
+        Object.defineProperty(global, 'window', {
+            value: {
+                location: {
+                    host: 'studyportals.com'
+                }
+            }
+        });
+        // Create mock data
+        setupMockData();
+    });
+    function setupMockData() {
+        // Mock FAQ items
+        mockFaqItems = [
+            {
+                question: 'What are the admission requirements?',
+                answer: '<p>You need a bachelor\'s degree with <ul><li>GPA 3.0+</li><li>English proficiency</li></ul></p>'
+            },
+            {
+                question: 'How long is the program?',
+                answer: '<p>The program duration is 2 years full-time.</p>'
+            }
+        ];
+        // Mock breadcrumbs
+        mockBreadcrumbs = [
+            {
+                name: 'Home',
+                position: 1,
+                url: 'https://localhost:8080/'
+            },
+            {
+                name: 'Study Abroad',
+                position: 2,
+                url: 'https://localhost:8080/study-abroad'
+            },
+            {
+                name: 'Computer Science Programs',
+                position: 3,
+                url: 'https://localhost:8080/study-abroad/computer-science'
+            }
+        ];
+        // Mock programme cards
+        mockProgrammeCards = createMockProgrammeCards();
+    }
+    function createMockProgrammeCards() {
+        const createMockTiming = (type, startDate) => ({
+            getType: vi.fn().mockReturnValue(type),
+            canShowStartDate: vi.fn().mockReturnValue(true),
+            getStartDate: vi.fn().mockReturnValue({
+                getDate: vi.fn().mockReturnValue(startDate)
+            }),
+            getDeadline: vi.fn().mockReturnValue(null),
+            canShowDeadline: vi.fn().mockReturnValue(false),
+            isApplyingAnytime: vi.fn().mockReturnValue(false),
+            isStartingAnytime: vi.fn().mockReturnValue(false)
+        });
+        const createMockTuitionFee = (target, amount, currency) => ({
+            getTarget: vi.fn().mockReturnValue(target),
+            getAmount: vi.fn().mockReturnValue(amount),
+            getCurrency: vi.fn().mockReturnValue(currency),
+            getOriginalAmount: vi.fn().mockReturnValue(amount),
+            getOriginalUnit: vi.fn().mockReturnValue(currency),
+            getUnit: vi.fn().mockReturnValue(currency),
+            isFree: vi.fn().mockReturnValue(false)
+        });
+        const createMockReviewRating = (avgRating, quantity) => ({
+            getAverageStarRating: vi.fn().mockReturnValue(avgRating),
+            getQuantity: vi.fn().mockReturnValue(quantity),
+            getAverage: vi.fn().mockReturnValue(avgRating),
+            hasEnoughQuantity: vi.fn().mockReturnValue(true)
+        });
+        const createMockLink = (url, description) => ({
+            getUrl: vi.fn().mockReturnValue(url),
+            getDescription: vi.fn().mockReturnValue(description),
+            canShowDescription: vi.fn().mockReturnValue(true)
+        });
+        // Card 1 - Full-time, on-campus program with ratings and tuition
+        const card1 = {
+            getTitle: vi.fn().mockReturnValue('Master of Computer Science'),
+            getSummary: vi.fn().mockReturnValue('Advanced computer science program focusing on AI and machine learning.'),
+            getProgrammeLink: vi.fn().mockReturnValue(createMockLink('/programmes/master-computer-science', 'Master of Computer Science')),
+            getUniversityLink: vi.fn().mockReturnValue(createMockLink('/universities/tech-university', 'Tech University')),
+            getReviewRating: vi.fn().mockReturnValue(createMockReviewRating(4.5, 120)),
+            getTuitionFees: vi.fn().mockReturnValue([
+                createMockTuitionFee('international', 30000, 'EUR'),
+                createMockTuitionFee('national', 15000, 'EUR')
+            ]),
+            canShowTimings: vi.fn().mockReturnValue(true),
+            getTimings: vi.fn().mockReturnValue([
+                createMockTiming('international', new Date('2024-09-01')),
+                createMockTiming('national', new Date('2024-09-15'))
+            ]),
+            isFullTime: vi.fn().mockReturnValue(true),
+            isPartTime: vi.fn().mockReturnValue(false),
+            isOnCampus: vi.fn().mockReturnValue(true),
+            isOnline: vi.fn().mockReturnValue(false),
+            isBlended: vi.fn().mockReturnValue(false),
+            // Add missing required properties with sensible defaults
+            getCountryIsoCode: vi.fn().mockReturnValue('US'),
+            getCover: vi.fn().mockReturnValue(null),
+            canShowCover: vi.fn().mockReturnValue(false),
+            getDegree: vi.fn().mockReturnValue(null),
+            getUniversity: vi.fn().mockReturnValue(null),
+            getCity: vi.fn().mockReturnValue(null),
+            getCountry: vi.fn().mockReturnValue(null),
+            getContinent: vi.fn().mockReturnValue(null),
+            getDiscipline: vi.fn().mockReturnValue(null),
+            getArea: vi.fn().mockReturnValue(null),
+            getSpecialProgrammes: vi.fn().mockReturnValue([]),
+            getEducationalForm: vi.fn().mockReturnValue(null),
+            getFormat: vi.fn().mockReturnValue(null),
+            getDuration: vi.fn().mockReturnValue(null),
+            getLanguage: vi.fn().mockReturnValue(null),
+            canShowTuitionFees: vi.fn().mockReturnValue(true),
+            getApplicationFees: vi.fn().mockReturnValue([]),
+            canShowApplicationFees: vi.fn().mockReturnValue(false),
+            getFees: vi.fn().mockReturnValue([]),
+            canShowFees: vi.fn().mockReturnValue(false),
+            getScholarships: vi.fn().mockReturnValue([]),
+            canShowScholarships: vi.fn().mockReturnValue(false),
+            canShowReviewRating: vi.fn().mockReturnValue(true),
+            getCredentials: vi.fn().mockReturnValue([]),
+            canShowCredentials: vi.fn().mockReturnValue(false),
+            getDeadlines: vi.fn().mockReturnValue([]),
+            canShowDeadlines: vi.fn().mockReturnValue(false),
+            getRequirements: vi.fn().mockReturnValue([]),
+            canShowRequirements: vi.fn().mockReturnValue(false),
+            getAttendance: vi.fn().mockReturnValue(null),
+            isDistance: vi.fn().mockReturnValue(false)
+        };
+        // Card 2 - Part-time, online program without ratings
+        const card2 = {
+            getTitle: vi.fn().mockReturnValue('MBA in Digital Marketing'),
+            getSummary: vi.fn().mockReturnValue('Flexible MBA program designed for working professionals.'),
+            getProgrammeLink: vi.fn().mockReturnValue(createMockLink('/programmes/mba-digital-marketing', 'MBA in Digital Marketing')),
+            getUniversityLink: vi.fn().mockReturnValue(createMockLink('/universities/business-school', 'International Business School')),
+            getReviewRating: vi.fn().mockReturnValue(undefined), // No review rating
+            getTuitionFees: vi.fn().mockReturnValue([
+                createMockTuitionFee('general', 45000, 'USD')
+            ]),
+            canShowTimings: vi.fn().mockReturnValue(true),
+            getTimings: vi.fn().mockReturnValue([
+                createMockTiming('general', new Date('2024-10-01'))
+            ]),
+            isFullTime: vi.fn().mockReturnValue(false),
+            isPartTime: vi.fn().mockReturnValue(true),
+            isOnCampus: vi.fn().mockReturnValue(false),
+            isOnline: vi.fn().mockReturnValue(true),
+            isBlended: vi.fn().mockReturnValue(false),
+            // Add missing required properties with sensible defaults
+            getCountryIsoCode: vi.fn().mockReturnValue('US'),
+            getCover: vi.fn().mockReturnValue(null),
+            canShowCover: vi.fn().mockReturnValue(false),
+            getDegree: vi.fn().mockReturnValue(null),
+            getUniversity: vi.fn().mockReturnValue(null),
+            getCity: vi.fn().mockReturnValue(null),
+            getCountry: vi.fn().mockReturnValue(null),
+            getContinent: vi.fn().mockReturnValue(null),
+            getDiscipline: vi.fn().mockReturnValue(null),
+            getArea: vi.fn().mockReturnValue(null),
+            getSpecialProgrammes: vi.fn().mockReturnValue([]),
+            getEducationalForm: vi.fn().mockReturnValue(null),
+            getFormat: vi.fn().mockReturnValue(null),
+            getDuration: vi.fn().mockReturnValue(null),
+            getLanguage: vi.fn().mockReturnValue(null),
+            canShowTuitionFees: vi.fn().mockReturnValue(true),
+            getApplicationFees: vi.fn().mockReturnValue([]),
+            canShowApplicationFees: vi.fn().mockReturnValue(false),
+            getFees: vi.fn().mockReturnValue([]),
+            canShowFees: vi.fn().mockReturnValue(false),
+            getScholarships: vi.fn().mockReturnValue([]),
+            canShowScholarships: vi.fn().mockReturnValue(false),
+            canShowReviewRating: vi.fn().mockReturnValue(false),
+            getCredentials: vi.fn().mockReturnValue([]),
+            canShowCredentials: vi.fn().mockReturnValue(false),
+            getDeadlines: vi.fn().mockReturnValue([]),
+            canShowDeadlines: vi.fn().mockReturnValue(false),
+            getRequirements: vi.fn().mockReturnValue([]),
+            canShowRequirements: vi.fn().mockReturnValue(false),
+            getAttendance: vi.fn().mockReturnValue(null),
+            isDistance: vi.fn().mockReturnValue(false)
+        };
+        // Card 3 - Blended program with ratings but no tuition fees
+        const card3 = {
+            getTitle: vi.fn().mockReturnValue('Bachelor of Engineering'),
+            getSummary: vi.fn().mockReturnValue('Comprehensive engineering program with flexible learning options.'),
+            getProgrammeLink: vi.fn().mockReturnValue(createMockLink('/programmes/bachelor-engineering', 'Bachelor of Engineering')),
+            getUniversityLink: vi.fn().mockReturnValue(createMockLink('/universities/engineering-institute', 'Engineering Institute')),
+            getReviewRating: vi.fn().mockReturnValue(createMockReviewRating(3.2, 85)),
+            getTuitionFees: vi.fn().mockReturnValue([
+                createMockTuitionFee('general', 20000, 'GBP') // Add tuition fees
+            ]),
+            canShowTimings: vi.fn().mockReturnValue(false), // No timing data
+            getTimings: vi.fn().mockReturnValue([]),
+            isFullTime: vi.fn().mockReturnValue(true),
+            isPartTime: vi.fn().mockReturnValue(false),
+            isOnCampus: vi.fn().mockReturnValue(false),
+            isOnline: vi.fn().mockReturnValue(false),
+            isBlended: vi.fn().mockReturnValue(true),
+            // Add missing required properties with sensible defaults
+            getCountryIsoCode: vi.fn().mockReturnValue('US'),
+            getCover: vi.fn().mockReturnValue(null),
+            canShowCover: vi.fn().mockReturnValue(false),
+            getDegree: vi.fn().mockReturnValue(null),
+            getUniversity: vi.fn().mockReturnValue(null),
+            getCity: vi.fn().mockReturnValue(null),
+            getCountry: vi.fn().mockReturnValue(null),
+            getContinent: vi.fn().mockReturnValue(null),
+            getDiscipline: vi.fn().mockReturnValue(null),
+            getArea: vi.fn().mockReturnValue(null),
+            getSpecialProgrammes: vi.fn().mockReturnValue([]),
+            getEducationalForm: vi.fn().mockReturnValue(null),
+            getFormat: vi.fn().mockReturnValue(null),
+            getDuration: vi.fn().mockReturnValue(null),
+            getLanguage: vi.fn().mockReturnValue(null),
+            canShowTuitionFees: vi.fn().mockReturnValue(true), // Change to true since it now has fees
+            getApplicationFees: vi.fn().mockReturnValue([]),
+            canShowApplicationFees: vi.fn().mockReturnValue(false),
+            getFees: vi.fn().mockReturnValue([]),
+            canShowFees: vi.fn().mockReturnValue(false),
+            getScholarships: vi.fn().mockReturnValue([]),
+            canShowScholarships: vi.fn().mockReturnValue(false),
+            canShowReviewRating: vi.fn().mockReturnValue(true),
+            getCredentials: vi.fn().mockReturnValue([]),
+            canShowCredentials: vi.fn().mockReturnValue(false),
+            getDeadlines: vi.fn().mockReturnValue([]),
+            canShowDeadlines: vi.fn().mockReturnValue(false),
+            getRequirements: vi.fn().mockReturnValue([]),
+            canShowRequirements: vi.fn().mockReturnValue(false),
+            getAttendance: vi.fn().mockReturnValue(null),
+            isDistance: vi.fn().mockReturnValue(false)
+        };
+        return [card1, card2, card3];
+    }
+    describe('buildStructuredData - Main Public Interface', () => {
+        it('should generate complete structured data with all components', async () => {
+            const result = await factory.buildStructuredData('Computer Science Programs', 'Find the best computer science programs worldwide', mockProgrammeCards, mockFaqItems, mockBreadcrumbs);
+            // Basic structure
+            expect(result['@context']).toBe('https://schema.org');
+            expect(result['@type']).toBe('SearchResultsPage');
+            expect(result.name).toBe('Computer Science Programs');
+            expect(result.description).toBe('Find the best computer science programs worldwide');
+            expect(result.mainEntity).toHaveLength(3); // All 3 cards now have tuition fees
+        });
+        it('should generate structured data with empty arrays gracefully', async () => {
+            const result = await factory.buildStructuredData('Empty Results', 'No programs found', [], [], []);
+            expect(result.mainEntity).toHaveLength(0);
+            expect(result.aggregateRating).toBeUndefined();
+            expect(result.offers).toBeUndefined();
+            expect(result.hasPart).toBeUndefined();
+            expect(result.breadcrumb).toBeUndefined();
+        });
+    });
+    describe('Course Structured Data Generation', () => {
+        it('should generate correct Course structured data for full-time on-campus program', async () => {
+            const result = await factory.buildStructuredData('Test', 'Test', [mockProgrammeCards[0]], [], []);
+            const course = result.mainEntity[0];
+            expect(course['@type']).toBe('Course');
+            expect(course.name).toBe('Master of Computer Science');
+            expect(course.description).toBe('Advanced computer science program focusing on AI and machine learning.');
+            expect(course.url).toBe('/programmes/master-computer-science');
+            // Provider information
+            expect(course.provider?.['@type']).toBe('EducationalOrganization');
+            expect(course.provider?.name).toBe('Tech University');
+            expect(course.provider?.url).toBe('https://studyportals.com/universities/tech-university');
+            // Course instance
+            expect(course.hasCourseInstance?.['@type']).toBe('CourseInstance');
+            expect(course.hasCourseInstance?.courseMode).toBe('onsite');
+            expect(course.hasCourseInstance?.courseWorkload).toBe('PT40H');
+            expect(course.hasCourseInstance?.startDate).toBe('2024-09-01');
+        });
+        it('should generate correct Course structured data for part-time online program', async () => {
+            const result = await factory.buildStructuredData('Test', 'Test', [mockProgrammeCards[1]], [], []);
+            const course = result.mainEntity[0];
+            expect(course.name).toBe('MBA in Digital Marketing');
+            expect(course.hasCourseInstance?.courseMode).toBe('online');
+            expect(course.hasCourseInstance?.courseWorkload).toBe('PT20H');
+            expect(course.hasCourseInstance?.startDate).toBe('2024-10-01');
+        });
+        it('should generate correct Course structured data for blended program', async () => {
+            const result = await factory.buildStructuredData('Test', 'Test', [mockProgrammeCards[2]], [], []);
+            const course = result.mainEntity[0];
+            expect(course.name).toBe('Bachelor of Engineering');
+            expect(course.hasCourseInstance?.courseMode).toBe('blended');
+            expect(course.hasCourseInstance?.courseWorkload).toBe('PT40H');
+            expect(course.hasCourseInstance?.startDate).toBeUndefined();
+        });
+    });
+    describe('Rating Integration', () => {
+        it('should include aggregate rating when cards have ratings', async () => {
+            const result = await factory.buildStructuredData('Test', 'Test', [mockProgrammeCards[0]], [], []);
+            const course = result.mainEntity[0];
+            expect(course.aggregateRating?.['@type']).toBe('AggregateRating');
+            expect(course.aggregateRating?.ratingValue).toBe(4.5);
+            expect(course.aggregateRating?.ratingCount).toBe(120);
+            expect(course.aggregateRating?.bestRating).toBe(5);
+            expect(course.aggregateRating?.worstRating).toBe(1);
+        });
+        it('should not include aggregate rating when card has no ratings', async () => {
+            const result = await factory.buildStructuredData('Test', 'Test', [mockProgrammeCards[1]], [], []);
+            const course = result.mainEntity[0];
+            expect(course.aggregateRating).toBeUndefined();
+        });
+        it('should not include aggregate rating when hasEnoughQuantity is false', async () => {
+            // Create a mock review rating with hasEnoughQuantity returning false
+            const createMockReviewRatingInsufficient = (avgRating, quantity) => ({
+                getAverageStarRating: vi.fn().mockReturnValue(avgRating),
+                getQuantity: vi.fn().mockReturnValue(quantity),
+                getAverage: vi.fn().mockReturnValue(avgRating),
+                hasEnoughQuantity: vi.fn().mockReturnValue(false) // This should prevent rating from being included
+            });
+            // Create a mock card with insufficient rating quantity
+            const cardWithInsufficientRating = {
+                ...mockProgrammeCards[0],
+                getReviewRating: vi.fn().mockReturnValue(createMockReviewRatingInsufficient(4.2, 3)), // Low quantity
+                canShowReviewRating: vi.fn().mockReturnValue(true)
+            };
+            const result = await factory.buildStructuredData('Test', 'Test', [cardWithInsufficientRating], [], []);
+            const course = result.mainEntity[0];
+            // Should not include aggregate rating when hasEnoughQuantity is false
+            expect(course.aggregateRating).toBeUndefined();
+        });
+    });
+    describe('Offer Integration', () => {
+        it('should include offer when card has tuition fees', async () => {
+            const result = await factory.buildStructuredData('Test', 'Test', [mockProgrammeCards[0]], [], []);
+            const course = result.mainEntity[0];
+            expect(mockCurrencyService.convert).toHaveBeenCalledWith(30000, 'EUR', 'USD');
+            expect(course.offers?.['@type']).toBe('Offer');
+            expect(course.offers?.price).toBe(25000);
+            expect(course.offers?.priceCurrency).toBe('USD');
+            expect(course.offers?.category).toBe('tuition');
+            expect(course.offers?.validFrom).toBe('2024-09-01');
+        });
+        it('should prioritize international tuition fees over other types', async () => {
+            await factory.buildStructuredData('Test', 'Test', [mockProgrammeCards[0]], [], []);
+            // Should call with international fee (30000 EUR) not national fee (15000 EUR)
+            expect(mockCurrencyService.convert).toHaveBeenCalledWith(30000, 'EUR', 'USD');
+        });
+        it('should calculate page-level aggregate offer from multiple cards', async () => {
+            const cardsWithOffers = [mockProgrammeCards[0], mockProgrammeCards[1]]; // Card 2 has no fees
+            const result = await factory.buildStructuredData('Test', 'Test', cardsWithOffers, [], []);
+            expect(result.offers?.['@type']).toBe('AggregateOffer');
+            expect(result.offers?.priceCurrency).toBe('USD');
+            expect(result.offers?.offerCount).toBe(2);
+            expect(result.offers?.lowPrice).toBe(25000);
+            expect(result.offers?.highPrice).toBe(25000);
+        });
+        it('should set minPrice to 0 in page-level aggregate offer when free tuition fee is detected', async () => {
+            // Create a mock card with free tuition fee
+            const createMockTuitionFee = (target, amount, currency) => ({
+                getTarget: vi.fn().mockReturnValue(target),
+                getAmount: vi.fn().mockReturnValue(amount),
+                getCurrency: vi.fn().mockReturnValue(currency),
+                getOriginalAmount: vi.fn().mockReturnValue(amount),
+                getOriginalUnit: vi.fn().mockReturnValue(currency),
+                getUnit: vi.fn().mockReturnValue(currency),
+                isFree: vi.fn().mockReturnValue(amount === 0)
+            });
+            const createMockLink = (url, description) => ({
+                getUrl: vi.fn().mockReturnValue(url),
+                getDescription: vi.fn().mockReturnValue(description),
+                canShowDescription: vi.fn().mockReturnValue(true)
+            });
+            const freeCard = {
+                ...mockProgrammeCards[0],
+                getTitle: vi.fn().mockReturnValue('Free Online Course'),
+                getProgrammeLink: vi.fn().mockReturnValue(createMockLink('/programmes/free-course', 'Free Online Course')),
+                getTuitionFees: vi.fn().mockReturnValue([
+                    createMockTuitionFee('general', 0, 'USD') // Free tuition
+                ])
+            };
+            // Mock currency service to return 0 for free course and 25000 for paid course
+            mockCurrencyService.convert = vi.fn()
+                .mockImplementation((amount) => Promise.resolve(amount === 0 ? 0 : 25000));
+            const cardsWithFreeAndPaid = [mockProgrammeCards[0], freeCard]; // One paid, one free
+            const result = await factory.buildStructuredData('Test', 'Test', cardsWithFreeAndPaid, [], []);
+            expect(result.offers?.['@type']).toBe('AggregateOffer');
+            expect(result.offers?.priceCurrency).toBe('USD');
+            expect(result.offers?.offerCount).toBe(2);
+            expect(result.offers?.lowPrice).toBe(0); // Should be 0 due to free course
+            expect(result.offers?.highPrice).toBe(25000);
+            // Verify currency conversion was called for both cards
+            expect(mockCurrencyService.convert).toHaveBeenCalledWith(30000, 'EUR', 'USD'); // Paid course
+            expect(mockCurrencyService.convert).toHaveBeenCalledWith(0, 'USD', 'USD'); // Free course
+        });
+        it('should exclude cards with no tuition fees from mainEntity object', async () => {
+            // Create a new card with no tuition fees for this specific test
+            const createMockLink = (url, description) => ({
+                getUrl: vi.fn().mockReturnValue(url),
+                getDescription: vi.fn().mockReturnValue(description),
+                canShowDescription: vi.fn().mockReturnValue(true)
+            });
+            const cardWithoutFees = {
+                ...mockProgrammeCards[0],
+                getTitle: vi.fn().mockReturnValue('Free Certificate Program'),
+                getProgrammeLink: vi.fn().mockReturnValue(createMockLink('/programmes/free-certificate', 'Free Certificate Program')),
+                getTuitionFees: vi.fn().mockReturnValue([]), // No tuition fees
+                canShowTuitionFees: vi.fn().mockReturnValue(false),
+            };
+            // Use card with tuition fees and card without tuition fees
+            const cardsWithAndWithoutFees = [mockProgrammeCards[0], cardWithoutFees]; // Card 1 has fees, new card has no fees
+            const result = await factory.buildStructuredData('Test', 'Test', cardsWithAndWithoutFees, [], []);
+            // Should only include the card with tuition fees in mainEntity
+            expect(result.mainEntity).toHaveLength(1);
+            expect(result.mainEntity?.[0]?.name).toBe('Master of Computer Science'); // Only card 1 should be included
+            // The aggregate offer should still be created but only for cards with fees
+            expect(result.offers?.['@type']).toBe('AggregateOffer');
+            expect(result.offers?.offerCount).toBe(1); // Only one card with fees
+            expect(result.offers?.lowPrice).toBe(25000);
+            expect(result.offers?.highPrice).toBe(25000);
+            // Verify currency conversion was only called for the card with fees
+            expect(mockCurrencyService.convert).toHaveBeenCalledWith(30000, 'EUR', 'USD'); // Card 1 with fees
+            expect(mockCurrencyService.convert).toHaveBeenCalledTimes(1); // Should only be called once
+        });
+    });
+    describe('FAQ Integration', () => {
+        it('should include FAQ page when FAQ items are provided', async () => {
+            const result = await factory.buildStructuredData('Test', 'Test', [], mockFaqItems, []);
+            expect(result.hasPart?.['@type']).toBe('FAQPage');
+            expect(result.hasPart?.mainEntity).toHaveLength(2);
+            const firstQuestion = result.hasPart?.mainEntity?.[0];
+            expect(firstQuestion?.['@type']).toBe('Question');
+            expect(firstQuestion?.name).toBe('What are the admission requirements?');
+            expect(firstQuestion?.acceptedAnswer?.['@type']).toBe('Answer');
+            expect(firstQuestion?.acceptedAnswer?.text).toContain('bachelor\'s degree');
+        });
+        it('should not include FAQ page when no FAQ items provided', async () => {
+            const result = await factory.buildStructuredData('Test', 'Test', [], [], []);
+            expect(result.hasPart).toBeUndefined();
+        });
+    });
+    describe('Breadcrumb Integration', () => {
+        it('should include breadcrumb list when breadcrumbs are provided', async () => {
+            const result = await factory.buildStructuredData('Test', 'Test', [], [], mockBreadcrumbs);
+            expect(result.breadcrumb?.['@type']).toBe('BreadcrumbList');
+            expect(result.breadcrumb?.itemListElement).toHaveLength(3);
+            const firstBreadcrumb = result.breadcrumb?.itemListElement?.[0];
+            expect(firstBreadcrumb?.['@type']).toBe('ListItem');
+            expect(firstBreadcrumb?.name).toBe('Home');
+            expect(firstBreadcrumb?.position).toBe(1);
+            expect(firstBreadcrumb?.item).toBe('https://localhost:8080/');
+        });
+        it('should not include breadcrumb list when no breadcrumbs provided', async () => {
+            const result = await factory.buildStructuredData('Test', 'Test', [], [], []);
+            expect(result.breadcrumb).toBeUndefined();
+        });
+    });
+    describe('Currency Conversion Service Integration', () => {
+        it('should call currency conversion service for each card with tuition fees', async () => {
+            await factory.buildStructuredData('Test', 'Test', mockProgrammeCards, [], []);
+            // Should be called three times: once for each card (all cards now have fees)
+            expect(mockCurrencyService.convert).toHaveBeenCalledTimes(3);
+            expect(mockCurrencyService.convert).toHaveBeenCalledWith(30000, 'EUR', 'USD'); // Card 1
+            expect(mockCurrencyService.convert).toHaveBeenCalledWith(45000, 'USD', 'USD'); // Card 2
+            expect(mockCurrencyService.convert).toHaveBeenCalledWith(20000, 'GBP', 'USD'); // Card 3
+        });
+        it('should handle currency conversion errors gracefully', async () => {
+            mockCurrencyService.convert = vi.fn().mockRejectedValue(new Error('Conversion failed'));
+            // The method should handle the error and continue processing
+            await expect(async () => {
+                await factory.buildStructuredData('Test', 'Test', [mockProgrammeCards[0]], [], []);
+            }).rejects.toThrow('Conversion failed');
+        });
+    });
+    describe('Edge Cases and Error Handling', () => {
+        it('should handle cards with no timing data', async () => {
+            const cardWithoutTimings = {
+                ...mockProgrammeCards[0],
+                canShowTimings: vi.fn().mockReturnValue(false),
+                getTimings: vi.fn().mockReturnValue([])
+            };
+            const result = await factory.buildStructuredData('Test', 'Test', [cardWithoutTimings], [], []);
+            const course = result.mainEntity[0];
+            expect(course.hasCourseInstance?.startDate).toBeUndefined();
+            expect(course.offers?.validFrom).toBeUndefined();
+        });
+        it('should handle cards with mixed course modes', async () => {
+            const mixedModeCard = {
+                ...mockProgrammeCards[0],
+                isFullTime: vi.fn().mockReturnValue(false),
+                isPartTime: vi.fn().mockReturnValue(false),
+                isOnCampus: vi.fn().mockReturnValue(false),
+                isOnline: vi.fn().mockReturnValue(false),
+                isBlended: vi.fn().mockReturnValue(false)
+            };
+            const result = await factory.buildStructuredData('Test', 'Test', [mixedModeCard], [], []);
+            const course = result.mainEntity[0];
+            expect(course.hasCourseInstance?.courseMode).toBeUndefined();
+            expect(course.hasCourseInstance?.courseWorkload).toBeUndefined();
+        });
+    });
+    describe('Basic Schema Structure Validation', () => {
+        it('should generate structured data with required schema.org fields', async () => {
+            const result = await factory.buildStructuredData('Computer Science Programs', 'Find the best computer science programs worldwide', mockProgrammeCards, mockFaqItems, mockBreadcrumbs);
+            // Validate basic structure
+            expect(result['@context']).toBe('https://schema.org');
+            expect(result['@type']).toBe('SearchResultsPage');
+            expect(result.name).toBeDefined();
+            expect(result.description).toBeDefined();
+            expect(Array.isArray(result.mainEntity)).toBe(true);
+        });
+        it('should generate minimal valid structured data', async () => {
+            const result = await factory.buildStructuredData('Test', 'Test Description', [], [], []);
+            expect(result['@context']).toBe('https://schema.org');
+            expect(result['@type']).toBe('SearchResultsPage');
+            expect(result.name).toBe('Test');
+            expect(result.description).toBe('Test Description');
+            expect(result.mainEntity).toEqual([]);
+        });
+    });
+    describe('Schema Validation', () => {
+        it('should generate valid structured data for complete scenario', async () => {
+            const result = await factory.buildStructuredData('Computer Science Programs', 'Find the best computer science programs worldwide', mockProgrammeCards, mockFaqItems, mockBreadcrumbs);
+            // Validate against schema.org standards using Adobe validator
+            const validationResults = await validator.validate({ jsonld: { SearchResultsPage: [result] } });
+            expect(validationResults.filter((issue) => issue.severity === 'ERROR')).toHaveLength(0); // No validation errors
+        });
+        it('should generate valid structured data for minimal scenario', async () => {
+            const result = await factory.buildStructuredData('Test', 'Test Description', [], [], []);
+            // Validate against schema.org standards using Adobe validator
+            const validationResults = await validator.validate({ jsonld: { SearchResultsPage: [result] } });
+            expect(validationResults).toHaveLength(0); // No validation errors
+        });
+        it('should generate valid structured data with only programme cards', async () => {
+            const result = await factory.buildStructuredData('Programme Cards Only', 'Testing with programme cards only', mockProgrammeCards, [], []);
+            // Validate against schema.org standards using Adobe validator
+            const validationResults = await validator.validate({ jsonld: { SearchResultsPage: [result] } });
+            expect(validationResults.filter((issue) => issue.severity === 'ERROR')).toHaveLength(0); // No validation errors
+        });
+        it('should generate valid structured data with only FAQ items', async () => {
+            const result = await factory.buildStructuredData('FAQ Only', 'Testing with FAQ items only', [], mockFaqItems, []);
+            // Validate against schema.org standards using Adobe validator
+            const validationResults = await validator.validate({ jsonld: { SearchResultsPage: [result] } });
+            expect(validationResults).toHaveLength(0); // No validation errors
+        });
+        it('should generate valid structured data with only breadcrumbs', async () => {
+            const result = await factory.buildStructuredData('Breadcrumbs Only', 'Testing with breadcrumbs only', [], [], mockBreadcrumbs);
+            // Validate against schema.org standards using Adobe validator
+            const validationResults = await validator.validate({ jsonld: { SearchResultsPage: [result] } });
+            expect(validationResults.filter((issue) => issue.severity === 'ERROR')).toHaveLength(0); // No validation errors
+        });
+    });
+});

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

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