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

unit testing framework, base on AOP, Ioc container

import { __awaiter, __decorate } from "tslib";
import { Injectable, isString, isClass, isArray, PromiseUtil } from '@tsdi/ioc';
import { Runnable, BuilderService, ApplicationExit } from '@tsdi/boot';
import { OldTestRunner } from './OldTestRunner';
import { Suite } from '../decorators';
import { TestReport } from '../reports/TestReport';
/**
 * Suite runner.
 *
 * @export
 * @class SuiteRunner
 * @implements {IRunner<any>}
 */
let UnitTestRunner = class UnitTestRunner extends Runnable {
    configureService(ctx) {
        return __awaiter(this, void 0, void 0, function* () {
            this.context = ctx;
        });
    }
    getContext() {
        return this.context;
    }
    run(data) {
        return __awaiter(this, void 0, void 0, function* () {
            let context = this.getContext();
            let config = yield context.getConfiguration();
            let src = config.src;
            let injector = context.injector;
            const exit = injector.get(ApplicationExit);
            if (exit) {
                exit.enable = false;
            }
            let suites = [];
            let oldRunner = injector.resolve(OldTestRunner);
            yield oldRunner.configureService(context);
            let loader = injector.getLoader();
            oldRunner.registerGlobalScope();
            if (isString(src)) {
                let alltypes = yield loader.loadTypes({ files: [src], basePath: this.context.baseURL });
                alltypes.forEach(tys => {
                    suites = suites.concat(tys);
                });
            }
            else if (isClass(src)) {
                suites = [src];
            }
            else if (isArray(src)) {
                if (src.some(t => isClass(t))) {
                    suites = src;
                }
                else {
                    let alltypes = yield loader.loadTypes({ files: src, basePath: this.context.baseURL });
                    alltypes.forEach(tys => {
                        suites = suites.concat(tys);
                    });
                }
            }
            oldRunner.unregisterGlobalScope();
            yield oldRunner.run();
            let builder = injector.resolve(BuilderService);
            let reflects = this.context.reflects;
            yield PromiseUtil.step(suites.filter(v => isClass(v) && reflects.hasMetadata(Suite, v)).map(s => () => builder.run({ type: s, injector: injector })));
            yield injector.resolve(TestReport).report();
        });
    }
    static ρAnn() {
        return { "name": "UnitTestRunner", "params": { "configureService": ["ctx"], "run": ["data"] } };
    }
};
UnitTestRunner = __decorate([
    Injectable
], UnitTestRunner);
export { UnitTestRunner };

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