作者：肖磊
个人主页：
最近将内部测试框架的底层库从mocha迁移到了AVA，迁移的原因之一是因为AVA提供了更好的流程控制。
我们从一个例子开始入手：
有A,B,C,D4个case，我要实现A -->> B -->> (C | D)，A最先执行，B等待A执行完再执行，最后是(C | D)并发执行，使用ava提供的API来完成case就是：
const ava = require('ava')ava.serial('A', async () => { // do something})ava.serial('B', async () => { // do something})ava('C', async () => { // do something})ava('D', async () => { // do something})复制代码 接下来我们就来具体看下AVA内部是如何实现流程控制的：
在AVA内实现了一个Sequence类：
class Sequence { constructor (runnables) { this.runnables = runnables } run() { // do something }}复制代码 这个Sequence类可以理解成集合的概念，这个集合内部包含的每一个元素可以是由一个case组成，也可以是由多个case组成。这个类的实例当中runnables属性(数组)保存了需要串行执行的case或case组。一个case可以当做一个组(runnables)，多个case也可以当做一组，AVA用Sequence这个类来保证在runnables中保存的不同元素的顺序执行。
顺序执行了解后，我们再看下AVA内部实现的另外一个控制case并行执行的类：Concurrent:
class Concurrent { constructor (runnables) { this.runnables = runnables } run () { // do something }}复制代码 可以将Concurrent可以理解为组的概念，实例当中的runnables属性(数组)保存了这个组中所有待执行的case。这个Concurrent和上面提到的Sequence组都部署了run方法，用以runnables的执行，不同的地方在于，这个组内的case都是并行执行的。
具体到我们提供的实例当中：A -->> B -->> (C | D)，AVA是如何从这2个类来实现他们之间的按序执行的呢？
在你定义case的时候：
ava.serial('A', async () => { // do something})ava.serial('B', async () => { // do something})ava('C', async () => { // do something})ava('D', async () => { // do something})复制代码 在ava内部便会维护一个serial数组用以保存顺序执行的case，concurrent数组用以保存并行执行的case：
const serial = ['A', 'B'];const concurrent = ['C', 'D']复制代码
然后用这2个数组，分别实例化一个Sequence和Concurrent实例：
const serialTests = new Sequence(serial)const concurrentTests = new Concurrent(concurrent)复制代码
这样保证了serialTests内部的case是顺序执行的，concurrentTests内部的case是并行执行的。但是如何保证这2个实例(serialTests和concurrentTests)之间的顺序执行呢？即serialTests内部case顺序执行完后，再进行concurrentTests的并行执行。
同样是使用Sequence这个类，实例化一个Sequence实例：
const allTests = new Sequence([serialTests, concurrentTests])复制代码
之前我们就提到过Sequence实例的runnables属性中就维护了串行执行的case，所以在这里的具体体现就是，serialTests和concurrentTests之间是串行执行的，这也对应着：A -->> B -->> (C | D)。
接下来，我们就具体看下对应具体的流程实现：
allTests是所有这些case的集合，Sequence类上部署了run方法，因此调用：
allTests.run()复制代码
开始case的执行。在Sequence类的run方法当中：
class Sequence { constructor (runnables) { this.runnables = runnables } run () { // 首先获取runnables的迭代器对象，runnables数组保存了顺序执行的case const iterator = this.runnables[Symbol.iterator]() let activeRunnable // 定义runNext方法，主要是用于保证case执行的顺序 // 因为ava支持同步和异步的case，这里也着重分析下异步case的执行顺序 const runNext = () => { // 每次调用runNext方法都初始化一个新变量，用以保存异步case返回的promise let promise // 通过迭代器指针去遍历需要串行执行的case for (let next = iterator.next(); !next.done; next = iterator.next()) { // activeRunnable即每一个case或者是case的集合 activeRunnable = next.value // 调用case的run方法，或者case集合的run方法，如果activeRunnable是一个case，那么就会执行这个case，而如果是case集合，调用run方法后，还是对应于sequence的run方法 // 因此在调用allTests.run()的时候，第一个activeRunnable就是'A',‘B’2个case的集合(sequence实例)。 const passedOrPromise = activeRunnable.run() // passedOrPromise如果返回为false，即代表这个同步的case执行失败 if (!passedOrPromise) { // do something } else if (passedOrPromise !== true) { // !!!注意这里，如果passedOrPromise是个promise，那么会调用break来跳出这个for循环，进行到下面的步骤，这也是sequence类保证case顺序执行的关键。 promise = passedOrPromise break; } } if (!promise) { return this.finish() } // !!!通过then方法，保证上一个promise被resolve后(即case执行完后)，再进行后面的步骤，如果then接受passed参数为真，那么继续调用runNext()方法。再次调用runNext方法后，通过迭代器访问的数组：iterator迭代器的内部指针就不会从这个数组的一开始的起始位置开始访问，而是从上一次for循环结束的地方开始。这样也就保证了异步case的顺序执行 return promise.then(passed => { if (!passed) { // do something } return runNext() }) } return runNext() }}复制代码 具体到我们提供的例子当中：
allTests这个Sequence实例的runnables属性保存了一个Sequence实例(A和B)和一个Concurrent实例(C和D)。
在调用allTests.run()后，在对allTesets的runnables的迭代器对象进行遍历的时候，首先调用包含A和B的Sequence实例的run方法，在run内部递归调用runNext方法，用以确保异步case的顺序执行。
具体的实现主要还是使用了Promise迭代链来完成异步任务的顺序执行：每次进行异步case时，这个异步的case会返回一个promise，这个时候停止迭代器对象的遍历，而是通过在promise的then方法中递归调用runNext()，来保证顺序执行。
return promise.then(passed => { if (!passed) { // do something } return runNext()})复制代码 当A和B组成的Sequence执行完成后，才会继续执行由C和D组成的Conccurent，接下来我们看下并发执行case的内部实现：同样在Concurrent类上也部署了run方法，用以开始需要并发执行的case：
class Concurrent { constructor(runnables, bail) { if (!Array.isArray(runnables)) { throw new TypeError('Expected an array of runnables'); } this.runnables = runnables; } run () { // 所有的case是否通过 let allPassed = true; let pending; let rejectPending; let resolvePending; // 维护一个promise数组 const allPromises = []; const handlePromise = promise => { // 初始化一个pending的promise if (!pending) { pending = new Promise((resolve, reject) => { rejectPending = reject; resolvePending = resolve; }); } // 如果每个case都返回的是一个promise，那么首先调用then方法添加对于这个promise被resolve或者reject的处理函数，（这个添加被reject的处理，主要是用于下面Promise.all方法来处理所有被resolve的case）同时将这个promise推入到allPromises数组当中 allPromises.push(promise.then(passed => { if (!passed) { allPassed = false; if (this.bail) { // Stop if the test failed and bail mode is on. resolvePending(); } } }, rejectPending)); }; // 通过for循环遍历runnables中保存的case。 for (const runnable of this.runnables) { // 调用每个case的run方法 const passedOrPromise = runnable.run(); // 如果是同步的case，且执行失败了 if (!passedOrPromise) { if (this.bail) { // Stop if the test failed and bail mode is on. return false; } allPassed = false; } else if (passedOrPromise !== true) { // !!!如果返回的是一个promise handlePromise(passedOrPromise); } } if (pending) { // 使用Promise.all去处理allPromises当中的promise。当所有的promise被resolve后才会调用resolvePending，因为resolvePending对应于pending这个promise的resolve方法，也就是pending这个promise也被resolve，最后调用pending的then方法中添加的对于promise被resolve的方法。 Promise.all(allPromises).then(resolvePending); // 返回一个处于pending态的promise，但是它的then方法中添加了这个promise被resolve后的处理函数，即返回allPassed return pending.then(() => allPassed); } // 如果是同步的测试 return allPassed; } }}复制代码 具体到我们的例子当中：Concurrent实例的runnables属性中保存了C和D2个case，调用实例的run方法后，C和D2个case即开始并发执行，不同于Sequence内部通过iterator遍历器来实现的case的顺序执行，Concurrent内部直接只用for循环来启动case的执行，然后通过维护一个promise数组，并调用Promise.all来处理promise数组的状态。
以上就是通过一个简单的例子介绍了AVA内部的流程控制模型。简单的总结下：
在AVA内部使用Promise来进行整个的流程控制(这里指的异步的case)。
串行：
Sequence类来保证case的串行执行，在需要串行运行的case当中，调用Sequence实例的runNext方法开始case的执行，通过获取case数组的iterator对象来手动对case(或case的集合)进行遍历执行，因为每个异步的case内部都返回了一个promise，这个时候会跳出对iterator的遍历，通过在这个promise的then方法中递归调用runNext方法，这样就保证了case的串行执行。
并行：
Concurrent类来保证case的并行执行，遇到需要并行运行的case时，同样是使用for循环，但是不是通过获取数组iterator迭代器对象去手动遍历，而是并发去执行，同时通过一个数组去收集这些并发执行的case返回的promise，最后通过Promise.all方法去处理这些未被resolve的promise，当然这里面也有一些小技巧，我在上面的分析中也指出了，这里不再赘述。
关于文中提到的Promise进行异步流程控制具体的应用，可以看下这2篇文章：