velocious 1.0.108 → 1.0.110

package/dist/src/testing/test-runner.js

@@ -0,0 +1,257 @@
+// @ts-check
+import { addTrackedStackToError } from "../utils/with-tracked-stack.js";
+import Application from "../../src/application.js";
+import BacktraceCleaner from "../utils/backtrace-cleaner.js";
+import RequestClient from "./request-client.js";
+import restArgsError from "../utils/rest-args-error.js";
+import { tests } from "./test.js";
+/**
+ * @typedef {object} TestArgs
+ * @property {Application} [application]
+ * @property {RequestClient} [client]
+ * @property {object} [databaseCleaning]
+ * @property {boolean} [databaseCleaning.transaction]
+ * @property {boolean} [databaseCleaning.truncate]
+ * @property {boolean} [focus]
+ * @property {() => Promise<void>} [function]
+ * @property {string} [type]
+ */
+/**
+ * @typedef {object} TestData
+ * @property {TestArgs} args
+ * @property {function(TestArgs) : Promise<void>} function
+ */
+/**
+ * @typedef {function({configuration: import("../configuration.js").default, testArgs: TestArgs, testData: TestData}) : Promise<void>} AfterBeforeEachCallbackType
+ */
+/**
+ * @typedef {object} AfterBeforeEachCallbackObjectType
+ * @property {AfterBeforeEachCallbackType} callback
+ */
+/**
+ * @typedef {object} TestsArgument
+ * @property {Record<string, TestData>} args
+ * @property {boolean} [anyTestsFocussed]
+ * @property {AfterBeforeEachCallbackObjectType[]} afterEaches
+ * @property {AfterBeforeEachCallbackObjectType[]} beforeEaches
+ * @property {Record<string, TestData>} tests - A unique identifier for the node.
+ * @property {Record<string, TestsArgument>} subs - Optional child nodes. Each item is another `Node`, allowing recursion.
+ */
+export default class TestRunner {
+    /**
+     * @param {object} args
+     * @param {import("../configuration.js").default} args.configuration
+     * @param {Array<string>} args.testFiles
+     */
+    constructor({ configuration, testFiles, ...restArgs }) {
+        restArgsError(restArgs);
+        if (!configuration)
+            throw new Error("configuration is required");
+        this._configuration = configuration;
+        this._testFiles = testFiles;
+        this._failedTests = 0;
+        this._successfulTests = 0;
+        this._testsCount = 0;
+    }
+    /**
+     * @returns {import("../configuration.js").default}
+     */
+    getConfiguration() { return this._configuration; }
+    /**
+     * @returns {string[]}
+     */
+    getTestFiles() { return this._testFiles; }
+    /**
+     * @returns {Promise<Application>}
+     */
+    async application() {
+        if (!this._application) {
+            this._application = new Application({
+                configuration: this.getConfiguration(),
+                httpServer: { port: 31006 },
+                type: "test-runner"
+            });
+            await this._application.initialize();
+            await this._application.startHttpServer();
+        }
+        return this._application;
+    }
+    /**
+     * @returns {Promise<RequestClient>}
+     */
+    async requestClient() {
+        if (!this._requestClient) {
+            this._requestClient = new RequestClient();
+        }
+        return this._requestClient;
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async importTestFiles() {
+        await this.getConfiguration().getEnvironmentHandler().importTestFiles(this.getTestFiles());
+    }
+    /**
+     * @returns {boolean}
+     */
+    isFailed() { return this._failedTests !== undefined && this._failedTests > 0; }
+    /**
+     * @returns {number}
+     */
+    getFailedTests() {
+        if (this._failedTests === undefined)
+            throw new Error("Tests hasn't been run yet");
+        return this._failedTests;
+    }
+    /**
+     * @returns {number}
+     */
+    getSuccessfulTests() {
+        if (this._successfulTests === undefined)
+            throw new Error("Tests hasn't been run yet");
+        return this._successfulTests;
+    }
+    /**
+     * @returns {number}
+     */
+    getTestsCount() {
+        if (this._testsCount === undefined)
+            throw new Error("Tests hasn't been run yet");
+        return this._testsCount;
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async prepare() {
+        this.anyTestsFocussed = false;
+        this._failedTests = 0;
+        this._successfulTests = 0;
+        this._testsCount = 0;
+        await this.importTestFiles();
+        await this.analyzeTests(tests);
+        this._onlyFocussed = this.anyTestsFocussed;
+        const testingConfigPath = this.getConfiguration().getTesting();
+        if (testingConfigPath) {
+            await this.getConfiguration().getEnvironmentHandler().importTestingConfigPath();
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    areAnyTestsFocussed() {
+        if (this.anyTestsFocussed === undefined) {
+            throw new Error("Hasn't been detected yet");
+        }
+        return this.anyTestsFocussed;
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async run() {
+        await this.getConfiguration().ensureConnections(async () => {
+            await this.runTests({
+                afterEaches: [],
+                beforeEaches: [],
+                tests,
+                descriptions: [],
+                indentLevel: 0
+            });
+        });
+    }
+    /**
+     * @param {TestsArgument} tests
+     * @returns {{anyTestsFocussed: boolean}}
+     */
+    analyzeTests(tests) {
+        let anyTestsFocussedFound = false;
+        for (const testDescription in tests.tests) {
+            const testData = tests.tests[testDescription];
+            const testArgs = Object.assign({}, testData.args);
+            this._testsCount++;
+            if (testArgs.focus) {
+                anyTestsFocussedFound = true;
+                this.anyTestsFocussed = true;
+            }
+        }
+        for (const subDescription in tests.subs) {
+            const subTest = tests.subs[subDescription];
+            const { anyTestsFocussed } = this.analyzeTests(subTest);
+            if (anyTestsFocussed) {
+                anyTestsFocussedFound = true;
+            }
+            subTest.anyTestsFocussed = anyTestsFocussed;
+        }
+        return { anyTestsFocussed: anyTestsFocussedFound };
+    }
+    /**
+     * @param {object} args
+     * @param {Array<AfterBeforeEachCallbackObjectType>} args.afterEaches
+     * @param {Array<AfterBeforeEachCallbackObjectType>} args.beforeEaches
+     * @param {TestsArgument} args.tests
+     * @param {string[]} args.descriptions
+     * @param {number} args.indentLevel
+     * @returns {Promise<void>}
+     */
+    async runTests({ afterEaches, beforeEaches, tests, descriptions, indentLevel }) {
+        const leftPadding = " ".repeat(indentLevel * 2);
+        const newAfterEaches = [...afterEaches, ...tests.afterEaches];
+        const newBeforeEaches = [...beforeEaches, ...tests.beforeEaches];
+        for (const testDescription in tests.tests) {
+            const testData = tests.tests[testDescription];
+            const testArgs = /** @type {TestArgs} */ (Object.assign({}, testData.args));
+            if (this._onlyFocussed && !testArgs.focus)
+                continue;
+            if (testArgs.type == "model" || testArgs.type == "request") {
+                testArgs.application = await this.application();
+            }
+            if (testArgs.type == "request") {
+                testArgs.client = await this.requestClient();
+            }
+            console.log(`${leftPadding}it ${testDescription}`);
+            try {
+                for (const beforeEachData of newBeforeEaches) {
+                    await beforeEachData.callback({ configuration: this.getConfiguration(), testArgs, testData });
+                }
+                await testData.function(testArgs);
+                this._successfulTests++;
+            }
+            catch (error) {
+                this._failedTests++;
+                if (error instanceof Error) {
+                    console.error(`${leftPadding}  Test failed:`, error.message);
+                    addTrackedStackToError(error);
+                    const backtraceCleaner = new BacktraceCleaner(error);
+                    const cleanedStack = backtraceCleaner.getCleanedStack();
+                    const stackLines = cleanedStack?.split("\n");
+                    if (stackLines) {
+                        for (const stackLine of stackLines) {
+                            console.error(`${leftPadding}  ${stackLine}`);
+                        }
+                    }
+                }
+                else {
+                    console.error(`${leftPadding}  Test failed with a ${typeof error}:`, error);
+                }
+            }
+            finally {
+                for (const afterEachData of newAfterEaches) {
+                    await afterEachData.callback({ configuration: this.getConfiguration(), testArgs, testData });
+                }
+            }
+        }
+        for (const subDescription in tests.subs) {
+            const subTest = tests.subs[subDescription];
+            const newDecriptions = descriptions.concat([subDescription]);
+            if (!this._onlyFocussed || subTest.anyTestsFocussed) {
+                console.log(`${leftPadding}${subDescription}`);
+                await this.runTests({
+                    afterEaches: newAfterEaches,
+                    beforeEaches: newBeforeEaches,
+                    tests: subTest,
+                    descriptions: newDecriptions,
+                    indentLevel: indentLevel + 1
+                });
+            }
+        }
+    }
+}

package/dist/src/testing/test.d.ts

@@ -0,0 +1,157 @@
+/**
+ * @param {import("./test-runner.js").AfterBeforeEachCallbackType} callback
+ * @returns {void}
+ */
+export function afterEach(callback: import("./test-runner.js").AfterBeforeEachCallbackType): void;
+/**
+ * @param {import("./test-runner.js").AfterBeforeEachCallbackType} callback
+ * @returns {void}
+ */
+export function beforeEach(callback: import("./test-runner.js").AfterBeforeEachCallbackType): void;
+/**
+ * @param {string} description
+ * @param {object|(() => Promise<void>)} arg1
+ * @param {undefined|(() => Promise<void>)} [arg2]
+ * @returns {Promise<void>}
+ */
+export function describe(description: string, arg1: object | (() => Promise<void>), arg2?: undefined | (() => Promise<void>)): Promise<void>;
+/**
+ * @param {any} arg
+ * @returns {Expect}
+ */
+export function expect(arg: any): Expect;
+/**
+ * @param {string} description
+ * @param {object|(() => Promise<void>)} arg1
+ * @param {undefined|(() => Promise<void>)} [arg2]
+ * @returns {void}
+ */
+export function fit(description: string, arg1: object | (() => Promise<void>), arg2?: undefined | (() => Promise<void>)): void;
+/**
+ * @param {string} description
+ * @param {object|(() => Promise<void>)} arg1
+ * @param {undefined|(() => Promise<void>)} [arg2]
+ * @returns {void}
+ */
+export function it(description: string, arg1: object | (() => Promise<void>), arg2?: undefined | (() => Promise<void>)): void;
+/** @type {import("./test-runner.js").TestsArgument} */
+export const tests: import("./test-runner.js").TestsArgument;
+declare class Expect extends BaseExpect {
+    /**
+     * @param {any} object
+     */
+    constructor(object: any);
+    _object: any;
+    /** @type {Array<Expect | ExpectToChange>} */
+    expectations: Array<Expect | ExpectToChange>;
+    /**
+     * @param {function(): Promise<number>} changeCallback
+     * @returns {ExpectToChange}
+     */
+    andChange(changeCallback: () => Promise<number>): ExpectToChange;
+    /**
+     * @returns {this}
+     */
+    get not(): this;
+    _not: boolean;
+    /**
+     * @param {any} result
+     * @returns {void}
+     */
+    toBe(result: any): void;
+    /**
+     * @returns {void}
+     */
+    toBeDefined(): void;
+    /**
+     * @param {Function} klass
+     * @returns {void}
+     */
+    toBeInstanceOf(klass: Function): void;
+    /**
+     * @returns {void}
+     */
+    toBeFalse(): void;
+    /**
+     * @returns {void}
+     */
+    toBeUndefined(): void;
+    /**
+     * @returns {void}
+     */
+    toBeTrue(): void;
+    /**
+     * @param {function(): Promise<number>} changeCallback
+     * @returns {ExpectToChange}
+     */
+    toChange(changeCallback: () => Promise<number>): ExpectToChange;
+    /**
+     * @param {any} valueToContain
+     * @returns {void}
+     */
+    toContain(valueToContain: any): void;
+    /**
+     * @param {any} result
+     * @returns {void}
+     */
+    toEqual(result: any): void;
+    /**
+     * @param {RegExp} regex
+     * @returns {void}
+     */
+    toMatch(regex: RegExp): void;
+    /**
+     * @template T extends Error
+     * @param {string|T} expectedError
+     * @returns {Promise<void>}
+     */
+    toThrowError<T>(expectedError: string | T): Promise<void>;
+    /**
+     * @returns {Promise<any>}
+     */
+    execute(): Promise<any>;
+    /**
+     * @param {Record<string, any>} result
+     * @returns {void}
+     */
+    toHaveAttributes(result: Record<string, any>): void;
+}
+declare class BaseExpect {
+    /**
+     * @abstract
+     * @returns {Promise<void>}
+     */
+    runBefore(): Promise<void>;
+    /**
+     * @abstract
+     * @returns {Promise<void>}
+     */
+    runAfter(): Promise<void>;
+}
+declare class ExpectToChange extends BaseExpect {
+    /**
+     * @param {object} args
+     * @param {function(): Promise<number>} args.changeCallback
+     * @param {Expect} args.expect
+     */
+    constructor({ changeCallback, expect, ...restArgs }: {
+        changeCallback: () => Promise<number>;
+        expect: Expect;
+    });
+    expect: Expect;
+    changeCallback: () => Promise<number>;
+    /**
+     * @param {number} count
+     * @returns {Expect}
+     */
+    by(count: number): Expect;
+    count: number;
+    oldCount: number;
+    newCount: number;
+    /**
+     * @returns {Promise<void>}
+     */
+    execute(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=test.d.ts.map

package/dist/src/testing/test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../../src/testing/test.js"],"names":[],"mappings":"AA6BA;;;GAGG;AACH,oCAHW,OAAO,kBAAkB,EAAE,2BAA2B,GACpD,IAAI,CAMhB;AAlBD;;;GAGG;AACH,qCAHW,OAAO,kBAAkB,EAAE,2BAA2B,GACpD,IAAI,CAMhB;AAuUD;;;;;GAKG;AACH,sCALW,MAAM,QACN,MAAM,GAAC,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,SAC5B,SAAS,GAAC,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,GAC7B,OAAO,CAAC,IAAI,CAAC,CAgCzB;AAED;;;GAGG;AACH,4BAHW,GAAG,GACD,MAAM,CAIlB;AA8BD;;;;;GAKG;AACH,iCALW,MAAM,QACN,MAAM,GAAC,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,SAC5B,SAAS,GAAC,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,GAC7B,IAAI,CAmBhB;AAnDD;;;;;GAKG;AACH,gCALW,MAAM,QACN,MAAM,GAAC,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,SAC5B,SAAS,GAAC,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,GAC7B,IAAI,CAsBhB;AAraD,uDAAuD;AACvD,oBADW,OAAO,kBAAkB,EAAE,aAAa,CAUlD;AAsFD;IACE;;OAEG;IACH,oBAFW,GAAG,EAQb;IAJC,aAAqB;IAErB,6CAA6C;IAC7C,cADW,KAAK,CAAC,MAAM,GAAG,cAAc,CAAC,CACnB;IAGxB;;;OAGG;IACH,0BAHW,MAAY,OAAO,CAAC,MAAM,CAAC,GACzB,cAAc,CAI1B;IAED;;OAEG;IACH,WAFa,IAAI,CAMhB;IAHC,cAAgB;IAKlB;;;OAGG;IACH,aAHW,GAAG,GACD,IAAI,CAYhB;IAED;;OAEG;IACH,eAFa,IAAI,CAYhB;IAED;;;OAGG;IACH,iCAFa,IAAI,CAMhB;IAED;;OAEG;IACH,aAFa,IAAI,CAIhB;IAED;;OAEG;IACH,iBAFa,IAAI,CAIhB;IAED;;OAEG;IACH,YAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,yBAHW,MAAY,OAAO,CAAC,MAAM,CAAC,GACzB,cAAc,CAU1B;IAED;;;OAGG;IACH,0BAHW,GAAG,GACD,IAAI,CAQhB;IAED;;;OAGG;IACH,gBAHW,GAAG,GACD,IAAI,CAwBhB;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,IAAI,CAchB;IAED;;;;OAIG;IACH,aAJa,CAAC,iBACH,MAAM,GAAC,CAAC,GACN,OAAO,CAAC,IAAI,CAAC,CAoCzB;IAED;;OAEG;IACH,WAFa,OAAO,CAAC,GAAG,CAAC,CAkBxB;IAED;;;OAGG;IACH,yBAHW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACjB,IAAI,CAuBhB;CACF;AAzTD;IACE;;;OAGG;IACH,aAFa,OAAO,CAAC,IAAI,CAAC,CAEY;IAEtC;;;OAGG;IACH,YAFa,OAAO,CAAC,IAAI,CAAC,CAEW;CACtC;AAED;IACE;;;;OAIG;IACH,qDAHG;QAA0C,cAAc,EAAhD,MAAY,OAAO,CAAC,MAAM,CAAC;QACd,MAAM,EAAnB,MAAM;KAChB,EAOA;IAFC,eAAoB;IACpB,sBARqB,OAAO,CAAC,MAAM,CAAC,CAQA;IAGtC;;;OAGG;IACH,UAHW,MAAM,GACJ,MAAM,CAMlB;IAHC,cAAkB;IAMlB,iBAA2C;IAI3C,iBAA2C;IAG7C;;OAEG;IACH,WAFa,OAAO,CAAC,IAAI,CAAC,CAYzB;CACF"}