testeranto 0.203.0 → 0.206.0

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

@@ -0,0 +1,174 @@
+export const specification = (Suite, Given, When, Then) => [
+    Suite.Default("PM Proxy Functionality", {
+        // Basic path rewriting tests
+        writeFileProxyTest: Given.SomeBaseString(["butThenProxy should rewrite writeFileSync paths"], [], [
+            Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/test.txt"),
+        ], "writeFileSync test"),
+        // createWriteStreamProxyTest: Given.SomeBaseString(
+        //   ["butThenProxy should rewrite createWriteStream paths"],
+        //   [],
+        //   [
+        //     Then.theButTheProxyReturns(
+        //       "createWriteStream",
+        //       "test/path/butThen/stream.txt"
+        //     ),
+        //   ],
+        //   "createWriteStream test"
+        // ),
+        // screencastProxyTest: Given.SomeBaseString(
+        //   ["butThenProxy should rewrite screencast paths"],
+        //   [],
+        //   [
+        //     Then.theButTheProxyReturns(
+        //       "screencast",
+        //       "test/path/butThen/screen.png"
+        //     ),
+        //   ],
+        //   "screencast test"
+        // ),
+        // customScreenShotProxyTest: Given.SomeBaseString(
+        //   ["butThenProxy should rewrite customScreenShot paths"],
+        //   [],
+        //   [
+        //     Then.theButTheProxyReturns(
+        //       "customScreenShot",
+        //       "test/path/butThen/shot.png"
+        //     ),
+        //   ],
+        //   "customScreenShot test"
+        // ),
+        // // Edge cases
+        // emptyPathTest: Given.SomeBaseString(
+        //   ["butThenProxy should handle empty paths"],
+        //   [],
+        //   [Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/")],
+        //   "empty path test"
+        // ),
+        // nestedPathTest: Given.SomeBaseString(
+        //   ["butThenProxy should handle nested paths"],
+        //   [],
+        //   [
+        //     Then.theButTheProxyReturns(
+        //       "writeFileSync",
+        //       "test/path/butThen/nested/folder/test.txt"
+        //     ),
+        //   ],
+        //   "nested path test"
+        // ),
+        // 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
+    //   butThenProxyTest: Given.SomeBaseString(
+    //     ["butThenProxy should work correctly"],
+    //     [],
+    //     [
+    //       Then.theButTheProxyReturns(
+    //         "writeFileSync",
+    //         "test/path/butThen/test.txt"
+    //       ),
+    //     ],
+    //     "butThenProxy test"
+    //   ),
+    //   andWhenProxyTest: Given.SomeBaseString(
+    //     ["andWhenProxy should work correctly"],
+    //     [],
+    //     [
+    //       Then.theButTheProxyReturns(
+    //         "writeFileSync",
+    //         "test/path/andWhen/test.txt"
+    //       ),
+    //     ],
+    //     "andWhenProxy test"
+    //   ),
+    //   beforeEachProxyTest: Given.SomeBaseString(
+    //     ["beforeEachProxy should work correctly"],
+    //     [],
+    //     [
+    //       Then.theButTheProxyReturns(
+    //         "writeFileSync",
+    //         "suite-1/beforeEach/test.txt"
+    //       ),
+    //     ],
+    //     "beforeEachProxy test"
+    //   ),
+    //   afterEachProxyTest: Given.SomeBaseString(
+    //     ["afterEachProxy should work correctly"],
+    //     [],
+    //     [
+    //       Then.theButTheProxyReturns(
+    //         "writeFileSync",
+    //         "suite-1/given-1/afterEach/test.txt"
+    //       ),
+    //     ],
+    //     "afterEachProxy test"
+    //   ),
+    // }),
+    // Suite.Default("Content Preservation", {
+    //   // Verify content is preserved
+    //   contentPreservationTest: Given.SomeBaseString(
+    //     ["Proxies should preserve file content"],
+    //     [],
+    //     [
+    //       Then.theButTheProxyReturns(
+    //         "writeFileSync",
+    //         "test/path/butThen/test.txt"
+    //       ),
+    //       Then.verifyContent("test content"),
+    //     ],
+    //     "content preservation test"
+    //   ),
+    //   objectContentTest: Given.SomeBaseString(
+    //     ["Proxies should preserve object content"],
+    //     [],
+    //     [
+    //       Then.theButTheProxyReturns(
+    //         "screencast",
+    //         "test/path/butThen/screen.png"
+    //       ),
+    //       Then.verifyContent({ quality: 80, fullPage: true }),
+    //     ],
+    //     "object content test"
+    //   ),
+    // }),
+    // Suite.Default("Error Cases", {
+    //   invalidPathTest: Given.SomeBaseString(
+    //     ["Proxies should handle invalid paths"],
+    //     [],
+    //     [
+    //       Then.theButTheProxyReturns(
+    //         "writeFileSync",
+    //         "test/path/butThen/../invalid.txt"
+    //       ),
+    //     ],
+    //     "invalid path test"
+    //   ),
+    //   undefinedInputTest: Given.SomeBaseString(
+    //     ["Proxies should handle undefined inputs"],
+    //     [],
+    //     [Then.theButTheProxyReturns("writeFileSync", undefined)],
+    //     "undefined input test"
+    //   ),
+    // }),
+];

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export {};

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

@@ -0,0 +1,196 @@
+// import Docker from "dockerode";
+console.log("hello mothership");
+export {};
+// const app = express();
+// app.use(express.json());
+// // const docker = new Docker();
+// // Track running services
+// const runningServices = new Map();
+// // Service to build file mapping
+// const serviceBuildFiles = {
+//   "node-build": "src/builders/node.ts",
+//   "web-build": "src/builders/web.ts",
+//   "golang-build": "src/builders/golang.ts",
+//   "python-build": "src/builders/python.ts",
+// };
+// // Automatically start build services on mothership startup
+// async function initializeServices() {
+//   console.log("Initializing build services...");
+//   for (const serviceName of Object.keys(serviceBuildFiles)) {
+//     try {
+//       // Get all containers
+//       // const containers = await docker.listContainers({ all: true });
+//       // Find the container for the requested service
+//       // const containerInfo = containers.find((container) =>
+//       //   container.Names.some((name) => name.includes(serviceName))
+//       // );
+//       // if (containerInfo) {
+//       //   // const container = docker.getContainer(containerInfo.Id);
+//       //   // Start the container if it's not running
+//       //   if (containerInfo.State !== "running") {
+//       //     console.log(`Starting ${serviceName}...`);
+//       //     await container.start();
+//       //   } else {
+//       //     console.log(`${serviceName} is already running`);
+//       //   }
+//       //   runningServices.set(serviceName, containerInfo.Id);
+//       // } else {
+//       //   console.warn(`Container for ${serviceName} not found`);
+//       // }
+//     } catch (error) {
+//       console.error(`Error initializing ${serviceName}:`, error);
+//     }
+//   }
+//   console.log("Build services initialization complete");
+// }
+// // Initialize services when mothership starts
+// initializeServices();
+// app.get("/", (req, res) => {
+//   res.send("Mothership is running");
+// });
+// // Start a specific service
+// app.post("/services/:serviceName/start", async (req, res) => {
+//   const { serviceName } = req.params;
+//   try {
+//     // // Get all containers
+//     // const containers = await docker.listContainers({ all: true });
+//     // // Find the container for the requested service
+//     // const containerInfo = containers.find((container) =>
+//     //   container.Names.some((name) => name.includes(serviceName))
+//     // );
+//     // if (!containerInfo) {
+//     //   return res
+//     //     .status(404)
+//     //     .json({ error: `Service ${serviceName} not found` });
+//     // }
+//     // const container = docker.getContainer(containerInfo.Id);
+//     // // Start the container if it's not running
+//     // if (containerInfo.State !== "running") {
+//     //   await container.start();
+//     // }
+//     // runningServices.set(serviceName, containerInfo.Id);
+//     // res.status(200).json({
+//     //   status: "started",
+//     //   service: serviceName,
+//     //   containerId: containerInfo.Id,
+//     // });
+//   } catch (error) {
+//     console.error(`Error starting service ${serviceName}:`, error);
+//     res
+//       .status(500)
+//       .json({ error: `Failed to start service: ${error.message}` });
+//   }
+// });
+// // Stop a specific service
+// app.post("/services/:serviceName/stop", async (req, res) => {
+//   const { serviceName } = req.params;
+//   try {
+//     // const containerId = runningServices.get(serviceName);
+//     // if (!containerId) {
+//     //   return res
+//     //     .status(404)
+//     //     .json({ error: `Service ${serviceName} is not running` });
+//     // }
+//     // const container = docker.getContainer(containerId);
+//     // await container.stop();
+//     // runningServices.delete(serviceName);
+//     res.status(200).json({
+//       status: "stopped",
+//       service: serviceName,
+//     });
+//   } catch (error) {
+//     console.error(`Error stopping service ${serviceName}:`, error);
+//     res.status(500).json({ error: `Failed to stop service: ${error.message}` });
+//   }
+// });
+// // Get status of all services
+// app.get("/services", async (req, res) => {
+//   try {
+//     // const containers = await docker.listContainers({ all: true });
+//     // const services = containers
+//     //   .filter((container) =>
+//     //     container.Names.some((name) =>
+//     //       name.match(
+//     //         /_(node-build|web-build|golang-build|python-build|mothership)_/
+//     //       )
+//     //     )
+//     //   )
+//     //   .map((container) => ({
+//     //     name: container.Names[0].replace("/", ""),
+//     //     id: container.Id,
+//     //     status: container.State,
+//     //     image: container.Image,
+//     //   }));
+//     // res.status(200).json({ services });
+//   } catch (error) {
+//     console.error("Error listing services:", error);
+//     res
+//       .status(500)
+//       .json({ error: `Failed to list services: ${error.message}` });
+//   }
+// });
+// // Trigger a build in a specific service
+// app.post("/build/:serviceName", async (req, res) => {
+//   // const { serviceName } = req.params;
+//   // try {
+//   //   const containerId = runningServices.get(serviceName);
+//   //   if (!containerId) {
+//   //     return res
+//   //       .status(404)
+//   //       .json({ error: `Service ${serviceName} is not running` });
+//   //   }
+//   //   // const container = docker.getContainer(containerId);
+//   //   // Execute the build command in the container
+//   //   const buildFile = serviceBuildFiles[serviceName];
+//   //   if (!buildFile) {
+//   //     return res
+//   //       .status(400)
+//   //       .json({ error: `No build file configured for ${serviceName}` });
+//   //   }
+//   //   // Run the TypeScript build file using ts-node
+//   //   const exec = await container.exec({
+//   //     Cmd: ["npx", "ts-node", "--transpile-only", buildFile],
+//   //     AttachStdout: true,
+//   //     AttachStderr: true,
+//   //   });
+//   //   // Start the exec instance
+//   //   const stream = await exec.start({ hijack: true, stdin: false });
+//   //   // Collect output
+//   //   let output = "";
+//   //   stream.on("data", (chunk: Buffer) => {
+//   //     output += chunk.toString();
+//   //   });
+//   //   stream.on("end", () => {
+//   //     res.status(200).json({
+//   //       status: "build completed",
+//   //       service: serviceName,
+//   //       output: output,
+//   //     });
+//   //   });
+//   //   stream.on("error", (error) => {
+//   //     console.error(`Stream error for ${serviceName}:`, error);
+//   //     res.status(500).json({ error: `Build stream error: ${error.message}` });
+//   //   });
+//   // } catch (error) {
+//   //   console.error(`Error triggering build for ${serviceName}:`, error);
+//   //   res
+//   //     .status(500)
+//   //     .json({ error: `Failed to trigger build: ${error.message}` });
+//   // }
+// });
+// // Get build file for each service
+// app.get("/build-files", (req, res) => {
+//   res.status(200).json(serviceBuildFiles);
+// });
+// // Claim resource endpoint
+// app.get("/claim", (req, res) => {
+//   const { resource } = req.query;
+//   console.log(`Resource claimed: ${resource}`);
+//   res.status(200).json({ status: "claimed", resource });
+// });
+// export default (port: number) => {
+//   app.listen(port, () => {
+//     console.log(`Mothership listening on port ${port}`);
+//   });
+//   return app;
+// };

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

@@ -0,0 +1,80 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import Testeranto from "../Node";
+import appFactory from "./index";
+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")]),
+        }),
+    ];
+};
+const implementation = {
+    suites: { TheMothership: "idk" },
+    givens: { ItIsRunning: () => undefined },
+    whens: {
+        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.");
+        },
+        IResetTheResource: function (Iw_0) {
+            throw new Error("Function not implemented.");
+        },
+    },
+    thens: {
+        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.");
+        },
+    },
+};
+const testAdapter = {
+    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/run.js

@@ -0,0 +1,49 @@
+"use strict";
+// import ansiC from "ansi-colors";
+// import readline from "readline";
+// import { PM_Main } from "./PM/main";
+// import { ITestconfig, IBuiltConfig, IProject } from "./Types";
+// readline.emitKeypressEvents(process.stdin);
+// if (process.stdin.isTTY) process.stdin.setRawMode(true);
+// console.log(ansiC.inverse("Press 'q' to initiate a graceful shutdown."));
+// console.log(ansiC.inverse("Press 'x' to quit forcefully."));
+// process.stdin.on("keypress", (str, key) => {
+//   if (key.name === "x") {
+//     console.log(ansiC.inverse("Shutting down forcefully..."));
+//     process.exit(-1);
+//   }
+// });
+// const projectName = process.argv[2];
+// const mode = process.argv[3] as "once" | "dev";
+// if (mode !== "once" && mode !== "dev") {
+//   console.error("the 2nd argument should be 'dev' or 'once' ");
+//   process.exit(-1);
+// }
+// const f = process.cwd() + "/" + "testeranto.config.ts";
+// console.log("config file:", f);
+// import(f).then(async (module) => {
+//   const bigConfig: IProject = module.default || module;
+//   const rawConfig: ITestconfig = 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: IBuiltConfig = {
+//     ...rawConfig,
+//     buildDir: process.cwd() + "/" + `testeranto/${projectName}.json`,
+//   };
+//   const pm = new PM_Main(config, projectName, mode);
+//   pm.start();
+//   process.stdin.on("keypress", (str, key) => {
+//     if (key.name === "q") {
+//       pm.stop();
+//     }
+//   });
+// });