@iamsergio/qttest-utils 0.1.1 → 0.3.0

package/code.code-workspace

@@ -0,0 +1,11 @@
+{
+	"folders": [
+		{
+			"path": "."
+		},
+		{
+			"path": "../vscode-extension-kdab-qttest/"
+		}
+	],
+	"settings": {}
+}

package/out/example.js

@@ -17,7 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const qttest_1 = require("./qttest");
 const fs_1 = __importDefault(require("fs"));
-function test() {
+function example() {
     return __awaiter(this, void 0, void 0, function* () {
         const args = process.argv.slice(2);
         if (args.length != 1) {
@@ -30,12 +30,16 @@ function test() {
             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();
     });
 }
-test();
+example();

package/out/index.d.ts

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

package/out/index.js

@@ -6,6 +6,6 @@ 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, CMakeTests: cmake_1.CMakeTests, CMakeTest: cmake_1.CMakeTest
+    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

@@ -4,13 +4,14 @@
  */
 export declare class QtTest {
     readonly filename: string;
+    slots: QtTestSlot[] | null;
     constructor(filename: string);
+    get id(): string;
+    get label(): string;
     /**
-     * Calls "./yourqttest -functions" and returns the result.
-     *
-     * @returns The name of the individual test slots present in the exactuable
+     * Calls "./yourqttest -functions" and stores the results in the slots property.
      */
-    testNames(): Promise<string[]>;
+    parseAvailableSlots(): Promise<void>;
     /**
      * Returns whether this executable links to libQtTest.so.
      *
@@ -19,14 +20,38 @@ export declare class QtTest {
      * Only implemented for Linux. Returns undefined on other platforms.
      */
     linksToQtTestLib(): Promise<boolean> | undefined;
+    isQtTestViaHelp(): Promise<boolean | undefined>;
+    runTest(slotName?: 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 {
-    qtTestExacutables: QtTest[];
+    qtTestExecutables: QtTest[];
     discoverViaCMake(buildDirPath: string): Promise<void>;
     removeNonLinking(): Promise<void>;
+    removeByRunningHelp(): Promise<void>;
     removeMatching(regex: RegExp): void;
     maintainMatching(regex: RegExp): void;
     dumpExecutablePaths(): void;

package/out/qttest.js

@@ -11,9 +11,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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.QtTest = void 0;
+exports.QtTests = exports.QtTestSlot = exports.QtTest = void 0;
 const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
 const cmake_1 = require("./cmake");
 /**
  * Represents a single QtTest executable.
@@ -21,16 +25,21 @@ const cmake_1 = require("./cmake");
  */
 class QtTest {
     constructor(filename) {
+        this.slots = null;
         this.filename = filename;
     }
+    get id() {
+        return this.filename;
+    }
+    get label() {
+        return path_1.default.basename(this.filename);
+    }
     /**
-     * Calls "./yourqttest -functions" and returns the result.
-     *
-     * @returns The name of the individual test slots present in the exactuable
+     * Calls "./yourqttest -functions" and stores the results in the slots property.
      */
-    testNames() {
+    parseAvailableSlots() {
         return __awaiter(this, void 0, void 0, function* () {
-            let subtests = [];
+            let slotNames = [];
             let output = "";
             yield new Promise((resolve, reject) => {
                 const child = (0, child_process_1.spawn)(this.filename, ["-functions"]);
@@ -39,17 +48,23 @@ class QtTest {
                 });
                 child.on("exit", (code) => {
                     if (code === 0) {
-                        subtests = subtests.concat(output.split("\n"));
-                        subtests = subtests.map(entry => entry.trim().replace("()", ""));
-                        subtests = subtests.filter(entry => entry.length > 0);
-                        resolve(subtests);
+                        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"));
                     }
                 });
             });
-            return subtests;
         });
     }
     /**
@@ -85,14 +100,91 @@ class QtTest {
             });
         });
     }
+    /// 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) {
+        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) => {
+                const child = (0, child_process_1.spawn)(this.filename, args);
+                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.qtTestExacutables = [];
+        this.qtTestExecutables = [];
     }
     discoverViaCMake(buildDirPath) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -101,7 +193,7 @@ class QtTests {
             if (ctests) {
                 for (let ctest of ctests) {
                     let qtest = new QtTest(ctest.executablePath());
-                    this.qtTestExacutables.push(qtest);
+                    this.qtTestExecutables.push(qtest);
                 }
             }
             else {
@@ -119,38 +211,44 @@ class QtTests {
                 return;
             }
             let acceptedExecutables = [];
-            for (let ex of this.qtTestExacutables) {
+            for (let ex of this.qtTestExecutables) {
                 let linksToQt = yield ex.linksToQtTestLib();
                 // undefined or true is accepted
                 if (linksToQt !== false) {
                     acceptedExecutables.push(ex);
                 }
-                this.qtTestExacutables = acceptedExecutables;
+                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) {
-        let acceptedExecutables = [];
-        this.qtTestExacutables = this.qtTestExacutables.filter((ex) => !regex.test(ex.filename));
+        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) {
-        let acceptedExecutables = [];
-        this.qtTestExacutables = this.qtTestExacutables.filter((ex) => regex.test(ex.filename));
+        this.qtTestExecutables = this.qtTestExecutables.filter((ex) => regex.test(ex.filename));
     }
     dumpExecutablePaths() {
-        for (var ex of this.qtTestExacutables) {
+        for (var ex of this.qtTestExecutables) {
             console.log(ex.filename);
         }
     }
     dumpTestSlots() {
         return __awaiter(this, void 0, void 0, function* () {
-            for (var ex of this.qtTestExacutables) {
-                let names = yield ex.testNames();
+            for (var ex of this.qtTestExecutables) {
+                if (!ex.slots)
+                    yield ex.parseAvailableSlots();
                 console.log(ex.filename);
-                for (let name of names) {
-                    console.log("    - " + name);
+                if (ex.slots) {
+                    for (let slot of ex.slots) {
+                        console.log("    - " + slot.name);
+                    }
                 }
             }
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iamsergio/qttest-utils",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "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.",
   "scripts": {
     "build": "tsc"

package/src/index.ts

@@ -3,10 +3,10 @@
 // SPDX-License-Identifier: MIT
 
 import { CMakeTests, CMakeTest } from "./cmake";
-import { QtTests, QtTest } from "./qttest";
+import { QtTests, QtTest, QtTestSlot } from "./qttest";
 
 const qttest = {
-    QtTests, QtTest, CMakeTests, CMakeTest
+    QtTests, QtTest, QtTestSlot, CMakeTests, CMakeTest
 };
 
 export default qttest;

package/src/qttest.ts

@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: MIT
 
 import { spawn } from "child_process";
+import path from "path";
 import { CMakeTests } from "./cmake";
 
 /**
@@ -11,17 +12,25 @@ import { CMakeTests } from "./cmake";
  */
 export class QtTest {
     readonly filename: string;
+    slots: QtTestSlot[] | null = null;
+
     constructor(filename: string) {
         this.filename = filename;
     }
 
+    public get id() {
+        return this.filename;
+    }
+
+    public get label() {
+        return path.basename(this.filename);
+    }
+
     /**
-     * Calls "./yourqttest -functions" and returns the result.
-     * 
-     * @returns The name of the individual test slots present in the exactuable
+     * Calls "./yourqttest -functions" and stores the results in the slots property.
      */
-    public async testNames(): Promise<string[]> {
-        let subtests: string[] = [];
+    public async parseAvailableSlots(): Promise<void> {
+        let slotNames: string[] = [];
         let output = "";
 
         await new Promise((resolve, reject) => {
@@ -33,17 +42,24 @@ export class QtTest {
 
             child.on("exit", (code) => {
                 if (code === 0) {
-                    subtests = subtests.concat(output.split("\n"));
-                    subtests = subtests.map(entry => entry.trim().replace("()", ""));
-                    subtests = subtests.filter(entry => entry.length > 0);
-                    resolve(subtests);
+                    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"));
                 }
             });
         });
-
-        return subtests;
     }
 
     /**
@@ -79,13 +95,97 @@ export class QtTest {
             });
         });
     }
+
+    /// 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
+    public async isQtTestViaHelp(): Promise<boolean | undefined> {
+        return await new Promise((resolve, reject) => {
+            const child = 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
+    public async runTest(slotName?: string): Promise<boolean> {
+        let args: string[] = [];
+        if (slotName) {
+            // Runs a single Qt test instead
+            args = args.concat(slotName);
+        }
+
+        return await new Promise((resolve, reject) => {
+            const child = spawn(this.filename, args);
+            child.stdout.on("data", (chunk) => {
+                // chunk.toString()
+            });
+
+            child.on("exit", (code) => {
+                if (code === 0) {
+                    resolve(true);
+                } else {
+                    resolve(false);
+                }
+            });
+        });
+    }
+
+    public command(): { label: string, executablePath: string, args: string[] } {
+        return { label: this.label, executablePath: this.filename, args: [] };
+    }
+}
+
+/**
+ * Represents a single Qt test slot
+ */
+export class QtTestSlot {
+    name: string;
+
+    // The QTest executable this slot belongs to
+    parentQTest: QtTest;
+
+    constructor(name: string, parent: QtTest) {
+        this.name = name;
+        this.parentQTest = parent;
+    }
+
+    public get id() {
+        return this.parentQTest.filename + this.name;
+    }
+
+    public get absoluteFilePath() {
+        return this.parentQTest.filename;
+    }
+
+    public async runTest(): Promise<boolean> {
+        return this.parentQTest.runTest(this.name);
+    }
+
+    public command(): { label: string, executablePath: string, args: string[] } {
+        return { label: this.name, executablePath: this.absoluteFilePath, args: [this.name] };
+    }
 }
 
 /**
  * Represents the list of all QtTest executables in your project
  */
 export class QtTests {
-    qtTestExacutables: QtTest[] = [];
+    qtTestExecutables: QtTest[] = [];
 
     async discoverViaCMake(buildDirPath: string) {
         var cmake = new CMakeTests(buildDirPath);
@@ -93,7 +193,7 @@ export class QtTests {
         if (ctests) {
             for (let ctest of ctests) {
                 let qtest = new QtTest(ctest.executablePath());
-                this.qtTestExacutables.push(qtest);
+                this.qtTestExecutables.push(qtest);
             }
         } else {
             console.error("Failed to retrieve ctests!");
@@ -108,40 +208,46 @@ export class QtTests {
         if (!isLinux) { return; }
 
         let acceptedExecutables: QtTest[] = [];
-        for (let ex of this.qtTestExacutables) {
+        for (let ex of this.qtTestExecutables) {
             let linksToQt = await ex.linksToQtTestLib();
             // undefined or true is accepted
             if (linksToQt !== false) {
                 acceptedExecutables.push(ex);
             }
-            this.qtTestExacutables = acceptedExecutables;
+            this.qtTestExecutables = acceptedExecutables;
         }
     }
 
+    public async removeByRunningHelp() {
+        this.qtTestExecutables = this.qtTestExecutables.filter(async (ex) => await ex.isQtTestViaHelp());
+    }
+
     /// Removes any executable (from the list) that matches the specified regex
     public removeMatching(regex: RegExp) {
-        let acceptedExecutables: QtTest[] = [];
-        this.qtTestExacutables = this.qtTestExacutables.filter((ex) => !regex.test(ex.filename));
+        this.qtTestExecutables = this.qtTestExecutables.filter((ex) => !regex.test(ex.filename));
     }
 
     /// Removes any executable (from the list) that doesn't match the specified regex
     public maintainMatching(regex: RegExp) {
-        let acceptedExecutables: QtTest[] = [];
-        this.qtTestExacutables = this.qtTestExacutables.filter((ex) => regex.test(ex.filename));
+        this.qtTestExecutables = this.qtTestExecutables.filter((ex) => regex.test(ex.filename));
     }
 
     public dumpExecutablePaths() {
-        for (var ex of this.qtTestExacutables) {
+        for (var ex of this.qtTestExecutables) {
             console.log(ex.filename);
         }
     }
 
     public async dumpTestSlots() {
-        for (var ex of this.qtTestExacutables) {
-            let names = await ex.testNames();
+        for (var ex of this.qtTestExecutables) {
+            if (!ex.slots)
+                await ex.parseAvailableSlots();
+
             console.log(ex.filename);
-            for (let name of names) {
-                console.log("    - " + name);
+            if (ex.slots) {
+                for (let slot of ex.slots) {
+                    console.log("    - " + slot.name);
+                }
             }
         }
     }