单元测试是否应该复用及复用方法咨询

这个问题提得好！在大多数服务里重复写相同的单元测试用例，完全是可以（而且应该）优化复用的场景——既能减少维护成本，还能保证测试逻辑的一致性。结合你的示例，给你几个实用的方案参考：

1. 继承基测试类（最直接的结构化复用） #

如果你的各个服务测试逻辑框架高度相似，继承基测试类是最直观的选择：把通用的测试逻辑、前置准备（Arrange）封装到基类中，子类只需要实现服务特有的部分（比如调用服务的方法）。

示例代码： #

// 基测试类：封装通用测试逻辑
abstract class BaseServiceTest {
  // 定义抽象属性/方法，让子类实现差异化部分
  protected abstract httpClient: HttpClient;
  protected abstract callServiceWithDefaultArguments(): void;

  // 通用的前置准备逻辑
  protected setup() {
    this.httpClient = jest.mocked(HttpClient);
    jest.clearAllMocks();
  }

  // 复用"验证HttpClient.get调用"的测试
  protected testHttpClientGetCalled() {
    it('should call HttpClient.get method', () => {
      this.setup();
      // Act
      this.callServiceWithDefaultArguments();
      // Assert
      expect(this.httpClient.get).toHaveBeenCalled();
    });
  }

  // 复用"空参数抛异常"的测试
  protected testNullIdThrows(exceptionMessage: RegExp) {
    it('with null id should throw an exception', () => {
      // Arrange：子类需确保id变量已被设置为null
      // Act & Assert
      expect(() => this.callServiceWithDefaultArguments()).toThrowError(exceptionMessage);
    });
  }
}

// 子类：UserService的测试类
class UserServiceTest extends BaseServiceTest {
  protected httpClient: HttpClient;
  private userService: UserService;
  protected id: number | null;

  beforeEach(() => {
    this.httpClient = jest.mocked(HttpClient);
    this.userService = new UserService(this.httpClient);
    this.id = 1; // 默认参数
  });

  // 实现基类的抽象方法：服务特有调用逻辑
  protected callServiceWithDefaultArguments(): void {
    this.userService.fetchUser(this.id);
  }

  // 执行所有测试
  runTests() {
    describe('UserService - Common Tests', () => {
      this.testHttpClientGetCalled();
      // 传入当前服务的异常信息
      this.testNullIdThrows(new RegExp(ExceptionConstants.NULL_OR_UNDEFINED));
    });

    // 服务特有的测试用例
    describe('UserService - Specific Tests', () => {
      it('should parse user data correctly', async () => {
        // ... 特有测试逻辑
      });
    });
  }
}

// 启动测试
new UserServiceTest().runTests();

优点：结构清晰，子类只需关注差异化逻辑；注意点：避免基类过于臃肿，只封装真正通用的逻辑，防止继承层级过深导致维护困难。

2. 封装测试工具函数（灵活无耦合） #

如果不想用继承带来的耦合，可以把通用测试逻辑封装成独立的工具函数，在各个服务测试文件中直接调用，按需传入差异化参数（比如服务实例、调用方法）。

示例代码： #

// test-utils.ts：通用测试工具函数集合
export function testHttpClientGetCalled(callServiceFn: () => void, httpClient: HttpClient) {
  it('should call HttpClient.get method', () => {
    jest.clearAllMocks();
    // Act
    callServiceFn();
    // Assert
    expect(httpClient.get).toHaveBeenCalled();
  });
}

export function testNullIdThrows(callServiceFn: () => void, exceptionMessage: RegExp) {
  it('with null id should throw an exception', () => {
    // Act & Assert
    expect(() => callServiceFn()).toThrowError(exceptionMessage);
  });
}

// UserService.test.ts：导入工具函数使用
import { testHttpClientGetCalled, testNullIdThrows } from './test-utils';

describe('UserService', () => {
  let httpClient: HttpClient;
  let userService: UserService;
  let id: number | null;

  beforeEach(() => {
    httpClient = jest.mocked(HttpClient);
    userService = new UserService(httpClient);
    id = 1;
  });

  // 复用通用测试
  testHttpClientGetCalled(() => userService.fetchUser(id), httpClient);
  
  // 测试空参数场景：先修改id为null
  testNullIdThrows(() => {
    id = null;
    userService.fetchUser(id);
  }, new RegExp(ExceptionConstants.NULL_OR_UNDEFINED));

  // 服务特有测试
  it('should return user data when id is valid', async () => {
    // ... 特有测试逻辑
  });
});

优点：无继承耦合，灵活适配不同服务的差异；注意点：把工具函数统一放到单独的文件中（比如test-utils.ts），方便管理和维护。

3. 复用测试描述块（适配测试框架） #

如果使用Jest这类支持函数式描述块的测试框架，可以把通用测试用例封装成可复用的describe函数，在各个服务测试文件中导入并执行。

示例代码： #

// test-shared.ts：封装通用测试块
export function createCommonServiceTests(
  serviceName: string,
  setupFn: () => void,
  callServiceFn: () => void,
  httpClient: HttpClient,
  exceptionMessage: RegExp
) {
  describe(`${serviceName} - Common Tests`, () => {
    beforeEach(() => setupFn());

    it('should call HttpClient.get method', () => {
      callServiceFn();
      expect(httpClient.get).toHaveBeenCalled();
    });

    it('with null id should throw an exception', () => {
      // 这里假设setupFn或外部已处理id为null的逻辑
      expect(() => callServiceFn()).toThrowError(exceptionMessage);
    });
  });
}

// UserService.test.ts：导入并使用通用测试块
import { createCommonServiceTests } from './test-shared';

describe('UserService', () => {
  let httpClient: HttpClient;
  let userService: UserService;
  let id: number | null;

  const setup = () => {
    httpClient = jest.mocked(HttpClient);
    userService = new UserService(httpClient);
    id = 1;
  };

  // 执行通用测试块
  createCommonServiceTests(
    'UserService',
    setup,
    () => userService.fetchUser(id),
    httpClient,
    new RegExp(ExceptionConstants.NULL_OR_UNDEFINED)
  );

  // 服务特有测试
  it('should handle non-existent user id', async () => {
    // ... 特有测试逻辑
  });
});

优点：和测试框架深度结合，复用性强；注意点：依赖框架特性，换框架时需要调整实现。

总结建议 #

• 如果服务间测试逻辑高度一致：优先选择继承基测试类，结构最清晰；
• 如果服务间差异较大：用测试工具函数更灵活，避免耦合；
• 不要过度复用：如果某个测试用例仅在少数服务中有特殊逻辑，单独编写反而比强行复用更易维护。

内容的提问来源于stack exchange，提问作者manfrom