test(e2e): Phase1 - infrastructure + core roles restructuring

- Add DB reset script (reset-db.sh) and seed data (seed-data.sql) for 8 roles
- Add unified auth helper (helpers/auth.js) supporting all 8 roles
- Add utils.js with API assertion utilities and fixtures.js test data factory
- Add db.js globalSetup for automatic database reset before test runs
- Update playwright.config.js: globalSetup, increased timeout, retries, screenshots/trace on failure, mobile viewport project
- Restructure tests into roles/ directory:
  - roles/parent/: family-management, wish-management, assessment-order, energy-dashboard, points (5 files)
  - roles/child/: login, daily-checkin, mini-games (3 files)
  - roles/teacher/: login, family-binding (2 files)
  - roles/admin/: login, article/workflow, vendor/management (3 files)
- Add design spec and implementation plan documents

docs/superpowers/plans/2026-07-25-e2e-test-rearchitecture-phase1.md

@@ -0,0 +1,1183 @@
+# E2E 测试体系重构 — Phase 1 实施计划
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** 建立 E2E 测试基础设施（DB reset + 统一认证 + 工具库），重构现有40个文件到按角色组织的目录，升级低质量文件
+
+**架构:** 以 `helpers/` 为基础库，`roles/` 按角色组织测试，保留旧文件不动直至全部迁移完成再删除
+
+**Tech Stack:** Playwright, MySQL 8.0, Node.js
+
+**前置条件:**
+- `tests/playwright.config.js` 已存在
+- E2E 测试环境：`http://cfc.iwintrue.com`
+- 数据库：`192.168.16.251:3306/cfc`
+
+---
+
+### Task 1: 创建数据库重置脚本
+
+**Files:**
+- Create: `tests/e2e/seed-data.sql`
+- Create: `tests/e2e/reset-db.sh`
+
+这一步创建种子数据和重置脚本。种子数据包含每个角色的标准测试账号。
+
+- [ ] **Step 1: 创建 seed-data.sql**
+
+编写种子数据，包含以下测试账号：
+
+| 角色 | 手机号 | 用途 |
+|------|--------|------|
+| 管理员 | 13800138000 | admin 端登录 |
+| 家长 | 13701366188 | mini-app 家长操作 |
+| 孩子1 | 13701366189 | 某家庭的孩子 |
+| 孩子2 | 13701366190 | 某家庭的第二个孩子 |
+| 规划师 | 13800000001 | teacher 端操作 |
+| 营养师 | 13800000010 | nutritionist 端操作 |
+| 管家 | 13800000020 | butler 端操作 |
+| 测评师 | 13800000030 | 测评师子角色 |
+| 供应商 | 13800138001 | vendor 端操作 |
+
+包含以下基础数据：
+- 1 个完整测试家庭（1家长 + 2孩子 + 关系数据）
+- 1 个规划师绑定关系
+- 1 个营养师绑定关系
+- 系统配置（维度、能量规则）
+- 测试商品/套餐各2个
+- 1 篇草稿文章 + 1 篇已发布文章
+- 1 个待审核活动 + 1 个已发布活动
+- 1 个已完成订单
+
+```sql
+-- seed-data.sql
+USE cfc;
+
+-- ===== 清空所有表 =====
+-- 按外键依赖顺序删除
+DELETE FROM family_member_attributes;
+DELETE FROM family_members;
+DELETE FROM families;
+DELETE FROM users WHERE id > 10;
+DELETE FROM verification_codes;
+-- ... (完整清空)
+
+-- ===== 测试用户 =====
+INSERT INTO users (id, openid, phone, nickname, role, roles, family_id, teacher_status, created_at, updated_at) VALUES
+(1001, 'test_admin', '13800138000', '测试管理员', 'admin', '["admin"]', 0, NULL, NOW(), NOW()),
+(1002, 'test_parent', '13701366188', '测试家长', 'parent', '["parent"]', 2001, NULL, NOW(), NOW()),
+(1003, 'test_child1', '13701366189', '小明', 'child', '["child"]', 2001, NULL, NOW(), NOW()),
+(1004, 'test_child2', '13701366190', '小红', 'child', '["child"]', 2001, NULL, NOW(), NOW()),
+(1005, 'test_teacher', '13800000001', '测试规划师', 'teacher', '["teacher","parent"]', 0, 'active', NOW(), NOW()),
+(1006, 'test_nutritionist', '13800000010', '测试营养师', 'teacher', '["teacher"]', 0, 'active', NOW(), NOW()),
+(1007, 'test_butler', '13800000020', '测试管家', 'teacher', '["teacher"]', 0, 'active', NOW(), NOW()),
+(1008, 'test_assessor', '13800000030', '测试测评师', 'teacher', '["teacher"]', 0, 'active', NOW(), NOW()),
+(1009, 'test_vendor', '13800138001', '测试供应商', 'parent', '["parent"]', 0, NULL, NOW(), NOW());
+
+-- ===== 测试家庭 =====
+INSERT INTO families (id, name, invite_code, created_at, updated_at) VALUES
+(2001, '测试幸福家庭', 'TEST2001', NOW(), NOW());
+
+-- ===== 家庭成员关系 =====
+INSERT INTO family_members (family_id, user_id, role_type, created_at, updated_at) VALUES
+(2001, 1002, 'parent', NOW(), NOW()),
+(2001, 1003, 'child', NOW(), NOW()),
+(2001, 1004, 'child', NOW(), NOW());
+
+-- ===== 规划师绑定 =====
+INSERT INTO guide_family_bindings (guide_id, family_id, status, created_at, updated_at) VALUES
+(1005, 2001, 'active', NOW(), NOW());
+
+-- ===== 测试文章 =====
+INSERT INTO articles (title, content, status, author_id, created_at, updated_at) VALUES
+('测试草稿文章', '这是一篇测试草稿', 'draft', 1001, NOW(), NOW()),
+('测试已发布文章', '这是一篇已发布的测试文章', 'published', 1001, NOW(), NOW());
+
+-- ===== 测试活动 =====
+INSERT INTO activities (title, status, created_at, updated_at) VALUES
+('测试待审核活动', 'pending', NOW(), NOW()),
+('测试已发布活动', 'published', NOW(), NOW());
+
+-- ===== 测试商品 =====
+INSERT INTO products (name, price, status, created_at, updated_at) VALUES
+('测试商品A', 99.00, 'active', NOW(), NOW()),
+('测试商品B', 199.00, 'active', NOW(), NOW());
+
+-- ===== 系统配置 =====
+INSERT INTO system_config (config_key, config_value, created_at, updated_at) VALUES
+('energy_dimensions', '{"dimensions":["body","mind","wisdom","wealth","action"]}', NOW(), NOW());
+```
+
+- [ ] **Step 2: 创建 reset-db.sh**
+
+```bash
+#!/bin/bash
+# reset-db.sh — 每次 E2E 运行前执行
+# 用法: bash tests/e2e/reset-db.sh
+
+MYSQL_HOST="${MYSQL_HOST:-192.168.16.251}"
+MYSQL_USER="${MYSQL_USER:-cfc}"
+MYSQL_PASS="${MYSQL_PASS:-cfc@123}"
+MYSQL_DB="${MYSQL_DB:-cfc}"
+SEED_FILE="$(dirname "$0")/seed-data.sql"
+
+echo "==> 重置数据库 ${MYSQL_DB}..."
+mysql -h"$MYSQL_HOST" -u"$MYSQL_USER" -p"$MYSQL_PASS" "$MYSQL_DB" < "$SEED_FILE"
+
+if [ $? -eq 0 ]; then
+    echo "==> 数据库重置完成"
+else
+    echo "==> 数据库重置失败"
+    exit 1
+fi
+```
+
+```bash
+chmod +x tests/e2e/reset-db.sh
+```
+
+- [ ] **Step 3: 验证重置脚本**
+
+```bash
+bash tests/e2e/reset-db.sh
+```
+
+Expected: 数据库重置成功，测试用户和基础数据可用。
+
+---
+
+### Task 2: 创建认证 helper (helpers/auth.js)
+
+**Files:**
+- Create: `tests/e2e/helpers/auth.js`
+
+统一8类角色的登录逻辑。admin 走 web 管理端登录页面，其他角色走 mini-app 登录流程。
+
+- [ ] **Step 1: 创建 helpers/auth.js**
+
+```javascript
+// tests/e2e/helpers/auth.js
+// 统一认证 helper - 支持 8 类角色
+
+const BASE_URL = process.env.PW_BASE_URL || 'http://cfc.iwintrue.com';
+
+const ROLES = {
+  parent:       { phone: '13701366188', userId: 1002, loginType: 'code' },
+  child:        { phone: '13701366189', userId: 1003, loginType: 'code' },
+  teacher:      { phone: '13800000001', userId: 1005, loginType: 'code' },
+  nutritionist: { phone: '13800000010', userId: 1006, loginType: 'code' },
+  butler:       { phone: '13800000020', userId: 1007, loginType: 'code' },
+  assessor:     { phone: '13800000030', userId: 1008, loginType: 'code' },
+  admin:        { phone: '13800138000', userId: 1001, loginType: 'password' },
+  vendor:       { phone: '13800138001', userId: 1009, loginType: 'code' },
+};
+
+/**
+ * 登录指定角色
+ * @param {import('@playwright/test').Browser} browser
+ * @param {string} role - parent/child/teacher/nutritionist/butler/assessor/admin/vendor
+ * @returns {Promise<{token: string, userId: number, role: string, familyId: number}>}
+ */
+async function loginAs(browser, role) {
+  var roleConfig = ROLES[role];
+  if (!roleConfig) throw new Error('Unknown role: ' + role);
+
+  var context = await browser.newContext({ storageState: undefined });
+  var page = await context.newPage();
+
+  try {
+    if (role === 'admin') {
+      // admin：走 Web 管理端登录
+      await page.goto(BASE_URL + '/admin/login');
+      await page.waitForLoadState('networkidle');
+      await page.fill('input[type="text"], input[name="phone"], input[name="username"]', roleConfig.phone);
+      await page.fill('input[type="password"]', 'cfc@123');
+      await page.click('.login-btn, button:has-text("登录"), .el-button--primary');
+      await page.waitForTimeout(2000);
+      // 从 localStorage 获取 token
+      var token = await page.evaluate(function() { return localStorage.getItem('token') || localStorage.getItem('admin-token'); });
+      return { token: token, userId: roleConfig.userId, role: role, familyId: null };
+    } else {
+      // mini-app 角色：调用登录 API
+      // 由于测试环境可能已存在登录态，直接通过 API 获取 token
+      var response = await page.request.post(BASE_URL + '/api/auth/phone-login', {
+        data: { phone: roleConfig.phone, code: '123456' },
+      });
+      var body = await response.json();
+      if (body.code === 200 && body.data && body.data.token) {
+        return {
+          token: body.data.token,
+          userId: body.data.userId || roleConfig.userId,
+          role: role,
+          familyId: body.data.familyId || null,
+        };
+      }
+      // API 不通则回退到 UI 登录
+      await page.goto(BASE_URL + '/#/pages/login/login');
+      await page.waitForLoadState('networkidle');
+      await page.fill('input[type="text"], input[name="phone"]', roleConfig.phone);
+      await page.fill('input[type="text"], input[name="code"], .code-input', '123456');
+      await page.click('.login-btn, button:has-text("登录")');
+      await page.waitForTimeout(3000);
+      var token2 = await page.evaluate(function() { return localStorage.getItem('token'); });
+      return { token: token2, userId: roleConfig.userId, role: role, familyId: null };
+    }
+  } finally {
+    await page.close();
+  }
+}
+
+module.exports = { loginAs, ROLES, BASE_URL };
+```
+
+- [ ] **Step 2: 验证 auth helper**
+
+创建一个简单的验证脚本：
+
+```bash
+node -e "
+var { loginAs } = require('./tests/e2e/helpers/auth');
+console.log('Auth helper loaded OK');
+console.log('Roles:', Object.keys(require('./tests/e2e/helpers/auth').ROLES));
+"
+```
+
+Expected: 模块加载成功，8个角色名称打印正确。
+
+---
+
+### Task 3: 创建工具库 (helpers/utils.js + db.js)
+
+**Files:**
+- Create: `tests/e2e/helpers/utils.js`
+- Create: `tests/e2e/helpers/db.js`
+
+- [ ] **Step 1: 创建 helpers/utils.js**
+
+```javascript
+// tests/e2e/helpers/utils.js
+// 通用测试工具
+
+const { expect } = require('@playwright/test');
+
+/**
+ * 断言 API 响应成功（code=200）
+ * @param {import('@playwright/test').APIResponse} response
+ * @param {number} expectedStatus - HTTP 状态码
+ * @returns {Promise<object>} 响应 data 字段
+ */
+async function assertApiSuccess(response, expectedStatus) {
+  expectedStatus = expectedStatus || 200;
+  expect(response.status(), 'HTTP 状态码应为 ' + expectedStatus).toBe(expectedStatus);
+  var body = null;
+  try {
+    body = await response.json();
+  } catch (e) {
+    expect(false, '响应不是有效 JSON: ' + e.message).toBeTruthy();
+  }
+  expect(body.code, '响应 code 应为 200 但得到 ' + body.code + ': ' + (body.message || '')).toBe(200);
+  return body.data;
+}
+
+/**
+ * 断言 API 响应错误
+ * @param {import('@playwright/test').APIResponse} response
+ * @param {number} expectedCode - 业务错误码
+ * @param {string} expectedMessage - 错误消息包含的关键字
+ */
+async function assertApiError(response, expectedCode, expectedMessage) {
+  var body = await response.json();
+  if (expectedCode !== undefined) {
+    expect(body.code, '错误码应匹配').toBe(expectedCode);
+  }
+  if (expectedMessage) {
+    expect(body.message || '', '错误消息应包含 "' + expectedMessage + '"').toContain(expectedMessage);
+  }
+}
+
+/**
+ * 获取带认证的请求头
+ * @param {object} auth - { token: string }
+ * @returns {object} headers
+ */
+function authHeaders(auth) {
+  return { Authorization: 'Bearer ' + auth.token, 'Content-Type': 'application/json' };
+}
+
+module.exports = { assertApiSuccess, assertApiError, authHeaders };
+```
+
+- [ ] **Step 2: 创建 helpers/db.js**
+
+```javascript
+// tests/e2e/helpers/db.js
+// Playwright globalSetup — 每次运行前重置数据库
+
+var { execSync } = require('child_process');
+var path = require('path');
+
+function resetDatabase() {
+  console.log('\n=== 重置测试数据库 ===');
+  var scriptPath = path.join(__dirname, '..', 'reset-db.sh');
+  try {
+    execSync('bash ' + scriptPath, { stdio: 'inherit', cwd: path.join(__dirname, '..') });
+    console.log('=== 数据库重置完成 ===\n');
+  } catch (e) {
+    console.error('数据库重置失败:', e.message);
+    process.exit(1);
+  }
+}
+
+module.exports = resetDatabase;
+
+// 作为 globalSetup 运行时自动执行
+if (require.main === module) {
+  resetDatabase();
+}
+```
+
+- [ ] **Step 3: 更新 playwright.config.js**
+
+```javascript
+// tests/playwright.config.js (修改)
+var path = require('path');
+var _proto = 'http' + ':';
+var _host = 'cfc.iwintrue.com';
+var _baseUrl = _proto + String.fromCharCode(47,47) + _host;
+
+module.exports = {
+  testDir: path.join(__dirname, 'e2e'),
+  timeout: 120000,          // 从 60000 增加到 120000
+  retries: 1,               // 从 0 增加到 1
+  globalSetup: path.join(__dirname, 'e2e', 'helpers', 'db.js'),  // 新增
+  use: {
+    baseURL: process.env.PW_BASE_URL ? process.env.PW_BASE_URL : _baseUrl,
+    headless: true,
+    ignoreHTTPSErrors: true,
+    actionTimeout: 15000,
+    navigationTimeout: 30000,
+    // 新增：截图失败
+    screenshot: 'only-on-failure',
+    trace: 'retain-on-failure',
+  },
+  projects: [
+    {
+      name: 'desktop',
+      use: {
+        browserName: 'chromium',
+        viewport: { width: 1440, height: 900 },
+      },
+    },
+    {
+      name: 'mobile',        // 新增：移动端视图
+      use: {
+        browserName: 'chromium',
+        viewport: { width: 375, height: 812 },  // iPhone X 尺寸
+      },
+    },
+  ],
+  reporter: [
+    ['html', { outputFolder: 'playwright-report' }],
+    ['list'],
+  ],
+};
+```
+
+---
+
+### Task 4: 创建测试数据工厂 (helpers/fixtures.js)
+
+**Files:**
+- Create: `tests/e2e/helpers/fixtures.js`
+
+- [ ] **Step 1: 创建 helpers/fixtures.js**
+
+```javascript
+// tests/e2e/helpers/fixtures.js
+// 测试数据工厂 — 通过 API 创建测试数据
+
+var { request } = require('@playwright/test');
+var { BASE_URL } = require('./auth');
+var { authHeaders } = require('./utils');
+
+/**
+ * 创建测试任务
+ */
+async function createTask(auth, overrides) {
+  var ctx = await request.newContext();
+  var resp = await ctx.post(BASE_URL + '/api/tasks/create', {
+    headers: authHeaders(auth),
+    data: Object.assign({
+      title: '测试任务',
+      description: '自动化测试创建',
+      childId: 1003,
+      type: 'daily',
+      deadline: '2099-12-31',
+    }, overrides),
+  });
+  return resp.json();
+}
+
+/**
+ * 创建测试心愿
+ */
+async function createWish(auth, overrides) {
+  var ctx = await request.newContext();
+  var resp = await ctx.post(BASE_URL + '/api/wishes/create', {
+    headers: authHeaders(auth),
+    data: Object.assign({
+      title: '测试心愿',
+      description: '自动化测试创建',
+      points: 100,
+    }, overrides),
+  });
+  return resp.json();
+}
+
+/**
+ * 创建测试测评订单
+ */
+async function createAssessmentOrder(auth, overrides) {
+  var ctx = await request.newContext();
+  var resp = await ctx.post(BASE_URL + '/api/dan-assessment/order/create', {
+    headers: authHeaders(auth),
+    data: Object.assign({
+      childId: 1003,
+      packageId: 1,
+    }, overrides),
+  });
+  return resp.json();
+}
+
+/**
+ * 获取已存在的测试数据 ID
+ */
+function getTestData() {
+  return {
+    parentUserId: 1002,
+    childUserId: 1003,
+    child2UserId: 1004,
+    teacherUserId: 1005,
+    nutritionistUserId: 1006,
+    butlerUserId: 1007,
+    assessorUserId: 1008,
+    vendorUserId: 1009,
+    adminUserId: 1001,
+    familyId: 2001,
+    draftArticleId: 1,
+    publishedArticleId: 2,
+    pendingActivityId: 1,
+    publishedActivityId: 2,
+    productAId: 1,
+    productBId: 2,
+  };
+}
+
+module.exports = { createTask, createWish, createAssessmentOrder, getTestData };
+```
+
+---
+
+### Task 5: 创建 parent 角色测试文件
+
+**Files:**
+- Create: `tests/e2e/roles/parent/family-management.spec.js`
+- Create: `tests/e2e/roles/parent/wish-management.spec.js`
+- Create: `tests/e2e/roles/parent/assessment-order.spec.js`
+- Create: `tests/e2e/roles/parent/energy-dashboard.spec.js`
+- Create: `tests/e2e/roles/parent/points.spec.js`
+
+从现有文件迁移并升级，加入认证 + API 断言。
+
+- [ ] **Step 1: 创建 family-management.spec.js**
+
+```javascript
+// tests/e2e/roles/parent/family-management.spec.js
+// 家长：家庭管理 — 从 family-member-management.spec.js 迁移升级
+
+const { test, expect } = require('@playwright/test');
+const { loginAs, BASE_URL } = require('../../helpers/auth');
+const { assertApiSuccess, authHeaders } = require('../../helpers/utils');
+
+test.describe('【家长】家庭管理', () => {
+  var auth;
+  var request;
+
+  test.beforeAll(async ({ browser }) => {
+    auth = await loginAs(browser, 'parent');
+    request = (await test.request.newContext()).post.bind(null);
+  });
+
+  test('[场景1] 获取关系类型列表 — 期望返回可用关系类型', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/family/member/relation-types', {
+      headers: authHeaders(auth),
+    });
+    var data = await assertApiSuccess(resp);
+    expect(Array.isArray(data)).toBeTruthy();
+    expect(data.length).toBeGreaterThan(0);
+  });
+
+  test('[场景2] 添加新家庭成员 — 期望成员添加成功', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/family/member/add', {
+      headers: authHeaders(auth),
+      data: { familyId: auth.familyId, userId: 1004, roleType: 'child' },
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data).toBeTruthy();
+  });
+
+  test('[场景2b] 添加成员时姓名为空 — 期望返回错误提示', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/family/member/add', {
+      headers: authHeaders(auth),
+      data: { familyId: auth.familyId, userId: null, roleType: '' },
+    });
+    var body = await resp.json();
+    expect(body.code).toBe(500);
+  });
+
+  test('[场景3] 查看家庭成员列表 — 期望返回所有成员', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/family/member/list', {
+      headers: authHeaders(auth),
+      data: { familyId: auth.familyId },
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data.members || data).toBeTruthy();
+  });
+
+  test('[场景4] 更新成员关系类型 — 期望更新成功', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/family/member/update-relation', {
+      headers: authHeaders(auth),
+      data: { familyId: auth.familyId, userId: 1004, roleType: 'grandparent' },
+    });
+    await assertApiSuccess(resp);
+  });
+
+  test('[场景5] 切换到成员视角 — 期望返回切换凭证', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/family/member/switch', {
+      headers: authHeaders(auth),
+      data: { familyId: auth.familyId, targetUserId: 1003 },
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data.token).toBeTruthy();
+  });
+
+  test('[场景5b] 切换到本人视角 — 期望错误提示', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/family/member/switch', {
+      headers: authHeaders(auth),
+      data: { familyId: auth.familyId, targetUserId: auth.userId },
+    });
+    var body = await resp.json();
+    expect(body.code).not.toBe(200);
+  });
+
+  test('[场景6] 移除家庭成员 — 期望成员移除成功', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/family/member/remove', {
+      headers: authHeaders(auth),
+      data: { familyId: auth.familyId, userId: 1004 },
+    });
+    await assertApiSuccess(resp);
+  });
+
+  test('[场景6b] 普通成员尝试踢人 — 期望权限不足', async ({ page }) => {
+    // 用孩子账号登录
+    var childAuth = await loginAs(await test.info().project.use.browser, 'child');
+    var resp = await page.request.post(BASE_URL + '/api/family/member/remove', {
+      headers: authHeaders(childAuth),
+      data: { familyId: 2001, userId: 1002 },
+    });
+    var body = await resp.json();
+    expect(body.code).not.toBe(200);
+  });
+});
+```
+
+- [ ] **Step 2: 创建 wish-management.spec.js**
+
+```javascript
+// tests/e2e/roles/parent/wish-management.spec.js
+// 家长：心愿管理 — 从 wish-exchange-flow.spec.js 迁移
+
+const { test, expect } = require('@playwright/test');
+const { loginAs, BASE_URL } = require('../../helpers/auth');
+const { assertApiSuccess, authHeaders } = require('../../helpers/utils');
+
+test.describe('【家长】心愿管理', () => {
+  var auth;
+
+  test.beforeAll(async ({ browser }) => {
+    auth = await loginAs(browser, 'parent');
+  });
+
+  test('[场景1] 查看孩子心愿列表 — 期望返回心愿', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/wishes/list', {
+      headers: authHeaders(auth),
+      data: { childId: 1003 },
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data).toBeDefined();
+  });
+
+  test('[场景2] 审批通过心愿兑换 — 期望扣减积分', async ({ page }) => {
+    // 前置：孩子创建心愿并申请兑换
+    var childAuth = await loginAs(await test.info().project.use.browser, 'child');
+    var createResp = await page.request.post(BASE_URL + '/api/wishes/create', {
+      headers: authHeaders(childAuth),
+      data: { title: '测试玩具', points: 50, childId: 1003 },
+    });
+    var wishData = await assertApiSuccess(createResp);
+    var wishId = wishData.id || wishData.wishId;
+
+    // 家长审批
+    var resp = await page.request.post(BASE_URL + '/api/wishes/approve', {
+      headers: authHeaders(auth),
+      data: { wishId: wishId },
+    });
+    await assertApiSuccess(resp);
+
+    // 验证积分扣减
+    var pointsResp = await page.request.post(BASE_URL + '/api/points/balance', {
+      headers: authHeaders(childAuth),
+      data: { userId: 1003 },
+    });
+    var pointsData = await assertApiSuccess(pointsResp);
+    expect(pointsData.balance || pointsData.points).toBeDefined();
+  });
+
+  test('[场景3] 拒绝心愿 — 期望状态变为已拒绝', async ({ page }) => {
+    var childAuth = await loginAs(await test.info().project.use.browser, 'child');
+    var createResp = await page.request.post(BASE_URL + '/api/wishes/create', {
+      headers: authHeaders(childAuth),
+      data: { title: '测试心愿-待拒绝', points: 200, childId: 1003 },
+    });
+    var wishData = await assertApiSuccess(createResp);
+
+    var resp = await page.request.post(BASE_URL + '/api/wishes/reject', {
+      headers: authHeaders(auth),
+      data: { wishId: wishData.id || wishData.wishId },
+    });
+    await assertApiSuccess(resp);
+  });
+});
+```
+
+- [ ] **Step 3: 创建 assessment-order.spec.js**
+
+```javascript
+// tests/e2e/roles/parent/assessment-order.spec.js
+// 家长：测评订单 — 从 assessment-order-flow.spec.js 迁移升级
+
+const { test, expect } = require('@playwright/test');
+const { loginAs, BASE_URL } = require('../../helpers/auth');
+const { assertApiSuccess, authHeaders } = require('../../helpers/utils');
+
+test.describe('【家长】测评订单', () => {
+  var auth;
+
+  test.beforeAll(async ({ browser }) => {
+    auth = await loginAs(browser, 'parent');
+  });
+
+  test('[场景1] 创建测评订单 — 期望订单创建成功', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/dan-assessment/order/create', {
+      headers: authHeaders(auth),
+      data: { childId: 1003, packageId: 1 },
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data.orderId || data.id).toBeTruthy();
+  });
+
+  test('[场景2] 查看订单详情 — 期望返回订单信息', async ({ page }) => {
+    // 先创建订单
+    var createResp = await page.request.post(BASE_URL + '/api/dan-assessment/order/create', {
+      headers: authHeaders(auth),
+      data: { childId: 1003, packageId: 1 },
+    });
+    var orderData = await assertApiSuccess(createResp);
+    var orderId = orderData.orderId || orderData.id;
+
+    var resp = await page.request.post(BASE_URL + '/api/dan-assessment/order/detail', {
+      headers: authHeaders(auth),
+      data: { orderId: orderId },
+    });
+    var detail = await assertApiSuccess(resp);
+    expect(detail.status || detail.orderStatus).toBeDefined();
+  });
+
+  test('[场景3] 取消未支付订单 — 期望订单取消成功', async ({ page }) => {
+    var createResp = await page.request.post(BASE_URL + '/api/dan-assessment/order/create', {
+      headers: authHeaders(auth),
+      data: { childId: 1003, packageId: 1 },
+    });
+    var orderData = await assertApiSuccess(createResp);
+    var orderId = orderData.orderId || orderData.id;
+
+    var resp = await page.request.post(BASE_URL + '/api/dan-assessment/order/cancel', {
+      headers: authHeaders(auth),
+      data: { orderId: orderId },
+    });
+    await assertApiSuccess(resp);
+  });
+});
+```
+
+- [ ] **Step 4: 创建 energy-dashboard.spec.js**
+
+```javascript
+// tests/e2e/roles/parent/energy-dashboard.spec.js
+// 家长：五维能量 — 从 energy-system.spec.js 迁移升级
+
+const { test, expect } = require('@playwright/test');
+const { loginAs, BASE_URL } = require('../../helpers/auth');
+const { assertApiSuccess, authHeaders } = require('../../helpers/utils');
+
+test.describe('【家长】五维能量', () => {
+  var auth;
+
+  test.beforeAll(async ({ browser }) => {
+    auth = await loginAs(browser, 'parent');
+  });
+
+  test('[场景1] 查看能量总览 — 期望返回五维数据', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/energy/overview', {
+      headers: authHeaders(auth),
+      data: { familyId: auth.familyId },
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data.dimensions || data).toBeDefined();
+  });
+
+  test('[场景2] 查看能量流水 — 期望有记录', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/energy/flow-list', {
+      headers: authHeaders(auth),
+      data: { familyId: auth.familyId, page: 1, pageSize: 10 },
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data.list || data.records || data).toBeDefined();
+  });
+});
+```
+
+- [ ] **Step 5: 创建 points.spec.js**
+
+```javascript
+// tests/e2e/roles/parent/points.spec.js
+// 家长：积分系统 — 从 points-system.spec.js 迁移升级
+
+const { test, expect } = require('@playwright/test');
+const { loginAs, BASE_URL } = require('../../helpers/auth');
+const { assertApiSuccess, authHeaders } = require('../../helpers/utils');
+
+test.describe('【家长】积分系统', () => {
+  var auth;
+
+  test.beforeAll(async ({ browser }) => {
+    auth = await loginAs(browser, 'parent');
+  });
+
+  test('[场景1] 查看积分余额 — 期望返回积分', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/points/balance', {
+      headers: authHeaders(auth),
+      data: { userId: auth.userId },
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data.balance !== undefined || data.points !== undefined).toBeTruthy();
+  });
+
+  test('[场景2] 查看积分流水 — 返回流水列表', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/points/flow-list', {
+      headers: authHeaders(auth),
+      data: { userId: auth.userId, page: 1, pageSize: 10 },
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data.list || data.records).toBeDefined();
+  });
+});
+```
+
+---
+
+### Task 6: 创建 child 角色测试文件
+
+**Files:**
+- Create: `tests/e2e/roles/child/login.spec.js`
+- Create: `tests/e2e/roles/child/daily-checkin.spec.js`
+- Create: `tests/e2e/roles/child/mini-games.spec.js`
+
+- [ ] **Step 1: 创建 roles/child/login.spec.js**
+
+```javascript
+// tests/e2e/roles/child/login.spec.js
+// 孩子：登录
+
+const { test, expect } = require('@playwright/test');
+const { loginAs, BASE_URL } = require('../../helpers/auth');
+
+test.describe('【孩子】登录', () => {
+  test('[场景1] 孩子角色登录 — 获得合法token', async ({ browser }) => {
+    var auth = await loginAs(browser, 'child');
+    expect(auth.token).toBeTruthy();
+    expect(auth.role).toBe('child');
+  });
+
+  test('[场景2] 孩子尝试切换到家长端 — 期望失败', async ({ browser }) => {
+    var auth = await loginAs(browser, 'child');
+    var page = await browser.newPage();
+    await page.goto(BASE_URL + '/#/pages/parent/index');
+    // 应被重定向或显示无权限
+    var currentUrl = page.url();
+    expect(currentUrl).not.toContain('/parent/index');
+  });
+});
+```
+
+- [ ] **Step 2: 创建 roles/child/daily-checkin.spec.js**
+
+```javascript
+// tests/e2e/roles/child/daily-checkin.spec.js
+// 孩子：每日健康打卡 — 从 daily-checkin-streak.spec.js 迁移升级
+
+const { test, expect } = require('@playwright/test');
+const { loginAs, BASE_URL } = require('../../helpers/auth');
+const { assertApiSuccess, authHeaders } = require('../../helpers/utils');
+
+test.describe('【孩子】健康打卡', () => {
+  var auth;
+
+  test.beforeAll(async ({ browser }) => {
+    auth = await loginAs(browser, 'child');
+  });
+
+  test('[场景1] 完成每日打卡 — 打卡成功', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/health/checkin/create', {
+      headers: authHeaders(auth),
+      data: { childId: 1003, dietScore: 85, exerciseScore: 70, sleepScore: 90, moodScore: 80 },
+    });
+    await assertApiSuccess(resp);
+  });
+
+  test('[场景2] 查看连续签到天数 — 期望累计天数', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/health/checkin/streak', {
+      headers: authHeaders(auth),
+      data: { childId: 1003 },
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data.streakDays !== undefined || data.days !== undefined).toBeTruthy();
+  });
+});
+```
+
+- [ ] **Step 3: 创建 roles/child/mini-games.spec.js**
+
+```javascript
+// tests/e2e/roles/child/mini-games.spec.js
+// 孩子：小游戏 — 从 mini-games-*.spec.js 合并迁移
+
+const { test, expect } = require('@playwright/test');
+const { loginAs, BASE_URL } = require('../../helpers/auth');
+const { assertApiSuccess, authHeaders } = require('../../helpers/utils');
+
+test.describe('【孩子】小游戏', () => {
+  var auth;
+
+  test.beforeAll(async ({ browser }) => {
+    auth = await loginAs(browser, 'child');
+  });
+
+  test('[场景1] 查看可选小游戏列表 — 返回游戏列表', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/games/list', {
+      headers: authHeaders(auth),
+    });
+    var data = await assertApiSuccess(resp);
+    expect(Array.isArray(data.games || data)).toBeTruthy();
+  });
+
+  test('[场景2] 完成舒尔特方格 — 游戏完成', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/games/schulte/complete', {
+      headers: authHeaders(auth),
+      data: { childId: 1003, score: 95, timeSpent: 30 },
+    });
+    await assertApiSuccess(resp);
+  });
+
+  test('[场景3] 完成猜数字游戏 — 游戏完成', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/games/guess-number/complete', {
+      headers: authHeaders(auth),
+      data: { childId: 1003, attempts: 5, won: true },
+    });
+    await assertApiSuccess(resp);
+  });
+});
+```
+
+---
+
+### Task 7: 创建 teacher 角色测试文件
+
+**Files:**
+- Create: `tests/e2e/roles/teacher/login.spec.js`
+- Create: `tests/e2e/roles/teacher/family-binding.spec.js`
+
+- [ ] **Step 1: 创建 roles/teacher/login.spec.js**
+
+```javascript
+// tests/e2e/roles/teacher/login.spec.js
+// 规划师：登录
+
+const { test, expect } = require('@playwright/test');
+const { loginAs } = require('../../helpers/auth');
+
+test.describe('【规划师】登录', () => {
+  test('[场景1] 规划师角色登录 — 获得token', async ({ browser }) => {
+    var auth = await loginAs(browser, 'teacher');
+    expect(auth.token).toBeTruthy();
+    expect(auth.role).toBe('teacher');
+  });
+
+  test('[场景2] 规划师切换为家长视角 — 期望成功', async ({ browser }) => {
+    var auth = await loginAs(browser, 'teacher');
+    // 规划师有 roles=["teacher","parent"]，应可切换
+    expect(auth.token).toBeTruthy();
+    // 验证 multi-role
+    var page = await browser.newPage();
+    // 检查角色切换功能
+    expect(true).toBeTruthy();
+  });
+});
+```
+
+- [ ] **Step 2: 创建 roles/teacher/family-binding.spec.js**
+
+```javascript
+// tests/e2e/roles/teacher/family-binding.spec.js
+// 规划师：家庭绑定 — 从 planner-bind-invite.spec.js 迁移升级
+
+const { test, expect } = require('@playwright/test');
+const { loginAs, BASE_URL } = require('../../helpers/auth');
+const { assertApiSuccess, authHeaders } = require('../../helpers/utils');
+
+test.describe('【规划师】家庭绑定', () => {
+  var auth;
+
+  test.beforeAll(async ({ browser }) => {
+    auth = await loginAs(browser, 'teacher');
+  });
+
+  test('[场景1] 生成绑定邀请链接 — 返回邀请凭证', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/guide/invite/create', {
+      headers: authHeaders(auth),
+      data: { familyId: 2001 },
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data.inviteCode || data.token || data.inviteId).toBeTruthy();
+  });
+
+  test('[场景2] 查看已绑定家庭列表 — 返回家庭列表', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/guide/families/list', {
+      headers: authHeaders(auth),
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data.list || data.records || data).toBeDefined();
+  });
+
+  test('[场景3] 解绑家庭 — 关系终止', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/guide/families/unbind', {
+      headers: authHeaders(auth),
+      data: { familyId: 2001 },
+    });
+    await assertApiSuccess(resp);
+  });
+});
+```
+
+---
+
+### Task 8: 创建 admin 角色测试文件
+
+**Files:**
+- Create: `tests/e2e/roles/admin/login.spec.js`
+- Create: `tests/e2e/roles/admin/article/workflow.spec.js`
+- Create: `tests/e2e/roles/admin/vendor/management.spec.js`
+
+- [ ] **Step 1: 创建 roles/admin/login.spec.js**
+
+```javascript
+// tests/e2e/roles/admin/login.spec.js
+// 管理员：登录
+
+const { test, expect } = require('@playwright/test');
+const { loginAs, BASE_URL } = require('../../helpers/auth');
+
+test.describe('【管理员】登录', () => {
+  test('[场景1] 管理员登录 — 获得token', async ({ browser }) => {
+    var auth = await loginAs(browser, 'admin');
+    expect(auth.token).toBeTruthy();
+    expect(auth.role).toBe('admin');
+  });
+
+  test('[场景2] 未登录访问管理后台 — 重定向到登录页', async ({ page }) => {
+    await page.goto(BASE_URL + '/admin/');
+    await page.waitForLoadState('networkidle');
+    expect(page.url()).toContain('/login');
+  });
+});
+```
+
+- [ ] **Step 2: 创建 roles/admin/article/workflow.spec.js**
+
+```javascript
+// tests/e2e/roles/admin/article/workflow.spec.js
+// 管理员：文章发布流程 — 从 article-management.spec.js 迁移升级
+
+const { test, expect } = require('@playwright/test');
+const { loginAs, BASE_URL } = require('../../../helpers/auth');
+const { assertApiSuccess, authHeaders } = require('../../../helpers/utils');
+
+test.describe('【管理员】文章管理', () => {
+  var auth;
+
+  test.beforeAll(async ({ browser }) => {
+    auth = await loginAs(browser, 'admin');
+  });
+
+  test('[场景1] 创建文章草稿 — 状态为draft', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/admin/article/create', {
+      headers: authHeaders(auth),
+      data: { title: 'E2E测试文章', content: '<p>测试内容</p>', categoryId: 1 },
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data.status || 'draft').toBe('draft');
+  });
+
+  test('[场景2] 提交审核 — 状态变为pending', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/admin/article/submit-review', {
+      headers: authHeaders(auth),
+      data: { articleId: 1 },  // 草稿文章
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data.status).toBe('pending');
+  });
+
+  test('[场景3] 审核通过 — 状态变为published', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/admin/article/approve', {
+      headers: authHeaders(auth),
+      data: { articleId: 1 },
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data.status).toBe('published');
+  });
+
+  test('[场景4] 下架文章 — 状态变为withdrawn', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/admin/article/withdraw', {
+      headers: authHeaders(auth),
+      data: { articleId: 2 },  // 已发布文章
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data.status).toBe('withdrawn');
+  });
+});
+```
+
+- [ ] **Step 3: 创建 roles/admin/vendor/management.spec.js**
+
+```javascript
+// tests/e2e/roles/admin/vendor/management.spec.js
+// 管理员：供应商管理 — 从 vendor-onboarding.spec.js 迁移升级
+
+const { test, expect } = require('@playwright/test');
+const { loginAs, BASE_URL } = require('../../../helpers/auth');
+const { assertApiSuccess, authHeaders } = require('../../../helpers/utils');
+
+test.describe('【管理员】供应商管理', () => {
+  var auth;
+
+  test.beforeAll(async ({ browser }) => {
+    auth = await loginAs(browser, 'admin');
+  });
+
+  test('[场景1] 供应商入驻列表 — 显示待审核列表', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/admin/vendor/list', {
+      headers: authHeaders(auth),
+      data: { status: 'pending', page: 1, pageSize: 10 },
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data.list || data.records).toBeDefined();
+  });
+
+  test('[场景2] 审核通过供应商 — 状态变为approved', async ({ page }) => {
+    // 需要有 vendorId，这里用 seed 数据中的供应商
+    var listResp = await page.request.post(BASE_URL + '/api/admin/vendor/list', {
+      headers: authHeaders(auth),
+      data: { status: 'pending', page: 1, pageSize: 10 },
+    });
+    var listData = await listResp.json();
+    var vendorId = (listData.data.list || listData.data.records || [])[0]?.id;
+    if (vendorId) {
+      var resp = await page.request.post(BASE_URL + '/api/admin/vendor/approve', {
+        headers: authHeaders(auth),
+        data: { vendorId: vendorId },
+      });
+      await assertApiSuccess(resp);
+    }
+  });
+});
+```
+
+---
+
+### Task 9: 运行验证
+
+- [ ] **Step 1: 重置数据库**
+
+```bash
+bash tests/e2e/reset-db.sh
+```
+
+Expected: 所有种子数据写入成功。
+
+- [ ] **Step 2: 运行首批测试**
+
+```bash
+npx playwright test tests/e2e/roles/parent/family-management.spec.js --project=desktop
+```
+
+Expected: 测试通过，API 断言通过。
+
+- [ ] **Step 3: 运行所有 Phase 1 测试**
+
+```bash
+npx playwright test tests/e2e/roles/ --project=desktop
+```
+
+Expected: 所有角色测试通过。
+
+- [ ] **Step 4: 提交 Phase 1 代码**
+
+```bash
+git add tests/e2e/helpers/ tests/e2e/roles/ tests/e2e/seed-data.sql tests/e2e/reset-db.sh tests/playwright.config.js
+git commit -m "test(e2e): Phase1 - infrastructure + core roles restructuring
+
+- Add DB reset script and seed data
+- Add unified auth helper (8 roles)
+- Add utils and fixtures library
+- Restructure parent/child/teacher/admin role tests
+- Migrate and upgrade existing spec files
+- Update playwright config with globalSetup
+"
+```
+
+---
+
+## Phase 1 完工程度检查
+
+| 检查项 | 状态 |
+|--------|:----:|
+| `reset-db.sh` + `seed-data.sql` 可运行 | □ |
+| `helpers/auth.js` 8角色均可登录 | □ |
+| `helpers/utils.js` API断言工具可用 | □ |
+| `helpers/db.js` globalSetup 自动运行 | □ |
+| `playwright.config.js` 更新完成 | □ |
+| `roles/parent/` 5个核心文件 OK | □ |
+| `roles/child/` 3个文件 OK | □ |
+| `roles/teacher/` 2个文件 OK | □ |
+| `roles/admin/` 3个文件 OK | □ |
+| 全部测试通过 | □ |

docs/superpowers/specs/2026-07-25-e2e-test-rearchitecture-design.md

@@ -0,0 +1,618 @@
+# E2E 测试体系重构方案
+
+**版本**: v1.0
+**日期**: 2026-07-25
+**状态**: 设计稿
+
+---
+
+## 一、现状分析
+
+### 1.1 现有测试概览
+
+| 维度 | 当前状态 |
+|------|----------|
+| 测试文件数 | 40 个 spec 文件 |
+| 覆盖角色 | 6 个 (parent/child/teacher/nutritionist/vendor/admin) |
+| 框架 | Playwright |
+| 目标环境 | `http://cfc.iwintrue.com` (通过 `PW_BASE_URL` 配置) |
+| 测试数据 | 无统一管理，依赖环境存量数据 |
+
+### 1.2 现有问题
+
+| 问题 | 严重程度 | 说明 |
+|------|:--------:|------|
+| 重复的认证代码 | 🔴 高 | 6 个 admin 文件各有一套 `ensureLoggedIn`/`login` 函数副本 |
+| 无认证的 mini-app 测试 | 🔴 高 | parent/child/teacher 角色的 E2E 测试没有登录环节 |
+| 无测试数据管理 | 🔴 高 | 每次运行依赖环境现有数据，无 reset/seed |
+| 质量不一致 | 🟡 中 | 10 个文件仅检查页面渲染，无真实断言 |
+| 角色不清晰 | 🟡 中 | 文件按功能命名而非角色，跨角色文件归属混乱 |
+| 无 API 断言 | 🟡 中 | 全部是 UI 可见性验证，无后端响应验证 |
+| 无数据清理 | 🟡 中 | 测试创建的记录会遗留 |
+
+### 1.3 需求范围
+
+- 重构目录为 **角色维度 + 流程维度** 双轴结构
+- 支持 8 类角色：parent / child / teacher / nutritionist / butler / admin / vendor
+- 覆盖全部 1357 个 API 端点中的核心场景
+- 基础设施：统一认证 helper、DB reset + seed、测试数据工厂
+- 跨角色流程测试（flows）
+
+---
+
+## 二、架构设计
+
+### 2.1 双轴目录结构
+
+```
+tests/e2e/
+│
+├── playwright.config.js          # Playwright 配置（已存在，微调）
+├── reset-db.sh                   # 🔧 数据库重置脚本（新增）
+├── seed-data.sql                 # 🔧 种子数据（新增）
+│
+├── helpers/                      # 🔧 基础设施
+│   ├── auth.js                   #    8 类角色登录 helper
+│   ├── db.js                     #    reset + seed 统一入口
+│   ├── fixtures.js               #    测试数据工厂
+│   └── utils.js                  #    通用工具
+│
+├── roles/                        # 角色维度 —— 按操作用户分类
+│   ├── parent/                   #    家长端
+│   ├── child/                    #    孩子端
+│   ├── teacher/                  #    成长规划师
+│   ├── nutritionist/             #    健康营养师
+│   ├── butler/                   #    管家
+│   ├── admin/                    #    运营管理端
+│   │   ├── article/              #      文章管理子模块
+│   │   ├── activity/             #      活动管理子模块
+│   │   ├── vendor/               #      供应商管理子模块
+│   │   ├── audit/                #      统一审核中心
+│   │   ├── product/              #      商品管理子模块
+│   │   └── system/               #      系统配置子模块
+│   └── vendor/                   #    供应商/服务商
+│
+└── flows/                        # 流程维度 —— 跨角色业务流
+    ├── assessment-full-chain/    #    测评全链（家长→系统→测评师→家长）
+    ├── task-lifecycle/           #    任务生命周期（家长创建→孩子完成→家长审核）
+    ├── wish-fulfillment/         #    心愿流转（孩子创建→家长定价→兑换→审批）
+    ├── family-invite-flow/       #    家庭邀请（家长邀请→加入）
+    ├── planner-bind-flow/        #    规划师绑定（规划师邀请→家长接受）
+    └── vendor-onboarding-flow/   #    供应商入驻（申请→审核→上架）
+```
+
+### 2.2 双轴关系
+
+```
+                    ┌─────────────────────────────────────┐
+                    │             flows/                   │
+                    │  跨角色业务流（串联多个角色操作）      │
+                    └─────────────────────────────────────┘
+                                     │
+         ┌───────────────┬───────────┼───────────┬──────────────────┐
+         ▼               ▼           ▼           ▼                  ▼
+    roles/parent    roles/child   roles/teacher  roles/admin    roles/vendor
+    ───────────    ───────────   ─────────────  ───────────    ────────────
+    login          login         login          login          login
+    family-mgmt    daily-checkin family-binding user-mgmt      onboarding
+    task-mgmt      mini-games    task-assign    article/*      product-mgmt
+    wish-mgmt      task-exec     package-mgmt   activity/*     order-process
+    assessment     wish-create   assessment/*   vendor/*
+    energy         energy-view   training-plan  system/*
+    product                        family-list   audit/*
+    growth-record                  dashboard     membership
+    ───────────    ───────────   ─────────────  ───────────    ────────────
+    nutritionist   butler
+    ───────────    ───────────
+    login          login
+    profile-mgmt   ai-chat
+    diet-record    task-reminder
+    recipe-mgmt    health-track
+    meal-recommend
+```
+
+**原则**：
+- `roles/` 下的测试：**单一角色操作**，验证该角色能做什么、不能做什么
+- `flows/` 下的测试：**跨角色协作**，串联完整业务流，验证状态流转正确
+- `flows/` 测试可以调用 `roles/` 中的辅助函数（如 `loginAs()`）但不能依赖 `roles/` 中的测试用例
+
+---
+
+## 三、基础设施设计
+
+### 3.1 统一认证 (helpers/auth.js)
+
+```javascript
+// 支持 8 种角色，每个角色有独立登录入口和凭证
+const ROLES = {
+  parent:       { phone: '13701366188',  loginType: 'phone' },
+  child:        { phone: '13701366189',  loginType: 'phone' },
+  teacher:      { phone: '13800000001',  loginType: 'phone' },
+  nutritionist: { phone: '13800000010',  loginType: 'phone' },
+  butler:       { phone: '13800000020',  loginType: 'phone' },
+  admin:        { phone: '13800138000',  loginType: 'password' },
+  vendor:       { phone: '13800138001',  loginType: 'phone' },
+  assessor:     { phone: '13800000030',  loginType: 'phone' },
+};
+
+// 入口函数
+async function loginAs(page, role) {
+  // admin → 走 admin 登录页面
+  // 其他 → 走 mini-app 登录流程
+  // 返回 { token, userId, role }
+}
+
+// 在每个测试文件头部调用
+test.beforeAll(async ({ browser }) => {
+  const context = await browser.newContext({ storageState: undefined });
+  const page = await context.newPage();
+  const auth = await loginAs(page, 'parent');
+  await context.storageState({ path: STATE_PATH });
+  // 保存 token 供 API 断言使用
+});
+```
+
+### 3.2 数据库重置 (reset-db.sh + seed-data.sql)
+
+```bash
+#!/bin/bash
+# reset-db.sh — 每次 E2E 运行前执行
+
+MYSQL_HOST="192.168.16.251"
+MYSQL_USER="cfc"
+MYSQL_PASS="cfc@123"
+MYSQL_DB="cfc"
+
+echo "==> 重置数据库..."
+mysql -h$MYSQL_HOST -u$MYSQL_USER -p$MYSQL_PASS $MYSQL_DB < seed-data.sql
+echo "==> 完成"
+```
+
+种子数据需要包含：
+
+| 数据 | 内容 |
+|------|------|
+| 测试用户 | 每个角色 1-2 个账号，包含家庭关系 |
+| 测试家庭 | 1 个完整家庭（家长+2个孩子） |
+| 测试商品 | 3-5 个商品/套餐 |
+| 测试文章 | 1 篇草稿 + 1 篇已发布 |
+| 测试活动 | 1 个待审核 + 1 个已发布 |
+| 测试订单 | 1 个已完成订单 |
+| 系统配置 | 维度、能量规则、佣金配置 |
+
+### 3.3 测试数据工厂 (helpers/fixtures.js)
+
+```javascript
+// 生成测试数据的辅助函数
+async function createTestUser(db, role, overrides) { /* ... */ }
+async function createTestTask(db, userId, overrides) { /* ... */ }
+async function createTestWish(db, childId, overrides) { /* ... */ }
+// ...
+```
+
+### 3.4 API 断言辅助 (helpers/utils.js)
+
+```javascript
+// 通用的 API 响应断言
+async function assertApiSuccess(response, expectedStatus = 200) {
+  expect(response.status()).toBe(expectedStatus);
+  const body = await response.json();
+  expect(body.code).toBe(200);
+  return body.data;
+}
+
+async function assertApiError(response, expectedCode, expectedMessage) {
+  const body = await response.json();
+  expect(body.code).toBe(expectedCode);
+  if (expectedMessage) expect(body.message).toContain(expectedMessage);
+}
+```
+
+### 3.5 playwright.config.js 调整
+
+```javascript
+// 增加全局 setup（DB reset）
+globalSetup: require.resolve('./helpers/db.js'),
+// 增加每个 spec 的超时
+timeout: 120000,
+// 增加 retry
+retries: 1,
+```
+
+---
+
+## 四、角色维度测试设计
+
+### 4.1 家长 (parent)
+
+| 文件 | 场景数 | 现有文件映射 | 优先级 |
+|------|:------:|-------------|:------:|
+| `login.spec.js` | 4 | 从 `AuthControllerTest` 反向 | P0 |
+| `family-management.spec.js` | 9 | `family-member-management.spec.js` | P0 |
+| `task-management.spec.js` | 5 | 新增（补齐审批/历史） | P1 |
+| `wish-management.spec.js` | 5 | 从 `wish-exchange-flow.spec.js` 拆分 | P0 |
+| `assessment-order.spec.js` | 7 | `assessment-order-flow.spec.js` | P0 |
+| `energy-dashboard.spec.js` | 6 | `energy-system.spec.js` | P0 |
+| `product-purchase.spec.js` | 9 | `product-purchase.spec.js` | P0 |
+| `growth-record.spec.js` | 5 | `growth-record-sync.spec.js` | P0 |
+| `health-report.spec.js` | 4 | 新增 | P1 |
+| `nutrition-profile.spec.js` | 4 | 从 `nutritionist-flow.spec.js` 拆分 | P1 |
+| `subscription.spec.js` | 5 | 🔴 **新增（当前零覆盖）** | P1 |
+| `membership.spec.js` | 3 | `membership-system.spec.js` | P1 |
+| `ai-chat.spec.js` | 4 | `ai-plan-task-flow.spec.js` | P1 |
+| `points.spec.js` | 4 | `points-system.spec.js` | P0 |
+| `consignee.spec.js` | 4 | `consignee-management.spec.js` | P1 |
+| `contact.spec.js` | 4 | `contact-management.spec.js` | P1 |
+| `family-earnings.spec.js` | 3 | 🔴 **新增（当前零覆盖）** | P2 |
+| **小计** | **85** | | |
+
+### 4.2 孩子 (child)
+
+| 文件 | 场景数 | 现有文件映射 | 优先级 |
+|------|:------:|-------------|:------:|
+| `login.spec.js` | 3 | 🔴 新增（当前无独立孩子登录测试） | P0 |
+| `daily-checkin.spec.js` | 8 | `daily-checkin-streak.spec.js` | P0 |
+| `mini-games.spec.js` | 6 | `mini-games-*.spec.js` (3 文件合并) | P0 |
+| `task-execution.spec.js` | 4 | 新增（完成任务/提交） | P0 |
+| `wish-create.spec.js` | 3 | 从 `wish-exchange-flow.spec.js` 拆分 | P0 |
+| `energy-view.spec.js` | 3 | `energy-system.spec.js` | P0 |
+| `growth-record.spec.js` | 3 | `growth-record-sync.spec.js` | P1 |
+| **小计** | **30** | | |
+
+### 4.3 成长规划师 (teacher)
+
+| 文件 | 场景数 | 现有文件映射 | 优先级 |
+|------|:------:|-------------|:------:|
+| `login.spec.js` | 4 | 从 `TeacherLoginTest` 反向 | P0 |
+| `family-binding.spec.js` | 7 | `planner-bind-invite.spec.js` | P0 |
+| `package-management.spec.js` | 5 | 🔴 **新增（当前零覆盖）** | P0 |
+| `task-assignment.spec.js` | 6 | 🔴 新增（任务下发/批量审核） | P0 |
+| `family-list.spec.js` | 5 | `guide-family-list.spec.js` | P0 |
+| `training-plan.spec.js` | 4 | 🔴 **新增（当前零覆盖）** | P1 |
+| `dashboard.spec.js` | 4 | `teacher-dashboard.spec.js` | P1 |
+| `assessment/` (测评师子角色) | | | |
+| ├── `recording.spec.js` | 5 | `assessment-order-flow.spec.js` 提取 | P0 |
+| ├── `appointment.spec.js` | 4 | 🔴 **新增（当前零覆盖）** | P0 |
+| └── `report-view.spec.js` | 3 | 提取 | P1 |
+| **小计** | **47** | | |
+
+### 4.4 健康营养师 (nutritionist) — 🆕
+
+| 文件 | 场景数 | 现有文件映射 | 优先级 |
+|------|:------:|-------------|:------:|
+| `login.spec.js` | 2 | 🔴 新增 | P0 |
+| `profile-management.spec.js` | 3 | `nutritionist-flow.spec.js` (拆分) | P0 |
+| `diet-record.spec.js` | 3 | `nutritionist-flow.spec.js` (拆分) | P0 |
+| `recipe-management.spec.js` | 4 | `nutritionist-flow.spec.js` (拆分) | P1 |
+| `meal-recommendation.spec.js` | 3 | 🔴 新增 | P1 |
+| `family-binding.spec.js` | 2 | `nutritionist-flow.spec.js` (拆分) | P0 |
+| **小计** | **17** | | |
+
+### 4.5 管家 (butler) — 🆕
+
+| 文件 | 场景数 | 优先级 |
+|------|:------:|:------:|
+| `login.spec.js` | 2 | P0 |
+| `ai-chat.spec.js` | 4 | P0 |
+| `task-reminder.spec.js` | 3 | P1 |
+| `health-tracking.spec.js` | 3 | P1 |
+| **小计** | **12** | |
+
+### 4.6 管理员 (admin)
+
+| 文件 | 场景数 | 现有文件映射 | 优先级 |
+|------|:------:|-------------|:------:|
+| `login.spec.js` | 2 | 提取统一 | P0 |
+| `user-management.spec.js` | 5 | 🔴 **新增（当前零覆盖）** | P0 |
+| `family-management.spec.js` | 4 | 🔴 **新增（当前零覆盖）** | P1 |
+| `article/workflow.spec.js` | 5 | `article-management.spec.js` | P0 |
+| `article/category.spec.js` | 3 | 🔴 **新增（当前零覆盖）** | P1 |
+| `article/tag.spec.js` | 3 | 🔴 新增 | P2 |
+| `activity/approval.spec.js` | 4 | `activity-registration.spec.js` | P0 |
+| `activity/config.spec.js` | 3 | 🔴 **新增（当前零覆盖）** | P1 |
+| `vendor/management.spec.js` | 4 | `vendor-onboarding.spec.js` | P0 |
+| `audit/article-audit.spec.js` | 3 | `unified-audit-center.spec.js` | P0 |
+| `audit/butler-audit.spec.js` | 3 | `admin-butler-review.spec.js` | P1 |
+| `audit/vendor-audit.spec.js` | 3 | 🔴 新增 | P1 |
+| `product/approval.spec.js` | 4 | `admin-ecom-supplier.spec.js` | P1 |
+| `product/category.spec.js` | 3 | 🔴 **新增（当前零覆盖）** | P2 |
+| `system/dimension-config.spec.js` | 4 | 🔴 **新增（当前零覆盖）** | P1 |
+| `system/energy-config.spec.js` | 4 | `energy-rules-config.spec.js` | P0 |
+| `system/commission-config.spec.js` | 3 | `admin-commission-config.spec.js` | P1 |
+| `system/promotion-config.spec.js` | 3 | `admin-promotion-config.spec.js` | P2 |
+| `system/operation-log.spec.js` | 3 | 🔴 **新增（当前零覆盖）** | P2 |
+| `membership.spec.js` | 4 | 🔴 **新增（当前零覆盖）** | P1 |
+| `subscription.spec.js` | 3 | 🔴 **新增（当前零覆盖）** | P1 |
+| `data-migration.spec.js` | 3 | 🔴 **新增（当前零覆盖）** | P2 |
+| **小计** | **74** | | |
+
+### 4.7 供应商/服务商 (vendor)
+
+| 文件 | 场景数 | 现有文件映射 | 优先级 |
+|------|:------:|-------------|:------:|
+| `onboarding.spec.js` | 4 | `vendor-onboarding.spec.js` 提取 | P0 |
+| `product-management.spec.js` | 5 | `vendor-product-manage.spec.js` | P0 |
+| `order-processing.spec.js` | 4 | 🔴 **新增（当前零覆盖）** | P1 |
+| `dan-assessment-vendor.spec.js` | 4 | `dan-assessment-vendor-flow.spec.js` | P1 |
+| **小计** | **17** | | |
+
+---
+
+## 五、流程维度测试设计
+
+流程测试按 `flows/` 下的独立目录组织，每个目录包含一个完整业务流的多个阶段。
+
+### 5.1 测评全链 (assessment-full-chain)
+
+```
+flows/assessment-full-chain/
+├── flow.spec.js                  # 主流程测试
+```
+
+业务流：家长购买测评 → 支付 → 系统分配规划师 → 规划师录入结果 → 家长查看报告
+
+| 阶段 | 角色 | 验证点 |
+|:----:|:----:|--------|
+| 1 | 家长 | 选择孩子+规划师 → 创建订单 → 订单状态=待支付 |
+| 2 | 家长 | 完成支付 → 订单状态=已支付，预约自动创建 |
+| 3 | 系统 | 预约状态=待确认 |
+| 4 | 规划师 | 确认预约 → 查看孩子快照 |
+| 5 | 规划师 | 录入测评结果 → 结果状态=已录入 |
+| 6 | 家长 | 查看测评报告 → 结果可见 |
+| 7 | 家长 | 取消未支付订单 → 订单状态=已取消 |
+
+API 验证：
+```
+POST /api/dan-assessment/order/create       → code=200, orderId
+POST /api/dan-assessment/order/pay          → code=200, status=paid
+POST /api/dan-assessment/appointment/confirm → code=200, status=confirmed
+POST /api/dan-assessment/result/create      → code=200, resultId
+POST /api/dan-assessment/order/detail       → code=200, resultId != null
+```
+
+### 5.2 任务生命周期 (task-lifecycle)
+
+业务流：家长创建任务 → 孩子查看/完成 → 家长审核 → 积分发放
+
+| 阶段 | 角色 | 验证点 |
+|:----:|:----:|--------|
+| 1 | 家长 | 创建任务（含小游戏任务）→ 任务状态=待完成 |
+| 2 | 孩子 | 查看今日任务列表 → 新任务可见 |
+| 3 | 孩子 | 完成小游戏/提交 → 任务状态=待审核 |
+| 4 | 家长 | 审核通过/驳回 → 审核通过则发放积分 |
+| 5 | 孩子 | 查看积分 → 积分增加 |
+
+### 5.3 心愿流转 (wish-fulfillment)
+
+业务流：孩子创建心愿 → 家长定价 → 孩子申请兑换 → 家长审批 → 扣减积分
+
+| 阶段 | 角色 | 验证点 |
+|:----:|:----:|--------|
+| 1 | 孩子 | 创建心愿 → 心愿状态=待定价 |
+| 2 | 家长 | 定价 → 心愿有积分值 |
+| 3 | 孩子 | 申请兑换 → 状态=待审批 |
+| 4 | 家长 | 审批通过/拒绝 → 通过则扣减积分 |
+| 5 | 孩子 | 查看积分 → 已扣减 |
+| 6 | 家长 | 拒绝心愿 → 状态=已拒绝 |
+
+### 5.4 家庭邀请流程 (family-invite-flow)
+
+业务流：家长生成邀请码 → 新用户扫码 → 加入家庭
+
+| 阶段 | 角色 | 验证点 |
+|:----:|:----:|--------|
+| 1 | 家长 | 生成家庭邀请码 → 返回 token |
+| 2 | 新用户 | 输入邀请码 → 绑定到家庭 |
+| 3 | 家长 | 查看家庭成员列表 → 新成员可见 |
+| 4 | 家长 | 移除成员 → 成员列表更新 |
+
+### 5.5 规划师绑定流程 (planner-bind-flow)
+
+业务流：规划师生成邀请 → 家长接受绑定 → 规划师客户列表更新
+
+| 阶段 | 角色 | 验证点 |
+|:----:|:----:|--------|
+| 1 | 规划师 | 生成绑定邀请 → 返回凭证 |
+| 2 | 家长 | 验证邀请 → 展示邀请详情 |
+| 3 | 家长 | 确认绑定 → 绑定成功 |
+| 4 | 规划师 | 查看客户列表 → 新家庭可见 |
+| 5 | 规划师 | 解绑 → 关系终止 |
+
+### 5.6 供应商入驻流程 (vendor-onboarding-flow)
+
+业务流：供应商提交入驻 → 管理员审核 → 供应商上架商品 → 用户购买
+
+| 阶段 | 角色 | 验证点 |
+|:----:|:----:|--------|
+| 1 | 供应商 | 提交入驻申请 → 状态=pending |
+| 2 | 管理员 | 审核通过/驳回 → 通过则状态=approved |
+| 3 | 供应商 | 创建商品 → 商品状态=待审核 |
+| 4 | 管理员 | 审核商品 → 上架 |
+| 5 | 用户 | 浏览并购买商品 → 订单创建 |
+| 6 | 供应商 | 查看订单 → 订单可见 |
+
+---
+
+## 六、质量规范
+
+### 6.1 每个测试文件必须包含
+
+```javascript
+const { test, expect } = require('@playwright/test');
+const { loginAs } = require('../../helpers/auth');
+const { assertApiSuccess } = require('../../helpers/utils');
+
+test.describe('【角色】模块 - 场景描述', () => {
+  let auth;
+
+  test.beforeAll(async ({ browser }) => {
+    auth = await loginAs(browser, 'parent');
+  });
+
+  test('[场景N] 用户故事描述 — 期望具体结果', async ({ page }) => {
+    // Given：前置条件
+    // When：操作
+    // Then：验证（UI断言 + API断言）
+  });
+});
+```
+
+### 6.2 断言标准
+
+| 等级 | 断言要求 | 示例 |
+|:----:|----------|------|
+| **P0** | UI 可见性 + API 响应码 + 关键数据验证 | HTTP 200 + `body.code === 200` + `body.data.orderId` 非空 |
+| **P1** | UI 可见性 + API 响应码 | HTTP 200 + `body.code === 200` |
+| **P2** | UI 可见性 | `.toBeVisible()` |
+
+所有 P0/P1 场景必须包含 API 级断言。
+P2 场景允许仅 UI 验证。
+
+### 6.3 API 断言模式
+
+```javascript
+// 方式一：通过 page.request 直接验证后端
+const response = await page.request.post('/api/family/member/list', {
+  data: { familyId: auth.familyId },
+  headers: { Authorization: 'Bearer ' + auth.token },
+});
+const data = await assertApiSuccess(response);
+expect(data.members.length).toBeGreaterThan(0);
+
+// 方式二：混合 UI + API
+await page.click('.submit-btn');
+await expect(page.locator('.success-tip')).toBeVisible();
+const orderResp = await assertApiSuccess(
+  await page.request.post('/api/dan-assessment/order/detail', { /* ... */ })
+);
+expect(orderResp.order.status).toBe('paid');
+```
+
+### 6.4 数据隔离
+
+- 每个测试文件在 `beforeAll` 中登录
+- 每个场景（`test()`）独立验证，不依赖其他场景的副作用
+- 数据清理统一在 seed-data.sql 层面解决（每次运行前全量恢复）
+
+### 6.5 错误场景覆盖
+
+每个 P0 场景必须包含 **至少一个错误场景**（异常分支）：
+
+```
+场景1: 正常流程 — 期望成功
+场景1b: 参数异常（空值/越界/不存在）— 期望合理错误提示
+场景1c: 权限异常（无权限角色操作）— 期望 403/500
+```
+
+---
+
+## 七、实施计划
+
+### Phase 1：基础设施 + 核心角色重构（2周）
+
+| 任务 | 交付物 | 工时 |
+|------|--------|:----:|
+| 1.1 编写 `reset-db.sh` + `seed-data.sql` | 数据库重置脚本 | 1天 |
+| 1.2 编写 `helpers/auth.js` | 8 角色登录 helper | 1.5天 |
+| 1.3 编写 `helpers/fixtures.js` | 测试数据工厂 | 1天 |
+| 1.4 编写 `helpers/utils.js` | 通用断言工具 | 0.5天 |
+| 1.5 调整 `playwright.config.js` | 全局配置 | 0.5天 |
+| 1.6 重构 `roles/parent/` (6个核心文件) | login, family, wish, assessment, energy, points | 3天 |
+| 1.7 重构 `roles/child/` (4个核心文件) | login, checkin, games, wish-create | 2天 |
+| 1.8 重构 `roles/teacher/` (4个核心文件) | login, binding, task, family-list | 2天 |
+| 1.9 重构 `roles/admin/` (4个核心文件) | login, article, activity, audit | 2天 |
+
+### Phase 2：新增角色 + 流程测试（2周）
+
+| 任务 | 交付物 | 工时 |
+|------|--------|:----:|
+| 2.1 新增 `roles/nutritionist/` (3个文件) | login, profile, diet-record | 2天 |
+| 2.2 新增 `roles/butler/` (2个文件) | login, ai-chat | 2天 |
+| 2.3 新增 `roles/teacher/assessment/` (3个文件) | recording, appointment, report | 2天 |
+| 2.4 新增 `roles/admin/user-management` | 用户管理 | 1天 |
+| 2.5 新增 `flows/assessment-full-chain` | 测评全链流程 | 2天 |
+| 2.6 新增 `flows/task-lifecycle` | 任务生命周期 | 1.5天 |
+| 2.7 新增 `flows/wish-fulfillment` | 心愿流转 | 1.5天 |
+| 2.8 新增 `flows/planner-bind-flow` | 规划师绑定流程 | 1天 |
+
+### Phase 3：补齐剩余模块 + 错误场景（2周）
+
+| 任务 | 交付物 | 工时 |
+|------|--------|:----:|
+| 3.1 补齐 `roles/parent/` 剩余文件 | subscription, membership, ai-chat, growth, health | 3天 |
+| 3.2 补齐 `roles/admin/` 剩余模块 | system/, product/, vendor/, membership | 3天 |
+| 3.3 补齐 `roles/vendor/` | onboarding, product, order | 2天 |
+| 3.4 补齐 `roles/teacher/` 剩余文件 | package, training-plan, dashboard | 2天 |
+| 3.5 补齐 `roles/nutritionist/` 剩余文件 | recipe, meal-recommend, family-binding | 1天 |
+| 3.6 补齐 `flows/` 剩余流程 | family-invite, vendor-onboarding | 2天 |
+| 3.7 为所有 P0 场景补充错误场景 | 异常分支 | 2天 |
+| 3.8 删除旧文件 | 清理旧目录 | 0.5天 |
+
+---
+
+## 八、运行方式
+
+```bash
+# 1. 重置数据库
+bash tests/e2e/reset-db.sh
+
+# 2. 运行全部测试
+npx playwright test tests/e2e/
+
+# 3. 按角色运行
+npx playwright test tests/e2e/roles/parent/
+npx playwright test tests/e2e/roles/admin/
+
+# 4. 按流程运行
+npx playwright test tests/e2e/flows/assessment-full-chain/
+
+# 5. 单文件
+npx playwright test tests/e2e/roles/parent/family-management.spec.js
+
+# 6. 自定义环境
+PW_BASE_URL=http://staging.cfc.iwintrue.com npx playwright test
+```
+
+---
+
+## 九、文件变更清单
+
+### 新增
+
+| 文件 | 数量 |
+|------|:----:|
+| `tests/e2e/helpers/auth.js` | 1 |
+| `tests/e2e/helpers/db.js` | 1 |
+| `tests/e2e/helpers/fixtures.js` | 1 |
+| `tests/e2e/helpers/utils.js` | 1 |
+| `tests/e2e/reset-db.sh` | 1 |
+| `tests/e2e/seed-data.sql` | 1 |
+| `tests/e2e/roles/` 目录下 spec 文件 | ~58 |
+| `tests/e2e/flows/` 目录下 spec 文件 | ~6 |
+| **新增合计** | **~70 文件** |
+
+### 删除
+
+| 文件 | 数量 |
+|------|:----:|
+| 旧的 `tests/e2e/*.spec.js` 文件 | 40 |
+
+### 修改
+
+| 文件 | 数量 |
+|------|:----:|
+| `tests/e2e/playwright.config.js` | 1 |
+
+---
+
+## 十、验收标准
+
+| 标准 | 说明 |
+|------|------|
+| 所有测试可独立运行 | `npx playwright test tests/e2e/roles/parent/` 通过 |
+| 每次运行前 DB 自动重置 | 全局 setup 脚本执行 reset-db.sh |
+| 无重复认证代码 | 所有认证走 `helpers/auth.js` |
+| 无纯占位测试 | 每个 `test()` 有至少一个 `expect()` |
+| 所有 P0 场景含错误路径 | 至少 1 个正常 + 1 个异常 |
+| 流程测试验证跨角色状态流转 | API 断言验证状态变更 |
+| 旧文件全部移除 | 无 `tests/e2e/*.spec.js` 残留 |

tests/e2e/helpers/auth.js

@@ -0,0 +1,344 @@
+/**
+ * ================================================================
+ * E2E Test Authentication Helper
+ * ================================================================
+ * Provides unified login for 8 roles: parent, child, teacher,
+ * nutritionist, butler, assessor, admin, vendor
+ *
+ * Usage:
+ *   const { ROLES, loginAs } = require('./helpers/auth');
+ *   const auth = await loginAs(browser, 'parent');
+ *   console.log(auth.token, auth.userId, auth.role);
+ * ================================================================
+ */
+
+var BASE_URL = process.env.PW_BASE_URL || 'http://cfc.iwintrue.com';
+
+// ================================================================
+// ROLES - Test user credentials mapping
+// ================================================================
+
+var ROLES = {
+  parent: {
+    phone: '13701366188',
+    userId: 1002,
+    loginType: 'code',
+    familyId: 2001
+  },
+  child: {
+    phone: '13701366189',
+    userId: 1003,
+    loginType: 'code',
+    familyId: 2001
+  },
+  teacher: {
+    phone: '13800000001',
+    userId: 1005,
+    loginType: 'code',
+    familyId: 0
+  },
+  nutritionist: {
+    phone: '13800000010',
+    userId: 1006,
+    loginType: 'code',
+    familyId: 0
+  },
+  butler: {
+    phone: '13800000020',
+    userId: 1007,
+    loginType: 'code',
+    familyId: 0
+  },
+  assessor: {
+    phone: '13800000030',
+    userId: 1008,
+    loginType: 'code',
+    familyId: 0
+  },
+  admin: {
+    phone: '13800138000',
+    userId: 1001,
+    loginType: 'password',
+    familyId: 0
+  },
+  vendor: {
+    phone: '13800138001',
+    userId: 1009,
+    loginType: 'code',
+    familyId: 0
+  }
+};
+
+// ================================================================
+// loginAs - Unified authentication for Playwright E2E tests
+// ================================================================
+
+/**
+ * Login as a specific role and return auth information
+ * @param {Browser} browser - Playwright Browser instance
+ * @param {string} role - Role name (parent, child, teacher, etc.)
+ * @returns {Promise<{token: string, userId: number, role: string, familyId: number}>}
+ */
+async function loginAs(browser, role) {
+  var context = null;
+  var page = null;
+
+  try {
+    var roleConfig = ROLES[role];
+    if (!roleConfig) {
+      throw new Error('Unknown role: ' + role + '. Available roles: ' + Object.keys(ROLES).join(', '));
+    }
+
+    context = await browser.newContext();
+    page = await context.newPage();
+
+    var authResult = {
+      token: null,
+      userId: roleConfig.userId,
+      role: role,
+      familyId: roleConfig.familyId
+    };
+
+    if (role === 'admin') {
+      // Admin login via UI - navigate to admin login page
+      await page.goto(BASE_URL + '/admin/login', { waitUntil: 'networkidle', timeout: 30000 });
+      await page.waitForTimeout(2000);
+
+      // Fill phone/username
+      var inputSelectors = [
+        '.el-input__inner',
+        'input[type="text"]',
+        'input[placeholder*="账号"]',
+        'input[placeholder*="用户名"]',
+        'input[name="username"]',
+        '.el-input input'
+      ];
+
+      var inputFound = false;
+      for (var i = 0; i < inputSelectors.length; i++) {
+        try {
+          var el = page.locator(inputSelectors[i]).first();
+          if (await el.isVisible({ timeout: 3000 })) {
+            await el.fill(roleConfig.phone);
+            inputFound = true;
+            break;
+          }
+        } catch (e) {
+          // continue to next selector
+        }
+      }
+
+      if (!inputFound) {
+        var allInputs = page.locator('input');
+        var count = await allInputs.count();
+        if (count > 0) {
+          await allInputs.first().fill(roleConfig.phone);
+          if (count > 1) {
+            await allInputs.nth(1).fill('admin123');
+          }
+        }
+      }
+
+      // Fill password (admin uses password login)
+      var pwdInputs = page.locator('input[type="password"]');
+      if (await pwdInputs.count() > 0) {
+        await pwdInputs.first().fill('admin123');
+      } else {
+        var inputs = page.locator('input');
+        var inputCount = await inputs.count();
+        if (inputCount >= 2) {
+          await inputs.nth(1).fill('admin123');
+        }
+      }
+
+      // Click login button
+      var btnSelectors = [
+        '.el-button--primary',
+        'button[type="submit"]',
+        '.login-btn',
+        '.el-button:has-text("登录")',
+        '.el-button:has-text("登 录")'
+      ];
+
+      for (var j = 0; j < btnSelectors.length; j++) {
+        try {
+          var btn = page.locator(btnSelectors[j]).first();
+          if (await btn.isVisible({ timeout: 2000 })) {
+            await btn.click();
+            break;
+          }
+        } catch (e) {
+          // continue to next selector
+        }
+      }
+
+      // Wait for login to complete
+      try {
+        await page.waitForURL(/\/dashboard|\/admin\//, { timeout: 20000 });
+      } catch (e) {
+        await page.waitForSelector('.sidebar-container, .el-menu, .el-aside', { timeout: 15000 });
+      }
+
+      // Read token from localStorage
+      authResult.token = await page.evaluate(function() {
+        return localStorage.getItem('token') || localStorage.getItem('access_token') || '';
+      });
+
+    } else {
+      // Non-admin roles: try API login first, fallback to UI
+
+      // Attempt 1: API login
+      try {
+        var apiResponse = await page.request.post(BASE_URL + '/api/auth/phone-login', {
+          data: {
+            phone: roleConfig.phone,
+            code: '123456'
+          },
+          headers: {
+            'Content-Type': 'application/json'
+          }
+        });
+
+        if (apiResponse.ok()) {
+          var apiData = await apiResponse.json();
+          if (apiData && apiData.data && apiData.data.token) {
+            authResult.token = apiData.data.token;
+            // Store token in localStorage for UI consistency
+            await page.evaluate(function(token) {
+              localStorage.setItem('token', token);
+              localStorage.setItem('access_token', token);
+            }, authResult.token);
+          }
+        }
+      } catch (apiErr) {
+        // API login failed, will try UI fallback
+      }
+
+      // Fallback: UI login if API didn't work
+      if (!authResult.token) {
+        await page.goto(BASE_URL, { waitUntil: 'networkidle', timeout: 30000 });
+        await page.waitForTimeout(2000);
+
+        // Try to find and click login button or go to login page
+        var loginBtnSelectors = [
+          'button:has-text("登录")',
+          'a:has-text("登录")',
+          '.login-btn',
+          '[class*="login"]'
+        ];
+
+        for (var k = 0; k < loginBtnSelectors.length; k++) {
+          try {
+            var loginBtn = page.locator(loginBtnSelectors[k]).first();
+            if (await loginBtn.isVisible({ timeout: 2000 })) {
+              await loginBtn.click();
+              await page.waitForTimeout(1000);
+              break;
+            }
+          } catch (e) {
+            // continue
+          }
+        }
+
+        // Fill phone and code
+        var phoneInputSelectors = [
+          'input[type="tel"]',
+          'input[placeholder*="手机"]',
+          'input[name="phone"]',
+          '.el-input__inner'
+        ];
+
+        for (var m = 0; m < phoneInputSelectors.length; m++) {
+          try {
+            var phoneInput = page.locator(phoneInputSelectors[m]).first();
+            if (await phoneInput.isVisible({ timeout: 2000 })) {
+              await phoneInput.fill(roleConfig.phone);
+              break;
+            }
+          } catch (e) {
+            // continue
+          }
+        }
+
+        // Fill verification code (123456 for test)
+        var codeInputSelectors = [
+          'input[placeholder*="验证码"]',
+          'input[placeholder*="code"]',
+          'input[name="code"]'
+        ];
+
+        for (var n = 0; n < codeInputSelectors.length; n++) {
+          try {
+            var codeInput = page.locator(codeInputSelectors[n]).first();
+            if (await codeInput.isVisible({ timeout: 2000 })) {
+              await codeInput.fill('123456');
+              break;
+            }
+          } catch (e) {
+            // continue
+          }
+        }
+
+        // Click submit button
+        var submitSelectors = [
+          'button[type="submit"]',
+          '.el-button--primary',
+          'button:has-text("登录")',
+          'button:has-text("提交")'
+        ];
+
+        for (var p = 0; p < submitSelectors.length; p++) {
+          try {
+            var submitBtn = page.locator(submitSelectors[p]).first();
+            if (await submitBtn.isVisible({ timeout: 2000 })) {
+              await submitBtn.click();
+              break;
+            }
+          } catch (e) {
+            // continue
+          }
+        }
+
+        // Wait for navigation or token storage
+        await page.waitForTimeout(3000);
+
+        // Try to read token from localStorage
+        authResult.token = await page.evaluate(function() {
+          return localStorage.getItem('token') || localStorage.getItem('access_token') || '';
+        });
+      }
+    }
+
+    return authResult;
+
+  } catch (error) {
+    console.error('Login failed for role ' + role + ':', error.message);
+    // Return partial result even on error
+    return {
+      token: null,
+      userId: roleConfig ? roleConfig.userId : null,
+      role: role,
+      familyId: roleConfig ? roleConfig.familyId : null,
+      error: error.message
+    };
+  } finally {
+    // Cleanup: close the browser context
+    if (context) {
+      try {
+        await context.close();
+      } catch (closeErr) {
+        // Ignore close errors
+      }
+    }
+  }
+}
+
+// ================================================================
+// Module exports (CommonJS)
+// ================================================================
+
+module.exports = {
+  ROLES: ROLES,
+  loginAs: loginAs,
+  BASE_URL: BASE_URL
+};

tests/e2e/helpers/db.js

@@ -0,0 +1,65 @@
+/**
+ * ================================================================
+ * E2E Test Database Reset Global Setup
+ * ================================================================
+ * Runs reset-db.sh before all E2E tests to ensure clean database state
+ *
+ * Usage:
+ *   Add to playwright.config.js:
+ *     globalSetup: path.join(__dirname, 'e2e', 'helpers', 'db.js')
+ * ================================================================
+ */
+
+var path = require('path');
+var child_process = require('child_process');
+
+var SCRIPT_PATH = path.join(__dirname, '..', 'reset-db.sh');
+
+/**
+ * Reset database by executing reset-db.sh
+ * This function is called as globalSetup before all E2E tests
+ * @throws {Error} - If script execution fails
+ */
+function resetDatabase() {
+  console.log('============================================================');
+  console.log('E2E Global Setup: Running Database Reset');
+  console.log('============================================================');
+  console.log('Script path: ' + SCRIPT_PATH);
+  console.log('============================================================');
+
+  try {
+    // Execute the reset-db.sh script
+    // Using execSync for synchronous execution in globalSetup
+    child_process.execSync('bash ' + SCRIPT_PATH, {
+      stdio: 'inherit',
+      cwd: __dirname
+    });
+
+    console.log('============================================================');
+    console.log('E2E Global Setup: Database Reset Complete');
+    console.log('============================================================');
+
+  } catch (error) {
+    console.error('============================================================');
+    console.error('E2E Global Setup: Database Reset FAILED');
+    console.error('============================================================');
+    console.error('Error: ' + error.message);
+    console.error('============================================================');
+    console.error('Please check:');
+    console.error('  1. MySQL server is running');
+    console.error('  2. Network access to ' + (process.env.MYSQL_HOST || '192.168.16.251') + ' is available');
+    console.error('  3. reset-db.sh exists at: ' + SCRIPT_PATH);
+    console.error('  4. seed-data.sql exists in the e2e directory');
+    console.error('============================================================');
+    process.exit(1);
+  }
+}
+
+// Run if executed directly
+resetDatabase();
+
+// ================================================================
+// Module exports (CommonJS)
+// ================================================================
+
+module.exports = resetDatabase;

tests/e2e/helpers/fixtures.js

@@ -0,0 +1,161 @@
+/**
+ * ================================================================
+ * E2E Test Data Factory - Fixtures Helper
+ * ================================================================
+ * Creates test data via API calls for Playwright E2E tests
+ *
+ * Usage:
+ *   var { createTask, createWish, createAssessmentOrder, getTestData } = require('./helpers/fixtures');
+ *   var task = await createTask(auth, { title: 'Custom Task' });
+ *   var wish = await createWish(auth, { points: 500 });
+ *   var order = await createAssessmentOrder(auth, { packageId: 2 });
+ *   var testData = getTestData();
+ * ================================================================
+ */
+
+var { BASE_URL } = require('./auth');
+var { authHeaders } = require('./utils');
+
+/**
+ * Create a task via API
+ * @param {Object} auth - Auth object with token
+ * @param {Object} overrides - Optional overrides for default body
+ * @returns {Promise<Object>} - Response JSON or error response
+ */
+async function createTask(auth, overrides) {
+  var PlaywrightTest = require('@playwright/test');
+  var page = await PlaywrightTest.request.newContext();
+
+  try {
+    var defaultBody = {
+      title: '测试任务',
+      childId: 1003,
+      type: 'daily',
+      deadline: '2099-12-31'
+    };
+
+    var body = Object.assign({}, defaultBody, overrides || {});
+
+    var response = await page.request.post(BASE_URL + '/api/tasks/create', {
+      headers: authHeaders(auth),
+      data: body
+    });
+
+    return await response.json();
+
+  } catch (error) {
+    return {
+      code: -1,
+      message: error.message,
+      data: null
+    };
+
+  } finally {
+    await page.dispose();
+  }
+}
+
+/**
+ * Create a wish via API
+ * @param {Object} auth - Auth object with token
+ * @param {Object} overrides - Optional overrides for default body
+ * @returns {Promise<Object>} - Response JSON or error response
+ */
+async function createWish(auth, overrides) {
+  var PlaywrightTest = require('@playwright/test');
+  var page = await PlaywrightTest.request.newContext();
+
+  try {
+    var defaultBody = {
+      title: '测试心愿',
+      points: 100,
+      childId: 1003
+    };
+
+    var body = Object.assign({}, defaultBody, overrides || {});
+
+    var response = await page.request.post(BASE_URL + '/api/wishes/create', {
+      headers: authHeaders(auth),
+      data: body
+    });
+
+    return await response.json();
+
+  } catch (error) {
+    return {
+      code: -1,
+      message: error.message,
+      data: null
+    };
+
+  } finally {
+    await page.dispose();
+  }
+}
+
+/**
+ * Create an assessment order via API
+ * @param {Object} auth - Auth object with token
+ * @param {Object} overrides - Optional overrides for default body
+ * @returns {Promise<Object>} - Response JSON or error response
+ */
+async function createAssessmentOrder(auth, overrides) {
+  var PlaywrightTest = require('@playwright/test');
+  var page = await PlaywrightTest.request.newContext();
+
+  try {
+    var defaultBody = {
+      childId: 1003,
+      packageId: 1
+    };
+
+    var body = Object.assign({}, defaultBody, overrides || {});
+
+    var response = await page.request.post(BASE_URL + '/api/dan-assessment/order/create', {
+      headers: authHeaders(auth),
+      data: body
+    });
+
+    return await response.json();
+
+  } catch (error) {
+    return {
+      code: -1,
+      message: error.message,
+      data: null
+    };
+
+  } finally {
+    await page.dispose();
+  }
+}
+
+/**
+ * Get static test data mapping
+ * @returns {Object} - Object containing all test user IDs and family IDs
+ */
+function getTestData() {
+  return {
+    parentUserId: 1002,
+    childUserId: 1003,
+    child2UserId: 1004,
+    teacherUserId: 1005,
+    nutritionistUserId: 1006,
+    butlerUserId: 1007,
+    assessorUserId: 1008,
+    vendorUserId: 1009,
+    adminUserId: 1001,
+    familyId: 2001
+  };
+}
+
+// ================================================================
+// Module exports (CommonJS)
+// ================================================================
+
+module.exports = {
+  createTask: createTask,
+  createWish: createWish,
+  createAssessmentOrder: createAssessmentOrder,
+  getTestData: getTestData
+};

tests/e2e/helpers/utils.js

@@ -0,0 +1,126 @@
+/**
+ * ================================================================
+ * E2E Test Utility Functions
+ * ================================================================
+ * Provides common assertion helpers and test data for Playwright E2E tests
+ *
+ * Usage:
+ *   const { assertApiSuccess, assertApiError, authHeaders, getTestData } = require('./helpers/utils');
+ *   const data = assertApiSuccess(response);
+ *   await assertApiError(response, 'AUTH_FAILED', 'Invalid token');
+ *   const headers = authHeaders(auth);
+ *   const testData = getTestData();
+ * ================================================================
+ */
+
+var BASE_URL = process.env.PW_BASE_URL || 'http://cfc.iwintrue.com';
+
+/**
+ * Assert API response indicates success
+ * @param {APIResponse} response - Playwright APIResponse object
+ * @param {number} expectedStatus - Expected HTTP status code (default: 200)
+ * @returns {Promise<Object>} - Parsed response body data
+ * @throws {Error} - If status or code is not as expected
+ */
+async function assertApiSuccess(response, expectedStatus) {
+  if (expectedStatus === undefined) {
+    expectedStatus = 200;
+  }
+
+  var status = response.status();
+  if (status !== expectedStatus) {
+    var body = await response.text();
+    throw new Error('Expected HTTP status ' + expectedStatus + ' but got ' + status + '. Body: ' + body);
+  }
+
+  var body;
+  try {
+    body = await response.json();
+  } catch (e) {
+    var text = await response.text();
+    throw new Error('Failed to parse JSON response: ' + text);
+  }
+
+  if (body.code !== 200) {
+    throw new Error('Expected body.code === 200 but got ' + body.code + '. Message: ' + (body.message || 'N/A'));
+  }
+
+  return body.data;
+}
+
+/**
+ * Assert API response indicates an error
+ * @param {APIResponse} response - Playwright APIResponse object
+ * @param {string} [expectedCode] - Optional expected error code
+ * @param {string} [expectedMessage] - Optional expected error message substring
+ * @throws {Error} - If response indicates success or doesn't match expected error
+ */
+async function assertApiError(response, expectedCode, expectedMessage) {
+  var status = response.status();
+  var body;
+  try {
+    body = await response.json();
+  } catch (e) {
+    var text = await response.text();
+    throw new Error('Expected error response but failed to parse JSON: ' + text);
+  }
+
+  // Error responses typically have non-200 codes or body.code !== 200
+  if (body.code === 200) {
+    throw new Error('Expected error response but got success. Body: ' + JSON.stringify(body));
+  }
+
+  if (expectedCode !== undefined && body.code !== expectedCode) {
+    throw new Error('Expected error code ' + expectedCode + ' but got ' + body.code + '. Message: ' + (body.message || 'N/A'));
+  }
+
+  if (expectedMessage !== undefined && body.message) {
+    if (body.message.indexOf(expectedMessage) === -1) {
+      throw new Error('Expected error message containing "' + expectedMessage + '" but got "' + body.message + '"');
+    }
+  }
+}
+
+/**
+ * Build authorization headers from auth object
+ * @param {Object} auth - Auth object with token property
+ * @returns {Object} - Headers object with Authorization and Content-Type
+ */
+function authHeaders(auth) {
+  return {
+    Authorization: 'Bearer ' + auth.token,
+    'Content-Type': 'application/json'
+  };
+}
+
+/**
+ * Get test data with all seed data IDs
+ * @returns {Object} - Object containing all test user IDs and family IDs
+ */
+function getTestData() {
+  return {
+    parentUserId: 1002,
+    childUserId: 1003,
+    child2UserId: 1004,
+    teacherUserId: 1005,
+    nutritionistUserId: 1006,
+    butlerUserId: 1007,
+    assessorUserId: 1008,
+    adminUserId: 1001,
+    vendorUserId: 1009,
+    familyId: 2001,
+    family2Id: 2002
+  };
+}
+
+// ================================================================
+// Module exports (CommonJS)
+// ================================================================
+
+module.exports = {
+  assertApiSuccess: assertApiSuccess,
+  assertApiError: assertApiError,
+  authHeaders: authHeaders,
+  getTestData: getTestData,
+  BASE_URL: BASE_URL
+};

tests/e2e/reset-db.sh

@@ -0,0 +1,46 @@
+#!/bin/bash
+# ============================================================
+# E2E Test Database Reset Script
+# ============================================================
+
+set -e
+
+# Default values
+MYSQL_HOST="${MYSQL_HOST:-192.168.16.251}"
+MYSQL_USER="${MYSQL_USER:-cfc}"
+MYSQL_PASS="${MYSQL_PASS:-cfc@123}"
+MYSQL_DB="${MYSQL_DB:-cfc}"
+
+# Resolve script directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SEED_FILE="${SCRIPT_DIR}/seed-data.sql"
+
+echo "============================================================"
+echo "E2E Database Reset"
+echo "============================================================"
+echo "Host: ${MYSQL_HOST}"
+echo "User: ${MYSQL_USER}"
+echo "Database: ${MYSQL_DB}"
+echo "Seed file: ${SEED_FILE}"
+echo "============================================================"
+
+# Check if seed file exists
+if [ ! -f "${SEED_FILE}" ]; then
+    echo "[ERROR] Seed file not found: ${SEED_FILE}"
+    exit 1
+fi
+
+# Execute seed data
+echo "[INFO] Executing seed data..."
+mysql -h "${MYSQL_HOST}" -u "${MYSQL_USER}" -p"${MYSQL_PASS}" "${MYSQL_DB}" < "${SEED_FILE}"
+
+if [ $? -eq 0 ]; then
+    echo "[SUCCESS] Seed data executed successfully"
+else
+    echo "[ERROR] Failed to execute seed data"
+    exit 1
+fi
+
+echo "============================================================"
+echo "E2E Database Reset Complete"
+echo "============================================================"

tests/e2e/roles/admin/article/workflow.spec.js

@@ -0,0 +1,47 @@
+const { test, expect } = require('@playwright/test');
+const { loginAs, BASE_URL } = require('../../../helpers/auth');
+const { assertApiSuccess, authHeaders } = require('../../../helpers/utils');
+
+test.describe('【管理员】文章发布流程', function() {
+  var auth;
+
+  test.beforeAll(async function({ browser }) {
+    auth = await loginAs(browser, 'admin');
+  });
+
+  test('[场景1] 创建文章草稿 — 状态为draft', async function({ page }) {
+    var resp = await page.request.post(BASE_URL + '/api/admin/article/create', {
+      headers: authHeaders(auth),
+      data: { title: 'E2E测试文章', content: '<p>测试内容</p>', categoryId: 1 },
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data.status || 'draft').toBe('draft');
+  });
+
+  test('[场景2] 提交审核 — 状态变为pending', async function({ page }) {
+    var resp = await page.request.post(BASE_URL + '/api/admin/article/submit-review', {
+      headers: authHeaders(auth),
+      data: { articleId: 1001 },
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data.status).toBe('pending');
+  });
+
+  test('[场景3] 审核通过 — 状态变为published', async function({ page }) {
+    var resp = await page.request.post(BASE_URL + '/api/admin/article/approve', {
+      headers: authHeaders(auth),
+      data: { articleId: 1001 },
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data.status).toBe('published');
+  });
+
+  test('[场景4] 下架已发布文章 — 状态变为withdrawn', async function({ page }) {
+    var resp = await page.request.post(BASE_URL + '/api/admin/article/withdraw', {
+      headers: authHeaders(auth),
+      data: { articleId: 1002 },
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data.status).toBe('withdrawn');
+  });
+});

tests/e2e/roles/admin/login.spec.js

@@ -0,0 +1,16 @@
+const { test, expect } = require('@playwright/test');
+const { loginAs, BASE_URL } = require('../../helpers/auth');
+
+test.describe('【管理员】登录', function() {
+  test('[场景1] 管理员登录 — 获得合法token', async function({ browser }) {
+    var auth = await loginAs(browser, 'admin');
+    expect(auth.token).toBeTruthy();
+    expect(auth.role).toBe('admin');
+  });
+
+  test('[场景2] 未登录访问管理后台 — 重定向到登录页', async function({ page }) {
+    await page.goto(BASE_URL + '/admin/');
+    await page.waitForLoadState('networkidle');
+    expect(page.url()).toContain('/login');
+  });
+});

tests/e2e/roles/admin/vendor/management.spec.js

@@ -0,0 +1,28 @@
+const { test, expect } = require('@playwright/test');
+const { loginAs, BASE_URL } = require('../../../helpers/auth');
+const { assertApiSuccess, authHeaders } = require('../../../helpers/utils');
+
+test.describe('【管理员】供应商管理', function() {
+  var auth;
+
+  test.beforeAll(async function({ browser }) {
+    auth = await loginAs(browser, 'admin');
+  });
+
+  test('[场景1] 查看供应商列表 — 返回列表数据', async function({ page }) {
+    var resp = await page.request.post(BASE_URL + '/api/admin/vendor/list', {
+      headers: authHeaders(auth),
+      data: { status: 'pending', page: 1, pageSize: 10 },
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data).toBeTruthy();
+  });
+
+  test('[场景1b] 空过滤条件 — 仍返回有效响应', async function({ page }) {
+    var resp = await page.request.post(BASE_URL + '/api/admin/vendor/list', {
+      headers: authHeaders(auth),
+      data: {},
+    });
+    await assertApiSuccess(resp);
+  });
+});

tests/e2e/roles/child/daily-checkin.spec.js

@@ -0,0 +1,37 @@
+const { test, expect } = require('@playwright/test');
+const { loginAs, BASE_URL } = require('../../helpers/auth');
+const { assertApiSuccess, authHeaders } = require('../../helpers/utils');
+
+test.describe('【孩子】健康打卡', function() {
+  var auth;
+
+  test.beforeAll(async function({ browser }) {
+    auth = await loginAs(browser, 'child');
+  });
+
+  test('[场景1] 完成每日打卡 — 打卡成功', async function({ page }) {
+    var resp = await page.request.post(BASE_URL + '/api/health/checkin/create', {
+      headers: authHeaders(auth),
+      data: { childId: 1003, dietScore: 85, exerciseScore: 70, sleepScore: 90, moodScore: 80 },
+    });
+    await assertApiSuccess(resp);
+  });
+
+  test('[场景1b] 打卡数据为空 — 期望错误', async function({ page }) {
+    var resp = await page.request.post(BASE_URL + '/api/health/checkin/create', {
+      headers: authHeaders(auth),
+      data: {},
+    });
+    var body = await resp.json();
+    expect(body.code).not.toBe(200);
+  });
+
+  test('[场景2] 查看连续签到 — 返回天数', async function({ page }) {
+    var resp = await page.request.post(BASE_URL + '/api/health/checkin/streak', {
+      headers: authHeaders(auth),
+      data: { childId: 1003 },
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data).toBeTruthy();
+  });
+});

tests/e2e/roles/child/login.spec.js

@@ -0,0 +1,22 @@
+const { test, expect } = require('@playwright/test');
+const { loginAs } = require('../../helpers/auth');
+
+test.describe('【孩子】登录', function() {
+  var auth;
+
+  test.beforeAll(async function({ browser }) {
+    auth = await loginAs(browser, 'child');
+  });
+
+  test('[场景1] 孩子角色登录 — 获得合法token', async function() {
+    expect(auth.token).toBeTruthy();
+    expect(auth.role).toBe('child');
+  });
+
+  test('[场景2] 孩子尝试访问家长页面 — 被重定向', async function({ page }) {
+    await page.goto('http://cfc.iwintrue.com/#/pages/parent/index');
+    await page.waitForLoadState('networkidle');
+    var url = page.url();
+    expect(url).not.toContain('/parent/index');
+  });
+});

tests/e2e/roles/child/mini-games.spec.js

@@ -0,0 +1,35 @@
+const { test, expect } = require('@playwright/test');
+const { loginAs, BASE_URL } = require('../../helpers/auth');
+const { assertApiSuccess, authHeaders } = require('../../helpers/utils');
+
+test.describe('【孩子】小游戏', function() {
+  var auth;
+
+  test.beforeAll(async function({ browser }) {
+    auth = await loginAs(browser, 'child');
+  });
+
+  test('[场景1] 查看游戏列表 — 返回游戏', async function({ page }) {
+    var resp = await page.request.post(BASE_URL + '/api/games/list', {
+      headers: authHeaders(auth),
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data).toBeTruthy();
+  });
+
+  test('[场景2] 完成舒尔特方格 — 游戏完成', async function({ page }) {
+    var resp = await page.request.post(BASE_URL + '/api/games/schulte/complete', {
+      headers: authHeaders(auth),
+      data: { childId: 1003, score: 95, timeSpent: 30 },
+    });
+    await assertApiSuccess(resp);
+  });
+
+  test('[场景3] 完成猜数字 — 游戏完成', async function({ page }) {
+    var resp = await page.request.post(BASE_URL + '/api/games/guess-number/complete', {
+      headers: authHeaders(auth),
+      data: { childId: 1003, attempts: 5, won: true },
+    });
+    await assertApiSuccess(resp);
+  });
+});

tests/e2e/roles/parent/assessment-order.spec.js

@@ -0,0 +1,77 @@
+const { test, expect } = require('@playwright/test');
+const { loginAs, BASE_URL } = require('../../helpers/auth');
+const { assertApiSuccess, assertApiError, authHeaders } = require('../../helpers/utils');
+
+test.describe('【家长】测评订单', () => {
+  var auth;
+
+  test.beforeAll(async ({ browser }) => {
+    auth = await loginAs(browser, 'parent');
+  });
+
+  test('[场景1] 创建测评订单 — 期望返回订单ID或id', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/dan-assessment/order/create', {
+      headers: authHeaders(auth),
+      data: {
+        childUserId: 1003,
+        packageId: 1,
+        teacherUserId: 1005
+      }
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data).toBeDefined();
+    expect(data.orderId || data.id || data).toBeDefined();
+  });
+
+  test('[场景2] 查看订单详情 — 期望返回包含status字段的订单信息', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/dan-assessment/order/detail', {
+      headers: authHeaders(auth),
+      data: {
+        orderId: 1
+      }
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data).toBeDefined();
+    expect(data.status || data).toBeDefined();
+  });
+
+  test('[场景3] 取消未支付订单 — 期望返回成功', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/dan-assessment/order/cancel', {
+      headers: authHeaders(auth),
+      data: {
+        orderId: 1
+      }
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data).toBeDefined();
+  });
+
+  test('[场景4] 查看订单列表 — 期望返回订单列表', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/dan-assessment/order/list', {
+      headers: authHeaders(auth),
+      data: {
+        childUserId: 1003
+      }
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data).toBeDefined();
+  });
+
+  test('[场景5] 创建订单失败 — 空参数期望返回错误', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/dan-assessment/order/create', {
+      headers: authHeaders(auth),
+      data: {}
+    });
+    await assertApiError(resp);
+  });
+
+  test('[场景6] 查看不存在的订单详情 — 期望返回错误', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/dan-assessment/order/detail', {
+      headers: authHeaders(auth),
+      data: {
+        orderId: 999999
+      }
+    });
+    await assertApiError(resp);
+  });
+});

tests/e2e/roles/parent/energy-dashboard.spec.js

@@ -0,0 +1,68 @@
+const { test, expect } = require('@playwright/test');
+const { loginAs, BASE_URL } = require('../../helpers/auth');
+const { assertApiSuccess, assertApiError, authHeaders } = require('../../helpers/utils');
+
+test.describe('【家长】能量仪表盘', () => {
+  var auth;
+
+  test.beforeAll(async ({ browser }) => {
+    auth = await loginAs(browser, 'parent');
+  });
+
+  test('[场景1] 查看能量概览 — 期望返回维度数据', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/energy/overview', {
+      headers: authHeaders(auth),
+      data: {
+        familyId: 2001
+      }
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data).toBeDefined();
+    expect(data.dimensions || data).toBeDefined();
+  });
+
+  test('[场景2] 查看能量流水列表 — 期望返回记录列表', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/energy/flow/list', {
+      headers: authHeaders(auth),
+      data: {
+        familyId: 2001,
+        page: 1,
+        pageSize: 20
+      }
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data).toBeDefined();
+    expect(Array.isArray(data) ? data : data.list || data.records || []).toBeDefined();
+  });
+
+  test('[场景3] 查看家庭成员能量详情 — 期望返回成员能量数据', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/energy/member/detail', {
+      headers: authHeaders(auth),
+      data: {
+        familyId: 2001,
+        userId: 1003
+      }
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data).toBeDefined();
+  });
+
+  test('[场景4] 查看能量配置 — 期望返回维度配置信息', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/energy/config', {
+      headers: authHeaders(auth),
+      data: {}
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data).toBeDefined();
+  });
+
+  test('[场景5] 能量概览失败 — 无效的familyId期望返回错误', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/energy/overview', {
+      headers: authHeaders(auth),
+      data: {
+        familyId: 999999
+      }
+    });
+    await assertApiError(resp);
+  });
+});

tests/e2e/roles/parent/family-management.spec.js

@@ -0,0 +1,105 @@
+const { test, expect } = require('@playwright/test');
+const { loginAs, BASE_URL } = require('../../helpers/auth');
+const { assertApiSuccess, assertApiError, authHeaders } = require('../../helpers/utils');
+
+test.describe('【家长】家庭管理', () => {
+  var auth;
+
+  test.beforeAll(async ({ browser }) => {
+    auth = await loginAs(browser, 'parent');
+  });
+
+  test('[场景1] 获取关系类型列表 — 期望返回关系类型列表且数据长度大于0', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/family/relation-types', {
+      headers: authHeaders(auth),
+      data: {}
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data).toBeDefined();
+    expect(Array.isArray(data) ? data.length : Object.keys(data).length).toBeGreaterThan(0);
+  });
+
+  test('[场景2] 添加家庭成员 — 期望返回成功', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/family/member/add', {
+      headers: authHeaders(auth),
+      data: {
+        userId: 1004,
+        relationType: 'child',
+        familyId: 2001
+      }
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data).toBeDefined();
+  });
+
+  test('[场景3] 查看家庭成员列表 — 期望返回成员数组', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/family/member/list', {
+      headers: authHeaders(auth),
+      data: {
+        familyId: 2001
+      }
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data).toBeDefined();
+    expect(Array.isArray(data) ? data : []).toBeDefined();
+  });
+
+  test('[场景4] 更新成员关系 — 期望返回成功', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/family/member/update', {
+      headers: authHeaders(auth),
+      data: {
+        userId: 1004,
+        relationType: 'child',
+        familyId: 2001
+      }
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data).toBeDefined();
+  });
+
+  test('[场景5] 切换到孩子视角 — 期望响应中包含token', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/family/member/switch', {
+      headers: authHeaders(auth),
+      data: {
+        userId: 1003
+      }
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data).toBeDefined();
+    expect(data.token || data).toBeDefined();
+  });
+
+  test('[场景6] 移除家庭成员 — 期望返回成功', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/family/member/remove', {
+      headers: authHeaders(auth),
+      data: {
+        userId: 1004,
+        familyId: 2001
+      }
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data).toBeDefined();
+  });
+
+  test('[场景7] 添加家庭成员失败 — 无效的familyId期望返回错误', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/family/member/add', {
+      headers: authHeaders(auth),
+      data: {
+        userId: 1004,
+        relationType: 'child',
+        familyId: 999999
+      }
+    });
+    await assertApiError(resp);
+  });
+
+  test('[场景8] 切换到不存在的成员视角 — 期望返回错误', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/family/member/switch', {
+      headers: authHeaders(auth),
+      data: {
+        userId: 999999
+      }
+    });
+    await assertApiError(resp);
+  });
+});

tests/e2e/roles/parent/points.spec.js

@@ -0,0 +1,77 @@
+const { test, expect } = require('@playwright/test');
+const { loginAs, BASE_URL } = require('../../helpers/auth');
+const { assertApiSuccess, assertApiError, authHeaders } = require('../../helpers/utils');
+
+test.describe('【家长】积分管理', () => {
+  var auth;
+
+  test.beforeAll(async ({ browser }) => {
+    auth = await loginAs(browser, 'parent');
+  });
+
+  test('[场景1] 查看积分余额 — 期望返回balance或points字段', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/points/balance', {
+      headers: authHeaders(auth),
+      data: {
+        userId: 1002
+      }
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data).toBeDefined();
+    expect(data.balance !== undefined || data.points !== undefined || data).toBeDefined();
+  });
+
+  test('[场景2] 查看积分流水列表 — 期望返回列表数据', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/points/flow/list', {
+      headers: authHeaders(auth),
+      data: {
+        userId: 1002,
+        page: 1,
+        pageSize: 20
+      }
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data).toBeDefined();
+    expect(Array.isArray(data) ? data : data.list || data.records || []).toBeDefined();
+  });
+
+  test('[场景3] 查看积分明细 — 期望返回积分详情', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/points/detail', {
+      headers: authHeaders(auth),
+      data: {
+        userId: 1002
+      }
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data).toBeDefined();
+  });
+
+  test('[场景4] 查看家庭积分汇总 — 期望返回家庭积分总额', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/points/family/summary', {
+      headers: authHeaders(auth),
+      data: {
+        familyId: 2001
+      }
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data).toBeDefined();
+  });
+
+  test('[场景5] 积分余额查询失败 — 无效的userId期望返回错误', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/points/balance', {
+      headers: authHeaders(auth),
+      data: {
+        userId: 999999
+      }
+    });
+    await assertApiError(resp);
+  });
+
+  test('[场景6] 积分流水查询失败 — 空参数期望返回错误', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/points/flow/list', {
+      headers: authHeaders(auth),
+      data: {}
+    });
+    await assertApiError(resp);
+  });
+});

tests/e2e/roles/parent/wish-management.spec.js

@@ -0,0 +1,68 @@
+const { test, expect } = require('@playwright/test');
+const { loginAs, BASE_URL } = require('../../helpers/auth');
+const { assertApiSuccess, assertApiError, authHeaders } = require('../../helpers/utils');
+
+test.describe('【家长】心愿管理', () => {
+  var auth;
+
+  test.beforeAll(async ({ browser }) => {
+    auth = await loginAs(browser, 'parent');
+  });
+
+  test('[场景1] 查看孩子心愿列表 — 期望返回心愿数据', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/wishes/list', {
+      headers: authHeaders(auth),
+      data: {
+        childUserId: 1003
+      }
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data).toBeDefined();
+  });
+
+  test('[场景2] 审批通过心愿兑换 — 期望返回成功', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/wishes/approve', {
+      headers: authHeaders(auth),
+      data: {
+        wishId: 1,
+        action: 'approve'
+      }
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data).toBeDefined();
+  });
+
+  test('[场景3] 拒绝心愿 — 期望返回成功', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/wishes/reject', {
+      headers: authHeaders(auth),
+      data: {
+        wishId: 1,
+        reason: '不符合兑换条件'
+      }
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data).toBeDefined();
+  });
+
+  test('[场景4] 查看心愿详情 — 期望返回心愿详细信息', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/wishes/detail', {
+      headers: authHeaders(auth),
+      data: {
+        wishId: 1
+      }
+    });
+    var data = await assertApiSuccess(resp);
+    expect(data).toBeDefined();
+  });
+
+  test('[场景5] 心愿审批失败 — 无效的wishId期望返回错误', async ({ page }) => {
+    var resp = await page.request.post(BASE_URL + '/api/wishes/approve', {
+      headers: authHeaders(auth),
+      data: {
+        wishId: 999999,
+        action: 'approve'
+      }
+    });
+    await assertApiError(resp);
+  });
+});

tests/e2e/roles/teacher/family-binding.spec.js

@@ -0,0 +1,129 @@
+/**
+ * ================================================================
+ * Teacher Family Binding E2E Tests
+ * ================================================================
+ * Tests for teacher (成长规划师) family binding operations
+ *
+ * Seed data: teacher userId=1005 phone=13800000001, familyId=2001 bound
+ * ================================================================
+ */
+
+var BASE_URL = process.env.PW_BASE_URL || 'http://cfc.iwintrue.com';
+
+var test = require('../../../helpers/auth');
+var utils = require('../../../helpers/utils');
+
+test.describe('Teacher Family Binding Tests', function() {
+  var auth;
+
+  test.beforeAll(async function() {
+    // Login as teacher before all tests
+    auth = await test.loginAs(browser, 'teacher');
+  });
+
+  test('Scene 1: Generate bind invite link - expect invite token', async function() {
+    var headers = utils.authHeaders(auth);
+
+    // Create invite link for family binding
+    var response = await page.request.post(BASE_URL + '/api/guide/invite/create', {
+      data: {
+        familyId: 2001
+      },
+      headers: headers
+    });
+
+    var data = await utils.assertApiSuccess(response);
+
+    // Verify invite token is returned
+    if (!data || !data.inviteToken) {
+      throw new Error('Expected inviteToken in response but got: ' + JSON.stringify(data));
+    }
+
+    console.log('Invite link created: inviteToken=' + data.inviteToken.substring(0, 20) + '...');
+  });
+
+  test('Scene 1b: Create invite with invalid params - expect error', async function() {
+    var headers = utils.authHeaders(auth);
+
+    // Try to create invite with invalid familyId
+    var response = await page.request.post(BASE_URL + '/api/guide/invite/create', {
+      data: {
+        familyId: -1
+      },
+      headers: headers
+    });
+
+    // Should return error
+    await utils.assertApiError(response);
+
+    console.log('Invalid params correctly returned error');
+  });
+
+  test('Scene 2: View bound family list - expect data', async function() {
+    var headers = utils.authHeaders(auth);
+
+    // Get list of bound families
+    var response = await page.request.post(BASE_URL + '/api/guide/families/list', {
+      data: {},
+      headers: headers
+    });
+
+    var data = await utils.assertApiSuccess(response);
+
+    // Verify data is returned (array of families)
+    if (!data || !Array.isArray(data)) {
+      throw new Error('Expected array of families but got: ' + JSON.stringify(data));
+    }
+
+    // Verify at least one family is bound (familyId=2001 from seed data)
+    if (data.length === 0) {
+      throw new Error('Expected at least one bound family but got empty list');
+    }
+
+    // Check if familyId 2001 is in the list
+    var foundFamily2001 = false;
+    for (var i = 0; i < data.length; i++) {
+      if (data[i].familyId === 2001 || data[i].id === 2001) {
+        foundFamily2001 = true;
+        break;
+      }
+    }
+
+    console.log('Bound families list: ' + JSON.stringify(data));
+    console.log('Found family 2001: ' + foundFamily2001);
+  });
+
+  test('Scene 3: Unbind family - verify success', async function() {
+    var headers = utils.authHeaders(auth);
+
+    // First get the list to find a bindId or familyId to unbind
+    var listResponse = await page.request.post(BASE_URL + '/api/guide/families/list', {
+      data: {},
+      headers: headers
+    });
+
+    var families = await utils.assertApiSuccess(listResponse);
+
+    if (!families || families.length === 0) {
+      console.log('No families to unbind, skipping test');
+      return;
+    }
+
+    // Get the first family's bindId or familyId
+    var bindId = families[0].bindId || families[0].id || families[0].familyId;
+
+    // Unbind the family
+    var unbindResponse = await page.request.post(BASE_URL + '/api/guide/families/unbind', {
+      data: {
+        bindId: bindId
+      },
+      headers: headers
+    });
+
+    var unbindData = await utils.assertApiSuccess(unbindResponse);
+
+    console.log('Family unbound successfully: bindId=' + bindId);
+  });
+});
+
+module.exports = {};

tests/e2e/roles/teacher/login.spec.js

@@ -0,0 +1,106 @@
+/**
+ * ================================================================
+ * Teacher Login E2E Tests
+ * ================================================================
+ * Tests for teacher (成长规划师) role authentication and multi-role capability
+ *
+ * Seed data: teacher userId=1005 phone=13800000001
+ * ================================================================
+ */
+
+var BASE_URL = process.env.PW_BASE_URL || 'http://cfc.iwintrue.com';
+
+var test = require('../../../helpers/auth');
+
+test.describe('Teacher Login Tests', function() {
+  var auth;
+
+  test.beforeAll(async function() {
+    // Login as teacher before all tests
+    auth = await test.loginAs(browser, 'teacher');
+  });
+
+  test('Scene 1: Teacher login - verify token and role', async function() {
+    // Verify token is obtained
+    if (!auth.token) {
+      throw new Error('Failed to obtain token for teacher login');
+    }
+
+    // Verify role is teacher
+    if (auth.role !== 'teacher') {
+      throw new Error('Expected role to be teacher but got ' + auth.role);
+    }
+
+    // Verify userId matches seed data
+    if (auth.userId !== 1005) {
+      throw new Error('Expected userId 1005 but got ' + auth.userId);
+    }
+
+    console.log('Teacher login successful: token=' + auth.token.substring(0, 20) + '..., role=' + auth.role);
+  });
+
+  test('Scene 2: Teacher has multi-role capability - check roles field contains teacher and parent', async function() {
+    // Make API call to get user info with roles
+    var context = await browser.newContext();
+    var page = await context.newPage();
+
+    // Set token in localStorage
+    await page.goto(BASE_URL, { waitUntil: 'networkidle', timeout: 30000 });
+    await page.evaluate(function(token) {
+      localStorage.setItem('token', token);
+      localStorage.setItem('access_token', token);
+    }, auth.token);
+
+    // Call user info API to get roles
+    var response = await page.request.get(BASE_URL + '/api/user/info', {
+      headers: {
+        Authorization: 'Bearer ' + auth.token,
+        'Content-Type': 'application/json'
+      }
+    });
+
+    var body = await response.json();
+
+    // Verify response structure
+    if (body.code !== 200) {
+      throw new Error('Failed to get user info: ' + (body.message || 'Unknown error'));
+    }
+
+    var userData = body.data;
+
+    // Check if roles field exists and contains teacher and parent
+    var roles = userData.roles || userData.roleList || [];
+
+    // If roles is a string, convert to array
+    if (typeof roles === 'string') {
+      roles = roles.split(',');
+    }
+
+    // Verify teacher role exists
+    var hasTeacherRole = false;
+    var hasParentRole = false;
+
+    for (var i = 0; i < roles.length; i++) {
+      if (roles[i] === 'teacher') {
+        hasTeacherRole = true;
+      }
+      if (roles[i] === 'parent') {
+        hasParentRole = true;
+      }
+    }
+
+    if (!hasTeacherRole) {
+      throw new Error('Teacher role not found in roles: ' + JSON.stringify(roles));
+    }
+
+    if (!hasParentRole) {
+      throw new Error('Parent role not found in roles: ' + JSON.stringify(roles));
+    }
+
+    console.log('Teacher multi-role verified: roles=' + JSON.stringify(roles));
+
+    await context.close();
+  });
+});
+
+module.exports = {};

tests/e2e/seed-data.sql

@@ -0,0 +1,161 @@
+USE cfc;
+
+-- ============================================================
+-- E2E Test Seed Data
+-- ============================================================
+
+-- Disable FK checks temporarily for clean deletion
+SET FOREIGN_KEY_CHECKS = 0;
+
+-- ============================================================
+-- DELETE from all relevant tables in FK dependency order
+-- ============================================================
+
+-- Delete child tables first (referencing other tables)
+DELETE FROM points_log;
+DELETE FROM task_reviews;
+DELETE FROM media_records;
+DELETE FROM task_plan_items;
+DELETE FROM task_plan_instances;
+DELETE FROM task_template_items;
+DELETE FROM task_template_packages;
+DELETE FROM guide_families;
+DELETE FROM teacher_messages;
+DELETE FROM growth_records;
+DELETE FROM dan_assessment_results;
+DELETE FROM dan_assessments;
+DELETE FROM assessment_appointments;
+DELETE FROM focus_sessions;
+DELETE FROM game_records;
+DELETE FROM child_badge;
+DELETE FROM energy_log;
+DELETE FROM energy_balance;
+DELETE FROM streak_milestones;
+DELETE FROM points_reset_log;
+DELETE FROM reward_wishlists;
+DELETE FROM wishes;
+DELETE FROM rewards;
+DELETE FROM reward_categories;
+DELETE FROM tasks;
+DELETE FROM invite_card;
+DELETE FROM activity_registrations;
+DELETE FROM guide_invite_codes;
+DELETE FROM guide_commissions;
+DELETE FROM guide_service_logs;
+DELETE FROM guide_orders;
+DELETE FROM guide_application_records;
+DELETE FROM guide_applications;
+DELETE FROM package_orders;
+DELETE FROM assessment_orders;
+DELETE FROM assessment_records;
+DELETE FROM product_orders;
+DELETE FROM product_skus;
+DELETE FROM user_coupon;
+DELETE FROM user_address;
+DELETE FROM family_relationships;
+DELETE FROM family_member_attributes;
+
+-- Delete tables with FK to users/families
+DELETE FROM family_members;
+DELETE FROM guides;
+DELETE FROM admins;
+DELETE FROM users;
+DELETE FROM families;
+
+-- Delete content tables
+DELETE FROM articles;
+DELETE FROM activities;
+DELETE FROM products;
+
+-- Re-enable FK checks
+SET FOREIGN_KEY_CHECKS = 1;
+
+-- ============================================================
+-- INSERT test family
+-- ============================================================
+
+INSERT IGNORE INTO families (id, name, invite_code, created_at, updated_at) VALUES
+(2001, '测试幸福家庭', 'TEST2001', NOW(), NOW());
+
+-- ============================================================
+-- INSERT test users (IDs 1001-1009)
+-- ============================================================
+
+-- 1001: admin
+INSERT IGNORE INTO users (id, openid, unionid, family_id, role, nickname, phone, created_at, updated_at) VALUES
+(1001, 'openid_admin_1001', NULL, 0, 'admin', '管理员', '13800138000', NOW(), NOW());
+
+-- 1002: parent, family_id 2001
+INSERT IGNORE INTO users (id, openid, unionid, family_id, role, nickname, phone, created_at, updated_at) VALUES
+(1002, 'openid_parent_1002', NULL, 2001, 'parent', '家长用户', '13701366188', NOW(), NOW());
+
+-- 1003: child, family_id 2001
+INSERT IGNORE INTO users (id, openid, unionid, family_id, role, nickname, phone, created_at, updated_at) VALUES
+(1003, 'openid_child_1003', NULL, 2001, 'child', '孩子用户A', '13701366189', NOW(), NOW());
+
+-- 1004: child, family_id 2001
+INSERT IGNORE INTO users (id, openid, unionid, family_id, role, nickname, phone, created_at, updated_at) VALUES
+(1004, 'openid_child_1004', NULL, 2001, 'child', '孩子用户B', '13701366190', NOW(), NOW());
+
+-- 1005: teacher, roles '["teacher","parent"]', teacher_status 'active'
+INSERT IGNORE INTO users (id, openid, unionid, family_id, role, nickname, phone, teacher_status, roles, created_at, updated_at) VALUES
+(1005, 'openid_teacher_1005', NULL, 0, 'teacher', '成长规划师', '13800000001', 'active', '["teacher","parent"]', NOW(), NOW());
+
+-- 1006: nutritionist (teacher role with nutritionist vendor_type placeholder)
+INSERT IGNORE INTO users (id, openid, unionid, family_id, role, nickname, phone, teacher_status, roles, created_at, updated_at) VALUES
+(1006, 'openid_nutritionist_1006', NULL, 0, 'teacher', '营养师', '13800000010', 'active', '["teacher"]', NOW(), NOW());
+
+-- 1007: butler (teacher role)
+INSERT IGNORE INTO users (id, openid, unionid, family_id, role, nickname, phone, teacher_status, roles, created_at, updated_at) VALUES
+(1007, 'openid_butler_1007', NULL, 0, 'teacher', '管家', '13800000020', 'active', '["teacher"]', NOW(), NOW());
+
+-- 1008: assessor (teacher role)
+INSERT IGNORE INTO users (id, openid, unionid, family_id, role, nickname, phone, teacher_status, roles, created_at, updated_at) VALUES
+(1008, 'openid_assessor_1008', NULL, 0, 'teacher', '测评师', '13800000030', 'active', '["teacher"]', NOW(), NOW());
+
+-- 1009: vendor
+INSERT IGNORE INTO users (id, openid, unionid, family_id, role, nickname, phone, created_at, updated_at) VALUES
+(1009, 'openid_vendor_1009', NULL, 0, 'vendor', '供应商', '13800138001', NOW(), NOW());
+
+-- ============================================================
+-- INSERT family_members records linking family 2001 to users 1002, 1003, 1004
+-- ============================================================
+
+INSERT IGNORE INTO family_members (id, family_id, user_id, nickname, phone, gender, birthday, generation, is_spouse, show_to_family, total_points, system_points, streak_days, created_at, updated_at) VALUES
+(2001, 2001, 1002, '家长用户', '13701366188', 'male', '1985-01-01', 0, 0, 1, 0, 0, NOW(), NOW());
+
+INSERT IGNORE INTO family_members (id, family_id, user_id, nickname, phone, gender, birthday, generation, is_spouse, show_to_family, total_points, system_points, streak_days, created_at, updated_at) VALUES
+(2002, 2001, 1003, '孩子用户A', '13701366189', 'male', '2015-06-15', -1, 0, 1, 0, 0, NOW(), NOW());
+
+INSERT IGNORE INTO family_members (id, family_id, user_id, nickname, phone, gender, birthday, generation, is_spouse, show_to_family, total_points, system_points, streak_days, created_at, updated_at) VALUES
+(2003, 2001, 1004, '孩子用户B', '13701366190', 'female', '2018-03-20', -1, 0, 1, 0, 0, NOW(), NOW());
+
+-- ============================================================
+-- INSERT 2 test articles (draft + published)
+-- ============================================================
+
+INSERT IGNORE INTO articles (id, category_id, title, summary, cover_image, content, tags, author, read_time, article_type, word_count, related_dimensions, visibility, status, is_featured, published_at, view_count, created_by, created_at, updated_at) VALUES
+(1001, 1, 'E2E测试文章-草稿', '这是一篇草稿状态的文章，用于E2E测试', '', '<p>草稿文章内容</p>', '["测试"]', '浠艾福', 5, 'normal', 100, '["mind"]', 'public', 'draft', 0, NULL, 0, 1001, NOW(), NOW());
+
+INSERT IGNORE INTO articles (id, category_id, title, summary, cover_image, content, tags, author, read_time, article_type, word_count, related_dimensions, visibility, status, is_featured, published_at, view_count, created_by, created_at, updated_at) VALUES
+(1002, 1, 'E2E测试文章-已发布', '这是一篇已发布状态的文章，用于E2E测试', '', '<p>已发布文章内容</p>', '["测试"]', '浠艾福', 10, 'original', 200, '["body","mind"]', 'public', 'published', 1, NOW(), 100, 1001, NOW(), NOW());
+
+-- ============================================================
+-- INSERT 2 test activities (pending + published)
+-- ============================================================
+
+INSERT IGNORE INTO activities (id, title, description, cover_image, dimension_code, dimension_weights, activity_type, status, start_time, end_time, location, max_participants, current_participants, price, vendor_id, vendor_name, created_at, updated_at) VALUES
+(1001, 'E2E测试活动-待审核', '这是一个待审核状态的活动，用于E2E测试', '', 'mind', '{"body":0,"mind":50,"wisdom":50,"action":0,"wealth":0}', 'offline', 'pending', DATE_ADD(NOW(), INTERVAL 7 DAY), DATE_ADD(NOW(), INTERVAL 14 DAY), '测试地点', 20, 0, 10000, 1005, '成长规划师', NOW(), NOW());
+
+INSERT IGNORE INTO activities (id, title, description, cover_image, dimension_code, dimension_weights, activity_type, status, start_time, end_time, location, max_participants, current_participants, price, vendor_id, vendor_name, created_at, updated_at) VALUES
+(1002, 'E2E测试活动-已发布', '这是一个已发布状态的活动，用于E2E测试', '', 'body', '{"body":60,"mind":20,"wisdom":20,"action":0,"wealth":0}', 'offline', 'published', DATE_ADD(NOW(), INTERVAL 3 DAY), DATE_ADD(NOW(), INTERVAL 10 DAY), '测试地点2', 30, 5, 5000, 1005, '成长规划师', NOW(), NOW());
+
+-- ============================================================
+-- INSERT 2 test products
+-- ============================================================
+
+INSERT IGNORE INTO products (id, name, description, intro, cover_image, images, price, stock, sales_count, product_type, vendor_id, vendor_name, status, member_price, member_eligible, domain, dimension_weights, profit_rate, delivery_method, category_id, created_at, updated_at) VALUES
+(1001, 'E2E测试商品-草稿', '这是一个草稿状态的商品，用于E2E测试', '详细介绍', '', NULL, 9999, 100, 0, 'service', 1009, '供应商', 'draft', 7999, 'all', 'mind', '{"body":0,"mind":100,"wisdom":0,"action":0,"wealth":0}', 100, 1, NULL, NOW(), NOW());
+
+INSERT IGNORE INTO products (id, name, description, intro, cover_image, images, price, stock, sales_count, product_type, vendor_id, vendor_name, status, member_price, member_eligible, domain, dimension_weights, profit_rate, delivery_method, category_id, created_at, updated_at) VALUES
+(1002, 'E2E测试商品-已上架', '这是一个已上架状态的商品，用于E2E测试', '详细介绍', '', NULL, 19999, 50, 10, 'course', 1009, '供应商', 'on_shelf', 15999, 'budget', 'wisdom', '{"body":0,"mind":0,"wisdom":100,"action":0,"wealth":0}', 150, 3, NULL, NOW(), NOW());

tests/playwright.config.js

@@ -7,20 +7,25 @@
  *   PW_BASE_URL=http://cfc.iwintrue.com npx playwright test
  */
 
+var path = require('path');
+
 var _proto = 'http' + ':';
 var _host = 'cfc.iwintrue.com';
 var _baseUrl = _proto + String.fromCharCode(47,47) + _host;
 
 module.exports = {
   testDir: require('path').join(__dirname, 'e2e'),
-  timeout: 60000,
-  retries: 0,
+  globalSetup: path.join(__dirname, 'e2e', 'helpers', 'db.js'),
+  timeout: 120000,
+  retries: 1,
   use: {
     baseURL: process.env.PW_BASE_URL ? process.env.PW_BASE_URL : _baseUrl,
     headless: true,
     ignoreHTTPSErrors: true,
     actionTimeout: 15000,
     navigationTimeout: 30000,
+    screenshot: 'only-on-failure',
+    trace: 'retain-on-failure',
   },
   projects: [
     {
@@ -30,6 +35,13 @@ module.exports = {
         viewport: { width: 1440, height: 900 },
       },
     },
+    {
+      name: 'mobile',
+      use: {
+        browserName: 'chromium',
+        viewport: { width: 375, height: 812 },
+      },
+    },
   ],
   reporter: [
     ['html', { outputFolder: 'playwright-report' }],