@empiricalrun/test-run 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @empiricalrun/test-run
+
+## 0.1.0
+
+### Minor Changes
+
+- 70668eb: feat: add test-run package

package/README.md

@@ -0,0 +1,21 @@
+# test-run
+
+Library to run playwright tests.
+
+This package helps to run all the dependent tests for a particular test case.
+
+## Usage
+
+```ts
+npx @empiricalrun/test-run -n "<test-name>" "<playwright-options>"
+```
+
+The playwright options are passed as is to the playwright test command.
+
+## Example
+
+```ts
+npx @empiricalrun/test-run -n "foo" --retries 0
+```
+
+This will run the test named "foo" in the `tests` directory.

package/dist/bin/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/bin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bin/index.ts"],"names":[],"mappings":""}

package/dist/bin/index.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const __1 = require("..");
+(async function main() {
+    // TODO: add support for suites
+    commander_1.program
+        .option("-n, --name <test-name>", "Name of the test to run")
+        .option("-d, --dir <test-dir>", "Path to the test directory")
+        .allowUnknownOption();
+    commander_1.program.parse(process.argv);
+    // Accessing the extracted parameters
+    const options = commander_1.program.opts();
+    if (!options.name) {
+        console.error("Please provide a test name");
+        process.exit(1);
+    }
+    const optionsToStrip = [
+        "-n",
+        "--name",
+        "-d",
+        "--dir",
+        options.name,
+        options.dir,
+    ];
+    const pwOptions = process.argv
+        .slice(2)
+        .filter((arg) => !optionsToStrip.includes(arg));
+    if (pwOptions.includes("--forbid-only")) {
+        console.error("forbid-only option is not supported");
+        process.exit(1);
+    }
+    await (0, __1.runTest)({
+        name: options.name,
+        dir: options.dir || "tests",
+        pwOptions: pwOptions.join(" "),
+    });
+})();

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { TestRunParameters } from "./types";
+/**
+ *
+ * @export
+ * @param {TestRunParameters} { name, dir, pwOptions }
+ */
+export declare function runTest({ name, dir, pwOptions }: TestRunParameters): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAW5C;;;;GAIG;AACH,wBAAsB,OAAO,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,EAAE,iBAAiB,iBAoDxE"}

package/dist/index.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTest = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const utils_1 = require("./utils");
+/**
+ *
+ * @export
+ * @param {TestRunParameters} { name, dir, pwOptions }
+ */
+async function runTest({ name, dir, pwOptions }) {
+    console.log("getting all files in directory:", dir);
+    const files = await (0, utils_1.getAllFilePaths)(dir);
+    let matchingFilePath = "";
+    // find the first file that contains the test block
+    // TODO: add suites support
+    for (const file of files) {
+        const match = await (0, utils_1.hasTestBlock)({ filePath: file, scenarioName: name });
+        if (match) {
+            matchingFilePath = file;
+            break;
+        }
+    }
+    if (!matchingFilePath) {
+        console.error("No test block found for the given test name");
+        return;
+    }
+    const testNode = await (0, utils_1.getTestCaseNode)({
+        filePath: matchingFilePath,
+        scenarioName: name,
+    });
+    const parentDescribe = (0, utils_1.findFirstSerialDescribeBlock)(testNode);
+    const isFileMarkedSerial = await (0, utils_1.hasTopLevelDescribeConfigureWithSerialMode)(matchingFilePath);
+    console.log("Identified test block:", !!testNode);
+    console.log("Is parent describe block marked serial:", !!parentDescribe);
+    console.log("Is file marked serial:", isFileMarkedSerial);
+    const currentFileContent = await fs_extra_1.default.readFile(matchingFilePath, "utf-8");
+    // if the file is not marked serial, we need to mark the test or describe block as only
+    if (!isFileMarkedSerial) {
+        await (0, utils_1.markTestAsOnly)(matchingFilePath, testNode.getText(), parentDescribe?.getText() || "");
+    }
+    try {
+        const env = Object({ ...process.env });
+        const pwRunCmd = `npx playwright test ${matchingFilePath} ${pwOptions}`;
+        console.log("Playwright test command:", pwRunCmd);
+        await (0, utils_1.cmd)(pwRunCmd.split(" "), {
+            env,
+        });
+    }
+    catch (e) {
+        console.error("Error executing playwright test", e);
+    }
+    // revert the changes made to the file to mark tests as only
+    await fs_extra_1.default.writeFile(matchingFilePath, currentFileContent);
+    if (!matchingFilePath) {
+        console.error("No test block found for the given test name");
+        return;
+    }
+}
+exports.runTest = runTest;

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export type TestRunParameters = {
+    name: string;
+    dir?: string;
+    pwOptions?: string;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC"}

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/index.d.ts

@@ -0,0 +1,23 @@
+import { Node } from "ts-morph";
+export declare function cmd(command: string[], options: {
+    env?: Record<string, string>;
+}): Promise<number>;
+/**
+ *
+ *
+ * @param {string} [directoryPath=""]
+ * @return {*}  {Promise<string[]>}
+ */
+export declare function getAllFilePaths(directoryPath?: string): Promise<string[]>;
+export declare function getTestCaseNode({ filePath, scenarioName, }: {
+    filePath: string;
+    scenarioName: string;
+}): Promise<Node | undefined>;
+export declare function hasTestBlock({ filePath, scenarioName, }: {
+    filePath: string;
+    scenarioName: string;
+}): Promise<boolean>;
+export declare function findFirstSerialDescribeBlock(node: Node | undefined): Node | undefined;
+export declare function hasTopLevelDescribeConfigureWithSerialMode(filePath: string): Promise<boolean>;
+export declare function markTestAsOnly(filePath: string, testBlock: string, parentDescribeBlock?: string): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAuB,MAAM,UAAU,CAAC;AAErD,wBAAgB,GAAG,CACjB,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GACxC,OAAO,CAAC,MAAM,CAAC,CA2BjB;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CACnC,aAAa,GAAE,MAAW,GACzB,OAAO,CAAC,MAAM,EAAE,CAAC,CAqBnB;AAED,wBAAsB,eAAe,CAAC,EACpC,QAAQ,EACR,YAAY,GACb,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;CACtB,GAAG,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC,CAc5B;AAED,wBAAsB,YAAY,CAAC,EACjC,QAAQ,EACR,YAAY,GACb,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;CACtB,GAAG,OAAO,CAAC,OAAO,CAAC,CAMnB;AAED,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,IAAI,GAAG,SAAS,GACrB,IAAI,GAAG,SAAS,CA2BlB;AAED,wBAAsB,0CAA0C,CAC9D,QAAQ,EAAE,MAAM,oBA+BjB;AAED,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,mBAAmB,CAAC,EAAE,MAAM,iBAkB7B"}

package/dist/utils/index.js

@@ -0,0 +1,155 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markTestAsOnly = exports.hasTopLevelDescribeConfigureWithSerialMode = exports.findFirstSerialDescribeBlock = exports.hasTestBlock = exports.getTestCaseNode = exports.getAllFilePaths = exports.cmd = void 0;
+const child_process_1 = require("child_process");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const ts_morph_1 = require("ts-morph");
+function cmd(command, options) {
+    let errorLogs = [];
+    return new Promise((resolveFunc, rejectFunc) => {
+        let p = (0, child_process_1.spawn)(command[0], command.slice(1), {
+            env: { ...process.env, ...options.env },
+        });
+        p.stdout.on("data", (x) => {
+            const log = x.toString();
+            if (log.includes("Error")) {
+                errorLogs.push(log);
+            }
+            process.stdout.write(log);
+        });
+        p.stderr.on("data", (x) => {
+            const log = x.toString();
+            process.stderr.write(x.toString());
+            errorLogs.push(log);
+        });
+        p.on("exit", (code) => {
+            if (code != 0) {
+                // assuming last log is the error message before exiting
+                rejectFunc(errorLogs.slice(-3).join("\n"));
+            }
+            else {
+                resolveFunc(code);
+            }
+        });
+    });
+}
+exports.cmd = cmd;
+/**
+ *
+ *
+ * @param {string} [directoryPath=""]
+ * @return {*}  {Promise<string[]>}
+ */
+async function getAllFilePaths(directoryPath = "") {
+    let filePaths = [];
+    try {
+        const files = await fs_extra_1.default.readdir(directoryPath);
+        for (const file of files) {
+            const filePath = path_1.default.join(directoryPath, file);
+            const stat = await fs_extra_1.default.lstat(filePath);
+            if (stat.isDirectory()) {
+                // If it's a directory, recursively get file paths from the directory
+                const nestedFiles = await getAllFilePaths(filePath);
+                filePaths = filePaths.concat(nestedFiles);
+            }
+            else {
+                // If it's a file, push its path to the array
+                filePaths.push(filePath);
+            }
+        }
+    }
+    catch (err) {
+        console.error("Error reading directory:", err);
+    }
+    return filePaths;
+}
+exports.getAllFilePaths = getAllFilePaths;
+async function getTestCaseNode({ filePath, scenarioName, }) {
+    const project = new ts_morph_1.Project();
+    const content = await fs_extra_1.default.readFile(filePath, "utf-8");
+    const sourceFile = project.createSourceFile("test.ts", content);
+    sourceFile.getDescendants;
+    const testFunctionNode = sourceFile.getFirstDescendant((node) => !!(node.isKind(ts_morph_1.SyntaxKind.CallExpression) &&
+        node.getExpression().getText() === "test" &&
+        node.getArguments()[0]?.getText().includes(scenarioName)));
+    return testFunctionNode;
+}
+exports.getTestCaseNode = getTestCaseNode;
+async function hasTestBlock({ filePath, scenarioName, }) {
+    const testNode = await getTestCaseNode({
+        filePath,
+        scenarioName,
+    });
+    return !!testNode;
+}
+exports.hasTestBlock = hasTestBlock;
+function findFirstSerialDescribeBlock(node) {
+    let currentNode = node;
+    // Traverse upwards until we find a 'describe' block with 'serial: true'
+    while (currentNode) {
+        const parentDescribe = currentNode.getFirstAncestorByKind(ts_morph_1.SyntaxKind.CallExpression);
+        if (parentDescribe) {
+            const isDescribe = parentDescribe.getFirstChild()?.getText() === "test.describe";
+            if (isDescribe) {
+                const configureCall = parentDescribe
+                    .getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression)
+                    .find((call) => call.getText().includes("configure"));
+                if (configureCall) {
+                    // Check if 'serial: true' exists
+                    if (configureCall.getText().includes("serial")) {
+                        return parentDescribe;
+                    }
+                }
+            }
+        }
+        currentNode = parentDescribe; // Move up the tree
+    }
+    return undefined; // Return undefined if no 'describe' with serial: true is found
+}
+exports.findFirstSerialDescribeBlock = findFirstSerialDescribeBlock;
+async function hasTopLevelDescribeConfigureWithSerialMode(filePath) {
+    const project = new ts_morph_1.Project();
+    const content = await fs_extra_1.default.readFile(filePath, "utf-8");
+    const sourceFile = project.createSourceFile("test.ts", content);
+    const statements = sourceFile.getStatements();
+    for (const statement of statements) {
+        // Check if the statement is an expression statement
+        if (statement.getKind() === ts_morph_1.SyntaxKind.ExpressionStatement) {
+            const expression = statement.getFirstChildByKind(ts_morph_1.SyntaxKind.CallExpression);
+            if (expression) {
+                const expressionText = expression.getExpression().getText();
+                // Check if it's `test.describe.configure`
+                if (expressionText === "test.describe.configure") {
+                    // Check if arguments exist and if the first argument is an object literal with mode serial
+                    const args = expression.getArguments();
+                    const firstArgText = args[0]?.getText();
+                    if (firstArgText &&
+                        firstArgText.includes("serial") &&
+                        firstArgText.includes("mode")) {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+    return false;
+}
+exports.hasTopLevelDescribeConfigureWithSerialMode = hasTopLevelDescribeConfigureWithSerialMode;
+async function markTestAsOnly(filePath, testBlock, parentDescribeBlock) {
+    const fileContent = await fs_extra_1.default.readFile(filePath, "utf-8");
+    let updatedTestFileContent = fileContent;
+    if (!parentDescribeBlock) {
+        const updatedTestBlock = testBlock.replace("test(", "test.only(");
+        updatedTestFileContent = fileContent.replace(testBlock, updatedTestBlock);
+    }
+    else {
+        const describeMarkedAsOnly = parentDescribeBlock.replace("test.describe(", "test.describe.only(");
+        updatedTestFileContent = fileContent.replace(parentDescribeBlock, describeMarkedAsOnly);
+    }
+    await fs_extra_1.default.writeFile(filePath, updatedTestFileContent);
+}
+exports.markTestAsOnly = markTestAsOnly;

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@empiricalrun/test-run",
+  "version": "0.1.0",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "bin": {
+    "@empiricalrun/test-run": "dist/bin/index.js"
+  },
+  "main": "dist/index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/empirical-run/empirical.git"
+  },
+  "author": "Empirical Team <hey@empirical.run>",
+  "dependencies": {
+    "commander": "^12.1.0",
+    "fs-extra": "^11.2.0",
+    "ts-morph": "^23.0.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^22.5.5"
+  },
+  "scripts": {
+    "dev": "tsc --build --watch",
+    "build": "tsc --build",
+    "clean": "tsc --build --clean",
+    "lint": "eslint .",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}