everything-is-suitable/everything-is-suitable-test/e2e/business-flows/role-management-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 { RoleManagementPage } from '../pages/role-management-page.js';
import {
  createRoleWorkflow,
  editRoleWorkflow,
  deleteRoleWorkflow,
  assignPermissionsWorkflow,
  roleLifecycleWorkflow,
  RoleWorkflowContext
} from '../workflows/role-management-workflow.js';

test.describe('角色管理端到端测试', () => {
  let page: Page;
  let testLogger: TestLogger;
  let testDataManager: TestDataManager;
  let workflowExecutor: WorkflowExecutor;
  let testReporter: TestReporter;
  let loginPage: LoginPage;
  let roleManagementPage: RoleManagementPage;
  let workflowContext: RoleWorkflowContext;

  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);
    roleManagementPage = new RoleManagementPage(page);

    workflowContext = {
      page,
      testLogger,
      testDataManager,
      loginPage,
      roleManagementPage
    };

    testReporter.startSuite('角色管理端到端测试');
  });

  test.afterAll(async () => {
    await testDataManager.cleanupAll();
    testReporter.endSuite();
    testReporter.generateHTMLReport('角色管理E2E测试报告');
    testReporter.generateJSONReport();
    testReporter.generateJUnitReport();
    await page.close();
  });

  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 = createRoleWorkflow(workflowContext);
      const result = await workflowExecutor.execute(workflow, {
        maxRetries: 3,
        retryDelay: 2000,
        enableRollback: true
      });

      expect(result.success).toBe(true);
      expect(workflowContext.createdRole).toBeDefined();

      testReporter.endTest('passed');
    } catch (error) {
      testReporter.endTest('failed', error as Error);
      throw error;
    }
  });

  test('应该成功编辑现有角色', async () => {
    testReporter.startTest('编辑现有角色');

    try {
      const createWorkflow = createRoleWorkflow(workflowContext);
      await workflowExecutor.execute(createWorkflow, {
        maxRetries: 3,
        enableRollback: true
      });

      expect(workflowContext.createdRole).toBeDefined();

      const editWorkflow = editRoleWorkflow(workflowContext, workflowContext.createdRole?.name);
      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 = createRoleWorkflow(workflowContext);
      await workflowExecutor.execute(createWorkflow, {
        maxRetries: 3,
        enableRollback: true
      });

      expect(workflowContext.createdRole).toBeDefined();

      const deleteWorkflow = deleteRoleWorkflow(workflowContext, workflowContext.createdRole?.name);
      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 createWorkflow = createRoleWorkflow(workflowContext);
      await workflowExecutor.execute(createWorkflow, {
        maxRetries: 3,
        enableRollback: true
      });

      expect(workflowContext.createdRole).toBeDefined();

      const permissionsWorkflow = assignPermissionsWorkflow(workflowContext, workflowContext.createdRole?.name);
      const result = await workflowExecutor.execute(permissionsWorkflow, {
        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 = roleLifecycleWorkflow(workflowContext);
      const result = await workflowExecutor.execute(workflow, {
        maxRetries: 3,
        retryDelay: 2000,
        enableRollback: true,
        timeout: 300000
      });

      expect(result.success).toBe(true);
      expect(result.completedSteps).toContain('createRole');
      expect(result.completedSteps).toContain('assignPermissions');
      expect(result.completedSteps).toContain('editRole');
      expect(result.completedSteps).toContain('deleteRole');

      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 = createRoleWorkflow(workflowContext);

      const result1 = await workflowExecutor.execute(workflow, {
        maxRetries: 3,
        enableRollback: false
      });
      expect(result1.success).toBe(true);

      const duplicateWorkflow = createRoleWorkflow({
        ...workflowContext,
        createdRole: {
          ...workflowContext.createdRole!,
          name: workflowContext.createdRole!.name
        }
      });

      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 = [];

      for (let i = 0; i < 5; i++) {
        const context: RoleWorkflowContext = {
          page,
          testLogger,
          testDataManager,
          loginPage,
          roleManagementPage
        };
        workflows.push(createRoleWorkflow(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);

      testReporter.endTest('passed');
    } catch (error) {
      testReporter.endTest('failed', error as Error);
      throw error;
    }
  });

  test('应该验证角色搜索功能', async () => {
    testReporter.startTest('角色搜索功能验证');

    try {
      await loginPage.navigate();
      await loginPage.login('admin', 'admin123');
      await roleManagementPage.navigate();
      await roleManagementPage.waitForLoad();

      await roleManagementPage.searchRole('admin');
      const count = await roleManagementPage.getRoleCount();
      expect(count).toBeGreaterThanOrEqual(0);

      testReporter.endTest('passed');
    } catch (error) {
      testReporter.endTest('failed', error as Error);
      throw error;
    }
  });

  test('应该验证角色表单验证', async () => {
    testReporter.startTest('角色表单验证');

    try {
      await loginPage.navigate();
      await loginPage.login('admin', 'admin123');
      await roleManagementPage.navigate();
      await roleManagementPage.waitForLoad();

      await roleManagementPage.clickAddRole();

      await page.click('button[type="submit"]');

      const hasError = await page.locator('.el-form-item__error').isVisible();
      expect(hasError).toBe(true);

      testReporter.endTest('passed');
    } catch (error) {
      testReporter.endTest('failed', error as Error);
      throw error;
    }
  });
});