testeranto 0.177.0 → 0.197.0

package/dist/common/src/lib/core.js

@@ -17,10 +17,8 @@ class TesterantoCore extends classBuilder_js_1.ClassBuilder {
                 return fullAdapter.assertThis(t);
             }
             async setup(s, artifactory, tr, pm) {
-                return (fullAdapter.beforeAll ||
-                    (async (input, artifactory, tr, pm) => input))(s, this.testResourceConfiguration, 
-                // artifactory,
-                pm);
+                var _a, _b;
+                return (_b = (_a = fullAdapter.beforeAll) === null || _a === void 0 ? void 0 : _a.call(fullAdapter, s, tr, pm)) !== null && _b !== void 0 ? _b : s;
             }
         }, class Given extends abstractBase_js_1.BaseGiven {
             constructor() {
@@ -28,11 +26,10 @@ class TesterantoCore extends classBuilder_js_1.ClassBuilder {
                 this.uberCatcher = uberCatcher;
             }
             async givenThat(subject, testResource, artifactory, initializer, initialValues, pm) {
-                console.log("mark800");
                 return fullAdapter.beforeEach(subject, initializer, testResource, initialValues, pm);
             }
             afterEach(store, key, artifactory, pm) {
-                return new Promise((res) => res(fullAdapter.afterEach(store, key, pm)));
+                return Promise.resolve(fullAdapter.afterEach(store, key, pm));
             }
         }, class When extends abstractBase_js_1.BaseWhen {
             async andWhen(store, whenCB, testResource, pm) {

package/dist/common/src/lib/core.test/MockCore.js

@@ -12,19 +12,6 @@ const core_1 = __importDefault(require("../core"));
  */
 class MockCore extends core_1.default {
     constructor(input, testSpecification, testImplementation, testResourceRequirement = { ports: [] }, testAdapter, uberCatcher = (cb) => cb()) {
-        console.log("[DEBUG] MockCore constructor starting...");
-        if (!testImplementation) {
-            throw new Error("testImplementation is required");
-        }
-        if (!testSpecification) {
-            console.warn("[WARN] testSpecification is null/undefined - tests may fail");
-        }
-        console.log("[DEBUG] MockCore constructor called with:");
-        console.log("- input:", JSON.stringify(input, null, 2));
-        console.log("- testSpecification keys:", Object.keys(testSpecification));
-        console.log("- testImplementation keys:", Object.keys(testImplementation));
-        console.log("- testResourceRequirement:", JSON.stringify(testResourceRequirement));
-        console.log("- testAdapter keys:", Object.keys(testAdapter));
         // Validate required implementation methods
         const requiredMethods = ["suites", "givens", "whens", "thens"];
         requiredMethods.forEach((method) => {
@@ -32,7 +19,6 @@ class MockCore extends core_1.default {
                 throw new Error(`Missing required implementation method: ${method}`);
             }
         });
-        console.log("[DEBUG] Validation passed, calling super...");
         // this.testResourceRequirement = testResourceRequirement;
         // this.testAdapter = testAdapter;
         super(input, testSpecification, testImplementation, testResourceRequirement, testAdapter, uberCatcher);

package/dist/common/src/lib/core.test/core.test.adapter.js

@@ -5,25 +5,18 @@ const MockCore_1 = require("./MockCore");
 exports.testAdapter = {
     beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
         var _a;
-        console.log('[DEBUG] BeforeEach - subject:', subject);
-        console.log('[DEBUG] BeforeEach - initialValues:', initialValues);
-        console.log('[DEBUG] BeforeEach called with:');
-        console.log('- subject type:', typeof subject);
-        console.log('- testResource:', JSON.stringify(testResource, null, 2));
-        console.log('- initialValues:', initialValues);
         try {
             const result = await initializer();
             if (!result) {
-                throw new Error('Initializer returned undefined');
+                throw new Error("Initializer returned undefined");
             }
             if (!(result instanceof MockCore_1.MockCore)) {
                 throw new Error(`Initializer returned ${(_a = result === null || result === void 0 ? void 0 : result.constructor) === null || _a === void 0 ? void 0 : _a.name}, expected MockCore`);
             }
-            console.log('[DEBUG] BeforeEach initialized MockCore successfully');
             return result;
         }
         catch (e) {
-            console.error('[ERROR] BeforeEach failed:', e);
+            console.error("[ERROR] BeforeEach failed:", e);
             throw e;
         }
     },

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

@@ -9,18 +9,14 @@ exports.implementation = {
     },
     givens: {
         Default: () => {
-            console.log('[DEBUG] Creating Default MockCore instance');
             const input = { debug: true };
             const resourceReq = { ports: [3000] };
-            console.log('[DEBUG] Default Given - input:', input);
-            console.log('[DEBUG] Default Given - resourceReq:', resourceReq);
             try {
                 const instance = new MockCore_1.MockCore(input, specification, exports.implementation, resourceReq, testAdapter, (cb) => cb());
-                console.log('[DEBUG] MockCore instance created successfully:', instance);
                 return instance;
             }
             catch (e) {
-                console.error('[ERROR] Failed to create MockCore:', e);
+                console.error("[ERROR] Failed to create MockCore:", e);
                 throw e;
             }
         },
@@ -45,9 +41,9 @@ exports.implementation = {
         },
         modifySpecs: (modifier) => (builder) => {
             var _a;
-            console.log('Modifying specs - current count:', (_a = builder.specs) === null || _a === void 0 ? void 0 : _a.length);
+            console.log("Modifying specs - current count:", (_a = builder.specs) === null || _a === void 0 ? void 0 : _a.length);
             const newSpecs = modifier(builder.specs || []);
-            console.log('Modifying specs - new count:', newSpecs.length);
+            console.log("Modifying specs - new count:", newSpecs.length);
             builder.specs = newSpecs;
             return builder;
         },

package/dist/common/src/lib/index.js

@@ -1,30 +1,29 @@
 "use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultTestResourceRequirement = exports.DefaultAdapter = exports.BaseAdapter = void 0;
 const BaseAdapter = () => ({
-    beforeAll: async (s) => s,
-    beforeEach: async function (subject, initialValues, x, testResource, pm) {
+    beforeAll: async (input, testResource, pm) => {
+        return input;
+    },
+    beforeEach: async function (subject, initializer, testResource, initialValues, pm) {
         return subject;
     },
-    afterEach: async (s) => s,
-    afterAll: (store) => undefined,
-    butThen: async (store, thenCb) => {
-        return thenCb(store);
+    afterEach: async (store, key, pm) => Promise.resolve(store),
+    afterAll: (store, pm) => undefined,
+    butThen: async (store, thenCb, testResource, pm) => {
+        return thenCb(store, pm);
     },
     andWhen: async (store, whenCB, testResource, pm) => {
-        try {
-            await whenCB(store, testResource, pm);
-        }
-        catch (error) {
-            console.error("Error in andWhen:", error);
-            throw error; // Re-throw to maintain test failure
-        }
+        return whenCB(store, pm);
     },
     assertThis: (x) => x,
 });
 exports.BaseAdapter = BaseAdapter;
 const DefaultAdapter = (p) => {
-    return Object.assign(Object.assign({}, exports.BaseAdapter), p);
+    const base = (0, exports.BaseAdapter)();
+    return Object.assign(Object.assign({}, base), p);
 };
 exports.DefaultAdapter = DefaultAdapter;
 exports.defaultTestResourceRequirement = {

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

@@ -10,10 +10,16 @@ const baseProxy = function (pm, mappings) {
                 const method = mapping[0];
                 const arger = mapping[1];
                 if (prop === method) {
-                    return (...x) => target[prop](arger(...x));
+                    return (...x) => {
+                        // Add debug logging
+                        const modifiedArgs = arger(...x);
+                        return target[prop](...modifiedArgs);
+                    };
                 }
             }
-            return (...x) => target[prop](...x);
+            return (...x) => {
+                return target[prop](...x);
+            };
         },
     });
 };
@@ -53,10 +59,27 @@ const butThenProxy = (pm, filepath, addArtifact) => {
         ],
         [
             "writeFileSync",
-            (fp, contents) => {
+            (fp, contents, testName) => {
+                console.log(`[DEBUG] butThenProxy writeFileSync: fp="${fp}" (type: ${typeof fp}), contents="${contents}" (type: ${typeof contents}), testName="${testName}" (type: ${typeof testName})`);
+                // Check if fp is being treated as individual characters
+                if (typeof fp !== "string") {
+                    console.log(`[ERROR] fp is not a string:`, fp);
+                    // If fp is not a string, try to handle it
+                    if (Array.isArray(fp)) {
+                        // If it's an array, join it back into a string
+                        fp = fp.join("");
+                        console.log(`[DEBUG] Converted array to string: "${fp}"`);
+                    }
+                    else {
+                        // For other cases, convert to string
+                        fp = String(fp);
+                        console.log(`[DEBUG] Converted to string: "${fp}"`);
+                    }
+                }
                 const path = `${filepath}/butThen/${fp}`;
+                console.log(`[DEBUG] Generated path: "${path}"`);
                 addArtifact(path);
-                return [path, contents];
+                return [path, contents, testName];
             },
         ],
         [
@@ -96,10 +119,10 @@ const andWhenProxy = (pm, filepath, addArtifact) => {
         ],
         [
             "writeFileSync",
-            (fp, contents) => {
+            (fp, contents, testName) => {
                 const path = `${filepath}/andWhen/${fp}`;
                 addArtifact(path);
-                return [path, contents];
+                return [path, contents, testName];
             },
         ],
         [
@@ -140,10 +163,10 @@ const afterEachProxy = (pm, suite, given, addArtifact) => {
         ],
         [
             "writeFileSync",
-            (fp, contents) => {
+            (fp, contents, testName) => {
                 const path = `suite-${suite}/given-${given}/afterEach/${fp}`;
                 addArtifact(path);
-                return [path, contents];
+                return [path, contents, testName];
             },
         ],
         [
@@ -176,10 +199,10 @@ const beforeEachProxy = (pm, suite, addArtifact) => {
         ],
         [
             "writeFileSync",
-            (fp, contents) => {
+            (fp, contents, testName) => {
                 const path = `suite-${suite}/beforeEach/${fp}`;
                 addArtifact(path);
-                return [path, contents];
+                return [path, contents, testName];
             },
         ],
         [
@@ -208,10 +231,10 @@ const beforeAllProxy = (pm, suite, addArtifact) => {
     return baseProxy(pm, [
         [
             "writeFileSync",
-            (fp, contents) => {
+            (fp, contents, testName) => {
                 const path = `suite-${suite}/beforeAll/${fp}`;
                 addArtifact(path);
-                return [path, contents];
+                return [path, contents, testName];
             },
         ],
         [
@@ -248,11 +271,10 @@ const afterAllProxy = (pm, suite, addArtifact) => {
         ],
         [
             "writeFileSync",
-            (fp, contents) => {
+            (fp, contents, testName) => {
                 const path = `suite-${suite}/afterAll/${fp}`;
-                console.log("MARK10");
                 addArtifact(path);
-                return [path, contents];
+                return [path, contents, testName];
             },
         ],
         [
@@ -260,7 +282,6 @@ const afterAllProxy = (pm, suite, addArtifact) => {
             (opts, p) => {
                 const path = `suite-${suite}/afterAll/${opts.path}`;
                 addArtifact(path);
-                console.log("MARK9");
                 return [
                     Object.assign(Object.assign({}, opts), { path }),
                     p,

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

@@ -18,11 +18,17 @@ exports.testAdapter = {
         // };
     },
     andWhen: async (store, whenCB, testResource, pm) => {
-        const proxiedPM = (0, pmProxy_1.andWhenProxy)(pm, "some/path", store);
+        const proxiedPM = (0, pmProxy_1.andWhenProxy)(pm, "some/path", (path) => {
+            console.log("Artifact added:", path);
+            return path;
+        });
         return whenCB(store, proxiedPM);
     },
     butThen: async (store, thenCB, testResource, pm) => {
-        const proxiedPM = (0, pmProxy_1.butThenProxy)(pm, "some/path", store);
+        const proxiedPM = (0, pmProxy_1.butThenProxy)(pm, "some/path", (path) => {
+            console.log("Artifact added:", path);
+            return path;
+        });
         return thenCB(store, proxiedPM);
     },
     afterEach: async (store, key, pm) => store,
@@ -32,7 +38,17 @@ exports.testAdapter = {
             beforeEachProxy: input.butThenProxy(new mockPMBase_1.MockPMBase(), theGivenString),
         };
     },
-    assertThis: (returnedFilePath, expectation) => {
-        chai_1.assert.equal(returnedFilePath, expectation);
+    assertThis: (actualResult, expectedResult) => {
+        // Handle both path assertions and our new test result
+        if (typeof actualResult === 'string' && actualResult.startsWith('PASS')) {
+            chai_1.assert.equal(actualResult, 'PASS', 'tests.json should be written with correct path and content');
+        }
+        else if (typeof actualResult === 'string' && actualResult.startsWith('FAIL')) {
+            // For the tests.json write test, we want to see what's actually happening
+            chai_1.assert.fail(`Test failed: ${actualResult}`);
+        }
+        else {
+            chai_1.assert.equal(actualResult, expectedResult);
+        }
     },
 };

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

@@ -2,6 +2,35 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.implementation = void 0;
 const mockPMBase_1 = require("./mockPMBase");
+const pmProxy_1 = require("../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}`;
+    };
+}
 exports.implementation = {
     suites: {
         Default: "PM Proxy Tests",
@@ -13,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";
-                        proxiedPm.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":
-                        proxiedPm.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":
-                        proxiedPm.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":
-                        proxiedPm.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) => {
@@ -74,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/mockPMBase.js

@@ -22,6 +22,15 @@ 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/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/mothership/index.js

@@ -8,6 +8,11 @@ const app = (0, express_1.default)();
 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 });
+});
 exports.default = (port) => {
     app.listen(port, () => {
         console.log(`Example app listening on port ${port}`);

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

@@ -9,9 +9,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")]),
         }, []),
     ];
 };
@@ -19,8 +17,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.");
@@ -30,8 +41,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.");
@@ -39,26 +52,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;
+    },
 };
 exports.default = (0, Node_1.default)(index_1.default, specification, implementation, testAdapter);

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTree = buildTree;
+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'
+                            }]
+                    }]
+            }]
+    }));
+}