自动化测试中的模式验证

自动化测试是现代软件开发中不可或缺的一环，而模式验证则是确保测试代码可维护性和可扩展性的关键。在JavaScript中，设计模式的应用能够显著提升自动化测试的效率，尤其是在处理复杂逻辑或动态数据时。通过合理运用模式验证，可以减少重复代码，增强测试的稳定性和可读性。

工厂模式在测试数据生成中的应用

工厂模式通过封装对象的创建过程，使得测试数据的生成更加灵活。例如，在测试用户注册功能时，可能需要生成大量不同属性的用户数据。使用工厂模式可以避免重复编写相似代码：

class UserFactory {
  static createUser(overrides = {}) {
    const defaultUser = {
      username: `user_${Math.random().toString(36).substring(2, 8)}`,
      email: `test${Math.random().toString(36).substring(2)}@example.com`,
      password: 'defaultPassword123'
    };
    return { ...defaultUser, ...overrides };
  }
}

// 测试用例
const adminUser = UserFactory.createUser({ role: 'admin' });
const guestUser = UserFactory.createUser({ role: 'guest', active: false });

这种方式使得测试数据易于维护，当用户模型发生变化时，只需修改工厂类即可。

策略模式处理多验证逻辑

在验证测试结果时，经常需要根据不同的条件应用不同的验证规则。策略模式可以将这些验证逻辑封装成独立的策略类：

class ValidationStrategy {
  validate(result) {
    throw new Error('必须实现validate方法');
  }
}

class StatusCodeValidation extends ValidationStrategy {
  validate(result) {
    return result.status === 200;
  }
}

class ResponseTimeValidation extends ValidationStrategy {
  constructor(maxTime) {
    super();
    this.maxTime = maxTime;
  }
  
  validate(result) {
    return result.responseTime <= this.maxTime;
  }
}

class Validator {
  constructor() {
    this.strategies = [];
  }
  
  addStrategy(strategy) {
    this.strategies.push(strategy);
  }
  
  validateAll(result) {
    return this.strategies.every(strategy => strategy.validate(result));
  }
}

// 使用示例
const validator = new Validator();
validator.addStrategy(new StatusCodeValidation());
validator.addStrategy(new ResponseTimeValidation(500));

const testResult = { status: 200, responseTime: 450 };
console.log(validator.validateAll(testResult)); // true

这种模式使得验证逻辑可以灵活组合，便于扩展新的验证规则。

观察者模式实现测试结果通知

在大型测试套件中，及时获取测试结果非常重要。观察者模式可以实现测试结果的多渠道通知：

class TestResultPublisher {
  constructor() {
    this.observers = [];
  }
  
  subscribe(observer) {
    this.observers.push(observer);
  }
  
  unsubscribe(observer) {
    this.observers = this.observers.filter(obs => obs !== observer);
  }
  
  notify(result) {
    this.observers.forEach(observer => observer.update(result));
  }
}

class EmailNotifier {
  update(result) {
    console.log(`发送邮件通知: 测试${result.success ? '通过' : '失败'}`);
  }
}

class SlackNotifier {
  update(result) {
    console.log(`发送Slack消息: 测试用例${result.testName}已完成`);
  }
}

// 使用示例
const publisher = new TestResultPublisher();
publisher.subscribe(new EmailNotifier());
publisher.subscribe(new SlackNotifier());

publisher.notify({ success: true, testName: '用户登录测试' });

装饰器模式增强测试功能

装饰器模式可以在不修改原有测试代码的情况下，为测试添加额外功能，如日志记录、性能监控等：

function withLogging(testFunc) {
  return function(...args) {
    console.log(`开始执行测试: ${testFunc.name}`);
    const start = Date.now();
    const result = testFunc.apply(this, args);
    const duration = Date.now() - start;
    console.log(`测试完成，耗时: ${duration}ms`);
    return result;
  };
}

class UserTests {
  @withLogging
  static testLogin() {
    // 实际的测试逻辑
    return true;
  }
}

// 执行测试
UserTests.testLogin();

单例模式管理测试配置

测试中经常需要共享配置信息，单例模式可以确保全局唯一配置实例：

class TestConfig {
  constructor() {
    if (TestConfig.instance) {
      return TestConfig.instance;
    }
    
    this.baseUrl = 'https://api.example.com';
    this.timeout = 5000;
    this.retryCount = 3;
    
    TestConfig.instance = this;
  }
}

// 使用示例
const config1 = new TestConfig();
const config2 = new TestConfig();

console.log(config1 === config2); // true
console.log(config1.baseUrl); // 'https://api.example.com'

组合模式构建复杂测试套件

对于层级结构的测试套件，组合模式可以统一处理单个测试用例和测试套件：

class TestComponent {
  run() {
    throw new Error('必须实现run方法');
  }
}

class TestCase extends TestComponent {
  constructor(name, testFunc) {
    super();
    this.name = name;
    this.testFunc = testFunc;
  }
  
  run() {
    console.log(`运行测试用例: ${this.name}`);
    return this.testFunc();
  }
}

class TestSuite extends TestComponent {
  constructor(name) {
    super();
    this.name = name;
    this.children = [];
  }
  
  add(component) {
    this.children.push(component);
  }
  
  run() {
    console.log(`开始测试套件: ${this.name}`);
    return this.children.map(child => child.run());
  }
}

// 使用示例
const suite = new TestSuite('用户模块测试');
suite.add(new TestCase('登录测试', () => true));
suite.add(new TestCase('注册测试', () => true));

const subSuite = new TestSuite('权限测试');
subSuite.add(new TestCase('管理员权限测试', () => true));
suite.add(subSuite);

suite.run();

模板方法模式定义测试流程

模板方法模式可以定义测试的标准流程，同时允许子类重写特定步骤：

class TestTemplate {
  runTest() {
    this.setup();
    this.execute();
    this.teardown();
  }
  
  setup() {
    console.log('默认设置');
  }
  
  execute() {
    throw new Error('必须实现execute方法');
  }
  
  teardown() {
    console.log('默认清理');
  }
}

class APITest extends TestTemplate {
  setup() {
    console.log('初始化API客户端');
  }
  
  execute() {
    console.log('发送API请求并验证响应');
  }
  
  teardown() {
    console.log('关闭API连接');
  }
}

// 使用示例
const test = new APITest();
test.runTest();

代理模式实现测试替身

代理模式可以创建测试替身(Mock/Stub)，用于隔离被测代码的依赖：

class RealDatabase {
  query(sql) {
    // 实际的数据库操作
    return '真实数据';
  }
}

class DatabaseProxy {
  constructor() {
    this.cache = {};
    this.realDatabase = new RealDatabase();
  }
  
  query(sql) {
    if (!this.cache[sql]) {
      console.log('从数据库获取数据');
      this.cache[sql] = this.realDatabase.query(sql);
    }
    return this.cache[sql];
  }
}

// 测试专用Mock
class MockDatabase {
  query(sql) {
    return '模拟数据';
  }
}

// 使用示例
function testUserService(database) {
  const result = database.query('SELECT * FROM users');
  console.log(result);
}

// 使用真实数据库
testUserService(new RealDatabase());

// 使用Mock数据库
testUserService(new MockDatabase());

状态模式处理测试流程状态

对于有复杂状态转换的测试场景，状态模式可以更好地管理状态逻辑：

class TestState {
  constructor(testRunner) {
    this.testRunner = testRunner;
  }
  
  start() {
    throw new Error('必须实现start方法');
  }
  
  complete() {
    throw new Error('必须实现complete方法');
  }
  
  fail() {
    throw new Error('必须实现fail方法');
  }
}

class PendingState extends TestState {
  start() {
    console.log('测试开始执行');
    this.testRunner.setState(new RunningState(this.testRunner));
  }
  
  complete() {
    console.log('测试尚未开始，不能直接完成');
  }
  
  fail() {
    console.log('测试尚未开始，不能标记为失败');
  }
}

class RunningState extends TestState {
  complete() {
    console.log('测试完成');
    this.testRunner.setState(new CompletedState(this.testRunner));
  }
  
  fail() {
    console.log('测试失败');
    this.testRunner.setState(new FailedState(this.testRunner));
  }
}

class TestRunner {
  constructor() {
    this.setState(new PendingState(this));
  }
  
  setState(state) {
    this.state = state;
  }
  
  start() {
    this.state.start();
  }
  
  complete() {
    this.state.complete();
  }
  
  fail() {
    this.state.fail();
  }
}

// 使用示例
const runner = new TestRunner();
runner.start();
runner.complete();