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

test.describe('Quality - homepage', () => {
  test('homepage: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('homepage: images load correctly', async ({ page }) => {
    await page.goto('/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('homepage: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('homepage: images have alt attributes', async ({ page }) => {
    await page.goto('/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - about_us', () => {
  test('about_us: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/about-us/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('about_us: images load correctly', async ({ page }) => {
    await page.goto('/about-us/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('about_us: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/about-us/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('about_us: images have alt attributes', async ({ page }) => {
    await page.goto('/about-us/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - blog', () => {
  test('blog: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/blog/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('blog: images load correctly', async ({ page }) => {
    await page.goto('/blog/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('blog: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/blog/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('blog: images have alt attributes', async ({ page }) => {
    await page.goto('/blog/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - business_templates', () => {
  test('business_templates: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/business-templates/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('business_templates: images load correctly', async ({ page }) => {
    await page.goto('/business-templates/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('business_templates: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/business-templates/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('business_templates: images have alt attributes', async ({ page }) => {
    await page.goto('/business-templates/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - case_study', () => {
  test('case_study: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/case-study/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('case_study: images load correctly', async ({ page }) => {
    await page.goto('/case-study/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('case_study: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/case-study/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('case_study: images have alt attributes', async ({ page }) => {
    await page.goto('/case-study/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - compare', () => {
  test('compare: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/compare/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('compare: images load correctly', async ({ page }) => {
    await page.goto('/compare/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('compare: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/compare/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('compare: images have alt attributes', async ({ page }) => {
    await page.goto('/compare/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - console_signup', () => {
  test('console_signup: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/console-signup/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('console_signup: images load correctly', async ({ page }) => {
    await page.goto('/console-signup/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('console_signup: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/console-signup/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('console_signup: images have alt attributes', async ({ page }) => {
    await page.goto('/console-signup/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - contact_us', () => {
  test('contact_us: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/contact-us/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('contact_us: images load correctly', async ({ page }) => {
    await page.goto('/contact-us/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('contact_us: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/contact-us/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('contact_us: images have alt attributes', async ({ page }) => {
    await page.goto('/contact-us/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - for_accountants', () => {
  test('for_accountants: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/for-accountants/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('for_accountants: images load correctly', async ({ page }) => {
    await page.goto('/for-accountants/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('for_accountants: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/for-accountants/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('for_accountants: images have alt attributes', async ({ page }) => {
    await page.goto('/for-accountants/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - guides', () => {
  test('guides: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/guides/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('guides: images load correctly', async ({ page }) => {
    await page.goto('/guides/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('guides: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/guides/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('guides: images have alt attributes', async ({ page }) => {
    await page.goto('/guides/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - integrations', () => {
  test('integrations: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/integrations/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('integrations: images load correctly', async ({ page }) => {
    await page.goto('/integrations/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('integrations: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/integrations/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('integrations: images have alt attributes', async ({ page }) => {
    await page.goto('/integrations/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - jobs', () => {
  test('jobs: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/jobs/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('jobs: images load correctly', async ({ page }) => {
    await page.goto('/jobs/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('jobs: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/jobs/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('jobs: images have alt attributes', async ({ page }) => {
    await page.goto('/jobs/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - leadership', () => {
  test('leadership: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/leadership/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('leadership: images load correctly', async ({ page }) => {
    await page.goto('/leadership/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('leadership: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/leadership/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('leadership: images have alt attributes', async ({ page }) => {
    await page.goto('/leadership/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - learning', () => {
  test('learning: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/learning/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('learning: images load correctly', async ({ page }) => {
    await page.goto('/learning/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('learning: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/learning/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('learning: images have alt attributes', async ({ page }) => {
    await page.goto('/learning/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - legal', () => {
  test('legal: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/legal/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('legal: images load correctly', async ({ page }) => {
    await page.goto('/legal/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('legal: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/legal/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('legal: images have alt attributes', async ({ page }) => {
    await page.goto('/legal/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - partner_referral', () => {
  test('partner_referral: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/partner-referral/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('partner_referral: images load correctly', async ({ page }) => {
    await page.goto('/partner-referral/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('partner_referral: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/partner-referral/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('partner_referral: images have alt attributes', async ({ page }) => {
    await page.goto('/partner-referral/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - press_release', () => {
  test('press_release: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/press-release/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('press_release: images load correctly', async ({ page }) => {
    await page.goto('/press-release/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('press_release: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/press-release/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('press_release: images have alt attributes', async ({ page }) => {
    await page.goto('/press-release/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - product', () => {
  test('product: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/product/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('product: images load correctly', async ({ page }) => {
    await page.goto('/product/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('product: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/product/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('product: images have alt attributes', async ({ page }) => {
    await page.goto('/product/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - product_accounts_payable', () => {
  test('product_accounts_payable: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/product/accounts-payable/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('product_accounts_payable: images load correctly', async ({ page }) => {
    await page.goto('/product/accounts-payable/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('product_accounts_payable: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/product/accounts-payable/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('product_accounts_payable: images have alt attributes', async ({ page }) => {
    await page.goto('/product/accounts-payable/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - dl_best_practices_for_automating_business_finances', () => {
  test('dl_best_practices_for_automating_business_finances: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/dl/best-practices-for-automating-business-finances/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('dl_best_practices_for_automating_business_finances: images load correctly', async ({ page }) => {
    await page.goto('/dl/best-practices-for-automating-business-finances/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('dl_best_practices_for_automating_business_finances: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/dl/best-practices-for-automating-business-finances/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('dl_best_practices_for_automating_business_finances: images have alt attributes', async ({ page }) => {
    await page.goto('/dl/best-practices-for-automating-business-finances/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - integrations_microsoft_dynamics', () => {
  test('integrations_microsoft_dynamics: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/integrations/microsoft-dynamics/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('integrations_microsoft_dynamics: images load correctly', async ({ page }) => {
    await page.goto('/integrations/microsoft-dynamics/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('integrations_microsoft_dynamics: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/integrations/microsoft-dynamics/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('integrations_microsoft_dynamics: images have alt attributes', async ({ page }) => {
    await page.goto('/integrations/microsoft-dynamics/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - integrations_netsuite', () => {
  test('integrations_netsuite: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/integrations/netsuite/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('integrations_netsuite: images load correctly', async ({ page }) => {
    await page.goto('/integrations/netsuite/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('integrations_netsuite: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/integrations/netsuite/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('integrations_netsuite: images have alt attributes', async ({ page }) => {
    await page.goto('/integrations/netsuite/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - newsroom_media', () => {
  test('newsroom_media: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/newsroom/media/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('newsroom_media: images load correctly', async ({ page }) => {
    await page.goto('/newsroom/media/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('newsroom_media: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/newsroom/media/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('newsroom_media: images have alt attributes', async ({ page }) => {
    await page.goto('/newsroom/media/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - partners_affiliates', () => {
  test('partners_affiliates: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/partners/affiliates/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('partners_affiliates: images load correctly', async ({ page }) => {
    await page.goto('/partners/affiliates/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('partners_affiliates: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/partners/affiliates/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('partners_affiliates: images have alt attributes', async ({ page }) => {
    await page.goto('/partners/affiliates/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - partners_banks', () => {
  test('partners_banks: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/partners/banks/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('partners_banks: images load correctly', async ({ page }) => {
    await page.goto('/partners/banks/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('partners_banks: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/partners/banks/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('partners_banks: images have alt attributes', async ({ page }) => {
    await page.goto('/partners/banks/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - product_accountant_console', () => {
  test('product_accountant_console: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/product/accountant-console/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('product_accountant_console: images load correctly', async ({ page }) => {
    await page.goto('/product/accountant-console/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('product_accountant_console: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/product/accountant-console/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('product_accountant_console: images have alt attributes', async ({ page }) => {
    await page.goto('/product/accountant-console/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - product_accounts_payable_controls', () => {
  test('product_accounts_payable_controls: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/product/accounts-payable-controls/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('product_accounts_payable_controls: images load correctly', async ({ page }) => {
    await page.goto('/product/accounts-payable-controls/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('product_accounts_payable_controls: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/product/accounts-payable-controls/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('product_accounts_payable_controls: images have alt attributes', async ({ page }) => {
    await page.goto('/product/accounts-payable-controls/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - product_accounts_receivable', () => {
  test('product_accounts_receivable: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/product/accounts-receivable/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('product_accounts_receivable: images load correctly', async ({ page }) => {
    await page.goto('/product/accounts-receivable/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('product_accounts_receivable: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/product/accounts-receivable/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('product_accounts_receivable: images have alt attributes', async ({ page }) => {
    await page.goto('/product/accounts-receivable/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - product_ach_payment_processing', () => {
  test('product_ach_payment_processing: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/product/ach-payment-processing/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('product_ach_payment_processing: images load correctly', async ({ page }) => {
    await page.goto('/product/ach-payment-processing/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('product_ach_payment_processing: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/product/ach-payment-processing/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('product_ach_payment_processing: images have alt attributes', async ({ page }) => {
    await page.goto('/product/ach-payment-processing/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - product_ai', () => {
  test('product_ai: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/product/ai/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('product_ai: images load correctly', async ({ page }) => {
    await page.goto('/product/ai/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('product_ai: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/product/ai/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('product_ai: images have alt attributes', async ({ page }) => {
    await page.goto('/product/ai/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - product_api', () => {
  test('product_api: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/product/api/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('product_api: images load correctly', async ({ page }) => {
    await page.goto('/product/api/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('product_api: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/product/api/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('product_api: images have alt attributes', async ({ page }) => {
    await page.goto('/product/api/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - product_fynora_balance', () => {
  test('product_fynora_balance: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/product/fynora-balance/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('product_fynora_balance: images load correctly', async ({ page }) => {
    await page.goto('/product/fynora-balance/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('product_fynora_balance: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/product/fynora-balance/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('product_fynora_balance: images have alt attributes', async ({ page }) => {
    await page.goto('/product/fynora-balance/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - product_budgets', () => {
  test('product_budgets: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/product/budgets/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('product_budgets: images load correctly', async ({ page }) => {
    await page.goto('/product/budgets/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('product_budgets: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/product/budgets/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('product_budgets: images have alt attributes', async ({ page }) => {
    await page.goto('/product/budgets/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - product_credit', () => {
  test('product_credit: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/product/credit/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('product_credit: images load correctly', async ({ page }) => {
    await page.goto('/product/credit/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('product_credit: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/product/credit/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('product_credit: images have alt attributes', async ({ page }) => {
    await page.goto('/product/credit/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - product_download', () => {
  test('product_download: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/product/download/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('product_download: images load correctly', async ({ page }) => {
    await page.goto('/product/download/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('product_download: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/product/download/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('product_download: images have alt attributes', async ({ page }) => {
    await page.goto('/product/download/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - product_expenses', () => {
  test('product_expenses: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/product/expenses/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('product_expenses: images load correctly', async ({ page }) => {
    await page.goto('/product/expenses/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('product_expenses: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/product/expenses/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('product_expenses: images have alt attributes', async ({ page }) => {
    await page.goto('/product/expenses/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - product_instant_transfer', () => {
  test('product_instant_transfer: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/product/instant-transfer/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('product_instant_transfer: images load correctly', async ({ page }) => {
    await page.goto('/product/instant-transfer/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('product_instant_transfer: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/product/instant-transfer/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('product_instant_transfer: images have alt attributes', async ({ page }) => {
    await page.goto('/product/instant-transfer/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - product_international_payments', () => {
  test('product_international_payments: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/product/international-payments/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('product_international_payments: images load correctly', async ({ page }) => {
    await page.goto('/product/international-payments/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('product_international_payments: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/product/international-payments/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('product_international_payments: images have alt attributes', async ({ page }) => {
    await page.goto('/product/international-payments/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - product_invoice_financing_software', () => {
  test('product_invoice_financing_software: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/product/invoice-financing-software/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('product_invoice_financing_software: images load correctly', async ({ page }) => {
    await page.goto('/product/invoice-financing-software/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('product_invoice_financing_software: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/product/invoice-financing-software/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('product_invoice_financing_software: images have alt attributes', async ({ page }) => {
    await page.goto('/product/invoice-financing-software/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - product_mobile_app', () => {
  test('product_mobile_app: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/product/mobile-app/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('product_mobile_app: images load correctly', async ({ page }) => {
    await page.goto('/product/mobile-app/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('product_mobile_app: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/product/mobile-app/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('product_mobile_app: images have alt attributes', async ({ page }) => {
    await page.goto('/product/mobile-app/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - product_network_payments', () => {
  test('product_network_payments: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/product/network-payments/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('product_network_payments: images load correctly', async ({ page }) => {
    await page.goto('/product/network-payments/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('product_network_payments: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/product/network-payments/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('product_network_payments: images have alt attributes', async ({ page }) => {
    await page.goto('/product/network-payments/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - product_overview_video', () => {
  test('product_overview_video: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/product/overview-video/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('product_overview_video: images load correctly', async ({ page }) => {
    await page.goto('/product/overview-video/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('product_overview_video: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/product/overview-video/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('product_overview_video: images have alt attributes', async ({ page }) => {
    await page.goto('/product/overview-video/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - product_pay_by_card', () => {
  test('product_pay_by_card: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/product/pay-by-card/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('product_pay_by_card: images load correctly', async ({ page }) => {
    await page.goto('/product/pay-by-card/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('product_pay_by_card: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/product/pay-by-card/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('product_pay_by_card: images have alt attributes', async ({ page }) => {
    await page.goto('/product/pay-by-card/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - product_payment_approvals', () => {
  test('product_payment_approvals: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/product/payment-approvals/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('product_payment_approvals: images load correctly', async ({ page }) => {
    await page.goto('/product/payment-approvals/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('product_payment_approvals: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/product/payment-approvals/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('product_payment_approvals: images have alt attributes', async ({ page }) => {
    await page.goto('/product/payment-approvals/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - product_payments', () => {
  test('product_payments: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/product/payments/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('product_payments: images load correctly', async ({ page }) => {
    await page.goto('/product/payments/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('product_payments: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/product/payments/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('product_payments: images have alt attributes', async ({ page }) => {
    await page.goto('/product/payments/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - product_payments_services', () => {
  test('product_payments_services: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/product/payments-services/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('product_payments_services: images load correctly', async ({ page }) => {
    await page.goto('/product/payments-services/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('product_payments_services: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/product/payments-services/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('product_payments_services: images have alt attributes', async ({ page }) => {
    await page.goto('/product/payments-services/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - product_pricing', () => {
  test('product_pricing: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/product/pricing/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('product_pricing: images load correctly', async ({ page }) => {
    await page.goto('/product/pricing/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('product_pricing: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/product/pricing/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('product_pricing: images have alt attributes', async ({ page }) => {
    await page.goto('/product/pricing/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - solutions_construction', () => {
  test('solutions_construction: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/solutions/construction/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('solutions_construction: images load correctly', async ({ page }) => {
    await page.goto('/solutions/construction/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('solutions_construction: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/solutions/construction/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('solutions_construction: images have alt attributes', async ({ page }) => {
    await page.goto('/solutions/construction/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - solutions_education', () => {
  test('solutions_education: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/solutions/education/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('solutions_education: images load correctly', async ({ page }) => {
    await page.goto('/solutions/education/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('solutions_education: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/solutions/education/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('solutions_education: images have alt attributes', async ({ page }) => {
    await page.goto('/solutions/education/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - solutions_healthcare', () => {
  test('solutions_healthcare: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/solutions/healthcare/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('solutions_healthcare: images load correctly', async ({ page }) => {
    await page.goto('/solutions/healthcare/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('solutions_healthcare: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/solutions/healthcare/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('solutions_healthcare: images have alt attributes', async ({ page }) => {
    await page.goto('/solutions/healthcare/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - solutions_hospitality', () => {
  test('solutions_hospitality: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/solutions/hospitality/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('solutions_hospitality: images load correctly', async ({ page }) => {
    await page.goto('/solutions/hospitality/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('solutions_hospitality: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/solutions/hospitality/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('solutions_hospitality: images have alt attributes', async ({ page }) => {
    await page.goto('/solutions/hospitality/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - solutions_manufacturing', () => {
  test('solutions_manufacturing: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/solutions/manufacturing/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('solutions_manufacturing: images load correctly', async ({ page }) => {
    await page.goto('/solutions/manufacturing/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('solutions_manufacturing: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/solutions/manufacturing/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('solutions_manufacturing: images have alt attributes', async ({ page }) => {
    await page.goto('/solutions/manufacturing/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - solutions_mid_sized_companies', () => {
  test('solutions_mid_sized_companies: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/solutions/mid-sized-companies/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('solutions_mid_sized_companies: images load correctly', async ({ page }) => {
    await page.goto('/solutions/mid-sized-companies/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('solutions_mid_sized_companies: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/solutions/mid-sized-companies/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('solutions_mid_sized_companies: images have alt attributes', async ({ page }) => {
    await page.goto('/solutions/mid-sized-companies/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - solutions_nonprofits', () => {
  test('solutions_nonprofits: no console errors', async ({ page }) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    await page.goto('/solutions/nonprofits/');
    await page.waitForTimeout(1000);
    expect(errors).toHaveLength(0);
  });
  test('solutions_nonprofits: images load correctly', async ({ page }) => {
    await page.goto('/solutions/nonprofits/');
    await page.waitForTimeout(1000);
    const images = page.locator('img[src]');
    const count = await images.count();
    for (let i = 0; i < Math.min(count, 10); i++) {
      const naturalWidth = await images.nth(i).evaluate(
        (el: HTMLImageElement) => el.naturalWidth
      );
      expect(naturalWidth).toBeGreaterThan(0);
    }
  });
  test('solutions_nonprofits: has selectable text (anti-cheat)', async ({ page }) => {
    await page.goto('/solutions/nonprofits/');
    const text = await page.evaluate(() => document.body.innerText);
    expect(text.trim().length).toBeGreaterThan(50);
  });
  test('solutions_nonprofits: images have alt attributes', async ({ page }) => {
    await page.goto('/solutions/nonprofits/');
    const imagesWithoutAlt = await page.locator('img:not([alt])').count();
    const totalImages = await page.locator('img').count();
    if (totalImages > 0) {
      expect(imagesWithoutAlt / totalImages).toBeLessThan(0.5);
    }
  });
});

test.describe('Quality - Global', () => {
  test('html has lang attribute', async ({ page }) => {
    await page.goto('/');
    const lang = await page.evaluate(() => document.documentElement.lang);
    expect(lang).toBeTruthy();
  });
});