@iamsergio/qttest-utils 0.4.3 → 0.4.4

package/out/cmake.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Represents tests added in cmake (Via add_test())
+ *
+ * Contains methods to discover Qt Tests via CMake
+ */
+export declare class CMakeTests {
+    readonly buildDirPath: string;
+    constructor(buildDirPath: string);
+    /**
+     * Invokes ctest.exe --show-only=json-v1
+     *
+     * @returns a promise with the list of tests
+     */
+    tests(): Promise<CMakeTest[] | undefined>;
+    private ctestJsonToList;
+}
+export declare class CMakeTest {
+    command: string[];
+    cwd: string;
+    id(): string;
+    label(): string;
+    executablePath(): string;
+}

package/out/cmake.js

@@ -0,0 +1,91 @@
+"use strict";
+// SPDX-FileCopyrightText: 2023 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
+// Author: Sergio Martins <sergio.martins@kdab.com>
+// SPDX-License-Identifier: MIT
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CMakeTest = exports.CMakeTests = void 0;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+/**
+ * Represents tests added in cmake (Via add_test())
+ *
+ * Contains methods to discover Qt Tests via CMake
+ */
+class CMakeTests {
+    constructor(buildDirPath) {
+        this.buildDirPath = buildDirPath;
+    }
+    /**
+     * Invokes ctest.exe --show-only=json-v1
+     *
+     * @returns a promise with the list of tests
+     */
+    tests() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO: Check if folder exists
+            if (this.buildDirPath.length == 0) {
+                console.error("Could not find out cmake build dir");
+                return undefined;
+            }
+            return new Promise((resolve, reject) => {
+                const child = (0, child_process_1.spawn)("ctest", ["--show-only=json-v1"], { "cwd": this.buildDirPath });
+                let output = "";
+                child.stdout.on("data", (chunk) => {
+                    output += chunk.toString();
+                });
+                child.on("exit", (code) => {
+                    if (code === 0) {
+                        resolve(this.ctestJsonToList(output));
+                    }
+                    else {
+                        reject(new Error("Failed to run ctest"));
+                    }
+                });
+                return undefined;
+            });
+        });
+    }
+    ctestJsonToList(json) {
+        let allJSON = JSON.parse(json);
+        if (!("tests" in allJSON)) {
+            return [];
+        }
+        let tests = allJSON.tests.map((testJSON) => {
+            let test = new CMakeTest();
+            test.command = testJSON.command;
+            test.cwd = testJSON.cwd;
+            return test;
+        });
+        return tests;
+    }
+}
+exports.CMakeTests = CMakeTests;
+/// Represents an inividual CTest test
+class CMakeTest {
+    constructor() {
+        this.command = [];
+        this.cwd = "";
+    }
+    id() {
+        return this.command.join(",");
+    }
+    label() {
+        return path_1.default.basename(this.executablePath());
+    }
+    executablePath() {
+        return this.command[0];
+    }
+}
+exports.CMakeTest = CMakeTest;

package/out/example.d.ts

@@ -0,0 +1 @@
+export {};

package/out/example.js

@@ -0,0 +1,45 @@
+"use strict";
+// SPDX-FileCopyrightText: 2023 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
+// Author: Sergio Martins <sergio.martins@kdab.com>
+// SPDX-License-Identifier: MIT
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const qttest_1 = require("./qttest");
+const fs_1 = __importDefault(require("fs"));
+function example() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const args = process.argv.slice(2);
+        if (args.length != 1) {
+            console.error("ERROR: Expected a single argument with the build-dir with cmake tests!");
+            process.exit(2);
+        }
+        let buildDirPath = args[0];
+        if (!fs_1.default.existsSync(buildDirPath)) {
+            console.error('Directory does not exist!');
+            process.exit(1);
+        }
+        let qt = new qttest_1.QtTests();
+        // Gather all tests that would be executed by CTest:
+        yield qt.discoverViaCMake(buildDirPath);
+        // Filter-out the ones that don't link to QtTest (doctests and such)
+        yield qt.removeNonLinking();
+        // Example of filtering out by regexp:
+        qt.removeMatching(/(tst_view|tst_window)/);
+        // Example of filtering out by regexp (inverted):
+        qt.maintainMatching(/(tst_docks|tst_qtwidgets|tst_multisplitter)/);
+        qt.dumpExecutablePaths();
+        qt.dumpTestSlots();
+    });
+}
+example();

package/out/index.d.ts

@@ -0,0 +1,10 @@
+import { CMakeTests, CMakeTest } from "./cmake";
+import { QtTests, QtTest, QtTestSlot } from "./qttest";
+declare const qttest: {
+    QtTests: typeof QtTests;
+    QtTest: typeof QtTest;
+    QtTestSlot: typeof QtTestSlot;
+    CMakeTests: typeof CMakeTests;
+    CMakeTest: typeof CMakeTest;
+};
+export default qttest;

package/out/index.js

@@ -0,0 +1,11 @@
+"use strict";
+// SPDX-FileCopyrightText: 2023 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
+// Author: Sergio Martins <sergio.martins@kdab.com>
+// SPDX-License-Identifier: MIT
+Object.defineProperty(exports, "__esModule", { value: true });
+const cmake_1 = require("./cmake");
+const qttest_1 = require("./qttest");
+const qttest = {
+    QtTests: qttest_1.QtTests, QtTest: qttest_1.QtTest, QtTestSlot: qttest_1.QtTestSlot, CMakeTests: cmake_1.CMakeTests, CMakeTest: cmake_1.CMakeTest
+};
+exports.default = qttest;

package/out/qttest.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Represents a single QtTest executable.
+ * Supports listing the individual test slots
+ */
+export declare class QtTest {
+    readonly filename: string;
+    readonly buildDirPath: string;
+    slots: QtTestSlot[] | null;
+    constructor(filename: string, buildDirPath: string);
+    get id(): string;
+    get label(): string;
+    /**
+     * Calls "./yourqttest -functions" and stores the results in the slots property.
+     */
+    parseAvailableSlots(): Promise<void>;
+    /**
+     * Returns whether this executable links to libQtTest.so.
+     *
+     * Useful for Qt autodetection, as some tests are doctest or so.
+     *
+     * Only implemented for Linux. Returns undefined on other platforms.
+     */
+    linksToQtTestLib(): Promise<boolean> | undefined;
+    isQtTestViaHelp(): Promise<boolean | undefined>;
+    runTest(slotName?: string, cwd?: string): Promise<boolean>;
+    command(): {
+        label: string;
+        executablePath: string;
+        args: string[];
+    };
+}
+/**
+ * Represents a single Qt test slot
+ */
+export declare class QtTestSlot {
+    name: string;
+    parentQTest: QtTest;
+    constructor(name: string, parent: QtTest);
+    get id(): string;
+    get absoluteFilePath(): string;
+    runTest(): Promise<boolean>;
+    command(): {
+        label: string;
+        executablePath: string;
+        args: string[];
+    };
+}
+/**
+ * Represents the list of all QtTest executables in your project
+ */
+export declare class QtTests {
+    qtTestExecutables: QtTest[];
+    discoverViaCMake(buildDirPath: string): Promise<void>;
+    removeNonLinking(): Promise<void>;
+    removeByRunningHelp(): Promise<void>;
+    removeMatching(regex: RegExp): void;
+    maintainMatching(regex: RegExp): void;
+    dumpExecutablePaths(): void;
+    dumpTestSlots(): Promise<void>;
+}

package/out/qttest.js

@@ -0,0 +1,291 @@
+"use strict";
+// SPDX-FileCopyrightText: 2023 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
+// Author: Sergio Martins <sergio.martins@kdab.com>
+// SPDX-License-Identifier: MIT
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QtTests = exports.QtTestSlot = exports.QtTest = void 0;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const fs = __importStar(require("fs"));
+const cmake_1 = require("./cmake");
+/**
+ * Represents a single QtTest executable.
+ * Supports listing the individual test slots
+ */
+class QtTest {
+    constructor(filename, buildDirPath) {
+        this.slots = null;
+        this.filename = filename;
+        this.buildDirPath = buildDirPath;
+    }
+    get id() {
+        return this.filename;
+    }
+    get label() {
+        return path_1.default.basename(this.filename);
+    }
+    /**
+     * Calls "./yourqttest -functions" and stores the results in the slots property.
+     */
+    parseAvailableSlots() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let slotNames = [];
+            let output = "";
+            let err = "";
+            yield new Promise((resolve, reject) => {
+                if (!fs.existsSync(this.filename)) {
+                    reject(new Error("File doesn't exit: " + this.filename));
+                    return;
+                }
+                const child = (0, child_process_1.spawn)(this.filename, ["-functions"], { cwd: this.buildDirPath });
+                child.stdout.on("data", (chunk) => {
+                    output += chunk.toString();
+                });
+                child.stderr.on("data", (chunk) => {
+                    err += chunk.toString();
+                });
+                child.on("exit", (code) => {
+                    if (code === 0) {
+                        slotNames = slotNames.concat(output.split("\n"));
+                        slotNames = slotNames.map(entry => entry.trim().replace("()", ""));
+                        slotNames = slotNames.filter(entry => entry.length > 0);
+                        if (slotNames.length > 0) {
+                            this.slots = [];
+                            for (var slotName of slotNames) {
+                                var slot = new QtTestSlot(slotName, this);
+                                this.slots.push(slot);
+                            }
+                        }
+                        resolve(slotNames);
+                    }
+                    else {
+                        reject(new Error("Failed to run -functions, stdout=" + output + "; stderr=" + err + "; code=" + code));
+                    }
+                });
+            });
+        });
+    }
+    /**
+     * Returns whether this executable links to libQtTest.so.
+     *
+     * Useful for Qt autodetection, as some tests are doctest or so.
+     *
+     * Only implemented for Linux. Returns undefined on other platforms.
+     */
+    linksToQtTestLib() {
+        let isLinux = process.platform === "linux";
+        if (!isLinux) {
+            return undefined;
+        }
+        return new Promise((resolve, reject) => {
+            const child = (0, child_process_1.spawn)("ldd", [this.filename]);
+            let output = "";
+            let result = false;
+            child.stdout.on("data", (chunk) => {
+                if (!result) {
+                    if (chunk.toString().includes("libQt5Test.so") || chunk.toString().includes("libQt6Test.so")) {
+                        result = true;
+                    }
+                }
+            });
+            child.on("exit", (code) => {
+                if (code === 0) {
+                    resolve(result);
+                }
+                else {
+                    reject(new Error("Failed to run ldd"));
+                }
+            });
+        });
+    }
+    /// Returns whether this test is a QtTest by running it with -help and checking if the help text looks familiar
+    /// Note that if this is not a QtTest it might not run help and instead execute the test itself
+    isQtTestViaHelp() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield new Promise((resolve, reject) => {
+                const child = (0, child_process_1.spawn)(this.filename, ["-help"]);
+                let output = "";
+                let result = false;
+                child.stdout.on("data", (chunk) => {
+                    if (!result) {
+                        if (chunk.toString().includes("[testfunction[:testdata]]")) {
+                            result = true;
+                        }
+                    }
+                });
+                child.on("exit", (code) => {
+                    if (code === 0) {
+                        resolve(result);
+                    }
+                    else {
+                        resolve(false);
+                    }
+                });
+            });
+        });
+    }
+    /// Runs this test
+    runTest(slotName, cwd = "") {
+        return __awaiter(this, void 0, void 0, function* () {
+            let args = [];
+            if (slotName) {
+                // Runs a single Qt test instead
+                args = args.concat(slotName);
+            }
+            return yield new Promise((resolve, reject) => {
+                let opts = cwd.length > 0 ? { cwd: cwd } : { cwd: this.buildDirPath };
+                const child = (0, child_process_1.spawn)(this.filename, args, opts);
+                child.stdout.on("data", (chunk) => {
+                    // chunk.toString()
+                });
+                child.on("exit", (code) => {
+                    if (code === 0) {
+                        resolve(true);
+                    }
+                    else {
+                        resolve(false);
+                    }
+                });
+            });
+        });
+    }
+    command() {
+        return { label: this.label, executablePath: this.filename, args: [] };
+    }
+}
+exports.QtTest = QtTest;
+/**
+ * Represents a single Qt test slot
+ */
+class QtTestSlot {
+    constructor(name, parent) {
+        this.name = name;
+        this.parentQTest = parent;
+    }
+    get id() {
+        return this.parentQTest.filename + this.name;
+    }
+    get absoluteFilePath() {
+        return this.parentQTest.filename;
+    }
+    runTest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.parentQTest.runTest(this.name);
+        });
+    }
+    command() {
+        return { label: this.name, executablePath: this.absoluteFilePath, args: [this.name] };
+    }
+}
+exports.QtTestSlot = QtTestSlot;
+/**
+ * Represents the list of all QtTest executables in your project
+ */
+class QtTests {
+    constructor() {
+        this.qtTestExecutables = [];
+    }
+    discoverViaCMake(buildDirPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var cmake = new cmake_1.CMakeTests(buildDirPath);
+            let ctests = yield cmake.tests();
+            if (ctests) {
+                for (let ctest of ctests) {
+                    let qtest = new QtTest(ctest.executablePath(), buildDirPath);
+                    this.qtTestExecutables.push(qtest);
+                }
+            }
+            else {
+                console.error("Failed to retrieve ctests!");
+            }
+        });
+    }
+    /// Removes any executable (from the list) that doesn't link to libQtTest.so
+    /// This heuristic tries to filter-out doctest and other non-Qt tests
+    /// Only implemented for linux for now
+    removeNonLinking() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let isLinux = process.platform === "linux";
+            if (!isLinux) {
+                return;
+            }
+            let acceptedExecutables = [];
+            for (let ex of this.qtTestExecutables) {
+                let linksToQt = yield ex.linksToQtTestLib();
+                // undefined or true is accepted
+                if (linksToQt !== false) {
+                    acceptedExecutables.push(ex);
+                }
+                this.qtTestExecutables = acceptedExecutables;
+            }
+        });
+    }
+    removeByRunningHelp() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.qtTestExecutables = this.qtTestExecutables.filter((ex) => __awaiter(this, void 0, void 0, function* () { return yield ex.isQtTestViaHelp(); }));
+        });
+    }
+    /// Removes any executable (from the list) that matches the specified regex
+    removeMatching(regex) {
+        this.qtTestExecutables = this.qtTestExecutables.filter((ex) => !regex.test(ex.filename));
+    }
+    /// Removes any executable (from the list) that doesn't match the specified regex
+    maintainMatching(regex) {
+        this.qtTestExecutables = this.qtTestExecutables.filter((ex) => regex.test(ex.filename));
+    }
+    dumpExecutablePaths() {
+        for (var ex of this.qtTestExecutables) {
+            console.log(ex.filename);
+        }
+    }
+    dumpTestSlots() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (var ex of this.qtTestExecutables) {
+                if (!ex.slots)
+                    yield ex.parseAvailableSlots();
+                console.log(ex.filename);
+                if (ex.slots) {
+                    for (let slot of ex.slots) {
+                        console.log("    - " + slot.name);
+                    }
+                }
+            }
+        });
+    }
+}
+exports.QtTests = QtTests;

package/out/utils.d.ts

@@ -0,0 +1 @@
+export {};

package/out/utils.js

@@ -0,0 +1,85 @@
+"use strict";
+// SPDX-FileCopyrightText: 2023 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
+// Author: Sergio Martins <sergio.martins@kdab.com>
+// SPDX-License-Identifier: MIT
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fs = __importStar(require("fs"));
+/// Returns whether the specified file is an executable
+function isExecutable(filePath) {
+    if (process.platform === "win32") {
+        return path_1.default.extname(filePath).toLocaleLowerCase() === ".exe";
+    }
+    else {
+        try {
+            fs.accessSync(filePath, fs.constants.X_OK);
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    }
+}
+/// Returns whether the specified file is a library
+function isLibrary(filename) {
+    const split = filename.split(".");
+    if (split.length <= 1) {
+        return false;
+    }
+    // Find the first non-numeric extension, so we ignore all the trailing numbers in libFoo.so.2.0.9
+    for (var i = split.length - 1; i >= 0; --i) {
+        const extension = split[i];
+        const isNumber = !isNaN(Number(extension));
+        if (isNumber) {
+            continue;
+        }
+        return ["so", "dll", "dylib"].includes(extension);
+    }
+    return false;
+}
+/// Recursively looks for executable files in folderPath
+function executableFiles(folderPath) {
+    const files = fs.readdirSync(folderPath);
+    var executables = [];
+    for (var file of files) {
+        // Ignore CMakeFiles directory, it has some of binaries
+        if (path_1.default.basename(file) === "CMakeFiles") {
+            continue;
+        }
+        const childPath = path_1.default.join(folderPath, file);
+        const info = fs.statSync(childPath);
+        if (info.isDirectory()) {
+            executables = executables.concat(executableFiles(childPath));
+        }
+        else if (info.isFile() && !isLibrary(path_1.default.basename(childPath)) && isExecutable(childPath)) {
+            executables.push(childPath);
+        }
+    }
+    return executables;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iamsergio/qttest-utils",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "description": "API for listing QtTest executables from a build directory and which individual test slots each executable contains. Useful for a Text Explorer VSCode extension.",
   "repository": {
     "type": "git",