everything-is-suitable/everything-is-suitable-test/e2e/config/assertion-helper.spec.ts

import { test, expect } from '@playwright/test';
import { AssertionHelper } from '../helpers/assertion-helper';

test.describe('AssertionHelper - 断言辅助工具测试', () => {
  let assertionHelper: AssertionHelper;
  let page: any;

  test.beforeAll(async ({ browser }) => {
    assertionHelper = new AssertionHelper();
    const context = await browser.newContext();
    page = await context.newPage();
  });

  test.afterAll(async ({ browser }) => {
    await browser.close();
  });

  test('应该能够验证元素可见性', async () => {
    await page.setContent('<button>点击我</button>');
    
    await assertionHelper.assertElementVisible(page, 'button', '按钮应该可见');
    
    const button = page.locator('button');
    await expect(button).toBeVisible();
  });

  test('应该能够验证元素隐藏', async () => {
    await page.setContent('<div style="display:none">隐藏的元素</div>');
    
    await assertionHelper.assertElementHidden(page, 'div', '元素应该隐藏');
    
    const div = page.locator('div');
    await expect(div).toBeHidden();
  });

  test('应该能够验证元素文本', async () => {
    await page.setContent('<h1>欢迎来到系统</h1>');
    
    await assertionHelper.assertElementText(page, 'h1', '欢迎来到系统', '标题文本应该正确');
    
    const h1 = page.locator('h1');
    await expect(h1).toHaveText('欢迎来到系统');
  });

  test('应该能够验证元素包含文本', async () => {
    await page.setContent('<p>这是一段很长的文本内容</p>');
    
    await assertionHelper.assertElementContainsText(page, 'p', '很长的文本', '段落应该包含指定文本');
    
    const p = page.locator('p');
    await expect(p).toContainText('很长的文本');
  });

  test('应该能够验证元素值', async () => {
    await page.setContent('<input type="text" value="默认值" />');
    
    await assertionHelper.assertElementValue(page, 'input', '默认值', '输入框值应该正确');
    
    const input = page.locator('input');
    await expect(input).toHaveValue('默认值');
  });

  test('应该能够验证元素启用状态', async () => {
    await page.setContent('<button>点击我</button>');
    
    await assertionHelper.assertElementEnabled(page, 'button', '按钮应该启用');
    
    const button = page.locator('button');
    await expect(button).toBeEnabled();
  });

  test('应该能够验证元素禁用状态', async () => {
    await page.setContent('<button disabled>禁用按钮</button>');
    
    await assertionHelper.assertElementDisabled(page, 'button', '按钮应该禁用');
    
    const button = page.locator('button');
    await expect(button).toBeDisabled();
  });

  test('应该能够验证复选框选中状态', async () => {
    await page.setContent('<input type="checkbox" checked />');
    
    await assertionHelper.assertElementChecked(page, 'input[type="checkbox"]', '复选框应该选中');
    
    const checkbox = page.locator('input[type="checkbox"]');
    await expect(checkbox).toBeChecked();
  });

  test('应该能够验证元素数量', async () => {
    await page.setContent('<ul><li>项目1</li><li>项目2</li><li>项目3</li></ul>');
    
    await assertionHelper.assertElementCount(page, 'li', 3, '应该有3个列表项');
    
    const items = page.locator('li');
    const count = await items.count();
    expect(count).toBe(3);
  });

  test('应该能够验证元素数量大于指定值', async () => {
    await page.setContent('<ul><li>项目1</li><li>项目2</li><li>项目3</li></ul>');
    
    await assertionHelper.assertElementCountGreaterThan(page, 'li', 2, '列表项数量应该大于2');
    
    const items = page.locator('li');
    const count = await items.count();
    expect(count).toBeGreaterThan(2);
  });

  test('应该能够验证元素数量小于指定值', async () => {
    await page.setContent('<ul><li>项目1</li><li>项目2</li></ul>');
    
    await assertionHelper.assertElementCountLessThan(page, 'li', 5, '列表项数量应该小于5');
    
    const items = page.locator('li');
    const count = await items.count();
    expect(count).toBeLessThan(5);
  });

  test('应该能够验证URL', async () => {
    await page.goto('https://example.com');
    
    await assertionHelper.assertURL(page, /example\.com/, 'URL应该包含example.com');
    
    await expect(page).toHaveURL(/example\.com/);
  });

  test('应该能够验证页面标题', async () => {
    await page.setContent('<title>测试页面</title>');
    
    await assertionHelper.assertTitle(page, '测试页面', '页面标题应该正确');
    
    await expect(page).toHaveTitle('测试页面');
  });

  test('应该能够验证元素属性', async () => {
    await page.setContent('<input type="password" name="password" />');
    
    await assertionHelper.assertAttributeValue(page, 'input', 'type', 'password', '输入框类型应该是password');
    
    const input = page.locator('input');
    await expect(input).toHaveAttribute('type', 'password');
  });

  test('应该能够验证CSS类', async () => {
    await page.setContent('<button class="btn btn-primary">点击我</button>');
    
    await assertionHelper.assertCSSClass(page, 'button', 'btn-primary', '按钮应该有btn-primary类');
    
    const button = page.locator('button');
    await expect(button).toHaveClass(/btn-primary/);
  });

  test('应该能够验证成功消息', async () => {
    await page.setContent('<div class="success-message">操作成功</div>');
    
    await assertionHelper.assertSuccessMessage(page, '应该显示成功消息');
    
    const successMessage = page.locator('.success-message');
    await expect(successMessage).toBeVisible();
  });

  test('应该能够验证错误消息', async () => {
    await page.setContent('<div class="error-message">操作失败</div>');
    
    await assertionHelper.assertErrorMessage(page, '操作失败', '应该显示错误消息');
    
    const errorMessage = page.locator('.error-message');
    await expect(errorMessage).toBeVisible();
    await expect(errorMessage).toContainText('操作失败');
  });

  test('应该能够验证加载状态', async () => {
    await page.setContent('<div class="loading">加载中...</div>');
    
    await assertionHelper.assertLoading(page, '应该显示加载状态');
    
    const loading = page.locator('.loading');
    await expect(loading).toBeVisible();
  });

  test('应该能够验证非加载状态', async () => {
    await page.setContent('<div>内容</div>');
    
    await assertionHelper.assertNotLoading(page, '不应该显示加载状态');
    
    const loading = page.locator('.loading');
    await expect(loading).toBeHidden();
  });

  test('应该能够验证模态框可见', async () => {
    await page.setContent('<div class="modal">模态框内容</div>');
    
    await assertionHelper.assertModalVisible(page, '应该显示模态框');
    
    const modal = page.locator('.modal');
    await expect(modal).toBeVisible();
  });

  test('应该能够验证模态框隐藏', async () => {
    await page.setContent('<div class="modal" style="display:none">模态框内容</div>');
    
    await assertionHelper.assertModalHidden(page, '模态框应该隐藏');
    
    const modal = page.locator('.modal');
    await expect(modal).toBeHidden();
  });

  test('应该能够验证Toast可见', async () => {
    await page.setContent('<div class="toast">通知消息</div>');
    
    await assertionHelper.assertToastVisible(page, '应该显示Toast');
    
    const toast = page.locator('.toast');
    await expect(toast).toBeVisible();
  });

  test('应该能够验证Toast隐藏', async () => {
    await page.setContent('<div class="toast" style="display:none">通知消息</div>');
    
    await assertionHelper.assertToastHidden(page, 'Toast应该隐藏');
    
    const toast = page.locator('.toast');
    await expect(toast).toBeHidden();
  });

  test('应该能够处理自定义消息', async () => {
    await page.setContent('<button>点击我</button>');
    
    await assertionHelper.assertElementVisible(page, 'button', '自定义消息：按钮应该可见');
    
    const button = page.locator('button');
    await expect(button).toBeVisible();
  });

  test('应该能够处理空选择器', async () => {
    await page.setContent('<div>内容</div>');
    
    try {
      await assertionHelper.assertElementVisible(page, '.non-existent', '不存在的元素');
      expect(true).toBe(false);
    } catch (error) {
      expect(error).toBeDefined();
    }
  });

  test('应该能够处理多个断言', async () => {
    await page.setContent(`
      <form>
        <input type="text" name="username" />
        <input type="password" name="password" />
        <button type="submit">登录</button>
      </form>
    `);
    
    await assertionHelper.assertElementVisible(page, 'input[name="username"]', '用户名输入框应该可见');
    await assertionHelper.assertElementVisible(page, 'input[name="password"]', '密码输入框应该可见');
    await assertionHelper.assertElementVisible(page, 'button[type="submit"]', '登录按钮应该可见');
    await assertionHelper.assertElementEnabled(page, 'button[type="submit"]', '登录按钮应该启用');
  });
});