@studyportals/fawkes 8.7.0 → 8.7.1-0

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

@@ -0,0 +1,334 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import Validator from '@adobe/structured-data-validator';
+import { OrganisationStructuredDataFactory } from '@/structured-data/OrganisationStructuredDataFactory';
+describe('OrganisationStructuredDataFactory', () => {
+    let factory;
+    let mockOrganisationCards;
+    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);
+        factory = new OrganisationStructuredDataFactory();
+        // Create mock data
+        setupMockData();
+    });
+    function setupMockData() {
+        // Mock FAQ items
+        mockFaqItems = [
+            {
+                question: 'What programs does the university offer?',
+                answer: '<p>We offer undergraduate and graduate programs in <ul><li>Computer Science</li><li>Business Administration</li><li>Engineering</li></ul></p>'
+            },
+            {
+                question: 'How do I apply for admission?',
+                answer: '<p>You can apply online through our admission portal. The application deadline is March 1st.</p>'
+            },
+            {
+                question: 'What are the tuition fees?',
+                answer: '<p>Tuition fees vary by program. Please check our <a href="/fees">fee schedule</a> for detailed information.</p>'
+            }
+        ];
+        // Mock breadcrumbs
+        mockBreadcrumbs = [
+            {
+                name: 'Home',
+                position: 1,
+                url: 'https://localhost:8080/'
+            },
+            {
+                name: 'Universities',
+                position: 2,
+                url: 'https://localhost:8080/universities'
+            },
+            {
+                name: 'Universities in USA',
+                position: 3,
+                url: 'https://localhost:8080/universities/usa'
+            }
+        ];
+        // Mock organisation cards
+        mockOrganisationCards = createMockOrganisationCards();
+    }
+    function createMockOrganisationCards() {
+        const createMockReviewRating = (avgRating, quantity, hasEnoughQuantity = true) => ({
+            getAverageStarRating: vi.fn().mockReturnValue(avgRating),
+            getQuantity: vi.fn().mockReturnValue(quantity),
+            getAverage: vi.fn().mockReturnValue(avgRating),
+            hasEnoughQuantity: vi.fn().mockReturnValue(hasEnoughQuantity)
+        });
+        // Organisation 1 - University with excellent ratings
+        const org1 = {
+            name: 'Stanford University',
+            url: 'https://studyportals.com/universities/stanford-university',
+            description: 'Stanford University is a private research university located in Stanford, California. Known for its academic excellence and innovation in technology and business.',
+            reviewRating: createMockReviewRating(4.8, 245)
+        };
+        // Organisation 2 - University with good ratings
+        const org2 = {
+            name: 'MIT - Massachusetts Institute of Technology',
+            url: 'https://studyportals.com/universities/mit',
+            description: 'MIT is a private research university in Cambridge, Massachusetts. It is renowned for its programs in engineering, computer science, and technology.',
+            reviewRating: createMockReviewRating(4.6, 189)
+        };
+        // Organisation 3 - University with moderate ratings
+        const org3 = {
+            name: 'University of California, Berkeley',
+            url: 'https://studyportals.com/universities/uc-berkeley',
+            description: 'UC Berkeley is a public research university in Berkeley, California. It offers a wide range of undergraduate and graduate programs.',
+            reviewRating: createMockReviewRating(4.2, 156)
+        };
+        // Organisation 4 - University without sufficient ratings
+        const org4 = {
+            name: 'New University',
+            url: 'https://studyportals.com/universities/new-university',
+            description: 'A newly established university offering innovative programs in emerging fields.',
+            reviewRating: createMockReviewRating(3.5, 8, false) // Not enough quantity
+        };
+        // Organisation 5 - University without any ratings
+        const org5 = {
+            name: 'International College',
+            url: 'https://studyportals.com/universities/international-college',
+            description: 'An international college providing quality education in various disciplines.',
+            reviewRating: undefined
+        };
+        // Organisation 6 - University with minimal description
+        const org6 = {
+            name: 'City Technical Institute',
+            url: 'https://studyportals.com/universities/city-tech',
+            description: undefined,
+            reviewRating: createMockReviewRating(4.1, 67)
+        };
+        return [org1, org2, org3, org4, org5, org6];
+    }
+    describe('buildStructuredData - Main Public Interface', () => {
+        it('should generate complete structured data with all components', async () => {
+            const result = await factory.buildStructuredData('Top Universities in California', 'Discover the best universities and colleges in California for international students', mockOrganisationCards, mockFaqItems, mockBreadcrumbs);
+            // Basic structure
+            expect(result['@context']).toBe('https://schema.org');
+            expect(result['@type']).toBe('SearchResultsPage');
+            expect(result.name).toBe('Top Universities in California');
+            expect(result.description).toBe('Discover the best universities and colleges in California for international students');
+            expect(result.mainEntity).toHaveLength(6); // All organisations should be included
+        });
+        it('should generate structured data with empty arrays gracefully', async () => {
+            const result = await factory.buildStructuredData('No Universities Found', 'No matching universities found for your search criteria', [], [], []);
+            expect(result['@context']).toBe('https://schema.org');
+            expect(result['@type']).toBe('SearchResultsPage');
+            expect(result.name).toBe('No Universities Found');
+            expect(result.description).toBe('No matching universities found for your search criteria');
+            expect(result.mainEntity).toHaveLength(0);
+            expect(result.offers).toBeUndefined();
+            expect(result.hasPart).toBeUndefined();
+            expect(result.breadcrumb).toBeUndefined();
+        });
+        it('should include FAQ section when FAQ items are provided', async () => {
+            const result = await factory.buildStructuredData('Universities with FAQ', 'Universities information with frequently asked questions', mockOrganisationCards.slice(0, 2), mockFaqItems, []);
+            expect(result.hasPart).toBeDefined();
+            expect(result.hasPart['@type']).toBe('FAQPage');
+            expect(result.hasPart.mainEntity).toHaveLength(3);
+            // Check FAQ structure
+            const firstFaq = result.hasPart.mainEntity[0];
+            expect(firstFaq['@type']).toBe('Question');
+            expect(firstFaq.name).toBe('What programs does the university offer?');
+            expect(firstFaq.acceptedAnswer['@type']).toBe('Answer');
+            expect(firstFaq.acceptedAnswer.text).toContain('Computer Science');
+            expect(firstFaq.acceptedAnswer.text).toContain('• Computer Science'); // HTML list converted to bullet points
+        });
+        it('should include breadcrumb navigation when breadcrumbs are provided', async () => {
+            const result = await factory.buildStructuredData('Universities with Breadcrumbs', 'Universities with navigation breadcrumbs', mockOrganisationCards.slice(0, 2), [], mockBreadcrumbs);
+            expect(result.breadcrumb).toBeDefined();
+            expect(result.breadcrumb['@type']).toBe('BreadcrumbList');
+            expect(result.breadcrumb.itemListElement).toHaveLength(3);
+            // Check breadcrumb structure
+            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/');
+        });
+    });
+    describe('buildStructuredDataForCard - Organisation-specific Logic', () => {
+        it('should create CollegeOrUniversity structured data with all properties', () => {
+            const org = mockOrganisationCards[0]; // Stanford with ratings
+            const entity = {
+                card: org,
+                reviewRating: {
+                    rating: 4.8,
+                    quantity: 245
+                }
+            };
+            const result = factory['buildStructuredDataForCard'](entity);
+            expect(result).toBeDefined();
+            expect(result['@type']).toBe('CollegeOrUniversity');
+            expect(result.name).toBe('Stanford University');
+            expect(result.description).toBe('Stanford University is a private research university located in Stanford, California. Known for its academic excellence and innovation in technology and business.');
+            expect(result.url).toBe('https://studyportals.com/universities/stanford-university');
+            expect(result.aggregateRating).toBeDefined();
+            expect(result.aggregateRating['@type']).toBe('AggregateRating');
+            expect(result.aggregateRating.ratingValue).toBe(4.8);
+            expect(result.aggregateRating.ratingCount).toBe(245);
+        });
+        it('should create CollegeOrUniversity without aggregate rating when no review rating', () => {
+            const org = mockOrganisationCards[4]; // International College without ratings
+            const entity = {
+                card: org,
+                reviewRating: undefined
+            };
+            const result = factory['buildStructuredDataForCard'](entity);
+            expect(result).toBeDefined();
+            expect(result['@type']).toBe('CollegeOrUniversity');
+            expect(result.name).toBe('International College');
+            expect(result.aggregateRating).toBeUndefined();
+        });
+        it('should handle organisation without description', () => {
+            const org = mockOrganisationCards[5]; // City Technical Institute without description
+            const entity = {
+                card: org,
+                reviewRating: {
+                    rating: 4.1,
+                    quantity: 67
+                }
+            };
+            const result = factory['buildStructuredDataForCard'](entity);
+            expect(result).toBeDefined();
+            expect(result.name).toBe('City Technical Institute');
+            expect(result.description).toBeUndefined();
+            expect(result.aggregateRating).toBeDefined();
+        });
+    });
+    describe('getRating - Rating Logic', () => {
+        it('should return rating data when review rating exists and has enough quantity', () => {
+            const org = mockOrganisationCards[0]; // Stanford with good ratings
+            const result = factory['getRating'](org);
+            expect(result).toBeDefined();
+            expect(result.rating).toBe(4.8);
+            expect(result.quantity).toBe(245);
+        });
+        it('should return undefined when review rating does not have enough quantity', () => {
+            const org = mockOrganisationCards[3]; // New University with insufficient ratings
+            const result = factory['getRating'](org);
+            expect(result).toBeUndefined();
+        });
+        it('should return undefined when no review rating exists', () => {
+            const org = mockOrganisationCards[4]; // International College without ratings
+            const result = factory['getRating'](org);
+            expect(result).toBeUndefined();
+        });
+    });
+    describe('Base Class Functionality - Inherited from SearchStructuredDataFactory', () => {
+        it('should construct aggregate rating correctly', () => {
+            const reviewRating = {
+                rating: 4.5,
+                quantity: 150
+            };
+            const result = factory['constructAggregateRating'](reviewRating);
+            expect(result).toBeDefined();
+            expect(result['@type']).toBe('AggregateRating');
+            expect(result.ratingValue).toBe(4.5);
+            expect(result.ratingCount).toBe(150);
+            expect(result.bestRating).toBe(5);
+            expect(result.worstRating).toBe(1);
+        });
+        it('should return undefined for aggregate rating when no review rating provided', () => {
+            const result = factory['constructAggregateRating'](undefined);
+            expect(result).toBeUndefined();
+        });
+        it('should construct FAQ page correctly', () => {
+            const result = factory['constructOptionalFaqPage'](mockFaqItems);
+            expect(result).toBeDefined();
+            expect(result['@type']).toBe('FAQPage');
+            expect(result.mainEntity).toHaveLength(3);
+            const firstQuestion = result.mainEntity[0];
+            expect(firstQuestion['@type']).toBe('Question');
+            expect(firstQuestion.name).toBe('What programs does the university offer?');
+            expect(firstQuestion.acceptedAnswer['@type']).toBe('Answer');
+            // HTML should be stripped but lists converted to bullet points
+            expect(firstQuestion.acceptedAnswer.text).toContain('• Computer Science');
+        });
+        it('should return undefined for FAQ page when no FAQ items provided', () => {
+            const result = factory['constructOptionalFaqPage']([]);
+            expect(result).toBeUndefined();
+        });
+    });
+    describe('Schema.org Validation', () => {
+        it('should generate valid structured data according to schema.org', async () => {
+            const result = await factory.buildStructuredData('Best Universities for Computer Science', 'Top-ranked universities offering computer science programs', mockOrganisationCards.slice(0, 3), // Use first 3 organisations
+            mockFaqItems, mockBreadcrumbs);
+            // Validate the structured data against schema.org
+            const validationResults = await validator.validate([result]);
+            // Check for validation errors
+            const errors = validationResults.filter(result => result.type === 'error');
+            if (errors.length > 0) {
+                console.error('Schema validation errors:', errors);
+            }
+            // The structured data should be valid (no critical errors)
+            expect(errors.length).toBe(0);
+        });
+        it('should generate valid structured data even with minimal organisation data', async () => {
+            const minimalOrg = {
+                name: 'Minimal University',
+                url: 'https://studyportals.com/universities/minimal',
+                description: undefined,
+                reviewRating: undefined
+            };
+            const result = await factory.buildStructuredData('Minimal Data Test', 'Testing with minimal organisation data', [minimalOrg], [], []);
+            // Validate the structured data against schema.org
+            const validationResults = await validator.validate([result]);
+            // Check for validation errors
+            const errors = validationResults.filter(result => result.type === 'error');
+            if (errors.length > 0) {
+                console.error('Schema validation errors:', errors);
+            }
+            // Should still be valid even with minimal data
+            expect(errors.length).toBe(0);
+        });
+    });
+    describe('Edge Cases and Error Handling', () => {
+        it('should handle organisations with various rating scenarios', async () => {
+            const mixedOrgs = [
+                mockOrganisationCards[0], // High ratings
+                mockOrganisationCards[3], // Insufficient ratings
+                mockOrganisationCards[4] // No ratings
+            ];
+            const result = await factory.buildStructuredData('Mixed Rating Scenarios', 'Testing various rating scenarios', mixedOrgs, [], []);
+            expect(result.mainEntity).toHaveLength(3);
+            // First org should have aggregate rating
+            const firstOrg = result.mainEntity[0];
+            expect(firstOrg.aggregateRating).toBeDefined();
+            // Second and third orgs should not have aggregate rating
+            const secondOrg = result.mainEntity[1];
+            const thirdOrg = result.mainEntity[2];
+            expect(secondOrg.aggregateRating).toBeUndefined();
+            expect(thirdOrg.aggregateRating).toBeUndefined();
+        });
+        it('should handle very long descriptions gracefully', async () => {
+            const longDescriptionOrg = {
+                name: 'University with Long Description',
+                url: 'https://studyportals.com/universities/long-desc',
+                description: 'This is a very long description that goes on and on about the university and its various programs, facilities, faculty, student life, campus culture, research opportunities, international partnerships, alumni network, and many other aspects that make it a comprehensive educational institution. '.repeat(10),
+                reviewRating: undefined
+            };
+            const result = await factory.buildStructuredData('Long Description Test', 'Testing with very long description', [longDescriptionOrg], [], []);
+            expect(result.mainEntity).toHaveLength(1);
+            const org = result.mainEntity[0];
+            expect(org.description).toBeDefined();
+            expect(org.description.length).toBeGreaterThan(1000);
+        });
+        it('should handle special characters in organisation data', async () => {
+            const specialCharOrg = {
+                name: 'Université de Münchën & São Paulo',
+                url: 'https://studyportals.com/universities/special-chars',
+                description: 'A university with special characters: åäö, ñÑ, çÇ, and émojis 🎓📚',
+                reviewRating: undefined
+            };
+            const result = await factory.buildStructuredData('Special Characters Test', 'Testing with special characters and unicode', [specialCharOrg], [], []);
+            expect(result.mainEntity).toHaveLength(1);
+            const org = result.mainEntity[0];
+            expect(org.name).toBe('Université de Münchën & São Paulo');
+            expect(org.description).toContain('🎓📚');
+        });
+    });
+});

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

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