@git.zone/tstest 1.0.79

package/cli.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+process.env.CLI_CALL = 'true';
+const cliTool = await import('./dist_ts/index.js');
+cliTool.runCli();

package/dist_ts/00_commitinfo_data.d.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export declare const commitinfo: {
+    name: string;
+    version: string;
+    description: string;
+};

package/dist_ts/00_commitinfo_data.js

@@ -0,0 +1,9 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+    name: '@git.zone/tstest',
+    version: '1.0.78',
+    description: 'a test utility to run tests that match test/**/*.ts'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxrQkFBa0I7SUFDeEIsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLHFEQUFxRDtDQUNuRSxDQUFBIn0=

package/dist_ts/index.d.ts

@@ -0,0 +1 @@
+export declare const runCli: () => Promise<void>;

package/dist_ts/index.js

@@ -0,0 +1,10 @@
+import { TsTest } from './tstest.classes.tstest.js';
+export const runCli = async () => {
+    if (!process.argv[2]) {
+        console.error('You must specify a test directory as argument. Please try again.');
+        process.exit(1);
+    }
+    const tsTestInstance = new TsTest(process.cwd(), process.argv[2]);
+    await tsTestInstance.run();
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFFcEQsTUFBTSxDQUFDLE1BQU0sTUFBTSxHQUFHLEtBQUssSUFBSSxFQUFFO0lBQy9CLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFO1FBQ3BCLE9BQU8sQ0FBQyxLQUFLLENBQUMsa0VBQWtFLENBQUMsQ0FBQztRQUNsRixPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDO0tBQ2pCO0lBQ0QsTUFBTSxjQUFjLEdBQUcsSUFBSSxNQUFNLENBQUMsT0FBTyxDQUFDLEdBQUcsRUFBRSxFQUFFLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNsRSxNQUFNLGNBQWMsQ0FBQyxHQUFHLEVBQUUsQ0FBQztBQUM3QixDQUFDLENBQUMifQ==

package/dist_ts/tstest.classes.tap.combinator.d.ts

@@ -0,0 +1,6 @@
+import { TapParser } from './tstest.classes.tap.parser.js';
+export declare class TapCombinator {
+    tapParserStore: TapParser[];
+    addTapParser(tapParserArg: TapParser): void;
+    evaluate(): void;
+}

package/dist_ts/tstest.classes.tap.combinator.js

@@ -0,0 +1,62 @@
+// ============
+// combines different tap test files to an overall result
+// ============
+import * as plugins from './tstest.plugins.js';
+import { coloredString as cs } from '@push.rocks/consolecolor';
+import { TapParser } from './tstest.classes.tap.parser.js';
+import * as logPrefixes from './tstest.logprefixes.js';
+export class TapCombinator {
+    constructor() {
+        this.tapParserStore = [];
+    }
+    addTapParser(tapParserArg) {
+        this.tapParserStore.push(tapParserArg);
+    }
+    evaluate() {
+        console.log(`${logPrefixes.TsTestPrefix} RESULTS FOR ${this.tapParserStore.length} TESTFILE(S):`);
+        let failGlobal = false; // determine wether tstest should fail
+        for (const tapParser of this.tapParserStore) {
+            if (!tapParser.expectedTests) {
+                failGlobal = true;
+                let overviewString = logPrefixes.TsTestPrefix +
+                    cs(` ${tapParser.fileName} ${plugins.figures.cross}`, 'red') +
+                    ` ${plugins.figures.pointer} ` +
+                    `does not specify tests!`;
+                console.log(overviewString);
+            }
+            else if (tapParser.expectedTests !== tapParser.receivedTests) {
+                failGlobal = true;
+                let overviewString = logPrefixes.TsTestPrefix +
+                    cs(` ${tapParser.fileName} ${plugins.figures.cross}`, 'red') +
+                    ` ${plugins.figures.pointer} ` +
+                    tapParser.getTestOverviewAsString() +
+                    `did not execute all specified tests!`;
+                console.log(overviewString);
+            }
+            else if (tapParser.getErrorTests().length === 0) {
+                let overviewString = logPrefixes.TsTestPrefix +
+                    cs(` ${tapParser.fileName} ${plugins.figures.tick}`, 'green') +
+                    ` ${plugins.figures.pointer} ` +
+                    tapParser.getTestOverviewAsString();
+                console.log(overviewString);
+            }
+            else {
+                failGlobal = true;
+                let overviewString = logPrefixes.TsTestPrefix +
+                    cs(` ${tapParser.fileName} ${plugins.figures.cross}`, 'red') +
+                    ` ${plugins.figures.pointer} ` +
+                    tapParser.getTestOverviewAsString();
+                console.log(overviewString);
+            }
+        }
+        console.log(cs(plugins.figures.hamburger.repeat(48), 'cyan'));
+        if (!failGlobal) {
+            console.log(cs('FINAL RESULT: SUCCESS!', 'green'));
+        }
+        else {
+            console.log(cs('FINAL RESULT: FAIL!', 'red'));
+            process.exit(1);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/tstest.classes.tap.parser.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" resolution-mode="require"/>
+import { ChildProcess } from 'child_process';
+import { TapTestResult } from './tstest.classes.tap.testresult.js';
+export declare class TapParser {
+    fileName: string;
+    testStore: TapTestResult[];
+    expectedTestsRegex: RegExp;
+    expectedTests: number;
+    receivedTests: number;
+    testStatusRegex: RegExp;
+    activeTapTestResult: TapTestResult;
+    /**
+     * the constructor for TapParser
+     */
+    constructor(fileName: string);
+    private _getNewTapTestResult;
+    private _processLog;
+    /**
+     * returns all tests that are not completed
+     */
+    getUncompletedTests(): void;
+    /**
+     * returns all tests that threw an error
+     */
+    getErrorTests(): TapTestResult[];
+    /**
+     * returns a test overview as string
+     */
+    getTestOverviewAsString(): string;
+    /**
+     * handles a tap process
+     * @param childProcessArg
+     */
+    handleTapProcess(childProcessArg: ChildProcess): Promise<void>;
+    handleTapLog(tapLog: string): Promise<void>;
+    private _evaluateResult;
+}

package/dist_ts/tstest.classes.tap.parser.js

@@ -0,0 +1,158 @@
+import { ChildProcess } from 'child_process';
+import { coloredString as cs } from '@push.rocks/consolecolor';
+// ============
+// combines different tap test files to an overall result
+// ============
+import * as plugins from './tstest.plugins.js';
+import { TapTestResult } from './tstest.classes.tap.testresult.js';
+import * as logPrefixes from './tstest.logprefixes.js';
+export class TapParser {
+    /**
+     * the constructor for TapParser
+     */
+    constructor(fileName) {
+        this.fileName = fileName;
+        this.testStore = [];
+        this.expectedTestsRegex = /([0-9]*)\.\.([0-9]*)$/;
+        this.testStatusRegex = /(ok|not\sok)\s([0-9]+)\s-\s(.*)\s#\stime=(.*)ms$/;
+    }
+    _getNewTapTestResult() {
+        this.activeTapTestResult = new TapTestResult(this.testStore.length + 1);
+    }
+    _processLog(logChunk) {
+        if (Buffer.isBuffer(logChunk)) {
+            logChunk = logChunk.toString();
+        }
+        const logLineArray = logChunk.split('\n');
+        if (logLineArray[logLineArray.length - 1] === '') {
+            logLineArray.pop();
+        }
+        // lets parse the log information
+        for (const logLine of logLineArray) {
+            let logLineIsTapProtocol = false;
+            if (!this.expectedTests && this.expectedTestsRegex.test(logLine)) {
+                logLineIsTapProtocol = true;
+                const regexResult = this.expectedTestsRegex.exec(logLine);
+                this.expectedTests = parseInt(regexResult[2]);
+                console.log(`${logPrefixes.TapPrefix} ${cs(`Expecting ${this.expectedTests} tests!`, 'blue')}`);
+                // initiating first TapResult
+                this._getNewTapTestResult();
+            }
+            else if (this.testStatusRegex.test(logLine)) {
+                logLineIsTapProtocol = true;
+                const regexResult = this.testStatusRegex.exec(logLine);
+                const testId = parseInt(regexResult[2]);
+                const testOk = (() => {
+                    if (regexResult[1] === 'ok') {
+                        return true;
+                    }
+                    return false;
+                })();
+                const testSubject = regexResult[3];
+                const testDuration = parseInt(regexResult[4]);
+                // test for protocol error
+                if (testId !== this.activeTapTestResult.id) {
+                    console.log(`${logPrefixes.TapErrorPrefix} Something is strange! Test Ids are not equal!`);
+                }
+                this.activeTapTestResult.setTestResult(testOk);
+                if (testOk) {
+                    console.log(logPrefixes.TapPrefix, `${cs(`T${testId} ${plugins.figures.tick}`, 'green')} ${plugins.figures.arrowRight} ` +
+                        cs(testSubject, 'blue') +
+                        ` | ${cs(`${testDuration} ms`, 'orange')}`);
+                }
+                else {
+                    console.log(logPrefixes.TapPrefix, `${cs(`T${testId} ${plugins.figures.cross}`, 'red')} ${plugins.figures.arrowRight} ` +
+                        cs(testSubject, 'blue') +
+                        ` | ${cs(`${testDuration} ms`, 'orange')}`);
+                }
+            }
+            if (!logLineIsTapProtocol) {
+                if (this.activeTapTestResult) {
+                    this.activeTapTestResult.addLogLine(logLine);
+                }
+                console.log(logLine);
+            }
+            if (this.activeTapTestResult && this.activeTapTestResult.testSettled) {
+                this.testStore.push(this.activeTapTestResult);
+                this._getNewTapTestResult();
+            }
+        }
+    }
+    /**
+     * returns all tests that are not completed
+     */
+    getUncompletedTests() {
+        // TODO:
+    }
+    /**
+     * returns all tests that threw an error
+     */
+    getErrorTests() {
+        return this.testStore.filter((tapTestArg) => {
+            return !tapTestArg.testOk;
+        });
+    }
+    /**
+     * returns a test overview as string
+     */
+    getTestOverviewAsString() {
+        let overviewString = '';
+        for (const test of this.testStore) {
+            if (overviewString !== '') {
+                overviewString += ' | ';
+            }
+            if (test.testOk) {
+                overviewString += cs(`T${test.id} ${plugins.figures.tick}`, 'green');
+            }
+            else {
+                overviewString += cs(`T${test.id} ${plugins.figures.cross}`, 'red');
+            }
+        }
+        return overviewString;
+    }
+    /**
+     * handles a tap process
+     * @param childProcessArg
+     */
+    async handleTapProcess(childProcessArg) {
+        const done = plugins.smartpromise.defer();
+        childProcessArg.stdout.on('data', (data) => {
+            this._processLog(data);
+        });
+        childProcessArg.stderr.on('data', (data) => {
+            this._processLog(data);
+        });
+        childProcessArg.on('exit', async () => {
+            await this._evaluateResult();
+            done.resolve();
+        });
+        await done.promise;
+    }
+    async handleTapLog(tapLog) {
+        this._processLog(tapLog);
+        await this._evaluateResult();
+    }
+    async _evaluateResult() {
+        this.receivedTests = this.testStore.length;
+        // check wether all tests ran
+        if (this.expectedTests === this.receivedTests) {
+            console.log(`${logPrefixes.TapPrefix} ${cs(`${this.receivedTests} out of ${this.expectedTests} Tests completed!`, 'green')}`);
+        }
+        else {
+            console.log(`${logPrefixes.TapErrorPrefix} ${cs(`Only ${this.receivedTests} out of ${this.expectedTests} completed!`, 'red')}`);
+        }
+        if (!this.expectedTests) {
+            console.log(cs('Error: No tests were defined. Therefore the testfile failed!', 'red'));
+        }
+        else if (this.expectedTests !== this.receivedTests) {
+            console.log(cs('Error: The amount of received tests and expectedTests is unequal! Therefore the testfile failed', 'red'));
+        }
+        else if (this.getErrorTests().length === 0) {
+            console.log(`${logPrefixes.TapPrefix} ${cs(`All tests are successfull!!!`, 'green')}`);
+        }
+        else {
+            console.log(`${logPrefixes.TapPrefix} ${cs(`${this.getErrorTests().length} tests threw an error!!!`, 'red')}`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/tstest.classes.tap.testresult.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" resolution-mode="require"/>
+export declare class TapTestResult {
+    id: number;
+    testLogBuffer: Buffer;
+    testOk: boolean;
+    testSettled: boolean;
+    constructor(id: number);
+    /**
+     * adds a logLine to the log buffer of the test
+     * @param logLine
+     */
+    addLogLine(logLine: string): void;
+    setTestResult(testOkArg: boolean): void;
+}

package/dist_ts/tstest.classes.tap.testresult.js

@@ -0,0 +1,26 @@
+// ============
+// combines different tap test files to an overall result
+// ============
+import * as plugins from './tstest.plugins.js';
+export class TapTestResult {
+    constructor(id) {
+        this.id = id;
+        this.testLogBuffer = Buffer.from('');
+        this.testOk = false;
+        this.testSettled = false;
+    }
+    /**
+     * adds a logLine to the log buffer of the test
+     * @param logLine
+     */
+    addLogLine(logLine) {
+        logLine = logLine + '\n';
+        const logLineBuffer = Buffer.from(logLine);
+        this.testLogBuffer = Buffer.concat([this.testLogBuffer, logLineBuffer]);
+    }
+    setTestResult(testOkArg) {
+        this.testOk = testOkArg;
+        this.testSettled = true;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHN0ZXN0LmNsYXNzZXMudGFwLnRlc3RyZXN1bHQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy90c3Rlc3QuY2xhc3Nlcy50YXAudGVzdHJlc3VsdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxlQUFlO0FBQ2YseURBQXlEO0FBQ3pELGVBQWU7QUFDZixPQUFPLEtBQUssT0FBTyxNQUFNLHFCQUFxQixDQUFDO0FBRS9DLE1BQU0sT0FBTyxhQUFhO0lBSXhCLFlBQW1CLEVBQVU7UUFBVixPQUFFLEdBQUYsRUFBRSxDQUFRO1FBSDdCLGtCQUFhLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUNoQyxXQUFNLEdBQVksS0FBSyxDQUFDO1FBQ3hCLGdCQUFXLEdBQVksS0FBSyxDQUFDO0lBQ0csQ0FBQztJQUVqQzs7O09BR0c7SUFDSCxVQUFVLENBQUMsT0FBZTtRQUN4QixPQUFPLEdBQUcsT0FBTyxHQUFHLElBQUksQ0FBQztRQUN6QixNQUFNLGFBQWEsR0FBRyxNQUFNLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQzNDLElBQUksQ0FBQyxhQUFhLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLElBQUksQ0FBQyxhQUFhLEVBQUUsYUFBYSxDQUFDLENBQUMsQ0FBQztJQUMxRSxDQUFDO0lBRUQsYUFBYSxDQUFDLFNBQWtCO1FBQzlCLElBQUksQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDO1FBQ3hCLElBQUksQ0FBQyxXQUFXLEdBQUcsSUFBSSxDQUFDO0lBQzFCLENBQUM7Q0FDRiJ9

package/dist_ts/tstest.classes.testdirectory.d.ts

@@ -0,0 +1,27 @@
+import { Smartfile } from '@push.rocks/smartfile';
+export declare class TestDirectory {
+    /**
+     * the current working directory
+     */
+    cwd: string;
+    /**
+     * the relative location of the test dir
+     */
+    relativePath: string;
+    /**
+     * the absolute path of the test dir
+     */
+    absolutePath: string;
+    /**
+     * an array of Smartfiles
+     */
+    testfileArray: Smartfile[];
+    /**
+     * the constructor for TestDirectory
+     * tell it the path
+     * @param pathToTestDirectory
+     */
+    constructor(cwdArg: string, relativePathToTestDirectory: string);
+    private _init;
+    getTestFilePathArray(): Promise<string[]>;
+}

package/dist_ts/tstest.classes.testdirectory.js

@@ -0,0 +1,35 @@
+import * as plugins from './tstest.plugins.js';
+import * as paths from './tstest.paths.js';
+import { Smartfile } from '@push.rocks/smartfile';
+// tap related stuff
+import { TapCombinator } from './tstest.classes.tap.combinator.js';
+import { TapParser } from './tstest.classes.tap.parser.js';
+import { TapTestResult } from './tstest.classes.tap.testresult.js';
+export class TestDirectory {
+    /**
+     * the constructor for TestDirectory
+     * tell it the path
+     * @param pathToTestDirectory
+     */
+    constructor(cwdArg, relativePathToTestDirectory) {
+        /**
+         * an array of Smartfiles
+         */
+        this.testfileArray = [];
+        this.cwd = cwdArg;
+        this.relativePath = relativePathToTestDirectory;
+    }
+    async _init() {
+        this.testfileArray = await plugins.smartfile.fs.fileTreeToObject(plugins.path.join(this.cwd, this.relativePath), 'test*.ts');
+    }
+    async getTestFilePathArray() {
+        await this._init();
+        const testFilePaths = [];
+        for (const testFile of this.testfileArray) {
+            const filePath = plugins.path.join(this.relativePath, testFile.path);
+            testFilePaths.push(filePath);
+        }
+        return testFilePaths;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHN0ZXN0LmNsYXNzZXMudGVzdGRpcmVjdG9yeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3RzdGVzdC5jbGFzc2VzLnRlc3RkaXJlY3RvcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxxQkFBcUIsQ0FBQztBQUMvQyxPQUFPLEtBQUssS0FBSyxNQUFNLG1CQUFtQixDQUFDO0FBQzNDLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUVsRCxvQkFBb0I7QUFDcEIsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBQ25FLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUMzRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sb0NBQW9DLENBQUM7QUFFbkUsTUFBTSxPQUFPLGFBQWE7SUFxQnhCOzs7O09BSUc7SUFDSCxZQUFZLE1BQWMsRUFBRSwyQkFBbUM7UUFWL0Q7O1dBRUc7UUFDSCxrQkFBYSxHQUFnQixFQUFFLENBQUM7UUFROUIsSUFBSSxDQUFDLEdBQUcsR0FBRyxNQUFNLENBQUM7UUFDbEIsSUFBSSxDQUFDLFlBQVksR0FBRywyQkFBMkIsQ0FBQztJQUNsRCxDQUFDO0lBRU8sS0FBSyxDQUFDLEtBQUs7UUFDakIsSUFBSSxDQUFDLGFBQWEsR0FBRyxNQUFNLE9BQU8sQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDLGdCQUFnQixDQUM5RCxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxFQUFFLElBQUksQ0FBQyxZQUFZLENBQUMsRUFDOUMsVUFBVSxDQUNYLENBQUM7SUFDSixDQUFDO0lBRUQsS0FBSyxDQUFDLG9CQUFvQjtRQUN4QixNQUFNLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUNuQixNQUFNLGFBQWEsR0FBYSxFQUFFLENBQUM7UUFDbkMsS0FBSyxNQUFNLFFBQVEsSUFBSSxJQUFJLENBQUMsYUFBYSxFQUFFO1lBQ3pDLE1BQU0sUUFBUSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxZQUFZLEVBQUUsUUFBUSxDQUFDLElBQUksQ0FBQyxDQUFDO1lBQ3JFLGFBQWEsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7U0FDOUI7UUFDRCxPQUFPLGFBQWEsQ0FBQztJQUN2QixDQUFDO0NBQ0YifQ==

package/dist_ts/tstest.classes.tstest.d.ts

@@ -0,0 +1,14 @@
+import * as plugins from './tstest.plugins.js';
+import { TestDirectory } from './tstest.classes.testdirectory.js';
+import { TapParser } from './tstest.classes.tap.parser.js';
+export declare class TsTest {
+    testDir: TestDirectory;
+    smartshellInstance: plugins.smartshell.Smartshell;
+    smartbrowserInstance: plugins.smartbrowser.SmartBrowser;
+    tsbundleInstance: plugins.tsbundle.TsBundle;
+    constructor(cwdArg: string, relativePathToTestDirectory: string);
+    run(): Promise<void>;
+    runInNode(fileNameArg: string): Promise<TapParser>;
+    runInChrome(fileNameArg: string): Promise<TapParser>;
+    runInDeno(): Promise<void>;
+}