AVA测试框架内部的Promise异步流程控制模型

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
})

复制代码

class Sequence {
    constructor (runnables) {
        this.runnables = runnables
    }
    
    run() {
        // do something
    }
}
复制代码

class Concurrent {
    constructor (runnables) {
        this.runnables = runnables
    }
    run () {
        // do something 
    }
}
复制代码

ava.serial('A', async () => {
    // do something
})
ava.serial('B', async () => {
    // do something
})
ava('C', async () => {
    // do something
})
ava('D', async () => {
    // do something
})
复制代码

const serial = ['A', 'B'];
const concurrent = ['C', 'D']
复制代码

const serialTests = new Sequence(serial)
const concurrentTests = new Concurrent(concurrent)
复制代码

const allTests = new Sequence([serialTests, concurrentTests])
复制代码

allTests.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()
}
}
复制代码

return promise.then(passed => {
if (!passed) {
// do something
}
return runNext()
})
复制代码

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;
}
}
}
复制代码