testeranto 0.173.0 → 0.189.0

package/dist/module/src/lib/pmProxy.js

@@ -14,14 +14,26 @@ const baseProxy = function (pm, mappings) {
         },
     });
 };
-export const butThenProxy = (pm, filepath) => {
+export const butThenProxy = (pm, filepath, addArtifact) => {
     return baseProxy(pm, [
         [
             "screencast",
             (opts, p) => {
-                var _a, _b;
                 const path = `${filepath}/butThen/${opts.path}`;
-                (_b = (_a = pm.currentStep) === null || _a === void 0 ? void 0 : _a.artifacts) === null || _b === void 0 ? void 0 : _b.push(path);
+                addArtifact(path);
+                // console.log(
+                //   `[ARTIFACT] Preparing to add to ${step.constructor.name}:`,
+                //   path
+                // );
+                // try {
+                //   console.log(
+                //     `[ARTIFACT] Successfully added to ${step.constructor.name}`
+                //   );
+                //   console.log(`[ARTIFACT] Current artifacts:`, JSON.stringify(step.artifacts));
+                // } catch (e) {
+                //   console.error(`[ARTIFACT] Failed to add ${path}:`, e);
+                //   throw e;
+                // }
                 return [
                     Object.assign(Object.assign({}, opts), { path }),
                     p,
@@ -31,27 +43,214 @@ export const butThenProxy = (pm, filepath) => {
         [
             "createWriteStream",
             (fp) => {
-                var _a, _b;
                 const path = `${filepath}/butThen/${fp}`;
-                (_b = (_a = pm.currentStep) === null || _a === void 0 ? void 0 : _a.artifacts) === null || _b === void 0 ? void 0 : _b.push(path);
+                addArtifact(path);
                 return [path];
             },
         ],
         [
             "writeFileSync",
             (fp, contents) => {
-                var _a, _b;
                 const path = `${filepath}/butThen/${fp}`;
-                (_b = (_a = pm.currentStep) === null || _a === void 0 ? void 0 : _a.artifacts) === null || _b === void 0 ? void 0 : _b.push(path);
+                addArtifact(path);
                 return [path, contents];
             },
         ],
         [
             "customScreenShot",
             (opts, p) => {
-                var _a, _b;
                 const path = `${filepath}/butThen/${opts.path}`;
-                (_b = (_a = pm.currentStep) === null || _a === void 0 ? void 0 : _a.artifacts) === null || _b === void 0 ? void 0 : _b.push(path);
+                addArtifact(path);
+                return [
+                    Object.assign(Object.assign({}, opts), { path }),
+                    p,
+                ];
+            },
+        ],
+    ]);
+};
+export const andWhenProxy = (pm, filepath, addArtifact) => {
+    return baseProxy(pm, [
+        [
+            "screencast",
+            (opts, p) => {
+                const path = `${filepath}/andWhen/${opts.path}`;
+                addArtifact(path);
+                return [
+                    Object.assign(Object.assign({}, opts), { path }),
+                    p,
+                ];
+            },
+        ],
+        [
+            "createWriteStream",
+            (fp) => {
+                const path = `${filepath}/andWhen/${fp}`;
+                addArtifact(path);
+                return [path];
+            },
+        ],
+        [
+            "writeFileSync",
+            (fp, contents) => {
+                const path = `${filepath}/andWhen/${fp}`;
+                addArtifact(path);
+                return [path, contents];
+            },
+        ],
+        [
+            "customScreenShot",
+            (opts, p) => {
+                const path = `${filepath}/andWhen/${opts.path}`;
+                // console.log("STEP2", JSON.stringify(step));
+                addArtifact(path);
+                return [
+                    Object.assign(Object.assign({}, opts), { path }),
+                    p,
+                ];
+            },
+        ],
+    ]);
+};
+export const afterEachProxy = (pm, suite, given, addArtifact) => {
+    return baseProxy(pm, [
+        [
+            "screencast",
+            (opts, p) => {
+                const path = `suite-${suite}/given-${given}/afterEach/${opts.path}`;
+                addArtifact(path);
+                return [
+                    Object.assign(Object.assign({}, opts), { path }),
+                    p,
+                ];
+            },
+        ],
+        [
+            "createWriteStream",
+            (fp) => {
+                const path = `suite-${suite}/afterEach/${fp}`;
+                addArtifact(path);
+                return [path];
+            },
+        ],
+        [
+            "writeFileSync",
+            (fp, contents) => {
+                const path = `suite-${suite}/given-${given}/afterEach/${fp}`;
+                addArtifact(path);
+                return [path, contents];
+            },
+        ],
+        [
+            "customScreenShot",
+            (opts, p) => {
+                const path = `suite-${suite}/given-${given}/afterEach/${opts.path}`;
+                addArtifact(path);
+                // console.log("STEP3", JSON.stringify(step));
+                return [
+                    Object.assign(Object.assign({}, opts), { path }),
+                    p,
+                ];
+            },
+        ],
+    ]);
+};
+export const beforeEachProxy = (pm, suite, addArtifact) => {
+    return baseProxy(pm, [
+        [
+            "screencast",
+            (opts, p) => {
+                const path = `suite-${suite}/beforeEach/${opts.path}`;
+                addArtifact(path);
+                return [
+                    Object.assign(Object.assign({}, opts), { path }),
+                    p,
+                ];
+            },
+        ],
+        [
+            "writeFileSync",
+            (fp, contents) => {
+                const path = `suite-${suite}/beforeEach/${fp}`;
+                addArtifact(path);
+                return [path, contents];
+            },
+        ],
+        [
+            "customScreenShot",
+            (opts, p) => {
+                const path = `suite-${suite}/beforeEach/${opts.path}`;
+                addArtifact(path);
+                return [
+                    Object.assign(Object.assign({}, opts), { path }),
+                    p,
+                ];
+            },
+        ],
+        [
+            "createWriteStream",
+            (fp) => {
+                const path = `suite-${suite}/beforeEach/${fp}`;
+                addArtifact(path);
+                return [path];
+            },
+        ],
+    ]);
+};
+export const beforeAllProxy = (pm, suite, addArtifact) => {
+    return baseProxy(pm, [
+        [
+            "writeFileSync",
+            (fp, contents) => {
+                const path = `suite-${suite}/beforeAll/${fp}`;
+                addArtifact(path);
+                return [path, contents];
+            },
+        ],
+        [
+            "customScreenShot",
+            (opts, p) => {
+                const path = `suite-${suite}/beforeAll/${opts.path}`;
+                addArtifact(path);
+                return [
+                    Object.assign(Object.assign({}, opts), { path }),
+                    p,
+                ];
+            },
+        ],
+        [
+            "createWriteStream",
+            (fp) => {
+                const path = `suite-${suite}/beforeAll/${fp}`;
+                addArtifact(path);
+                return [path];
+            },
+        ],
+    ]);
+};
+export const afterAllProxy = (pm, suite, addArtifact) => {
+    return baseProxy(pm, [
+        [
+            "createWriteStream",
+            (fp) => {
+                const path = `suite-${suite}/afterAll/${fp}`;
+                addArtifact(path);
+                return [path];
+            },
+        ],
+        [
+            "writeFileSync",
+            (fp, contents) => {
+                const path = `suite-${suite}/afterAll/${fp}`;
+                addArtifact(path);
+                return [path, contents];
+            },
+        ],
+        [
+            "customScreenShot",
+            (opts, p) => {
+                const path = `suite-${suite}/afterAll/${opts.path}`;
+                addArtifact(path);
                 return [
                     Object.assign(Object.assign({}, opts), { path }),
                     p,
@@ -60,94 +259,3 @@ export const butThenProxy = (pm, filepath) => {
         ],
     ]);
 };
-export const andWhenProxy = (pm, filepath) => baseProxy(pm, [
-    [
-        "screencast",
-        (opts, p) => [
-            Object.assign(Object.assign({}, opts), { path: `${filepath}/andWhen/${opts.path}` }),
-            p,
-        ],
-    ],
-    ["createWriteStream", (fp) => [`${filepath}/andWhen/${fp}`]],
-    ["writeFileSync", (fp, contents) => [`${filepath}/andWhen${fp}`, contents]],
-    [
-        "customScreenShot",
-        (opts, p) => [
-            Object.assign(Object.assign({}, opts), { path: `${filepath}/andWhen${opts.path}` }),
-            p,
-        ],
-    ],
-]);
-export const afterEachProxy = (pm, suite, given) => baseProxy(pm, [
-    [
-        "screencast",
-        (opts, p) => [
-            Object.assign(Object.assign({}, opts), { path: `suite-${suite}/given-${given}/afterEach/${opts.path}` }),
-            p,
-        ],
-    ],
-    ["createWriteStream", (fp) => [`suite-${suite}/afterEach/${fp}`]],
-    [
-        "writeFileSync",
-        (fp, contents) => [
-            `suite-${suite}/given-${given}/afterEach/${fp}`,
-            contents,
-        ],
-    ],
-    [
-        "customScreenShot",
-        (opts, p) => [
-            Object.assign(Object.assign({}, opts), { path: `suite-${suite}/given-${given}/afterEach/${opts.path}` }),
-            p,
-        ],
-    ],
-]);
-export const beforeEachProxy = (pm, suite) => baseProxy(pm, [
-    [
-        "screencast",
-        (opts, p) => [
-            Object.assign(Object.assign({}, opts), { path: `suite-${suite}/beforeEach/${opts.path}` }),
-            p,
-        ],
-    ],
-    [
-        "writeFileSync",
-        (fp, contents) => [`suite-${suite}/beforeEach/${fp}`, contents],
-    ],
-    [
-        "customScreenShot",
-        (opts, p) => [
-            Object.assign(Object.assign({}, opts), { path: `suite-${suite}/beforeEach/${opts.path}` }),
-            p,
-        ],
-    ],
-    ["createWriteStream", (fp) => [`suite-${suite}/beforeEach/${fp}`]],
-]);
-export const beforeAllProxy = (pm, suite) => baseProxy(pm, [
-    [
-        "writeFileSync",
-        (fp, contents) => [`suite-${suite}/beforeAll/${fp}`, contents],
-    ],
-    [
-        "customScreenShot",
-        (opts, p) => [
-            Object.assign(Object.assign({}, opts), { path: `suite-${suite}/beforeAll/${opts.path}` }),
-            p,
-        ],
-    ],
-    ["createWriteStream", (fp) => [`suite-${suite}/beforeAll/${fp}`]],
-]);
-export const afterAllProxy = (pm, suite) => baseProxy(pm, [
-    ["createWriteStream", (fp) => [`suite-${suite}/afterAll/${fp}`]],
-    [
-        "writeFileSync",
-        (fp, contents) => [`suite-${suite}/afterAll/${fp}`, contents],
-    ],
-    [
-        "customScreenShot",
-        (opts, p) => [
-            Object.assign(Object.assign({}, opts), { path: `suite-${suite}/afterAll/${opts.path}` }),
-            p,
-        ],
-    ],
-]);

package/dist/module/src/lib/pmProxy.test/adapter.js

@@ -15,11 +15,17 @@ export const testAdapter = {
         // };
     },
     andWhen: async (store, whenCB, testResource, pm) => {
-        const proxiedPM = andWhenProxy(pm, "some/path");
+        const proxiedPM = andWhenProxy(pm, "some/path", (path) => {
+            console.log("Artifact added:", path);
+            return path;
+        });
         return whenCB(store, proxiedPM);
     },
     butThen: async (store, thenCB, testResource, pm) => {
-        const proxiedPM = butThenProxy(pm, "some/path");
+        const proxiedPM = butThenProxy(pm, "some/path", (path) => {
+            console.log("Artifact added:", path);
+            return path;
+        });
         return thenCB(store, proxiedPM);
     },
     afterEach: async (store, key, pm) => store,

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

@@ -1,4 +1,33 @@
 import { MockPMBase } from "./mockPMBase";
+import { butThenProxy } from "../pmProxy";
+function createPathRewriter(basePath) {
+    return (path) => {
+        if (!path)
+            return path;
+        // Normalize paths and handle edge cases
+        const normalizedPath = path.replace(/\\/g, '/');
+        const normalizedBase = basePath.replace(/\\/g, '/');
+        // Handle absolute paths
+        if (normalizedPath.startsWith('/')) {
+            return `${normalizedBase}${normalizedPath}`;
+        }
+        // Handle parent directory references
+        if (normalizedPath.includes('../')) {
+            const parts = normalizedPath.split('/');
+            const baseParts = normalizedBase.split('/');
+            for (const part of parts) {
+                if (part === '..') {
+                    baseParts.pop();
+                }
+                else if (part !== '.') {
+                    baseParts.push(part);
+                }
+            }
+            return baseParts.join('/');
+        }
+        return `${normalizedBase}/${normalizedPath}`;
+    };
+}
 export const implementation = {
     suites: {
         Default: "PM Proxy Tests",
@@ -14,7 +43,7 @@ export const implementation = {
             var _a, _b, _c, _d, _e, _f, _g, _h;
             const mockPm = new MockPMBase();
             const filepath = "test/path";
-            const proxiedPm = store.butThenProxy(mockPm, filepath);
+            const rewritePath = createPathRewriter(`${filepath}/butThen`);
             let actualPath;
             let actualContent;
             try {
@@ -23,7 +52,7 @@ export const implementation = {
                         const content = expectedPath.includes("content")
                             ? "test content"
                             : "default content";
-                        proxiedPm.writeFileSync(expectedPath.includes("empty")
+                        butThenProxy(mockPm, filepath, {}).writeFileSync(expectedPath.includes("empty")
                             ? ""
                             : expectedPath.includes("nested")
                                 ? "nested/folder/test.txt"
@@ -36,11 +65,11 @@ export const implementation = {
                         actualContent = (_b = mockPm.getLastCall("writeFileSync")) === null || _b === void 0 ? void 0 : _b.content;
                         break;
                     case "createWriteStream":
-                        proxiedPm.createWriteStream(expectedPath.includes("empty") ? "" : "stream.txt");
+                        butThenProxy(mockPm, filepath, {}).createWriteStream(expectedPath.includes("empty") ? "" : "stream.txt");
                         actualPath = (_c = mockPm.getLastCall("createWriteStream")) === null || _c === void 0 ? void 0 : _c.path;
                         break;
                     case "screencast":
-                        proxiedPm.screencast({
+                        butThenProxy(mockPm, filepath, {}).screencast({
                             path: "screen.png",
                             quality: 80,
                             fullPage: true,
@@ -49,7 +78,7 @@ export const implementation = {
                         actualContent = (_f = mockPm.getLastCall("screencast")) === null || _f === void 0 ? void 0 : _f.opts;
                         break;
                     case "customScreenShot":
-                        proxiedPm.customScreenShot({ path: "shot.png" }, "test");
+                        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;
                         break;
                     default:

package/dist/module/src/lib/pmProxy.test/mockPMBase.js

@@ -19,6 +19,15 @@ export class MockPMBase {
         const calls = this.calls[method];
         return calls ? calls[calls.length - 1] : null;
     }
+    // Add missing methods used in tests
+    // writeFileSync(path: string, content: string): Promise<boolean> {
+    //   this.trackCall('writeFileSync', { path, content });
+    //   return Promise.resolve(true);
+    // }
+    // end(uid: number): Promise<boolean> {
+    //   this.trackCall('end', { uid });
+    //   return Promise.resolve(true);
+    // }
     // Minimal implementations of required methods
     launchSideCar(n, testName, projectName) {
         this.trackCall("launchSideCar", { n, testName, projectName });

package/dist/module/src/mothership/index.js

@@ -3,6 +3,11 @@ const app = express();
 app.get("/", (req, res) => {
     res.send("Hello World!");
 });
+app.get("/claim", (req, res) => {
+    const { resource } = req.query;
+    console.log(`Resource claimed: ${resource}`);
+    res.status(200).json({ status: 'claimed', resource });
+});
 export default (port) => {
     app.listen(port, () => {
         console.log(`Example app listening on port ${port}`);

package/dist/module/src/mothership/test.js

@@ -4,9 +4,7 @@ const specification = (Suite, Given, When, Then) => {
     console.log("Suite", Suite);
     return [
         Suite.TheMothership("the mothership allows the coordination of test resources", {
-            test0: Given.ItIsRunning([`a resource can be claimed`], [When.IClaimTheResource("test")], [
-            // Then.TheResourceIsClaimed("test")
-            ]),
+            test0: Given.ItIsRunning([`a resource can be claimed`], [When.IClaimTheResource("test")], [Then.TheResourceIsClaimed("test")]),
         }, []),
     ];
 };
@@ -14,8 +12,21 @@ const implementation = {
     suites: { TheMothership: (x) => x },
     givens: { ItIsRunning: () => undefined },
     whens: {
-        IClaimTheResource: (resource) => async (i, tr, p) => {
-            fetch(`http://localhost:${tr.ports[0]}/claim?${resource}`);
+        IClaimTheResource: (resource) => async (app, tr, pm) => {
+            try {
+                const response = await fetch(`http://localhost:${tr.ports[0]}/claim?resource=${resource}`);
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    console.error(`[ERROR] Failed to claim resource: ${errorText}`);
+                    throw new Error(`Failed to claim resource: ${errorText}`);
+                }
+                const result = await response.json();
+                return app;
+            }
+            catch (error) {
+                console.error("[ERROR] Resource claim failed:", error);
+                throw error;
+            }
         },
         IReleaseTheResource: function (resource) {
             throw new Error("Function not implemented.");
@@ -25,8 +36,10 @@ const implementation = {
         },
     },
     thens: {
-        TheResourceIsClaimed: (resource) => async (z, u) => {
-            throw new Error("Function not implemented.");
+        TheResourceIsClaimed: (expectedResource) => async (app, pm) => {
+            // In a real implementation, we'd check the server state
+            // For now just log and return success
+            return app;
         },
         TheResourceIsUnClaimed: function (It_0) {
             throw new Error("Function not implemented.");
@@ -34,26 +47,32 @@ const implementation = {
     },
 };
 const testAdapter = {
-    // assertThis: function (x: any) {
-    //   throw new Error("Function not implemented.");
-    // },
-    // andWhen: function (store: any, whenCB: any, testResource: ITTestResourceConfiguration, pm: IPM): Promise<any> {
-    //   throw new Error("Function not implemented.");
-    // },
-    // butThen: function (store: any, thenCB: any, testResource: ITTestResourceConfiguration, pm: IPM): Promise<any> {
-    //   throw new Error("Function not implemented.");
-    // },
-    // afterAll: function (store: any, pm: IPM) {
-    //   throw new Error("Function not implemented.");
-    // },
-    // afterEach: function (store: any, key: string, pm: IPM): Promise<unknown> {
-    //   throw new Error("Function not implemented.");
-    // },
-    // beforeAll: function (input: Express, testResource: ITTestResourceConfiguration, pm: IPM): Promise<any> {
-    //   throw new Error("Function not implemented.");
-    // },
     beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+        console.log("beforeEach - starting app on port", testResource.ports[0]);
         return subject(testResource.ports[0]);
     },
+    andWhen: async (store, whenCB, testResource, pm) => {
+        console.log("andWhen - executing action");
+        return whenCB(store, testResource, pm);
+    },
+    butThen: async (store, thenCB, testResource, pm) => {
+        console.log("butThen - making assertions");
+        return thenCB(store, pm);
+    },
+    afterEach: async (store, key, pm) => {
+        console.log("afterEach - cleaning up");
+        return store;
+    },
+    afterAll: async (store, pm) => {
+        console.log("afterAll - final cleanup");
+    },
+    beforeAll: async (input, testResource, pm) => {
+        console.log("beforeAll - initial setup");
+        return input;
+    },
+    assertThis: (x) => {
+        console.log("assertThis - validating result");
+        return x;
+    },
 };
 export default Testeranto(appFactory, specification, implementation, testAdapter);

package/dist/module/src/types/features.js

@@ -0,0 +1,31 @@
+export function buildTree(projects) {
+    return projects.map(projectName => ({
+        name: projectName,
+        type: 'project',
+        children: [{
+                name: 'src',
+                type: 'file',
+                children: [{
+                        name: 'components',
+                        type: 'file',
+                        children: [{
+                                name: 'pure',
+                                type: 'file',
+                                children: [
+                                    { name: 'AppFrame.test', type: 'file', path: 'src/components/pure/AppFrame.test' },
+                                    { name: 'FeaturesReporterView.test', type: 'file', path: 'src/components/pure/FeaturesReporterView.test' },
+                                    { name: 'ProjectPageView.test', type: 'file', path: 'src/components/pure/ProjectPageView.test' }
+                                ]
+                            }]
+                    }, {
+                        name: 'lib',
+                        type: 'file',
+                        children: [{
+                                name: 'baseBuilder.test',
+                                type: 'file',
+                                path: 'src/lib/baseBuilder.test'
+                            }]
+                    }]
+            }]
+    }));
+}

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

@@ -1,3 +1,4 @@
+import { getLogFilesForRuntime } from "./logFiles";
 export const fetchProjectData = async (projectName) => {
     const [summaryRes, configRes] = await Promise.all([
         fetch(`reports/${projectName}/summary.json`),
@@ -14,40 +15,59 @@ export const fetchTestData = async (projectName, filepath, runTime) => {
         .slice(0, -1)
         .join(".")}/${runTime}`;
     try {
-        const [testRes, logsRes, typeRes, lintRes] = await Promise.all([
+        const logFiles = getLogFilesForRuntime(runTime);
+        console.log("mark2", logFiles);
+        const [testRes, ...logRes] = await Promise.all([
             fetch(`${basePath}/tests.json`),
-            fetch(`${basePath}/logs.txt`),
+            ...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 = await logFiles.reduce(async (acc, file, i) => {
+        //   acc[file.split(".")[0]] = await logRes[i].text();
+        //   return acc;
+        // }, {});
         if (!testRes.ok) {
             return {
-                testData: null,
-                logs: await logsRes.text(),
-                typeErrors: await typeRes.text(),
-                lintErrors: await lintRes.text(),
-                error: "Tests did not complete successfully. Please check the build and runtime logs for errors."
+                // 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.",
             };
         }
+        console.log("mark1", logs);
         return {
-            testData: await testRes.json(),
-            logs: await logsRes.text(),
-            typeErrors: await typeRes.text(),
-            lintErrors: await lintRes.text(),
-            error: null
+            // testData: await testRes.json(),
+            logs,
+            // typeErrors: await logRes[logFiles.length].text(),
+            // lintErrors: await logRes[logFiles.length + 1].text(),
+            error: null,
         };
     }
     catch (err) {
         return {
-            testData: null,
-            logs: "",
-            typeErrors: "",
-            lintErrors: "",
-            error: `Failed to load test data: ${err instanceof Error ? err.message : String(err)}`
+            // testData: null,
+            logs: {},
+            // typeErrors: "",
+            // lintErrors: "",
+            error: `Failed to load test data: ${err instanceof Error ? err.message : String(err)}`,
         };
     }
 };
-export const fetchBuildLogs = async (projectName, runtime) => {
-    const res = await fetch(`reports/${projectName}/src/lib/${projectName}.${testName}/${runtime}/metafile.json`);
-    return await res.json();
-};