#用 Claude Code 做测试

// tests/e2e/create-project.spec.ts
import { test, expect } from '@playwright/test';

test.describe('创建项目 — 验收测试', () => {
  test.beforeEach(async ({ page }) => {
    // 假设原型部署在本地 3000 端口
    await page.goto('http://localhost:3000/design/create-project/');
  });

  test.describe('页面元素存在性', () => {
    test('所有必填字段可见', async ({ page }) => {
      await expect(page.getByLabel('项目名称')).toBeVisible();
      await expect(page.getByLabel('所属分类')).toBeVisible();
      await expect(page.getByRole('button', { name: '提交' })).toBeVisible();
      await expect(page.getByRole('button', { name: '取消' })).toBeVisible();
    });

    test('选填字段可见', async ({ page }) => {
      await expect(page.getByLabel('项目描述')).toBeVisible();
    });

    test('默认选中"草稿"状态', async ({ page }) => {
      await expect(page.getByLabel('草稿')).toBeChecked();
      await expect(page.getByLabel('发布')).not.toBeChecked();
    });

    test('提交按钮初始状态可用', async ({ page }) => {
      await expect(page.getByRole('button', { name: '提交' })).toBeEnabled();
    });
  });

  test.describe('正常提交流程', () => {
    test('填写所有必填项后提交成功', async ({ page }) => {
      // 填写表单
      await page.getByLabel('项目名称').fill('AI 测试平台');
      await page.getByLabel('项目描述').fill('基于 Claude Code 的自动化测试工具');
      await page.getByLabel('所属分类').selectOption('技术研发');
      await page.getByLabel('发布').check();

      // 提交
      await page.getByRole('button', { name: '提交' }).click();

      // 验证：跳转到项目列表或显示成功提示
      await expect(page).toHaveURL(/\/projects/);
      // 或验证成功 toast
      // await expect(page.getByText('创建成功')).toBeVisible()
    });

    test('仅填必填项（跳过选填）提交成功', async ({ page }) => {
      await page.getByLabel('项目名称').fill('最小项目');
      await page.getByLabel('所属分类').selectOption('产品设计');

      await page.getByRole('button', { name: '提交' }).click();

      await expect(page).toHaveURL(/\/projects/);
    });
  });

  test.describe('字段校验', () => {
    test('项目名称为空时提交显示错误', async ({ page }) => {
      // 不填项目名称，只填分类
      await page.getByLabel('所属分类').selectOption('市场运营');

      await page.getByRole('button', { name: '提交' }).click();

      // 验证错误提示
      await expect(page.getByText('请输入项目名称')).toBeVisible();
      // 验证输入框变红
      await expect(page.getByLabel('项目名称')).toHaveClass(/error/);
    });

    test('项目名称仅空格时提交失败', async ({ page }) => {
      await page.getByLabel('项目名称').fill('   ');
      await page.getByLabel('所属分类').selectOption('技术研发');

      await page.getByRole('button', { name: '提交' }).click();

      await expect(page.getByText('请输入项目名称')).toBeVisible();
    });

    test('所属分类未选择时提交显示错误', async ({ page }) => {
      await page.getByLabel('项目名称').fill('测试项目');
      // 不选分类

      await page.getByRole('button', { name: '提交' }).click();

      await expect(page.getByText('请选择所属分类')).toBeVisible();
    });

    test('输入有效内容后错误提示消失', async ({ page }) => {
      // 先触发错误
      await page.getByRole('button', { name: '提交' }).click();
      await expect(page.getByText('请输入项目名称')).toBeVisible();

      // 修正输入
      await page.getByLabel('项目名称').fill('修复后的名称');

      // 错误提示消失
      await expect(page.getByText('请输入项目名称')).not.toBeVisible();
    });
  });

  test.describe('交互行为', () => {
    test('点击取消返回上一页', async ({ page }) => {
      await page.getByRole('button', { name: '取消' }).click();

      await expect(page).not.toHaveURL(/create-project/);
    });

    test('提交中按钮显示加载状态', async ({ page }) => {
      await page.getByLabel('项目名称').fill('加载测试');
      await page.getByLabel('所属分类').selectOption('技术研发');

      await page.getByRole('button', { name: '提交' }).click();

      // 提交按钮应变为 loading 状态
      await expect(page.getByRole('button', { name: '提交中...' })).toBeVisible();
    });
  });
});

// tests/e2e/create-project-visual.spec.ts
import { test, expect } from '@playwright/test';

test.describe('创建项目 — 视觉回归', () => {
  test('表单初始状态截图对比', async ({ page }) => {
    await page.goto('http://localhost:3000/design/create-project/');
    await expect(page).toHaveScreenshot('create-project-initial.png', {
      fullPage: true,
    });
  });

  test('表单校验错误状态截图对比', async ({ page }) => {
    await page.goto('http://localhost:3000/design/create-project/');
    await page.getByRole('button', { name: '提交' }).click();
    // 等待错误样式渲染
    await page.waitForTimeout(300);
    await expect(page).toHaveScreenshot('create-project-error.png', {
      fullPage: true,
    });
  });

  test('表单填写完成状态截图对比', async ({ page }) => {
    await page.goto('http://localhost:3000/design/create-project/');
    await page.getByLabel('项目名称').fill('视觉回归测试项目');
    await page.getByLabel('项目描述').fill('用于截图对比的测试数据');
    await page.getByLabel('所属分类').selectOption('技术研发');
    await page.getByLabel('发布').check();
    await expect(page).toHaveScreenshot('create-project-filled.png', {
      fullPage: true,
    });
  });
});

// tests/orders.test.ts
import { describe, it, expect, vi, beforeEach } from 'vitest';
import express from 'express';
import request from 'supertest';

// Mock 依赖
const mockDb = {
  findUser: vi.fn(),
  findProduct: vi.fn(),
  findCoupon: vi.fn(),
  createOrder: vi.fn(),
  findOrder: vi.fn(),
};
const mockSendNotification = vi.fn();

// 动态导入路由（绕过模块级 mock 限制，这里用工厂模式示意）
function createApp() {
  const app = express();
  app.use(express.json());

  // 注入 mock 依赖（实际项目中用 rewire 或依赖注入容器）
  const router = require('../routes/orders');
  // ... 注入逻辑（省略，实际用 vitest mock 工厂）
  app.use('/api/orders', router);
  return app;
}

describe('POST /api/orders', () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  // === P0: 核心流程 ===

  it('正常创建订单', async () => {
    mockDb.findUser.mockResolvedValue({ id: 1, name: '张三' });
    mockDb.findProduct.mockResolvedValue({ id: 101, name: '商品A', price: 99, stock: 10 });
    mockDb.createOrder.mockResolvedValue({ id: 1001, userId: 1, items: [{ productId: 101, quantity: 2 }], total: 198 });

    const res = await request(app)
      .post('/api/orders')
      .send({ userId: 1, items: [{ productId: 101, quantity: 2 }] });

    expect(res.status).toBe(201);
    expect(res.body.id).toBe(1001);
    expect(res.body.total).toBe(198);
    expect(mockSendNotification).toHaveBeenCalledWith(1, '订单 1001 已创建，金额：198');
  });

  it('多商品订单，总价正确', async () => {
    mockDb.findUser.mockResolvedValue({ id: 1, name: '张三' });
    mockDb.findProduct
      .mockResolvedValueOnce({ id: 101, name: '商品A', price: 100, stock: 10 })
      .mockResolvedValueOnce({ id: 102, name: '商品B', price: 50, stock: 5 });
    mockDb.createOrder.mockResolvedValue({ id: 1002, total: 250 });

    const res = await request(app)
      .post('/api/orders')
      .send({
        userId: 1,
        items: [
          { productId: 101, quantity: 2 },
          { productId: 102, quantity: 1 },
        ],
      });

    expect(res.status).toBe(201);
    expect(res.body.total).toBe(250);
  });

  // === P1: 参数校验 ===

  it('缺少 userId 返回 400', async () => {
    const res = await request(app)
      .post('/api/orders')
      .send({ items: [{ productId: 101, quantity: 1 }] });

    expect(res.status).toBe(400);
    expect(res.body.error).toContain('userId');
  });

  it('缺少 items 返回 400', async () => {
    const res = await request(app).post('/api/orders').send({ userId: 1 });

    expect(res.status).toBe(400);
    expect(res.body.error).toContain('items');
  });

  it('items 为空数组返回 400', async () => {
    const res = await request(app).post('/api/orders').send({ userId: 1, items: [] });

    expect(res.status).toBe(400);
    expect(res.body.error).toContain('不能为空');
  });

  it('items 不是数组返回 400', async () => {
    const res = await request(app).post('/api/orders').send({ userId: 1, items: 'not-array' });

    expect(res.status).toBe(400);
  });

  // === P1: 业务异常 ===

  it('用户不存在返回 404', async () => {
    mockDb.findUser.mockResolvedValue(null);

    const res = await request(app)
      .post('/api/orders')
      .send({ userId: 999, items: [{ productId: 101, quantity: 1 }] });

    expect(res.status).toBe(404);
    expect(res.body.error).toContain('用户不存在');
  });

  it('商品不存在返回 400', async () => {
    mockDb.findUser.mockResolvedValue({ id: 1 });
    mockDb.findProduct.mockResolvedValue(null);

    const res = await request(app)
      .post('/api/orders')
      .send({ userId: 1, items: [{ productId: 999, quantity: 1 }] });

    expect(res.status).toBe(400);
    expect(res.body.error).toContain('不存在');
  });

  it('库存不足返回 409', async () => {
    mockDb.findUser.mockResolvedValue({ id: 1 });
    mockDb.findProduct.mockResolvedValue({ id: 101, name: '热卖品', price: 99, stock: 0 });

    const res = await request(app)
      .post('/api/orders')
      .send({ userId: 1, items: [{ productId: 101, quantity: 1 }] });

    expect(res.status).toBe(409);
    expect(res.body.error).toContain('库存不足');
  });

  // === P2: 优惠券场景 ===

  it('有效优惠券抵扣总价', async () => {
    mockDb.findUser.mockResolvedValue({ id: 1 });
    mockDb.findProduct.mockResolvedValue({ id: 101, name: '商品A', price: 100, stock: 10 });
    mockDb.findCoupon.mockResolvedValue({ code: 'SAVE20', discount: 20, expireAt: '2099-12-31' });
    mockDb.createOrder.mockResolvedValue({ id: 1003, total: 80 });

    const res = await request(app)
      .post('/api/orders')
      .send({
        userId: 1,
        items: [{ productId: 101, quantity: 1 }],
        couponCode: 'SAVE20',
      });

    expect(res.status).toBe(201);
    expect(res.body.total).toBe(80);
  });

  it('无效优惠券返回 400', async () => {
    mockDb.findUser.mockResolvedValue({ id: 1 });
    mockDb.findProduct.mockResolvedValue({ id: 101, name: '商品A', price: 100, stock: 10 });
    mockDb.findCoupon.mockResolvedValue(null);

    const res = await request(app)
      .post('/api/orders')
      .send({
        userId: 1,
        items: [{ productId: 101, quantity: 1 }],
        couponCode: 'INVALID',
      });

    expect(res.status).toBe(400);
    expect(res.body.error).toContain('优惠券无效');
  });

  it('过期优惠券返回 400', async () => {
    mockDb.findUser.mockResolvedValue({ id: 1 });
    mockDb.findProduct.mockResolvedValue({ id: 101, name: '商品A', price: 100, stock: 10 });
    mockDb.findCoupon.mockResolvedValue({ code: 'OLD50', discount: 50, expireAt: '2020-01-01' });

    const res = await request(app)
      .post('/api/orders')
      .send({
        userId: 1,
        items: [{ productId: 101, quantity: 1 }],
        couponCode: 'OLD50',
      });

    expect(res.status).toBe(400);
    expect(res.body.error).toContain('已过期');
  });

  it('优惠券折扣大于总价，总价不为负', async () => {
    mockDb.findUser.mockResolvedValue({ id: 1 });
    mockDb.findProduct.mockResolvedValue({ id: 101, name: '商品A', price: 10, stock: 10 });
    mockDb.findCoupon.mockResolvedValue({ code: 'BIG50', discount: 50, expireAt: '2099-12-31' });
    mockDb.createOrder.mockResolvedValue({ id: 1004, total: 0 });

    const res = await request(app)
      .post('/api/orders')
      .send({
        userId: 1,
        items: [{ productId: 101, quantity: 1 }],
        couponCode: 'BIG50',
      });

    expect(res.status).toBe(201);
    expect(res.body.total).toBe(0); // Math.max(0, 10 - 50)
  });
});

describe('GET /api/orders/:id', () => {
  it('查询存在的订单返回 200', async () => {
    mockDb.findOrder.mockResolvedValue({ id: 1001, total: 198 });

    const res = await request(app).get('/api/orders/1001');

    expect(res.status).toBe(200);
    expect(res.body.id).toBe(1001);
  });

  it('查询不存在的订单返回 404', async () => {
    mockDb.findOrder.mockResolvedValue(null);

    const res = await request(app).get('/api/orders/99999');

    expect(res.status).toBe(404);
    expect(res.body.error).toContain('不存在');
  });
});