upskill-event-manager/wordpress-dev/tests/e2e/archived/certificates.test.ts

import { test as baseTest, expect } from '@playwright/test';

// Create a fixture that contains a page, browser context, and browser
const test = baseTest.extend({
  // Define your custom fixtures here if needed
});

// Define constants
const STAGING_URL = 'https://wordpress-974670-5399585.cloudwaysapps.com';
const LOGIN_URL = `${STAGING_URL}/community-login/`;
const DASHBOARD_URL = `${STAGING_URL}/hvac-dashboard/`;
const USER = 'test_trainer';
const PASSWORD = 'Test123!';

// Test for generating certificates for checked-in attendees
test('Generate certificates for checked-in attendees', async ({ page }) => {
  // Login
  await page.goto(LOGIN_URL);
  await page.fill('#user_login', USER);
  await page.fill('#user_pass', PASSWORD);
  await page.click('#wp-submit');
  await page.waitForLoadState('networkidle');
  
  // Go to dashboard
  await page.goto(DASHBOARD_URL);
  await page.waitForLoadState('networkidle');
  
  // Navigate to "Generate Certificates" page
  const generateCertificatesLink = page.locator('a:has-text("Generate Certificates")');
  await generateCertificatesLink.click();
  await page.waitForLoadState('networkidle');
  
  // Verify page title is visible
  const pageTitle = page.locator('h1:has-text("Generate Certificates")');
  await expect(pageTitle).toBeVisible();
  
  // Select an event from the dropdown
  // Note: We'll need to select an event that already exists with attendees
  // In a real test, we'd likely create a test event with attendees first
  const eventDropdown = page.locator('select[name="event_id"]');
  
  // Verify dropdown is visible
  await expect(eventDropdown).toBeVisible();
  
  // Check if any events exist in the dropdown
  const optionCount = await page.locator('select[name="event_id"] option').count();
  if (optionCount <= 1) {
    // Skip the rest of the test if no events are available
    console.log('No events available for certificate generation. Skipping test.');
    return;
  }
  
  // Select the first event that's not the empty/default option
  await eventDropdown.selectOption({ index: 1 });
  await page.waitForTimeout(1000); // Wait for attendee list to load
  
  // Check for attendees
  const attendeeList = page.locator('.hvac-attendee-list');
  
  // If there's no attendee list or it's empty, skip the test
  const attendeeItems = page.locator('.hvac-attendee-item');
  const attendeeCount = await attendeeItems.count();
  if (attendeeCount === 0) {
    console.log('No attendees available for certificate generation. Skipping test.');
    return;
  }
  
  // Select all attendees
  const selectAllCheckbox = page.locator('#select_all_attendees');
  if (await selectAllCheckbox.isVisible()) {
    await selectAllCheckbox.check();
  } else {
    // If no "select all" checkbox, select the first attendee manually
    const firstAttendeeCheckbox = attendeeItems.first().locator('input[type="checkbox"]');
    await firstAttendeeCheckbox.check();
  }
  
  // Generate certificates
  const generateButton = page.locator('button:has-text("Generate Certificates")');
  await generateButton.click();
  await page.waitForTimeout(2000); // Wait for processing
  
  // Check for success message
  const successMessage = page.locator('.hvac-success-message');
  const errorMessage = page.locator('.hvac-error-message');
  
  if (await successMessage.isVisible()) {
    console.log('Certificate generation succeeded');
    // Success path - verify certificates were created
    
    // Go back to dashboard
    await page.goto(DASHBOARD_URL);
    await page.waitForLoadState('networkidle');
    
    // Navigate to Certificate Reports
    const certificateReportsLink = page.locator('a:has-text("Certificate Reports")');
    await certificateReportsLink.click();
    await page.waitForLoadState('networkidle');
    
    // Verify certificates exist
    const certificateTable = page.locator('.hvac-certificate-table');
    await expect(certificateTable).toBeVisible();
    
    // Check for at least one certificate row
    const certificateRows = page.locator('.hvac-certificate-table tbody tr');
    const certificateCount = await certificateRows.count();
    expect(certificateCount).toBeGreaterThan(0);
  } else if (await errorMessage.isVisible()) {
    // Certificate generation failed with an error
    const errorText = await errorMessage.textContent();
    console.log(`Certificate generation failed with error: ${errorText}`);
    
    // This might be expected behavior for some tests (e.g., non-checked-in attendees)
    // We'll allow the test to pass, but log the error
  } else {
    // No clear success or error message
    throw new Error('No success or error message was displayed after certificate generation');
  }
});

// Test for certificate management features
test('Certificate management functionality', async ({ page }) => {
  // Login
  await page.goto(LOGIN_URL);
  await page.fill('#user_login', USER);
  await page.fill('#user_pass', PASSWORD);
  await page.click('#wp-submit');
  await page.waitForLoadState('networkidle');
  
  // Go to dashboard
  await page.goto(DASHBOARD_URL);
  await page.waitForLoadState('networkidle');
  
  // Navigate to Certificate Reports
  const certificateReportsLink = page.locator('a:has-text("Certificate Reports")');
  await certificateReportsLink.click();
  await page.waitForLoadState('networkidle');
  
  // Verify page title is visible
  const pageTitle = page.locator('h1:has-text("Certificate Reports")');
  await expect(pageTitle).toBeVisible();
  
  // Check if certificates exist
  const certificateTable = page.locator('.hvac-certificate-table');
  
  // If no certificate table or it's empty, skip the test
  if (!await certificateTable.isVisible()) {
    console.log('No certificate table available. Skipping test.');
    return;
  }
  
  const certificateRows = page.locator('.hvac-certificate-table tbody tr');
  const certificateCount = await certificateRows.count();
  
  if (certificateCount === 0) {
    console.log('No certificates available for management. Skipping test.');
    return;
  }
  
  // Test viewing a certificate
  const viewButton = page.locator('.hvac-certificate-download, button:has-text("View")').first();
  if (await viewButton.isVisible()) {
    await viewButton.click();
    await page.waitForTimeout(1000);
    
    // Close the preview if there's a close button
    const closeButton = page.locator('.hvac-modal-close, button:has-text("Close")');
    if (await closeButton.isVisible()) {
      await closeButton.click();
      await page.waitForTimeout(500);
    }
  }
  
  // Test filtering if a filter input exists
  const filterInput = page.locator('#certificate_filter, input[placeholder*="filter"], input[placeholder*="search"]');
  if (await filterInput.isVisible()) {
    await filterInput.fill('test');
    
    // Look for a filter button
    const filterButton = page.locator('button.hvac-filter-button, button:has-text("Filter"), button:has-text("Search")');
    if (await filterButton.isVisible()) {
      await filterButton.click();
    } else {
      // If no button, press Enter in the input
      await filterInput.press('Enter');
    }
    
    await page.waitForTimeout(1000);
  }
  
  // Test pagination if it exists
  const paginationNext = page.locator('.hvac-pagination-next, a:has-text("Next")');
  if (await paginationNext.isVisible() && await paginationNext.isEnabled()) {
    await paginationNext.click();
    await page.waitForTimeout(1000);
    
    // Go back
    const paginationPrev = page.locator('.hvac-pagination-prev, a:has-text("Previous")');
    if (await paginationPrev.isVisible() && await paginationPrev.isEnabled()) {
      await paginationPrev.click();
      await page.waitForTimeout(1000);
    }
  }
});