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

对{ body: { title: 'Lorem ipsum', content: 'Lorem ipsum dolor sit amet' } }进行POST调用。

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间谍的原因是，addPost正在直接调用该方法，而不使用本地创建的间谍。

在调用sinon.spy()时会创建一个直通函数，该函数跟踪是否执行了此新方法。这是设计使然，因为您不希望代码不断从下面改变功能。

通常来说，您根本不会在乎normalizefinalResposne是否已执行。您唯一需要担心的是，给定输入addPost(x)会返回y，内部细节并不重要，只要对于输入x您得到结果y。这也简化了以后的重构，因为只有在功能按预期停止运行时，单元测试才会中断，这不仅仅是因为代码看起来不同而功能保持不变。

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

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

1 个答案: