[Feature request] MockService 增加仅重置 mock 的方法

[cyjake]

The feature, motivation（功能、动机）

当前提供的 restoreAllMocks() 方法调用的是 MockService#restore()，后者除了会重置掉所有的 mock，还会清除原先配置过的 cache，也就是各种开发期 mock 和单元测试里调用的 mockClassProperty、mockContext etc.

给标准应用单元测试时，有一种效率比较高的单元测试执行方式：

1. beforeAll 初始化 app 实例
2. test suite 中按需 mock 各种 service、context
3. beforeEach 重置掉所有的 mock

这种执行方式，只需要调用一次 createApp。在实际案例中，由于 jest 默认是并发执行测试，beforeAll 只在当前测试文件生效，如果测试文件较多，仍然会出现需要多次 createApp 的情况，作为对比，我将运行框架替换成 mocha，原先需要 10 分钟跑完的单测，现在 5 分钟就可以

但是这种执行方式在第三步没办法直接用 restoreAllMocks()，因为这个方法会连同开发期 mock 一并清除，并且是连 cache 一起干掉，所以提议给 MockService 增加一个仅重置 mock 的方法，例如 MockService#restoreOnly()，保留 simulartorList 即可

  restoreOnly() {
    for (let i = this.mocks.length - 1; i >= 0; i--) {
      const m = this.mocks[i];
      if (!m.hasOwnProperty) {
        // Delete the mock key, use key on the prototype
        delete m.obj[m.key];
      } else {
        // Redefine the origin key instead of the mock key
        Object.defineProperty(m.obj, m.key, m.descriptor);
      }
    }
    this.mocks = [];
    this.contextMocks = [];
    this.cache.clear();
    // this.simulatorList = [];
    // MidwayMockService.prepareMocks = [];
  }

Alternatives（替代方案）

也可以调整现有的 MockService#restore() 方法，另外增加一个 restoreAndDestroy()，后者再去清除 simulatorList 以及处理 service destroy

Additional context（其他上下文）

No response

[waitingsong]

我也是用 mocha， 只在全局初始化一次 mockApp。不过不能并发测试

[cyjake]

嗯，想要并发的话，感觉得拆成单独的进程才可以，不然 service 或者 context mock 容易串，单测挺不好写的

[waitingsong]

业务级别单测我觉得还是串行的比较稳妥，虽然是单测但是可能会有（数据库的）数据依赖场景，并发测试出问题不容易debug

[cyjake]

@czy88840616 挺哥，上次聊到可以通过 mock 分组来支持，可否进一步描述这个方案，或者发一下相关的开发文档/代码，我可以尝试 pr 实现

[czy88840616]

大概是这样（AI 版本）

修改 core 中的 MidwayMockService，引用到的 mock 库里的可能也要改。

@Provide()
@Scope(ScopeEnum.Singleton)
export class MidwayMockService {
  protected mocks: Map<string, Array<{
    obj: any;
    key: string;
    descriptor: PropertyDescriptor;
    hasOwnProperty: boolean;
  }>> = new Map();
  protected contextMocks: Map<string, Array<{
    app: IMidwayApplication;
    key: string | ((ctx: IMidwayContext) => void);
    value: any;
  }>> = new Map();
  protected cache = new Map<any, Set<string>>();
  protected simulatorList: Array<ISimulation> = [];
  constructor(readonly applicationContext: IMidwayContainer) {}

  @Init()
  async init() {
    if (MidwayMockService.prepareMocks.length > 0) {
      for (const item of MidwayMockService.prepareMocks) {
        this.mockProperty(item.obj, item.key, item.value, item.group);
      }
      MidwayMockService.prepareMocks = [];
    }
  }

  static prepareMocks = [];

  static mockClassProperty(
    clzz: new (...args) => any,
    propertyName: string,
    value: any,
    group: string = 'default'
  ) {
    this.mockProperty(clzz.prototype, propertyName, value, group);
  }

  static mockProperty(obj: new (...args) => any, key: string, value: any, group: string = 'default') {
    this.prepareMocks.push({
      obj,
      key,
      value,
      group,
    });
  }

  public mockClassProperty(
    clzz: new (...args) => any,
    propertyName: string,
    value: any,
    group: string = 'default'
  ) {
    return this.mockProperty(clzz.prototype, propertyName, value, group);
  }

  public mockProperty(obj: any, key: string, value: any, group: string = 'default') {
    const hasOwnProperty = obj.hasOwnProperty(key);
    const mockItem = {
      obj,
      key,
      descriptor: Object.getOwnPropertyDescriptor(obj, key),
      hasOwnProperty,
    };

    if (!this.mocks.has(group)) {
      this.mocks.set(group, []);
    }
    this.mocks.get(group).push(mockItem);

    if (hasOwnProperty) {
      delete obj[key];
    }

    let flag = this.cache.get(obj);
    if (!flag) {
      flag = new Set();
      this.cache.set(obj, flag);
    }
    flag.add(key);

    const descriptor = this.overridePropertyDescriptor(value);
    Object.defineProperty(obj, key, descriptor);
  }

  public mockContext(
    app: IMidwayApplication,
    key: string | ((ctx: IMidwayContext) => void),
    value?: PropertyDescriptor | any,
    group: string = 'default'
  ) {
    if (!this.contextMocks.has(group)) {
      this.contextMocks.set(group, []);
    }
    this.contextMocks.get(group).push({
      app,
      key,
      value,
    });
  }

  @Destroy()
  restore(group?: string) {
    if (group) {
      this.restoreGroup(group);
    } else {
      for (const [group] of this.mocks) {
        this.restoreGroup(group);
      }
    }
  }

  private restoreGroup(group: string) {
    const groupMocks = this.mocks.get(group) || [];
    for (let i = groupMocks.length - 1; i >= 0; i--) {
      const m = groupMocks[i];
      if (!m.hasOwnProperty) {
        delete m.obj[m.key];
      } else {
        Object.defineProperty(m.obj, m.key, m.descriptor);
      }
    }
    this.mocks.delete(group);
    this.contextMocks.delete(group);
    this.cache.clear();
    this.simulatorList = this.simulatorList.filter(sim => sim['group'] !== group);
  }

  isMocked(obj, key) {
    const flag = this.cache.get(obj);
    return flag ? flag.has(key) : false;
  }

  applyContextMocks(app: IMidwayApplication, ctx: IMidwayContext) {
    for (const [, groupMocks] of this.contextMocks) {
      for (const mockItem of groupMocks) {
        if (mockItem.app === app) {
          const descriptor = this.overridePropertyDescriptor(mockItem.value);
          if (typeof mockItem.key === 'string') {
            Object.defineProperty(ctx, mockItem.key, descriptor);
          } else {
            mockItem.key(ctx);
          }
        }
      }
    }
  }

  getContextMocksSize() {
    return Array.from(this.contextMocks.values()).reduce((sum, group) => sum + group.length, 0);
  }

  // ... 其他方法保持不变 ...

  public async initSimulation(group: string = 'default') {
    const simulationModule: Array<new (...args) => ISimulation> =
      DecoratorManager.listModule(MOCK_KEY);

    for (const module of simulationModule) {
      const instance = await this.applicationContext.getAsync(module);
      if (await instance.enableCondition()) {
        instance['group'] = group;
        this.simulatorList.push(instance);
      }
    }
  }

  // ... 其他方法保持不变 ...
}

主要的修改包括:

1. 将 mocks 和 contextMocks 改为 Map 类型,以支持分组功能。
2. 在 mockProperty, mockClassProperty, 和 mockContext 方法中添加了可选的 group 参数,默认值为 'default'。
3. 修改 restore 方法以支持按组恢复。如果没有指定组,则恢复所有组。
4. 添加了私有的 restoreGroup 方法来处理单个组的恢复。
5. 在 initSimulation 方法中添加了 group 参数,并将组信息存储在模拟器实例中。
6. 修改了 applyContextMocks 和 getContextMocksSize 方法以适应新的数据结构。

使用这个修改后的版本,您可以这样使用分组功能:

// 使用默认组进行 mock
mockService.mockProperty(obj, 'key', 'value');

// 使用自定义组进行 mock
mockService.mockProperty(obj, 'key', 'value', 'customGroup');

// 恢复特定组的 mock
mockService.restore('customGroup');

// 恢复所有 mock
mockService.restore();

[czy88840616]

主要是打算发v4，涉及core的改动v3都不太想动