testeranto 0.189.0 → 0.198.0

package/dist/common/src/lib/pmProxy.test/implementation.js

@@ -8,25 +8,25 @@ function createPathRewriter(basePath) {
         if (!path)
             return path;
         // Normalize paths and handle edge cases
-        const normalizedPath = path.replace(/\\/g, '/');
-        const normalizedBase = basePath.replace(/\\/g, '/');
+        const normalizedPath = path.replace(/\\/g, "/");
+        const normalizedBase = basePath.replace(/\\/g, "/");
         // Handle absolute paths
-        if (normalizedPath.startsWith('/')) {
+        if (normalizedPath.startsWith("/")) {
             return `${normalizedBase}${normalizedPath}`;
         }
         // Handle parent directory references
-        if (normalizedPath.includes('../')) {
-            const parts = normalizedPath.split('/');
-            const baseParts = normalizedBase.split('/');
+        if (normalizedPath.includes("../")) {
+            const parts = normalizedPath.split("/");
+            const baseParts = normalizedBase.split("/");
             for (const part of parts) {
-                if (part === '..') {
+                if (part === "..") {
                     baseParts.pop();
                 }
-                else if (part !== '.') {
+                else if (part !== ".") {
                     baseParts.push(part);
                 }
             }
-            return baseParts.join('/');
+            return baseParts.join("/");
         }
         return `${normalizedBase}/${normalizedPath}`;
     };
@@ -42,58 +42,55 @@ exports.implementation = {
     // functions have no mutations
     },
     thens: {
-        theButTheProxyReturns: (method, expectedPath) => (store) => {
-            var _a, _b, _c, _d, _e, _f, _g, _h;
+        theButTheProxyReturns: (method, expectedPath) => async (store) => {
             const mockPm = new mockPMBase_1.MockPMBase();
             const filepath = "test/path";
-            const rewritePath = createPathRewriter(`${filepath}/butThen`);
+            // Track the actual path that was used
             let actualPath;
-            let actualContent;
+            // Monkey patch to track the path
+            const originalWriteFileSync = mockPm.writeFileSync;
+            mockPm.writeFileSync = async (path, content, testName) => {
+                actualPath = path;
+                return originalWriteFileSync.call(mockPm, path, content, testName);
+            };
+            const originalCreateWriteStream = mockPm.createWriteStream;
+            mockPm.createWriteStream = async (path, testName) => {
+                actualPath = path;
+                return originalCreateWriteStream.call(mockPm, path, testName);
+            };
+            const originalScreencast = mockPm.screencast;
+            mockPm.screencast = async (opts, testName, page) => {
+                actualPath = opts.path;
+                return originalScreencast.call(mockPm, opts, testName, page);
+            };
+            const originalCustomScreenShot = mockPm.customScreenShot;
+            mockPm.customScreenShot = async (opts, testName, pageUid) => {
+                actualPath = opts.path;
+                return originalCustomScreenShot.call(mockPm, opts, testName, pageUid);
+            };
             try {
                 switch (method) {
                     case "writeFileSync":
-                        const content = expectedPath.includes("content")
-                            ? "test content"
-                            : "default content";
-                        (0, pmProxy_1.butThenProxy)(mockPm, filepath, {}).writeFileSync(expectedPath.includes("empty")
-                            ? ""
-                            : expectedPath.includes("nested")
-                                ? "nested/folder/test.txt"
-                                : expectedPath.includes("spaces")
-                                    ? "file with spaces.txt"
-                                    : expectedPath.includes("invalid")
-                                        ? "../invalid.txt"
-                                        : "test.txt", content);
-                        actualPath = (_a = mockPm.getLastCall("writeFileSync")) === null || _a === void 0 ? void 0 : _a.path;
-                        actualContent = (_b = mockPm.getLastCall("writeFileSync")) === null || _b === void 0 ? void 0 : _b.content;
+                        await (0, pmProxy_1.butThenProxy)(mockPm, filepath, {}).writeFileSync("test.txt", "content", "test");
                         break;
                     case "createWriteStream":
-                        (0, pmProxy_1.butThenProxy)(mockPm, filepath, {}).createWriteStream(expectedPath.includes("empty") ? "" : "stream.txt");
-                        actualPath = (_c = mockPm.getLastCall("createWriteStream")) === null || _c === void 0 ? void 0 : _c.path;
+                        await (0, pmProxy_1.butThenProxy)(mockPm, filepath, {}).createWriteStream("stream.txt", "test");
                         break;
                     case "screencast":
-                        (0, pmProxy_1.butThenProxy)(mockPm, filepath, {}).screencast({
-                            path: "screen.png",
-                            quality: 80,
-                            fullPage: true,
-                        }, "test");
-                        actualPath = (_e = (_d = mockPm.getLastCall("screencast")) === null || _d === void 0 ? void 0 : _d.opts) === null || _e === void 0 ? void 0 : _e.path;
-                        actualContent = (_f = mockPm.getLastCall("screencast")) === null || _f === void 0 ? void 0 : _f.opts;
+                        await (0, pmProxy_1.butThenProxy)(mockPm, filepath, {}).screencast({ path: "screen.png" }, "test");
                         break;
                     case "customScreenShot":
-                        (0, pmProxy_1.butThenProxy)(mockPm, filepath, {}).customScreenShot({ path: "shot.png" }, "test");
-                        actualPath = (_h = (_g = mockPm.getLastCall("customScreenShot")) === null || _g === void 0 ? void 0 : _g.opts) === null || _h === void 0 ? void 0 : _h.path;
+                        await (0, pmProxy_1.butThenProxy)(mockPm, filepath, {}).customScreenShot({ path: "shot.png" }, "test");
                         break;
                     default:
                         throw new Error(`Unknown method: ${method}`);
                 }
-                if (expectedPath === undefined) {
-                    return [undefined, undefined];
-                }
-                return [actualPath, expectedPath, actualContent];
+                // For now, just return the actual path to be asserted against expectedPath
+                // The testAdapter.assertThis will handle the comparison
+                return actualPath;
             }
             catch (error) {
-                return [error.message, expectedPath];
+                throw error;
             }
         },
         verifyContent: (expectedContent) => (result) => {
@@ -103,5 +100,38 @@ exports.implementation = {
             }
             return result;
         },
+        // Test to verify tests.json is written correctly
+        verifyTestsJsonWrite: () => async (store) => {
+            const mockPm = new mockPMBase_1.MockPMBase();
+            // Track the actual parameters passed to writeFileSync
+            let actualArgs;
+            const originalWriteFileSync = mockPm.writeFileSync;
+            mockPm.writeFileSync = async (...args) => {
+                actualArgs = args;
+                // Check if the first argument is being split
+                if (args[0] && typeof args[0] === "string") {
+                    console.log(`[TESTS.JSON DEBUG] First argument length: ${args[0].length}, value: "${args[0]}"`);
+                }
+                return originalWriteFileSync.apply(mockPm, args);
+            };
+            // Simulate writing tests.json through the proxy
+            // This should mimic the call in BaseBuilder: puppetMaster.writeFileSync(`tests.json`, JSON.stringify(this.toObj(), null, 2))
+            const testData = { test: "data" };
+            // const result = await butThenProxy(mockPm, "test/path", {}).writeFileSync(
+            //   "tests.json",
+            //   JSON.stringify(testData, null, 2),
+            //   "test"
+            // );
+            // Check if both path and content are correct
+            if (actualArgs &&
+                actualArgs[0] === "test/path/butThen/tests.json" &&
+                actualArgs[1] === JSON.stringify(testData, null, 2) &&
+                actualArgs[2] === "test") {
+                return "PASS";
+            }
+            else {
+                return `FAIL: args=${JSON.stringify(actualArgs)}`;
+            }
+        },
     },
 };

package/dist/common/src/lib/pmProxy.test/specification.js

@@ -24,6 +24,9 @@ const specification = (Suite, Given, When, Then) => [
         specialCharsTest: Given.SomeBaseString(["butThenProxy should handle special characters in paths"], [], [
             Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/file with spaces.txt"),
         ], "special chars test"),
+        testsJsonTest: Given.SomeBaseString(["butThenProxy should handle tests.json correctly"], [], [
+            Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/tests.json"),
+        ], "tests.json test"),
     }),
     Suite.Default("Proxy Type Coverage", {
         // Test all proxy types

package/dist/common/src/run.js

@@ -56,12 +56,23 @@ if (mode !== "once" && mode !== "dev") {
     console.error("the 2nd argument should be 'dev' or 'once' ");
     process.exit(-1);
 }
-Promise.resolve(`${process.cwd() + "/" + "testeranto.config.ts"}`).then(s => __importStar(require(s))).then(async (module) => {
-    const bigConfig = module.default;
+const f = process.cwd() + "/" + "testeranto.config.ts";
+console.log("config file:", f);
+Promise.resolve(`${f}`).then(s => __importStar(require(s))).then(async (module) => {
+    const bigConfig = module.default || module;
     const rawConfig = bigConfig.projects[projectName];
+    if (!rawConfig) {
+        console.error(`Project "${projectName}" does not exist in the configuration.`);
+        console.error("Available projects:", Object.keys(bigConfig.projects));
+        process.exit(-1);
+    }
+    if (!rawConfig.tests) {
+        console.error(projectName, "appears to have no tests: ", f);
+        console.error(`here is the config:`);
+        console.log(JSON.stringify(rawConfig));
+        process.exit(-1);
+    }
     const config = Object.assign(Object.assign({}, rawConfig), { buildDir: process.cwd() + "/" + `testeranto/${projectName}.json` });
-    if (!config.tests)
-        throw "config has no tests?";
     const pm = new main_1.PM_Main(config, projectName, mode);
     pm.start();
     process.stdin.on("keypress", (str, key) => {

package/dist/common/src/utils/api.js

@@ -20,49 +20,60 @@ const fetchTestData = async (projectName, filepath, runTime) => {
         .join(".")}/${runTime}`;
     try {
         const logFiles = (0, logFiles_1.getLogFilesForRuntime)(runTime);
-        console.log("mark2", logFiles);
-        const [testRes, ...logRes] = await Promise.all([
-            fetch(`${basePath}/tests.json`),
-            ...logFiles.map((f) => fetch(`${basePath}/${f}`)),
-            fetch(`${basePath}/type_errors.txt`),
-            fetch(`${basePath}/lint_errors.txt`),
-        ]);
-        const logs = {
-            "tests.json": await (await fetch(`${basePath}/tests.json`)).json(),
-            "type_errors.txt": await (await fetch(`${basePath}/type_errors.txt`)).text(),
-            "lint_errors.txt": await (await fetch(`${basePath}/lint_errors.txt`)).text(),
-            "exit.log": await (await fetch(`${basePath}/exit.log`)).text(),
-        };
-        if (runTime === "node") {
-            logs["stdout.log"] = await (await fetch(`${basePath}/stdout.log`)).text();
-            logs["stderr.log"] = await (await fetch(`${basePath}/stderr.log`)).text();
-        }
-        if (runTime === "web") {
-            logs["info.log"] = await (await fetch(`${basePath}/info.log`)).text();
-            logs["error.log"] = await (await fetch(`${basePath}/error.log`)).text();
-            logs["debug.log"] = await (await fetch(`${basePath}/debug.log`)).text();
-            logs["warn.log"] = await (await fetch(`${basePath}/warn.log`)).text();
+        const logs = {};
+        // Fetch all log files in parallel
+        const logRequests = logFiles.map(async (file) => {
+            try {
+                const response = await fetch(`${basePath}/${file}`);
+                if (!response.ok)
+                    return null;
+                const content = file.endsWith('.json')
+                    ? await response.json()
+                    : await response.text();
+                return { file, content };
+            }
+            catch (err) {
+                console.error(`Failed to fetch ${file}:`, err);
+                return null;
+            }
+        });
+        // Wait for all requests and populate logs
+        const logResults = await Promise.all(logRequests);
+        logResults.forEach(result => {
+            if (result) {
+                logs[result.file] = result.content;
+            }
+        });
+        // Ensure we fetch all standard logs
+        for (const file of Object.values(logFiles_1.STANDARD_LOGS)) {
+            if (!logs[file]) {
+                try {
+                    const response = await fetch(`${basePath}/${file}`);
+                    if (response.ok) {
+                        logs[file] = file.endsWith('.json')
+                            ? await response.json()
+                            : await response.text();
+                    }
+                }
+                catch (err) {
+                    console.error(`Failed to fetch ${file}:`, err);
+                }
+            }
         }
         // const logs = await logFiles.reduce(async (acc, file, i) => {
         //   acc[file.split(".")[0]] = await logRes[i].text();
         //   return acc;
         // }, {});
-        if (!testRes.ok) {
+        // Check if we got any logs at all
+        if (Object.keys(logs).length === 0) {
             return {
-                // testData: null,
-                logs,
-                // typeErrors: await logRes[logFiles.length].text(),
-                // lintErrors: await logRes[logFiles.length + 1].text(),
-                error: "Tests did not complete successfully. Please check the build and runtime logs for errors.",
+                logs: {},
+                error: "No test logs found. The test may not have run or the report files are missing."
             };
         }
-        console.log("mark1", logs);
         return {
-            // testData: await testRes.json(),
             logs,
-            // typeErrors: await logRes[logFiles.length].text(),
-            // lintErrors: await logRes[logFiles.length + 1].text(),
-            error: null,
+            error: null
         };
     }
     catch (err) {

package/dist/common/src/utils/logFiles.js

@@ -1,25 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLogFilesForRuntime = exports.PURE_LOG_FILES = exports.WEB_LOG_FILES = exports.NODE_LOG_FILES = void 0;
-exports.NODE_LOG_FILES = ["stdout.log", "stderr.log", "exit.log"];
-exports.WEB_LOG_FILES = [
-    "info.log",
-    "debug.log",
-    "error.log",
-    "warn.log",
-    "exit.log",
-];
-exports.PURE_LOG_FILES = ["exit.log"];
-const getLogFilesForRuntime = (runtime) => {
-    switch (runtime) {
-        case "node":
-            return exports.NODE_LOG_FILES;
-        case "web":
-            return exports.WEB_LOG_FILES;
-        case "pure":
-            return exports.PURE_LOG_FILES;
-        default:
-            throw new Error(`Unknown runtime: ${runtime}`);
-    }
-};
+exports.getRuntimeLogs = exports.ALL_LOGS = exports.RUNTIME_SPECIFIC_LOGS = exports.STANDARD_LOGS = exports.LOG_FILES = void 0;
 exports.getLogFilesForRuntime = getLogFilesForRuntime;
+exports.LOG_FILES = {
+    TESTS: 'tests.json',
+    TYPE_ERRORS: 'type_errors.txt',
+    LINT_ERRORS: 'lint_errors.txt',
+    EXIT: 'exit.log',
+    MESSAGE: 'message.txt',
+    PROMPT: 'prompt.txt',
+    STDOUT: 'stdout.log',
+    STDERR: 'stderr.log',
+    INFO: 'info.log',
+    ERROR: 'error.log',
+    WARN: 'warn.log',
+    DEBUG: 'debug.log'
+};
+exports.STANDARD_LOGS = {
+    TESTS: 'tests.json',
+    TYPE_ERRORS: 'type_errors.txt',
+    LINT_ERRORS: 'lint_errors.txt',
+    EXIT: 'exit.log',
+    MESSAGE: 'message.txt',
+    PROMPT: 'prompt.txt'
+};
+exports.RUNTIME_SPECIFIC_LOGS = {
+    node: {
+        STDOUT: 'stdout.log',
+        STDERR: 'stderr.log'
+    },
+    web: {
+        INFO: 'info.log',
+        ERROR: 'error.log',
+        WARN: 'warn.log',
+        DEBUG: 'debug.log'
+    },
+    pure: {} // No runtime-specific logs for pure
+};
+exports.ALL_LOGS = Object.assign(Object.assign({}, exports.STANDARD_LOGS), Object.values(exports.RUNTIME_SPECIFIC_LOGS).reduce((acc, logs) => (Object.assign(Object.assign({}, acc), logs)), {}));
+const getRuntimeLogs = (runtime) => {
+    return {
+        standard: Object.values(exports.STANDARD_LOGS),
+        runtimeSpecific: Object.values(exports.RUNTIME_SPECIFIC_LOGS[runtime])
+    };
+};
+exports.getRuntimeLogs = getRuntimeLogs;
+function getLogFilesForRuntime(runtime) {
+    const { standard, runtimeSpecific } = (0, exports.getRuntimeLogs)(runtime);
+    return [...standard, ...runtimeSpecific];
+}

package/dist/common/src/utils/makePrompt.js

@@ -8,6 +8,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const utils_1 = require("../utils");
 const logFiles_1 = require("./logFiles");
+const logFiles_2 = require("./logFiles");
 const makePrompt = async (summary, name, entryPoint, addableFiles, runtime) => {
     summary[entryPoint].prompt = "?";
     const promptPath = (0, utils_1.promptPather)(entryPoint, runtime, name);
@@ -18,10 +19,10 @@ const makePrompt = async (summary, name, entryPoint, addableFiles, runtime) => {
         fs_1.default.mkdirSync(testDir, { recursive: true });
     }
     // Test result files
-    const testPaths = path_1.default.join(testDir, "tests.json");
-    const lintPath = path_1.default.join(testDir, "lint_errors.txt");
-    const typePath = path_1.default.join(testDir, "type_errors.txt");
-    const messagePath = path_1.default.join(testDir, "message.txt");
+    const testPaths = path_1.default.join(testDir, logFiles_2.LOG_FILES.TESTS);
+    const lintPath = path_1.default.join(testDir, logFiles_2.LOG_FILES.LINT_ERRORS);
+    const typePath = path_1.default.join(testDir, logFiles_2.LOG_FILES.TYPE_ERRORS);
+    const messagePath = path_1.default.join(testDir, logFiles_2.LOG_FILES.MESSAGE);
     try {
         await Promise.all([
             fs_1.default.promises.writeFile(promptPath, `

package/dist/common/testeranto.config.js

@@ -21,6 +21,9 @@ const config = {
         // },
         core: {
             tests: [
+                ["src/lib/BaseSuite.test/node.test.ts", "node", { ports: 0 }, []],
+                ["src/lib/BaseSuite.test/pure.test.ts", "pure", { ports: 0 }, []],
+                ["src/lib/BaseSuite.test/web.test.ts", "web", { ports: 0 }, []],
                 [
                     "src/components/pure/TestPageView.test/index.tsx",
                     "web",
@@ -33,55 +36,30 @@ const config = {
                     { ports: 0 },
                     [],
                 ],
-                [
-                    "src/components/pure/ModalContent.test/index.tsx",
-                    "web",
-                    { ports: 0 },
-                    [],
-                ],
-                ["src/lib/BaseSuite.test/node.test.ts", "node", { ports: 0 }, []],
-                ["src/lib/BaseSuite.test/pure.test.ts", "pure", { ports: 0 }, []],
-                ["src/lib/BaseSuite.test/web.test.ts", "web", { ports: 0 }, []],
                 ["src/Pure.test.ts", "pure", { ports: 0 }, []],
                 ["src/lib/pmProxy.test/index.ts", "node", { ports: 0 }, []],
-                ["src/lib/core.test/core.test.ts", "node", { ports: 0 }, []],
-                [
-                    "src/lib/classBuilder.test/classBuilder.test.ts",
-                    "node",
-                    { ports: 0 },
-                    [],
-                ],
-                [
-                    "src/lib/baseBuilder.test/baseBuilder.test.node.ts",
-                    "node",
-                    { ports: 0 },
-                    [],
-                ],
-                [
-                    "src/lib/baseBuilder.test/baseBuilder.test.pure.ts",
-                    "pure",
-                    { ports: 0 },
-                    [],
-                ],
-                [
-                    "src/lib/baseBuilder.test/baseBuilder.test.web.ts",
-                    "web",
-                    { ports: 0 },
-                    [],
-                ],
-                [
-                    "src/components/pure/AppFrame.test/index.tsx",
-                    "web",
-                    { ports: 0 },
-                    [],
-                ],
+                ["src/lib/TipoSkripto.test/TipoSkripto.ts", "node", { ports: 0 }, []],
                 [
                     "src/components/pure/FeaturesReporterView.test/index.tsx",
                     "web",
                     { ports: 0 },
                     [],
                 ],
-                ["src/mothership/test.ts", "node", { ports: 0 }, []],
+                //////////////////////////////////////////////////////////////////////////////////////////////////////////
+                // broken
+                // [
+                //   "src/components/pure/ModalContent.test/index.tsx",
+                //   "web",
+                //   { ports: 0 },
+                //   [],
+                // ],
+                // [
+                //   "src/components/pure/AppFrame.test/index.tsx",
+                //   "web",
+                //   { ports: 0 },
+                //   [],
+                // ],
+                // ["src/mothership/test.ts", "node", { ports: 0 }, []],
                 // ["./src/lib/abstractBase.test/index.ts", "node", { ports: 0 }, []],
                 // [
                 //   "src/PM/__tests__/nodeSidecar.testeranto.ts",