Jasmine + Node单元测试中依赖处理的最佳实践探讨

针对你给出的testMe函数（调用外部API并返回Promise），我来分享下Jasmine + Node环境下处理这类依赖的最佳实践，核心思路就是隔离外部依赖，聚焦函数自身的业务逻辑：

单元测试的本质是验证目标函数的逻辑是否符合预期，而不是测试外部API的可用性。所以必须把外部依赖（比如这里的request模块、外部API）完全mock掉，避免测试受外部环境影响，同时让测试用例更可控。

1. 依赖注入（最推荐的低耦合方案） #

原来的函数直接在内部require('request')，相当于把调用工具和业务逻辑绑死了。我们可以把request作为可选参数传入，既不影响原有代码的调用方式（给个默认值），又能在测试时替换成mock对象：

修改后的函数 #

function testMe(a, request = require('request')) {
  return new Promise((resolve, reject)=>{
    request.get('someexternalulr?a='+a, (error, response, body) => {
      // 原有逻辑保持不变
      if (error === null) {
        switch(body) {
          case 'one thing': resolve(true); break;
          case 'something else': reject(new Error('whatever')); break;
          // 更多逻辑
        }
      } else {
        reject(error);
      }
    });
  });
}

对应的Jasmine测试用例 #

describe('testMe function', () => {
  it('should resolve to true when API returns "one thing"', (done) => {
    // 构建mock的request对象，模拟成功响应
    const mockRequest = {
      get: jasmine.createSpy('get').and.callFake((url, callback) => {
        callback(null, {}, 'one thing');
      })
    };

    testMe('testValue', mockRequest)
      .then(result => {
        expect(result).toBe(true);
        // 验证调用的URL是否正确
        expect(mockRequest.get).toHaveBeenCalledWith('someexternalulr?a=testValue', jasmine.any(Function));
        done();
      })
      .catch(done.fail);
  });

  it('should reject with error when request fails', (done) => {
    const testError = new Error('API connection failed');
    const mockRequest = {
      get: jasmine.createSpy('get').and.callFake((url, callback) => {
        callback(testError);
      })
    };

    testMe('testValue', mockRequest)
      .catch(error => {
        expect(error).toBe(testError);
        expect(mockRequest.get).toHaveBeenCalled();
        done();
      })
      .catch(done.fail);
  });
});

这个方案的优势是完全解耦，不需要额外依赖，测试逻辑清晰。

2. Mock整个模块（无需修改原函数） #

如果不想改动原函数的结构，可以直接用Jasmine的spyOn来mockrequest模块的方法，利用Node的模块缓存特性：

测试用例示例 #

const request = require('request');
const testMe = require('./your-module-path'); // 导入目标函数

describe('testMe function', () => {
  beforeEach(() => {
    // 每次测试前重置spy
    spyOn(request, 'get').and.callFake(() => {});
  });

  it('resolves true for "one thing" response', (done) => {
    request.get.and.callFake((url, callback) => {
      callback(null, {}, 'one thing');
    });

    testMe('testValue')
      .then(result => {
        expect(result).toBe(true);
        expect(request.get).toHaveBeenCalledWith('someexternalulr?a=testValue', jasmine.any(Function));
        done();
      })
      .catch(done.fail);
  });

  it('rejects with error when API returns failure', (done) => {
    const mockError = new Error('Network timeout');
    request.get.and.callFake((url, callback) => {
      callback(mockError);
    });

    testMe('testValue')
      .catch(error => {
        expect(error).toBe(mockError);
        done();
      })
      .catch(done.fail);
  });
});

如果需要更真实地模拟HTTP请求（比如验证URL参数、HTTP状态码），也可以用nock库来拦截目标域名的请求：

const nock = require('nock');
const testMe = require('./your-module-path');

describe('testMe function', () => {
  it('handles successful API response', (done) => {
    // 拦截目标URL的GET请求，模拟返回"one thing"
    nock('http://someexternalulr')
      .get('/')
      .query({ a: 'testValue' })
      .reply(200, 'one thing');

    testMe('testValue')
      .then(result => {
        expect(result).toBe(true);
        done();
      })
      .catch(done.fail);
  });
});

3. 提取API调用逻辑到单独模块（适合复杂项目） #

把外部API调用的逻辑抽成独立模块，让业务逻辑和API调用解耦，这样测试时只需要mock这个API模块即可：

新建apiClient.js模块 #

const request = require('request');

exports.fetchData = (a) => {
  return new Promise((resolve, reject) => {
    request.get(`someexternalulr?a=${a}`, (error, response, body) => {
      error ? reject(error) : resolve(body);
    });
  });
};

修改原函数 #

const apiClient = require('./apiClient');

function testMe(a) {
  return apiClient.fetchData(a)
    .then(body => {
      switch(body) {
        case 'one thing': return true;
        case 'something else': throw new Error('whatever');
        // 其他逻辑
      }
    });
}

测试用例 #

const apiClient = require('./apiClient');
const testMe = require('./your-module-path');

describe('testMe function', () => {
  it('returns true when API returns "one thing"', (done) => {
    // mock API模块的fetchData方法
    spyOn(apiClient, 'fetchData').and.returnValue(Promise.resolve('one thing'));

    testMe('testValue')
      .then(result => {
        expect(result).toBe(true);
        expect(apiClient.fetchData).toHaveBeenCalledWith('testValue');
        done();
      })
      .catch(done.fail);
  });
});

这个方案的好处是关注点分离，代码更易维护，测试也更聚焦于业务逻辑本身。

• 如果可以修改原函数，优先选依赖注入，最灵活且无额外依赖；
• 不想改动原有代码时，用Jasmine spyOn mock模块方法，简单直接；
• 需要模拟真实HTTP请求场景时，用nock；
• 复杂项目建议提取API模块，提升代码的可维护性和可测试性。

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