upskill-event-manager/wordpress-dev/tests/e2e/certificate-core.test.ts

import { test, expect } from './fixtures/auth';
import { CommonActions } from './utils/common-actions';
import { STAGING_URL } from './config/staging-config';

/**
 * Core certificate functionality tests
 * Tests: generation, viewing, and basic functionality
 * @tag @certificates @core
 */

test.describe('Certificate Core Functionality', () => {
  test('Certificate generation and viewing flow', async ({ authenticatedPage: page }) => {
    const actions = new CommonActions(page);
    
    // Navigate to Generate Certificates page
    await actions.navigateAndWait('/generate-certificates/');
    await actions.screenshot('certificate-generation-page');
    
    // Verify page loaded correctly
    await expect(page.locator('h1, h2').filter({ hasText: /generate certificates/i })).toBeVisible();
    
    // Test AJAX functionality - get events
    const eventSelect = page.locator('select[name="event_id"]');
    await expect(eventSelect).toBeVisible();
    
    // Check if events are available
    const eventOptions = await eventSelect.locator('option').count();
    if (eventOptions > 1) {
      // Select first available event
      await eventSelect.selectOption({ index: 1 });
      await actions.waitForComplexAjax();
      
      // Check for attendee elements more flexibly
      const attendeeSelectors = [
        'input[name="attendee_ids[]"]',
        'input[name*="attendee"]',
        'input[type="checkbox"][name*="attendee"]',
        '.attendee-list input[type="checkbox"]',
        '.certificate-attendees input',
        'input[type="checkbox"]:visible:not([name="select_all"]):not([name="event_id"]):not([name*="checked_in"])'
      ];
      
      let attendeeCheckboxes = null;
      let foundAttendees = false;
      
      for (const selector of attendeeSelectors) {
        const checkboxes = page.locator(selector);
        const count = await checkboxes.count();
        if (count > 0) {
          attendeeCheckboxes = checkboxes;
          foundAttendees = true;
          console.log(`Found ${count} attendees using selector: ${selector}`);
          break;
        }
      }
      
      if (!foundAttendees) {
        console.log('No attendees found for this event - testing event selection only');
        await actions.screenshot('no-attendees-found');
        
        // Verify event selection worked even if no attendees
        const currentSelection = await eventSelect.inputValue();
        expect(currentSelection).not.toBe('');
        return; // Skip attendee-specific tests
      }
      
      // Now test with the found attendees
      const attendeeCount = await attendeeCheckboxes.count();
      
      if (attendeeCount > 0) {
        console.log(`Found ${attendeeCount} attendees for certificate generation`);
        
        // Just verify attendees are available - don't try to interact with them
        await actions.screenshot('attendees-available');
        
        // Test submit button presence
        const submitButton = page.locator('button[type="submit"], input[type="submit"]');
        const submitCount = await submitButton.count();
        
        if (submitCount > 0) {
          console.log('Certificate generation form is complete and ready');
          await expect(submitButton.first()).toBeVisible();
          await actions.screenshot('certificate-form-ready');
        } else {
          console.log('No submit button found - form may need additional configuration');
        }
      } else {
        console.log('Certificate generation form loaded but no attendees found');
      }
    }
  });

  test('Certificate Reports page functionality', async ({ authenticatedPage: page }) => {
    const actions = new CommonActions(page);
    
    // Navigate to Certificate Reports
    await actions.navigateAndWait('/certificate-reports/');
    await actions.screenshot('certificate-reports-page');
    
    // Verify page loaded
    await expect(page.locator('h1, h2').filter({ hasText: /certificate reports/i })).toBeVisible();
    
    // Verify navigation
    await actions.verifyNavigation();
    
    // Check for statistics
    const statElements = page.locator('.stat-value, .stat-number, .dashboard-stat');
    const statCount = await statElements.count();
    
    if (statCount > 0) {
      console.log(`Found ${statCount} certificate statistics`);
      
      // Verify statistics are numbers
      for (let i = 0; i < Math.min(statCount, 4); i++) {
        const statText = await statElements.nth(i).textContent();
        const statNumber = parseInt(statText?.replace(/[^\d]/g, '') || '0');
        expect(statNumber).toBeGreaterThanOrEqual(0);
      }
    }
    
    await actions.screenshot('certificate-reports-verified');
  });

  test('Certificate system navigation and integration', async ({ authenticatedPage: page }) => {
    const actions = new CommonActions(page);
    
    // Test navigation between certificate pages
    const certificatePages = [
      { path: '/certificate-reports/', name: 'Certificate Reports' },
      { path: '/generate-certificates/', name: 'Generate Certificates' }
    ];
    
    for (const certPage of certificatePages) {
      await actions.navigateAndWait(certPage.path);
      
      // Verify page loaded
      await expect(page.locator('h1, h2').filter({ 
        hasText: new RegExp(certPage.name, 'i') 
      })).toBeVisible();
      
      // Verify navigation buttons work
      await actions.verifyNavigation();
      
      await actions.screenshot(`${certPage.name.toLowerCase().replace(/\s+/g, '-')}-navigation`);
    }
    
    // Test return to dashboard
    await page.click('text=Dashboard');
    await actions.waitForAjax();
    await expect(page).toHaveURL(/hvac-dashboard/);
  });
});