everything-is-suitable/everything-is-suitable-test/e2e/business-flows/user-lifecycle-e2e.spec.ts

/**
 * 用户生命周期端到端测试
 * 测试用户从创建到删除的完整业务流程
 */

import { test, expect, Page } from '@playwright/test';
import { TestLogger } from '../core/test-logger.js';
import { TestDataManager } from '../core/test-data-manager.js';
import { WorkflowExecutor } from '../core/workflow-executor.js';
import { TestReporter } from '../core/test-reporter.js';
import { LoginPage } from '../pages/login-page.js';
import { UserManagementPage } from '../pages/user-management-page.js';
import { 
  createUserWorkflow, 
  editUserWorkflow, 
  deleteUserWorkflow,
  userLifecycleWorkflow,
  UserWorkflowContext 
} from '../workflows/user-management-workflow.js';

test.describe('用户生命周期端到端测试', () => {
  let page: Page;
  let testLogger: TestLogger;
  let testDataManager: TestDataManager;
  let workflowExecutor: WorkflowExecutor;
  let testReporter: TestReporter;
  let loginPage: LoginPage;
  let userManagementPage: UserManagementPage;
  let workflowContext: UserWorkflowContext;

  test.beforeAll(async ({ browser }) => {
    page = await browser.newPage();
    testLogger = new TestLogger();
    testDataManager = TestDataManager.getInstance(testLogger);
    workflowExecutor = new WorkflowExecutor(testLogger);
    testReporter = new TestReporter(testLogger);
    
    loginPage = new LoginPage(page, testLogger);
    userManagementPage = new UserManagementPage(page);
    
    workflowContext = {
      page,
      testLogger,
      testDataManager,
      loginPage,
      userManagementPage
    };

    testReporter.startSuite('用户生命周期端到端测试');
  });

  test.afterAll(async () => {
    // 清理测试数据
    await testDataManager.cleanupAll();
    
    // 生成测试报告
    testReporter.endSuite();
    testReporter.generateHTMLReport('用户生命周期E2E测试报告');
    testReporter.generateJSONReport();
    testReporter.generateJUnitReport();
    
    await page.close();
  });

  test.beforeEach(async () => {
    testLogger.info('🔄 开始新的测试用例');
  });

  test.afterEach(async ({}, testInfo) => {
    // 如果测试失败，截图保存
    if (testInfo.status === 'failed') {
      const screenshotPath = `test-results/screenshots/${testInfo.title}-${Date.now()}.png`;
      await page.screenshot({ path: screenshotPath, fullPage: true });
      testReporter.addScreenshot(screenshotPath);
    }
  });

  test('应该成功创建新用户', async () => {
    testReporter.startTest('创建新用户');
    
    try {
      const workflow = createUserWorkflow(workflowContext);
      const result = await workflowExecutor.execute(workflow, {
        maxRetries: 3,
        retryDelay: 2000,
        enableRollback: true
      });

      expect(result.success).toBe(true);
      expect(workflowContext.createdUser).toBeDefined();
      
      testReporter.endTest('passed');
    } catch (error) {
      testReporter.endTest('failed', error as Error);
      throw error;
    }
  });

  test('应该成功编辑现有用户', async () => {
    testReporter.startTest('编辑现有用户');
    
    try {
      // 首先创建一个用户用于编辑
      const createWorkflow = createUserWorkflow(workflowContext);
      await workflowExecutor.execute(createWorkflow, {
        maxRetries: 3,
        enableRollback: true
      });

      expect(workflowContext.createdUser).toBeDefined();
      
      // 然后编辑该用户
      const editWorkflow = editUserWorkflow(workflowContext, workflowContext.createdUser?.username);
      const result = await workflowExecutor.execute(editWorkflow, {
        maxRetries: 3,
        enableRollback: false
      });

      expect(result.success).toBe(true);
      testReporter.endTest('passed');
    } catch (error) {
      testReporter.endTest('failed', error as Error);
      throw error;
    }
  });

  test('应该成功删除用户', async () => {
    testReporter.startTest('删除用户');
    
    try {
      // 首先创建一个用户用于删除
      const createWorkflow = createUserWorkflow(workflowContext);
      await workflowExecutor.execute(createWorkflow, {
        maxRetries: 3,
        enableRollback: true
      });

      expect(workflowContext.createdUser).toBeDefined();
      
      // 然后删除该用户
      const deleteWorkflow = deleteUserWorkflow(workflowContext, workflowContext.createdUser?.username);
      const result = await workflowExecutor.execute(deleteWorkflow, {
        maxRetries: 3,
        enableRollback: false
      });

      expect(result.success).toBe(true);
      testReporter.endTest('passed');
    } catch (error) {
      testReporter.endTest('failed', error as Error);
      throw error;
    }
  });

  test('应该完成完整的用户生命周期流程', async () => {
    testReporter.startTest('完整用户生命周期');
    
    try {
      const workflow = userLifecycleWorkflow(workflowContext);
      const result = await workflowExecutor.execute(workflow, {
        maxRetries: 3,
        retryDelay: 2000,
        enableRollback: true,
        timeout: 300000 // 5分钟超时
      });

      expect(result.success).toBe(true);
      expect(result.completedSteps).toContain('createUser');
      expect(result.completedSteps).toContain('editUser');
      expect(result.completedSteps).toContain('deleteUser');
      
      testLogger.success(`✅ 工作流执行完成，耗时: ${result.executionTime}ms`);
      testReporter.endTest('passed');
    } catch (error) {
      testReporter.endTest('failed', error as Error);
      throw error;
    }
  });

  test('应该处理创建用户的异常情况', async () => {
    testReporter.startTest('异常情况处理-创建用户');
    
    try {
      // 尝试创建重复用户
      const workflow = createUserWorkflow(workflowContext);
      
      // 第一次创建
      const result1 = await workflowExecutor.execute(workflow, {
        maxRetries: 3,
        enableRollback: false
      });
      expect(result1.success).toBe(true);
      
      // 尝试创建相同用户名的用户（应该失败）
      const duplicateWorkflow = createUserWorkflow({
        ...workflowContext,
        createdUser: {
          ...workflowContext.createdUser!,
          username: workflowContext.createdUser!.username // 使用相同的用户名
        }
      });
      
      const result2 = await workflowExecutor.execute(duplicateWorkflow, {
        maxRetries: 1,
        enableRollback: false
      });
      
      // 预期会失败，因为用户名已存在
      expect(result2.success).toBe(false);
      
      testReporter.endTest('passed');
    } catch (error) {
      testReporter.endTest('passed'); // 异常是预期的
    }
  });

  test('应该支持批量用户操作', async () => {
    testReporter.startTest('批量用户操作');
    
    try {
      const workflows = [];
      
      // 创建5个用户
      for (let i = 0; i < 5; i++) {
        const context: UserWorkflowContext = {
          page,
          testLogger,
          testDataManager,
          loginPage,
          userManagementPage
        };
        workflows.push(createUserWorkflow(context));
      }

      // 批量执行
      const results = await workflowExecutor.executeBatch(workflows, {
        maxRetries: 3,
        continueOnError: true,
        enableRollback: true
      });

      const successCount = results.filter(r => r.success).length;
      testLogger.info(`批量创建结果: ${successCount}/${workflows.length} 成功`);
      
      expect(successCount).toBeGreaterThanOrEqual(3); // 至少3个成功
      
      testReporter.endTest('passed');
    } catch (error) {
      testReporter.endTest('failed', error as Error);
      throw error;
    }
  });
});