Node.js - 如何处理测试文件中的异步模拟？

Question

目前我正在学习如何测试节点模块。最近几天，我在 StackOverflow 上问了几个关于如何模拟节点模块以测试的问题，例如，promise 的 .then() 子句中发生了什么。 我从社区那里得到了一些关于如何解决这个问题的好建议，我已经走了很远。但是，我仍然无法理解，它与异步调用有关。

例如，我目前有以下代码来添加帖子：

const makeRequestStructure = require('./modules/makeRequestStructure.js').makeRequestStructure
const normalizeFinalResponse = require('./modules/normalizeFinalResponse.js').normalizeFinalResponse
const doARequest = require('./modules/doARequest.js').doARequest

exports.addPost = (event) => {
  const requestStructure = makeRequestStructure('POST', '/posts')

  const requestPostData = {
    title: event.body.title,
    content: event.body.content
  }

  return doARequest(requestStructure, requestPostData).then((res) => {
    const finalResponse = normalizeFinalResponse(200, res)
    return finalResponse
  }).catch((err) => {
    const finalResponse = normalizeFinalResponse(400, err)
    return finalResponse
  })
}

运行此文件所需的辅助函数是：

makeRequestStructure.js（位于./modules/makeRequestStructure.js）

require('dotenv').config()
const { HOST, PORT } = process.env

module.exports.makeRequestStructure = function (method, path) {
  return {
    host: HOST,
    port: PORT,
    method: method,
    path: path
  }
}

这个模块使用环境变量，我在 .env 文件中配置的那些是

HOST=jsonplaceholder.typicode.com
POST=433

接下来我有normalizeFinalResponse.js 文件和doARequest.js 文件：

normalizeFinalResponse.js（位于./modules/normalizeFinalResponse.js）

module.exports.normalizeFinalResponse = function (statusCode, message) {
  return {
    'statusCode': statusCode,
    'body': { message: message }
  }
}

doARequest.js（位于./modules/doARequest.js）

const https = require('https')

module.exports.doARequest = function (params, postData) {
  return new Promise((resolve, reject) => {
    const req = https.request(params, (res) => {
      let body = []
      res.on('data', (chunk) => {
        body.push(chunk)
      })
      res.on('end', () => {
        try {
          body = JSON.parse(Buffer.concat(body).toString())
        } catch (e) {
          reject(e)
        }
        resolve(body)
      })
    })
    req.on('error', (err) => {
      reject(err)
    })
    if (postData) {
      req.write(JSON.stringify(postData))
    }
    req.end()
  })
}

现在，这段代码非常简单。通过运行以下文件，它将对 jsonplaceholder.typicode.com:433/posts 进行 POST 调用，其主体为 { body: { title: 'Lorem ipsum', content: 'Lorem ipsum dolor sit amet' } }

const addPost = require('./addPost.js').addPost;
const event = { body: { title: 'Lorem ipsum', content: 'Lorem ipsum dolor sit amet' } }

addPost(event).then((res) => {
  console.log(res);
}).catch((err) => {
  console.log(err);
});

在addPost 模块中，函数normalizeFinalResponse 被调用以规范来自jsonplaceholder api 的响应。为了检查这一点，我创建了以下测试文件。

//Dependencies
const mock = require('mock-require')
const sinon = require('sinon')
const expect = require('chai').expect

//Helper modules
const normalizeFinalResponse = require('../modules/normalizeFinalResponse.js')
const doARequest = require('../modules/doARequest.js')

//Module to test
const addPost = require('../addPost.js')

//Mocks
const addPostReturnMock = { id: 101 }

describe('the addPost API call', () => {
  it('Calls the necessary methods', () => {

    console.log(1)

    //Mock doARequest so that it returns a promise with fake data.
    //This seems to be running async. The test file continues to run when its not resolved yet
    mock('../modules/doARequest', { doARequest: function() {
      console.log(2)
      return Promise.resolve(addPostReturnMock);
    }});

    console.log(3)

    //Stub functions expected to be called
    let normalizeFinalResponseShouldBeCalled = sinon.spy(normalizeFinalResponse, 'normalizeFinalResponse');

    //Set a fake eventBody
    let event = { body: { title: 'Lorem ipsum', content: 'Lorem ipsum dolor sit amet' } }

    //Call the method we want to test and run assertions
    return addPost.addPost(event).then((res) => {
      expect(res.statusCode).to.eql(200);
      sinon.assert.calledOnce(normalizeFinalResponseShouldBeCalled);
    })
  });
});

运行此测试文件会使断言失败，因为显然从未调用过 normalizeFinalResponse 函数。当我使用console.log 时，它们按1、3、2 的顺序打印。 这让我相信 mock() 函数还没有完成，所以它会实际调用 jsonplaceholder api。但还是应该调用函数normalizeFinalResponse，对吧？

我有一种感觉，我忽略了眼前的东西。但是我无法弄清楚它是什么。如果你知道我的测试有什么问题，我很想听听。它帮助我更好地理解编写这种测试。

我的 package.json 供参考：

{
  "name": "mock-requests-tests",
  "version": "0.0.1",
  "description": "A test repository so i can learn how to mock requests",
  "scripts": {
    "test": "mocha --recursive tests/",
    "test:watch": "mocha --recursive --watch tests/"
  },
  "devDependencies": {
    "chai": "^4.1.2",
    "mock-require": "^3.0.2",
    "sinon": "^7.2.2"
  }
}

Answer 1

从未调用过normalizeFinalResponse spy 的原因是addPost 直接调用该方法，而不是使用本地创建的spy。

当您调用sinon.spy() 时，它会创建一个传递函数来跟踪是否执行了此新方法。这是设计使然，因为您不希望代码不断地改变您的功能。

一般来说，您根本不会关心normalizefinalResposne 是否已执行。您唯一应该关心的是给定输入addPost(x) 它返回y，只要输入x 得到结果y，内部细节就无关紧要了。这也简化了以后的重构，因为您的单元测试只会在功能停止按预期工作时中断，而不仅仅是因为代码看起来不同而功能保持不变。

此规则有一些例外情况，主要是在使用 3rd 方代码时。 doARequest 就是一个这样的例子。您可能希望使用模拟库来覆盖 http 模块，以便它返回精心设计的响应并且不会发出实时网络请求。