@tsdi/unit/es2015/runner/SuiteRunner.js

unit testing framework, base on AOP, Ioc container

import { __awaiter, __decorate } from "tslib";
import { isNumber, lang, PromiseUtil, Injectable, Refs } from '@tsdi/ioc';
import { Runnable, Startup } from '@tsdi/boot';
import { Before, BeforeEach, Test, After, AfterEach } from '../decorators';
import { RunCaseToken, RunSuiteToken, Assert } from '../assert/assert';
/**
 * Suite runner.
 *
 * @export
 * @class SuiteRunner
 * @implements {IRunner<any>}
 */
let SuiteRunner = class SuiteRunner extends Runnable {
    configureService(ctx) {
        return __awaiter(this, void 0, void 0, function* () {
            this.context = ctx;
        });
    }
    /**
     * get suite describe.
     *
     * @returns {ISuiteDescribe}
     * @memberof SuiteRunner
     */
    getSuiteDescribe() {
        let meta = this.context.getTargetReflect().getAnnoation();
        this.timeout = (meta && meta.timeout) ? meta.timeout : (3 * 60 * 60 * 1000);
        this.describe = meta.describe || lang.getClassName(this.getBootType());
        return {
            timeout: this.timeout,
            describe: this.describe,
            cases: []
        };
    }
    run(data) {
        return __awaiter(this, void 0, void 0, function* () {
            try {
                let desc = this.getSuiteDescribe();
                yield this.runSuite(desc);
            }
            catch (err) {
                // console.error(err);
            }
        });
    }
    runSuite(desc) {
        return __awaiter(this, void 0, void 0, function* () {
            yield this.runBefore(desc);
            yield this.runTest(desc);
            yield this.runAfter(desc);
        });
    }
    runTimeout(key, describe, timeout) {
        let instance = this.getBoot();
        let defer = PromiseUtil.defer();
        let injector = this.getContext().injector;
        let timer = setTimeout(() => {
            if (timer) {
                clearTimeout(timer);
                let assert = injector.resolve(Assert);
                let err = new assert.AssertionError({
                    message: `${describe}, timeout ${timeout}`,
                    stackStartFunction: instance[key],
                    stackStartFn: instance[key]
                });
                defer.reject(err);
            }
        }, timeout || this.timeout);
        Promise.resolve(injector.invoke(instance, key, { provide: RunCaseToken, useValue: instance[key] }, { provide: RunSuiteToken, useValue: instance }))
            .then(r => {
            clearTimeout(timer);
            timer = null;
            defer.resolve(r);
        })
            .catch(err => {
            clearTimeout(timer);
            timer = null;
            defer.reject(err);
        });
        return defer.promise;
    }
    runBefore(describe) {
        return __awaiter(this, void 0, void 0, function* () {
            let methodMaps = this.context.reflects.getMethodMetadata(Before, this.getBoot());
            yield PromiseUtil.step(Object.keys(methodMaps)
                .map(key => () => {
                let meta = methodMaps[key].find(m => isNumber(m.timeout));
                return this.runTimeout(key, 'sutie before ' + key, meta ? meta.timeout : describe.timeout);
            }));
        });
    }
    runBeforeEach() {
        return __awaiter(this, void 0, void 0, function* () {
            let methodMaps = this.context.reflects.getMethodMetadata(BeforeEach, this.getBoot());
            yield PromiseUtil.step(Object.keys(methodMaps)
                .map(key => () => {
                let meta = methodMaps[key].find(m => isNumber(m.timeout));
                return this.runTimeout(key, 'before each ' + key, meta ? meta.timeout : this.timeout);
            }));
        });
    }
    runAfterEach() {
        return __awaiter(this, void 0, void 0, function* () {
            let methodMaps = this.context.reflects.getMethodMetadata(AfterEach, this.getBoot());
            yield PromiseUtil.step(Object.keys(methodMaps)
                .map(key => () => {
                let meta = methodMaps[key].find(m => isNumber(m.timeout));
                return this.runTimeout(key, 'after each ' + key, meta ? meta.timeout : this.timeout);
            }));
        });
    }
    runAfter(describe) {
        return __awaiter(this, void 0, void 0, function* () {
            let methodMaps = this.context.reflects.getMethodMetadata(After, this.getBoot());
            yield PromiseUtil.step(Object.keys(methodMaps)
                .map(key => () => {
                let meta = methodMaps[key].find(m => isNumber(m.timeout));
                return this.runTimeout(key, 'sutie after ' + key, meta ? meta.timeout : describe.timeout);
            }));
        });
    }
    runTest(desc) {
        return __awaiter(this, void 0, void 0, function* () {
            let methodMaps = this.context.reflects.getMethodMetadata(Test, this.getBoot());
            let keys = Object.keys(methodMaps);
            yield PromiseUtil.step(keys.map(key => {
                let meta = methodMaps[key].find(m => isNumber(m.setp));
                let timeoutMeta = methodMaps[key].find(m => isNumber(m.timeout));
                let title = methodMaps[key].map(m => m.title).filter(t => t).join('; ');
                return {
                    key: key,
                    order: meta ? meta.setp : keys.length,
                    timeout: timeoutMeta ? timeoutMeta.timeout : this.timeout,
                    title: title || key
                };
            })
                .sort((a, b) => {
                return b.order - a.order;
            })
                .map(caseDesc => {
                return () => this.runCase(caseDesc);
            }));
        });
    }
    runCase(caseDesc) {
        return __awaiter(this, void 0, void 0, function* () {
            try {
                yield this.runBeforeEach();
                yield this.runTimeout(caseDesc.key, caseDesc.title, caseDesc.timeout);
                yield this.runAfterEach();
            }
            catch (err) {
                caseDesc.error = err;
            }
            return caseDesc;
        });
    }
    static ρAnn() {
        return { "name": "SuiteRunner", "params": { "configureService": ["ctx"], "run": ["data"], "runSuite": ["desc"], "runTimeout": ["key", "describe", "timeout"], "runBefore": ["describe"], "runAfter": ["describe"], "runTest": ["desc"], "runCase": ["caseDesc"] } };
    }
};
SuiteRunner = __decorate([
    Injectable(),
    Refs('@Suite', Startup)
], SuiteRunner);
export { SuiteRunner };

//# sourceMappingURL=../sourcemaps/runner/SuiteRunner.js.map