2

我继承了一个没有测试的 typescript@2 项目。

它基本上是一个 cli 任务运行器，一个任务多次请求外部 api 以创建文件。作为第一个故障保险，我想设置验收测试。

因此，我想模拟对外部 api 的调用并从本地文件中获取响应。我该如何做到这一点？

我已经研究了 nock，因为它似乎提供了这个功能，但是我该如何使用它呢？

（我没有提供示例，因为我打算自己回答我的问题，因为我最近刚刚经历了整个考验。）

4

1 回答 1

4

我已经重构了我的应用程序，所有对外部 api 的调用都发生在 Task 对象执行其execute方法时。这样的任务实现了接口ITask：

import {ReadStream} from 'fs';
export interface ITask {
    execute(): Promise<ReadStream>;
}

这使我可以将任务包装在记录器或播放装饰器中。（我也不再让execute创建文件，但它返回流的承诺。在我的正常工作流程中，我会将该流转储到文件系统（或将其上传到我想要的任何地方）。

记录装饰器：

import {writeFile} from 'fs';
import {ITask} from './ITask';
import nock = require('nock');
import mkdirp = require('mkdirp');
import {ReadStream} from 'fs';

export class TaskMockRecorder implements ITask {
    constructor(private task: ITask, private pathToFile: string) {
    }

    public async execute(): Promise <ReadStream> {
        this.setupNock();
        const stream = await this.task.execute();
        this.writeRecordFile();

        return Promise.resolve(stream);
    }

    private writeRecordFile() {
        const nockCallObjects = nock.recorder.play();

        mkdirp(this.pathToFile, async() => {
            writeFile(`${this.pathToFile}`, JSON.stringify(nockCallObjects, null, 4));
        });
    }

    private setupNock() {
        nock.recorder.rec({
            dont_print: true,
            enable_reqheaders_recording: true,
            output_objects: true,
        });
    }
}

播放装饰器

import {ITask} from './ITask';
import {ReadStream} from 'fs';
import {Partner} from '../Types';
import nock = require('nock');

export class TaskMockPlaybackDecorator implements ITask {
    constructor(private task: ITask, private pathToFile: string) {
    }

    public async execute(): Promise<ReadStream> {
        nock.load(this.pathToFile);
        nock.recorder.play();

        return this.task.execute();
    }
}

装饰任务

我还介绍了自定义类型MockMode：

export type MockeMode = 'recording'|'playback'|'none';

然后我可以将其注入到我的 appRunner 函数中：

export async function appRun(config: IConfig, mockMode: MockeMode): Promise<ReadStream> {
    let task: ITask;

    task = new MyTask(config);

    const pathToFile = `tapes/${config.taskName}/tape.json`;
    switch (mockMode) {
        case 'playback':
            console.warn('playback mode!');
            task = new TaskMockPlaybackDecorator(task, path);
            break;
        case 'recording':
            console.warn('recording mode!');
            task = new TaskMockRecorder(task, path);
            break;
        default:
            console.log('normal mode');
    }

    const csvStream = await task.execute();

    return Promise.resolve(csvStream);
}

实施验收测试：

我现在必须添加参考文件并设置 mocha 测试，将回放运行生成的流与参考文件进行比较：

import nock = require('nock');
import {appRun} from '../../src/core/task/taskRunner';
import {createReadStream} from 'fs';
import {brands} from '../../src/config/BrandConfig';
import isEqual = require('lodash/isEqual');
const streamEqual = require('stream-equal');

describe('myTask', () => {
    const myConfig = { // myConfig // }
    const referencePath = `references/${myConfig.taskName}.csv`;
    it(`generates csv that matches ${referencePath}`, async() => {
        nock.load(`tapes/${config}.taskName}/tape.json`);
        nock.recorder.play();

        return new Promise(async(resolve, reject) => {
            const actual = await appRun(myConfig, 'playback');
            const expected = createReadStream(referencePath);
            streamEqual(actual, expected, (err: any, isEqual: boolean) => {
                if (err) {
                    reject(err);
                }
                if (isEqual) {                          
                    resolve('equals');
                    return;
                }

                reject('not equals');               
            });
        });
    });
});

根据录制的 json 请求/响应的大小，可能需要通过 增加运行大小timeout，因为默认值为 2 秒，此类测试可能运行速度较慢。

mocha --recursive dist/tests -t 10000

这种方法还可以轻松更新磁带，只需将mockMode参数作为参数传递，它就会更新tape.json.

缺点是tape.json可能会很大，具体取决于流量，但这是我有意为之的第一步，我想确保我的应用程序在对其代码库进行任何更改时表现相同。

于 2016-12-04T15:18:05.233 回答