koa2从起步到填坑

╰+哭是因爲堅強的太久メ 2022-05-23 06:23 156阅读 0赞

出于兴趣最近开始研究koa2，由于之前有过一些express经验，以为koa还是很好上手的，但是用起来发现还是有些地方容易懵逼，因此整理此文，希望能够帮助到一些新人。

如果你不懂javascript，建议你先去撸一遍红宝书[javascript高级程序设计][javascript]  
如果你不熟悉ES6，建议你先去撸一遍阮一峰老师的[ECMAScript 6入门][ECMAScript 6]

因为我也是新人，我只是整理了我的学习经历，如何填平踩到的坑。

如果有读者发现我有写错的地方希望你能及时留言给我，别让我误导了其他新手。

本文的系统环境Mac OS  
编译器 VScode

## 1 构建项目 ##

想使用koa，我们肯定首先想到去官网看看，没准有个guide之类的能够轻松入门，可是[koa官网][koa]跟koa本身一样简洁。

如果要我一点点搭建环境的话，感觉好麻烦，所以先去找了找有没有项目生成器，然后就发现了**狼叔-桑世龙**写的[koa-generator][]。

### 1.1 安装koa-generator ###

在终端输入：

$ npm install -g koa-generator

### 1.2 使用koa-generator生成koa2项目 ###

在你的工作目录下，输入：

$ koa2 HelloKoa2

成功创建项目后，进入项目目录，并执行<code>npm install</code>命令

$ cd HelloKoa2 $ npm install

### 1.3 启动项目 ###

在终端输入：

$ npm start

项目启动后，默认端口号是3000，在浏览器中运行可以得到下图的效果说明运行成功。

![Image 1][]

在此再次感谢**狼叔-桑世龙**。

当前项目的文件目录如下图

![Image 1][]

FileTree

### 1.4 关于koa2 ###

#### 1.4.1 中间件的执行顺序 ####

koa的中间件是由generator组成的，这决定了中间件的执行顺序。  
Express的中间件是顺序执行，从第一个中间件执行到最后一个中间件，发出响应。

![Image 1][]

koa是从第一个中间件开始执行，遇到<code>next</code>进入下一个中间件，一直执行到最后一个中间件，在逆序，执行上一个中间件<code>next</code>之后的代码，一直到第一个中间件执行结束才发出响应。

![Image 1][]

#### 1.4.2 async await语法支持 ####

koa2增加了<code>async</code> <code>await</code>语法的支持.

原来koa的中间件写法

app.use(function *(next){ var start = new Date; yield next; var ms = new Date - start; this.set('X-Response-Time', ms + 'ms'); });

koa2中的写法

app.use(async (next) => { var start = new Date; await next(); var ms = new Date - start; this.set('X-Response-Time', ms + 'ms'); });

koa声明说要在v3版本中取消对**generator**中间件的支持，所以为了长久考虑还是用async语法的好。  
如果想要继续使用<code>function\*</code>语法，可以使用 <code>koa-convert</code> 这个中间件进行转换。这也是你看到项目中会有下面代码的原因

const convert = require('koa-convert'); app.use(convert(bodyparser)); app.use(convert(json())); app.use(convert(logger()));

#### 1.4.3 Context ####

**Context**封装了node中的request和response。

koa@1.x使用this引用**Context**对象：

app.use(function *(){ this.body = 'Hello World'; });

koa@2.x中使用**ctx**来访问**Context**对象：

app.use(async (ctx, next) => { await next(); ctx.body = 'Hello World'; });

上面代码中的<code>ctx.body = 'Hello World'</code>这行代码表示设置response.body的值为'Hello World'。

如果你看文档就有可能懵逼，那么我发送**post**请求的参数应该怎么获取呢?  
貌似ctx不能直接获取request的body，想要获取**post**请求中的参数要使用<code>ctx.request.body</code>。

如需查看项目代码 –> 代码地址:

> [https://github.com/tough1985/hello-koa2][https_github.com_tough1985_hello-koa2]  
> 选择Tag -> step1

## 2 项目配置 ##

这里的配置指的是运行环境的配置，比如我们在开发阶段使用本地的数据库，测试要使用测试库，发布上线时候使用线上的库，也会有不同的端口号。

### 2.1 当我们输入npm start的时候都干了些什么 ###

在*package.json*文件中

"scripts": {
        "start": "./node_modules/.bin/nodemon bin/run",
        "koa": "./node_modules/.bin/runkoa bin/www",
        "pm2": "pm2 start bin/run ",
        "test": "echo \"Error: no test specified\" && exit 1"
      }

可以看到这部分内容，当我们在终端输入：

$ npm start

在就会运行*package.json*中**scripts**对象对应的**start**字段后面的内容，相当于你在终端输入：

$ ./node_modules/.bin/nodemon bin/run

**nodemon**插件的作用是在你启动了服务之后，修改文件可以自动重启服务。  
关于**nodemon**的更多内容 --> [nodemon][]

如果不考虑自动重启功能，其实这句代码相当于执行了<code>node bin/run</code>  
我们可以看到项目的**bin**目录下，有一个run文件，代码如下：

#!/usr/bin/env node var current_path = process.cwd(); require('runkoa')(current_path + '/bin/www' )

这里引入了一个**runkoa**，这个组件是**狼叔**写的koa2对babel环境依赖的一个封装插件。

关于**runkoa**相关内容说明 --> [runkoa][]。这里我们最终会执行bin目录下的www文件来启动服务。

### 2.2 npm scripts ###

我们在**scripts**对象中添加一段代码`"start_koa": "bin/run"`，修改后**scripts**对象的内容如下：

那么既然输入<code>npm start</code>执行*start*后面的脚本，聪明的你一定会想：是不是我输入<code>npm start\_koa</code>就可以执行*start\_koa*后面相关的代码了呢？  
不管你是怎么想的，反正我当时就想的这么天真。  
事实上我们输入<code>npm start\_koa</code>之后，终端会提示**npm**没有相关的命令。  
那么在**scripts**中的**start\_koa**命令要怎么使用呢，其实要加一个**run**命令才能执行，在终端输入：

$ npm run start_koa

可以看到服务正常运行了。

在**npm**中，有四个常用的缩写

> npm start是npm run start  
> npm stop是npm run stop的简写  
> npm test是npm run test的简写  
> npm restart是npm run stop && npm run restart && npm run start的简写

其他的都要使用<code>npm run</code>来执行了。

推荐读一遍阮一峰老师写的[npm scripts 使用指南][npm scripts]，很有帮助。

### 2.3 配置环境 ###

关于配置环境常用的有development、test、production、debug。  
可以使用node提供的<code>process.env.NODE\_ENV</code>来设置。

在启动服务的时候可以对*NODE\_ENV*进行赋值，例如：

$ NODE_ENV=test npm start

然后我们可以在*bin/www*文件中输出一下，看看是否配置成功，添加如下代码：

console.log("process.env.NODE_ENV=" + process.env.NODE_ENV);

然后在终端输入

$ NODE_ENV=test npm start

可以看到终端打印：

process.env.NODE_ENV=test

我们可以在**scripts**对象中将环境配置好，例如我们将**start**和**test**分别设置*development*和*test*环境，代码如下：

"scripts": {
        "start": "NODE_ENV=development ./node_modules/.bin/nodemon bin/run",
        "koa": "./node_modules/.bin/runkoa bin/www",
        "pm2": "pm2 start bin/run ",
        "test": "NODE_ENV=test echo \"Error: no test specified\" && exit 1",
        "start_koa": "bin/run"
    },

可以在终端分别输入<code>npm start</code>和<code>npm test</code>来测试环境配置是否生效。

由于并没有测试内容，现在的**test**脚本会退出，后面我们在详谈koa的测试。

### 2.4 配置文件 ###

为了能够根据不同的运行环境加载不同的配置内容，我们需要添加一些配置文件。  
首先在项目根目录下添加**config**目录，在**config**目录下添加index.js、test.js、development.js三个文件，内容如下。

**development.js**

/** * 开发环境的配置内容 */ module.exports = { env: 'development', //环境名称 port: 3001, //服务端口号 mongodb_url: '', //数据库地址 redis_url:'', //redis地址 redis_port: '' //redis端口号 }

**test.js**

/** * 测试环境的配置内容 */ module.exports = { env: 'test', //环境名称 port: 3002, //服务端口号 mongodb_url: '', //数据库地址 redis_url:'', //redis地址 redis_port: '' //redis端口号 }

**index.js**

var development_env = require('./development'); var test_env = require('./test'); //根据不同的NODE_ENV，输出不同的配置对象，默认输出development的配置对象 module.exports = { development: development_env, test: test_env }[process.env.NODE_ENV || 'development']

代码应该都没什么可解释的，然后我们再来编辑*bin/www*文件。

**bin/www**添加如下代码

//引入配置文件 var config = require('../config'); // 将端口号设置为配置文件的端口号，默认值为3000 var port = normalizePort(config.port || '3000'); // 打印输出端口号 console.log('port = ' + config.port);

测试效果，在终端输入<code>npm start</code>，可以看到

process.env.NODE_ENV=development
    port = 3001

到浏览器中访问*http://127.0.0.1:3001*，可以看到原来的输入内容，说明配置文件已经生效。

如需查看项目代码 –> 代码地址:

> [https://github.com/tough1985/hello-koa2][https_github.com_tough1985_hello-koa2]  
> 选择Tag -> step2

## 3 日志 ##

**狼叔**的**koa-generator**已经添加了*koa-logger*，在*app.js*文件你可以找到这样的代码：

const logger = require('koa-logger'); ... ... app.use(convert(logger()));

[koa-logger][]是**tj**大神写的koa开发时替换console.log输出的一个插件。

如果你需要按照时间或者按照文件大小，本地输出log文件的话，建议还是采用[log4js-node][]。

### 3.1 log4js ###

log4js提供了多个日志等级分类，同时也能替换console.log输出，另外他还可以按照文件大小或者日期来生成本地日志文件，还可以使用邮件等形式发送日志。

我们在这演示用*info*和*error*两种日志等级分别记录响应日志和错误日志。

### 3.2 log4js 配置 ###

在*config*目录下创建一个*log\_config.js*文件，内容如下：

然后创建一个*utils*目录，添加*log\_util.js*文件，内容如下：

接下来修改*app.js* 文件中的logger部分。

//log工具 const logUtil = require('./utils/log_util'); // logger app.use(async (ctx, next) => { //响应开始时间 const start = new Date(); //响应间隔时间 var ms; try { //开始进入到下一个中间件 await next(); ms = new Date() - start; //记录响应日志 logUtil.logResponse(ctx, ms); } catch (error) { ms = new Date() - start; //记录异常日志 logUtil.logError(ctx, error, ms); } });

在这将<code>await next();</code>放到了一个<code>try catch</code>里面，这样后面的中间件有异常都可以在这集中处理。

比如你会将一些API异常作为正常值返回给客户端，就可以在这集中进行处理。然后后面的中间件只要<code>throw</code>自定义的API异常就可以了。

在启动服务之前不要忘记先安装*log4js*插件：

$ npm install log4js --save

启动服务

$ npm start

这时候会启动失败，控制台会输出没有文件或文件目录。原因是我们在配置里面虽然配置了文件目录，但是并没有创建相关目录，解决的办法是手动创建相关目录，或者在服务启动的时候，确认一下目录是否存在，如果不存在则创建相关目录。

### 3.3 初始化logs文件目录 ###

先来修改一下*log\_config.js*文件，让后面的创建过程更舒适。

修改后的代码：

然后打开*bin/www*文件，添加如下代码：

这样每次启动服务的时候，都会去确认一下相关的文件目录是否存在，如果不存在就创建相关的文件目录。

现在在来启动服务。在浏览器访问，可以看到项目中多了logs目录以及相关子目录，并产生了日子文件。

![Image 1][]

内容如下：

[2016-10-31 12:58:48.832] [INFO] resLogger - 
    *************** response log start ***************
    request method: GET
    request originalUrl:  /
    request client ip:  ::ffff:127.0.0.1
    request query:  {}
    response time: 418
    response status: 200
    response body: 
    "<!DOCTYPE html><html><head><title>koa2 title</title><link rel=\"stylesheet\" href=\"/stylesheets/style.css\"></head><body><h1>koa2 title</h1><p>Welcome to koa2 title</p></body></html>"
    *************** response log end ***************

可以根据自己的需求，定制相关的日志格式。

另外关于配置文件的选项可以参考[log4js-node Appenders说明][log4js-node Appenders]。

如需查看项目代码 –> 代码地址:

> [https://github.com/tough1985/hello-koa2][https_github.com_tough1985_hello-koa2]  
> 选择Tag -> step3

## 4 格式化输出 ##

假设我们现在开发的是一个API服务接口，会有一个统一的响应格式，同时也希望发生API错误时统一错误格式。

### 4.1 建立一个API接口 ###

为当前的服务添加两个接口，一个getUser一个registerUser。

先在当前项目下创建一个*app/controllers*目录，在该目录下添加一个*user\_controller.js*文件。

![Image 1][]

代码如下：

//获取用户 exports.getUser = async (ctx, next) => { ctx.body = { username: '阿，希爸', age: 30 } } //用户注册 exports.registerUser = async (ctx, next) => { console.log('registerUser', ctx.request.body); }

简单的模拟一下。getUser返回一个user对象，registerUser只是打印输出一下请求参数。

接下来为这两个方法配置路由。

### 4.2 为API接口配置路由 ###

我们希望服务的地址的组成是这要的

域名 + 端口号 /api/功能类型/具体端口

例如

127.0.0.1:3001/api/users/getUser

先来添加一个api的路由和其他路由分开管理。在*routes*目录下创建一个*api*目录，添加**user\_router.js**文件，代码如下：

var router = require('koa-router')(); var user_controller = require('../../app/controllers/user_controller'); router.get('/getUser', user_controller.getUser); router.post('/registerUser', user_controller.registerUser); module.exports = router;

这样就完成了*getUser*和*registerUser*进行了路由配置，其中*getUser*是**GET**方式请求，*registerUser*是用**POST**方式请求。

接下来对*users*这个功能模块进行路由配置，在*routes/api*目录下添加一个*index.js*文件，代码如下：

var router = require('koa-router')(); var user_router = require('./user_router'); router.use('/users', user_router.routes(), user_router.allowedMethods()); module.exports = router;

最后对*api*进行路由配置，在*app.js*文件中添加如下代码：

const api = require('./routes/api'); ...... router.use('/api', api.routes(), api.allowedMethods());

启动服务，在浏览器中访问*127.0.0.1:3001/api/users/getUser*可以得到如下输出，说明配置成功。

{
      "username": "阿，希爸",
      "age": 30
    }

### 4.3 格式化输出 ###

作为一个API接口，我们可能希望统一返回格式，例如getUser的输出给客户端的返回值是这样的：

{
        "code": 0,
        "message": "成功",
        "data": {
          "username": "阿，希爸",
          "age": 30
        }
    }

按照koa的中间件执行顺序，我们要处理数据应该在发送响应之前和路由得到数据之后添加一个中间件。在项目的根目录下添加一个*middlewares*目录，在该目录下添加*response\_formatter.js*文件，内容如下：

/** * 在app.use(router)之前调用 */ var response_formatter = async (ctx, next) => { //先去执行路由 await next(); //如果有返回数据，将返回数据添加到data中 if (ctx.body) { ctx.body = { code: 0, message: 'success', data: ctx.body } } else { ctx.body = { code: 0, message: 'success' } } } module.exports = response_formatter;

然后在*app.js*中载入。

const response_formatter = require('./middlewares/response_formatter'); ... //添加格式化处理响应结果的中间件，在添加路由之前调用 app.use(response_formatter); router.use('/', index.routes(), index.allowedMethods()); router.use('/users', users.routes(), users.allowedMethods()); router.use('/api', api.routes(), api.allowedMethods()); app.use(router.routes(), router.allowedMethods());

启动服务，在浏览器中访问*127.0.0.1:3001/api/users/getUser*可以得到如下输出，说明配置成功。

{
      "code": 0,
      "message": "success",
      "data": {
        "username": "阿，希爸",
        "age": 30
      }
    }

### 4.4 对URL进行过滤 ###

**为什么一定要在router之前设置？**  
其实在router之后设置也可以，但是必须在controller里面执行<code>await next()</code>才会调用。也就是说谁需要格式化输出结果自己手动调用。

在router前面设置也有一个问题，就是所有的路由响应输出都会进行格式化输出，这显然也不符合预期，那么我们要对URL进行过滤，通过过滤的才对他进行格式化处理。

重新改造一下*response\_formatter*中间件，让他接受一个参数，然后返回一个async function做为中间件。改造后的代码如下：

/** * 在app.use(router)之前调用 */ var response_formatter = (ctx) => { //如果有返回数据，将返回数据添加到data中 if (ctx.body) { ctx.body = { code: 0, message: 'success', data: ctx.body } } else { ctx.body = { code: 0, message: 'success' } } } var url_filter = function(pattern){ return async function(ctx, next){ var reg = new RegExp(pattern); //先去执行路由 await next(); //通过正则的url进行格式化处理 if(reg.test(ctx.originalUrl)){ response_formatter(ctx); } } } module.exports = url_filter;

*app.js*中对应的代码改为：

//仅对/api开头的url进行格式化处理 app.use(response_formatter('^/api'));

现在访问*127.0.0.1:3001/api/users/getUser*这样以api开头的地址都会进行格式化处理，而其他的地址则不会。

### 4.5 API异常处理 ###

要集中处理API异常，首先要创建一个API异常类，在*app*目录下新建一个*error*目录，添加*ApiError.js*文件，代码如下：

/** * 自定义Api异常 */ class ApiError extends Error{ //构造方法 constructor(error_name， error_code, error_message){ super(); this.name = error_name; this.code = error_code; this.message = error_message; } } module.exports = ApiError;

为了让自定义Api异常能够更好的使用，我们创建一个*ApiErrorNames.js*文件来封装API异常信息，并可以通过API错误名称获取异常信息。代码如下：

/** * API错误名称 */ var ApiErrorNames = {}; ApiErrorNames.UNKNOW_ERROR = "unknowError"; ApiErrorNames.USER_NOT_EXIST = "userNotExist"; /** * API错误名称对应的错误信息 */ const error_map = new Map(); error_map.set(ApiErrorNames.UNKNOW_ERROR, { code: -1, message: '未知错误' }); error_map.set(ApiErrorNames.USER_NOT_EXIST, { code: 101, message: '用户不存在' }); //根据错误名称获取错误信息 ApiErrorNames.getErrorInfo = (error_name) => { var error_info; if (error_name) { error_info = error_map.get(error_name); } //如果没有对应的错误信息，默认'未知错误' if (!error_info) { error_name = UNKNOW_ERROR; error_info = error_map.get(error_name); } return error_info; } module.exports = ApiErrorNames;

修改*ApiError.js*文件，引入*ApiErrorNames*

**ApiError.js**

const ApiErrorNames = require('./ApiErrorNames'); /** * 自定义Api异常 */ class ApiError extends Error{ //构造方法 constructor(error_name){ super(); var error_info = ApiErrorNames.getErrorInfo(error_name); this.name = error_name; this.code = error_info.code; this.message = error_info.message; } } module.exports = ApiError;

在*response\_formatter.js*文件中处理API异常。

先引入*ApiError*:  
<code>var ApiError = require('../app/error/ApiError');</code>

然后修改*url\_filter*

解释一下这段代码

1.  使用<code>try catch</code>包裹<code>await next();</code>，这样后面的中间件抛出的异常都可以在这几集中处理；
2.  <code>throw error;</code>是为了让外层的logger中间件能够处理日志。

为了模拟运行效果，我们修改*user\_controller.js*文件，内容如下：

启动服务，在浏览器中访问*127.0.0.1:3001/api/users/getUser*可以得到结果如下：

{
      "code": 101,
      "message": "用户不存在"
    }

在浏览器中访问*127.0.0.1:3001/api/users/getUser?id=1*可以得到结果如下：

{
      "code": 0,
      "message": "success",
      "data": {
        "username": "阿，希爸",
        "age": 30
      }
    }

如需查看项目代码 –> 代码地址:

> [https://github.com/tough1985/hello-koa2][https_github.com_tough1985_hello-koa2]  
> 选择Tag -> step4

## 5 测试 ##

node使用主流的测试框架基本就是**mocha**和**AVA**了，这里主要以**mocha**为基础进行构建相关的测试。

### 5.1 mocha ###

#### 安装mocha ####

在终端输入

$ npm install --save-dev mocha

**--dev**表示只在development环境下添加依赖。

#### 使用mocha ####

在项目的根目录下添加*test*目录，添加一个*test.js*文件，内容如下：

在终端输入：

$ mocha

可以得到输出如下：

Array #indexOf() ✓ should return -1 when the value is not present 1 passing (9ms)

**mocha**默认运行*test*目录下的测试文件，测试文件一般与要测试的脚步文件同名以<code>.test.js</code>作为后缀名。例如`add.js`的测试脚本名字就是`add.test.js`。

**describe**表示测试套件，每个测试脚本至少应该包含一个<code>describe</code>。

**it**表示测试用例。

每个**describe**可以包含多个**describe**或多个**it**。

**assert**是node提供的断言库。

assert.equal(-1, [1,2,3].indexOf(4));

这句代码的意思是我们期望`[1,2,3].indexOf(4)`的值应该是`-1`，如果`[1,2,3].indexOf(4)`的运行结果是`-1`，则通过测试，否则不通过。

可以把`-1`改成`-2`再试一下。

上面的例子是mocha提供的，[mocha官网][mocha]。

#### 测试环境 ####

之前说过环境配置的内容，我们需要执行测试的时候，加载相关的测试配置该怎么做？

在终端输入

$ NODE_ENV=test mocha

为了避免每次都去输入`NODE_ENV=test`，可以修改*package.json*文件中的`scripts.test`改为：

"test": "NODE_ENV=test mocha",

以后运行测试直接输入`npm test`就可以了。

#### 常用的参数 ####

**mocha**在执行时可以携带很多参数，这里介绍几个常用的。

##### \--recursive #####

**mocha**默认执行*test*目录下的测试脚本，但是不会运行*test*下的子目录中的脚本。  
想要执行子目录中的测试脚本，可以在运行时添加`--recursive`参数。

$ mocha --recursive

##### \--grep #####

如果你写了很多测试用例，当你添加了一个新的测试，执行之后要在结果里面找半天。这种情况就可以考虑`--grep`参数。  
`--grep`可以只执行单个测试用例，也就是执行某一个`it`。比如将刚才的测试修改如下：

describe('Array', function() { describe('#indexOf()', function() { it('should return -1 when the value is not present', function(){ assert.equal(-1, [1,2,3].indexOf(4)); }) it('length', function(){ assert.equal(3, [1, 2, 3].length); }) }) });

添加了一个*length*测试用例，想要单独执行这个测试用例就要在终端输入：

$ mocha --grep 'length'

可以看到*length*用例被单独执行了。

这里有一点需要注意，因为我们配置了`npm test`，如果直接运行

$ npm test --grep 'length'

这样是不能达到效果的。

要给*npm scripts*脚本传参需要先输入`--`然后在输入参数，所以想要执行上面的效果应该输入：

$ npm test -- --grep 'length'

关于**mocha**就简单的介绍这么多，想要了解更多相关的内容，推荐仔细阅读一遍阮一峰老师写的[测试框架 Mocha 实例教程][Mocha]。

### 5.2 chai ###

**chai**是一个断言库。之前的例子中，我们使用的是node提供的断言库，他的功能比较少，基本上只有*equal*、*ok*、*fail*这样简单的功能，很难满足日常的需求。

**mocha**官方表示你爱用什么断言用什么断言，反正老子都支持。

选择**chai**是因为他对断言的几种语法都支持，而且功能也比较全面 --> [chai官网][chai]。

**chai**支持`should`、`expect`和`assert`三种断言形式。

**assert**语法之前我们已经见过了，**chai**只是丰富了功能，语法并没有变化。  
**expect**和**should**的语法更接近自然语言的习惯，但是**should**使用的时候会出现一些意想不到的情况。所以比较常用的还是**expect**。

官方的DEMO

var expect = chai.expect; expect(foo).to.be.a('string'); expect(foo).to.equal('bar'); expect(foo).to.have.length(3); expect(tea).to.have.property('flavors') .with.length(3);

明显语法的可读性更好，更接近人类的语言。

简单的解释其中的`to`、`be`这样的语法。

**chai**使用了链式语法，为了使语法更加接近自然语言，添加了很多表达语义但是没有任何功能的词汇。

*  to
 *  be
 *  been
 *  is
 *  that
 *  which
 *  and
 *  has
 *  have
 *  with
 *  at
 *  of
 *  same

上面列出的这些词没有任何功能，只是为了增强语义。

也就是说  
`expect(1+1).to.be.equal(2)`  
与  
`expect(1+1).equal(2)`  
是完全相同的。

#### 安装chai ####

在终端输入：

$ npm install --save-dev chai

#### 使用chai ####

在*test*目录下新建一个*chai.test.js*文件，内容如下：

const expect = require('chai').expect; describe('chai expect demo', function() { it('expect equal', function() { expect(1+1).to.equal(2); expect(1+1).not.equal(3); }); });

在终端输入：

$ npm test -- --grep 'expect equal'

得到输出：

chai expect demo
        ✓ expect equal
    
    
      1 passing (6ms)

说明配置成功。有关**chai**的更多功能请查看官方API --> [chai\_api][chai_api]

### 5.3 supertest ###

目前我们可以使用测试框架做一些简单的测试，想要测试接口的相应数据，就要用到**supertest**了。

**supertest**主要功能就是对HTTP进行测试。尤其是对REST API，我们对get请求很容易模拟，但是post方法就很难（当然你也可以使用postman这样的插件）。

**supertest**可以模拟HTTP的各种请求，设置header，添加请求数据，并对响应进行断言。

#### 安装supertest ####

在终端输入：

$ npm install --save-dev supertest

#### 使用supertest ####

我们对现有的两个API接口*getUser*和*registerUser*进行测试。在*test*目录下创建*user\_api.test.js*文件，内容如下：

如果现在直接运行`npm test`进行测试会报错，原因是**mocha**默认是不支持`async await`语法，解决的办法是**Babel**。

**Babel**的主要作用是对不同版本的js进行转码。

如果你对**Babel**不了解，请仔细阅读[Babel 入门教程][Babel]与[Babel官网][Babel 1]。

由于**koa-generator**已经帮我们添加相关的**Babel**依赖，我们只需要添加相关的规则就可以了。在项目的根目录下添加一个*.babelrc*文件，内容如下：

{
      "env": {
        "test": {
            "presets": ["es2015-node5"],
            "plugins": [
                "transform-async-to-generator",
                "syntax-async-functions"
            ]
        }
      }
    }

这段文件的意思是对当env=test时，应用`es2015-node5`、`transform-async-to-generator`、`syntax-async-functions`规则进行转码。

**Babel**我们设置好了，想要**mocha**应用这个规则还要在执行时添加一个命令。  
打开*package.json*，将*scripts.test*修改为：

"test": "NODE_ENV=test mocha --compilers js:babel-core/register",

在终端执行`npm test`，输出如下内容说明测试通过。

user_api
      <-- GET /api/users/getUser?id=1
      --> GET /api/users/getUser?id=1 200 14ms 74b
    { code: 0,
      message: 'success',
      data: { username: '阿，希爸', age: 30 } }
        ✓ getUser (57ms)
      <-- POST /api/users/registerUser
    registerUser { username: '阿，希爸', age: 31 }
      --> POST /api/users/registerUser 200 2ms 30b
    { code: 0, message: 'success' }
        ✓ registerUser

有关**supertest**的更多用法请参考 [github\_supertest][github_supertest]。

如需查看项目代码 –> 代码地址:

> [https://github.com/tough1985/hello-koa2][https_github.com_tough1985_hello-koa2]  
>

作者：阿\_希爸  
链接：https://www.jianshu.com/p/6b816c609669  
來源：简书  
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

[javascript]: https://link.jianshu.com?t=http://item.jd.com/10951037.html
[ECMAScript 6]: https://link.jianshu.com?t=http://es6.ruanyifeng.com
[koa]: https://link.jianshu.com?t=http://koajs.com
[koa-generator]: https://link.jianshu.com?t=https://github.com/17koa/koa-generator
[Image 1]: 
[https_github.com_tough1985_hello-koa2]: https://link.jianshu.com?t=https://github.com/tough1985/hello-koa2
[nodemon]: https://link.jianshu.com?t=https://github.com/remy/nodemon
[runkoa]: https://link.jianshu.com?t=https://github.com/17koa/runkoa
[npm scripts]: https://link.jianshu.com?t=http://www.ruanyifeng.com/blog/2016/10/npm_scripts.html
[koa-logger]: https://link.jianshu.com?t=https://github.com/koajs/logger
[log4js-node]: https://link.jianshu.com?t=https://github.com/nomiddlename/log4js-node
[log4js-node Appenders]: https://link.jianshu.com?t=https://github.com/nomiddlename/log4js-node/wiki/Appenders
[mocha]: https://link.jianshu.com?t=http://mochajs.org/#pending-tests
[Mocha]: https://link.jianshu.com?t=http://www.ruanyifeng.com/blog/2015/12/a-mocha-tutorial-of-examples.html
[chai]: https://link.jianshu.com?t=http://chaijs.com
[chai_api]: https://link.jianshu.com?t=http://chaijs.com/api/bdd/
[Babel]: https://link.jianshu.com?t=http://www.ruanyifeng.com/blog/2016/01/babel.html
[Babel 1]: https://link.jianshu.com?t=https://babeljs.io
[github_supertest]: https://link.jianshu.com?t=https://github.com/visionmedia/supertest