testeranto 0.203.0 → 0.205.0

package/src/lib/pmProxy.test/implementation.ts

@@ -1,44 +1,44 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { ITestImplementation } from "../../CoreTypes";
 import { IPM } from "../types";
-import { IProxy } from "../pmProxy";
 import { I, M, O } from "./types";
 import { MockPMBase } from "./mockPMBase";
 import { butThenProxy } from "../pmProxy";
 
 type PathRewriter = (path: string) => string;
 
-function createPathRewriter(basePath: string): PathRewriter {
-  return (path: string) => {
-    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}`;
-  };
-}
+// function createPathRewriter(basePath: string): PathRewriter {
+//   return (path: string) => {
+//     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: ITestImplementation<I, O, M> = {
   suites: {
@@ -95,95 +95,90 @@ export const implementation: ITestImplementation<I, O, M> = {
           return originalCustomScreenShot.call(mockPm, opts, testName, pageUid);
         };
 
-        try {
-          switch (method) {
-            case "writeFileSync":
-              await butThenProxy(mockPm, filepath, {}).writeFileSync(
-                "test.txt",
-                "content",
-                "test"
-              );
-              break;
-            case "createWriteStream":
-              await butThenProxy(mockPm, filepath, {}).createWriteStream(
-                "stream.txt",
-                "test"
-              );
-              break;
-            case "screencast":
-              await butThenProxy(mockPm, filepath, {}).screencast(
-                { path: "screen.png" },
-                "test"
-              );
-              break;
-            case "customScreenShot":
-              await butThenProxy(mockPm, filepath, {}).customScreenShot(
-                { path: "shot.png" },
-                "test"
-              );
-              break;
-            default:
-              throw new Error(`Unknown method: ${method}`);
-          }
-
-          // For now, just return the actual path to be asserted against expectedPath
-          // The testAdapter.assertThis will handle the comparison
-          return actualPath;
-        } catch (error) {
-          throw error;
+        switch (method) {
+          case "writeFileSync":
+            await butThenProxy(mockPm, filepath, {}).writeFileSync(
+              "test.txt",
+              "content",
+              "test"
+            );
+            break;
+          case "createWriteStream":
+            await butThenProxy(mockPm, filepath, {}).createWriteStream(
+              "stream.txt",
+              "test"
+            );
+            break;
+          case "screencast":
+            await butThenProxy(mockPm, filepath, {}).screencast(
+              { path: "screen.png" },
+              "test"
+            );
+            break;
+          case "customScreenShot":
+            await butThenProxy(mockPm, filepath, {}).customScreenShot(
+              { path: "shot.png" },
+              "test"
+            );
+            break;
+          default:
+            throw new Error(`Unknown method: ${method}`);
         }
+
+        // For now, just return the actual path to be asserted against expectedPath
+        // The testAdapter.assertThis will handle the comparison
+        return actualPath;
       },
+  },
 
-    verifyContent: (expectedContent: any) => (result: any[]) => {
-      const actualContent = result[2];
-      if (JSON.stringify(actualContent) !== JSON.stringify(expectedContent)) {
-        throw new Error(
-          `Content mismatch. Expected: ${JSON.stringify(
-            expectedContent
-          )}, Got: ${JSON.stringify(actualContent)}`
+  verifyContent: (expectedContent: any) => (result: any[]) => {
+    const actualContent = result[2];
+    if (JSON.stringify(actualContent) !== JSON.stringify(expectedContent)) {
+      throw new Error(
+        `Content mismatch. Expected: ${JSON.stringify(
+          expectedContent
+        )}, Got: ${JSON.stringify(actualContent)}`
+      );
+    }
+    return result;
+  },
+  // Test to verify tests.json is written correctly
+  verifyTestsJsonWrite: () => async (store: { pathRewriter: PathRewriter }) => {
+    const mockPm = new MockPMBase() as unknown as IPM;
+
+    // Track the actual parameters passed to writeFileSync
+    let actualArgs: any[] | undefined;
+    const originalWriteFileSync = mockPm.writeFileSync;
+    mockPm.writeFileSync = async (...args: any[]) => {
+      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 result;
-    },
-    // Test to verify tests.json is written correctly
-    verifyTestsJsonWrite:
-      () => async (store: { pathRewriter: PathRewriter }) => {
-        const mockPm = new MockPMBase() as unknown as IPM;
-
-        // Track the actual parameters passed to writeFileSync
-        let actualArgs: any[] | undefined;
-        const originalWriteFileSync = mockPm.writeFileSync;
-        mockPm.writeFileSync = async (...args: any[]) => {
-          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)}`;
-        }
-      },
+      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/src/lib/pmProxy.test/index.ts

@@ -1,4 +1,5 @@
 import Testeranto from "../../Node";
+
 import { implementation } from "./implementation";
 import { specification } from "./specification";
 import { testAdapter } from "./adapter";
@@ -8,8 +9,7 @@ import { butThenProxy, IProxy } from "../pmProxy";
 
 export type ITestProxies = { butThenProxy: IProxy };
 
-export default Testeranto<I, O, {}>(
-  // because of the nature of testeranto, we must add all the testable items here
+export default Testeranto<I, O, object>(
   {
     butThenProxy,
   },

package/src/lib/pmProxy.test/mockPM.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { MockPMBase } from "./mockPMBase";
 
 export class MockPM extends MockPMBase {

package/src/lib/pmProxy.test/mockPMBase.ts

@@ -3,7 +3,7 @@
 import { Browser } from "puppeteer-core";
 
 import { IBuiltConfig, ITLog } from "../index";
-import { PM_Base } from "../../PM/base";
+import { PM_Base } from "../../app/backend/PM_0";
 
 export class MockPMBase implements PM_Base {
   browser: Browser;

package/src/lib/pmProxy.test/specification.ts

@@ -2,8 +2,6 @@ import { ITestSpecification } from "../../CoreTypes";
 
 import { I, O } from "./types";
 
-console.log("wtf");
-
 export const specification: ITestSpecification<I, O> = (
   Suite,
   Given,

package/src/lib/pmProxy.test/types.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { ITestProxies } from ".";
 import { Ibdd_in, Ibdd_out } from "../../CoreTypes";
 

package/src/lib/pmProxy.ts

@@ -37,10 +37,7 @@ const baseProxy: IProxyBase = function (
 
         if (prop === method) {
           return (...x) => {
-            // Add debug logging
-
             const modifiedArgs = arger(...x);
-
             return (target[prop] as any)(...modifiedArgs);
           };
         }
@@ -64,20 +61,6 @@ export const butThenProxy: IProxy = (
       (opts, p) => {
         const path = `${filepath}/butThen/${opts.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 [
           {
             ...opts,
@@ -90,25 +73,6 @@ export const butThenProxy: IProxy = (
     [
       "createWriteStream",
       (fp) => {
-        // Add debug logging to see what fp is
-        // console.log(
-        //   `[DEBUG] createWriteStream fp type: ${typeof fp}, value:`,
-        //   fp
-        // );
-
-        // // Ensure fp is always a string
-        // if (typeof fp !== "string") {
-        //   console.error(
-        //     `[PROXY ERROR] createWriteStream fp is not a string:`,
-        //     fp
-        //   );
-        //   // Don't convert, just throw to find the source
-        //   throw new Error(
-        //     `createWriteStream expected string for fp, got ${typeof fp}: ${JSON.stringify(
-        //       fp
-        //     )}`
-        //   );
-        // }
         const path = `${filepath}/butThen/${fp}`;
         addArtifact(path);
         return [path];
@@ -117,17 +81,7 @@ export const butThenProxy: IProxy = (
     [
       "writeFileSync",
       (fp, contents, testName) => {
-        // Add debug logging to see what fp is
-        // console.log(`[DEBUG] writeFileSync fp type: ${typeof fp}, value:`, fp);
-
-        // Ensure fp is always a string
-        // if (typeof fp !== "string") {
-        //   console.error(`[PROXY ERROR] writeFileSync fp is not a string:`, fp);
-        //   // Don't convert, just throw to find the source
-        //   throw new Error(`writeFileSync expected string for fp, got ${typeof fp}: ${JSON.stringify(fp)}`);
-        // }
         const path = `${filepath}/butThen/${fp}`;
-        // console.log(`[DEBUG] Adding artifact: "${path}"`);
         addArtifact(path);
         return [path, contents, testName];
       },
@@ -173,19 +127,6 @@ export const andWhenProxy: IProxy = (
     [
       "createWriteStream",
       (fp) => {
-        // // Add debug logging to see what fp is
-        // console.log(
-        //   `[DEBUG] andWhen createWriteStream fp type: ${typeof fp}, value:`,
-        //   fp
-        // );
-
-        // if (typeof fp !== "string") {
-        //   throw new Error(
-        //     `andWhen createWriteStream expected string for fp, got ${typeof fp}: ${JSON.stringify(
-        //       fp
-        //     )}`
-        //   );
-        // }
         const path = `${filepath}/andWhen/${fp}`;
         addArtifact(path);
         return [path];
@@ -195,19 +136,6 @@ export const andWhenProxy: IProxy = (
     [
       "writeFileSync",
       (fp, contents, testName) => {
-        // Add debug logging to see what fp is
-        // console.log(
-        //   `[DEBUG] andWhen writeFileSync fp type: ${typeof fp}, value:`,
-        //   fp
-        // );
-
-        // if (typeof fp !== "string") {
-        //   throw new Error(
-        //     `andWhen writeFileSync expected string for fp, got ${typeof fp}: ${JSON.stringify(
-        //       fp
-        //     )}`
-        //   );
-        // }
         const path = `${filepath}/andWhen/${fp}`;
         addArtifact(path);
         return [path, contents, testName];
@@ -218,7 +146,6 @@ export const andWhenProxy: IProxy = (
       "customScreenShot",
       (opts, p) => {
         const path = `${filepath}/andWhen/${opts.path}`;
-        // console.log("STEP2", JSON.stringify(step));
         addArtifact(path);
         return [
           {
@@ -276,7 +203,6 @@ export const afterEachProxy: IProxyAfterEach = (
       (opts, p) => {
         const path = `suite-${suite}/given-${given}/afterEach/${opts.path}`;
         addArtifact(path);
-        // console.log("STEP3", JSON.stringify(step));
         return [
           {
             ...opts,

package/src/mothership/index.ts

@@ -1,11 +1,206 @@
 import express from "express";
+import Docker from "dockerode";
 
 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("Hello World!");
+  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}`);
@@ -14,7 +209,7 @@ app.get("/claim", (req, res) => {
 
 export default (port: number) => {
   app.listen(port, () => {
-    console.log(`Example app listening on port ${port}`);
+    console.log(`Mothership listening on port ${port}`);
   });
 
   return app;

package/src/mothership/test.ts

@@ -1,5 +1,8 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unused-vars */
+
+import type { Express } from "express";
+
 import {
   Ibdd_in,
   Ibdd_out,
@@ -14,8 +17,6 @@ import { PM } from "../PM";
 
 import appFactory from "./index";
 
-import type { Express } from "express";
-
 type I = Ibdd_in<
   (port: number) => Express,
   (port: number) => Express,
@@ -60,14 +61,13 @@ const specification: ITestSpecification<Ibdd_in_any, O> = (
           [When.IClaimTheResource("test")],
           [Then.TheResourceIsClaimed("test")]
         ),
-      },
-      []
+      }
     ),
   ];
 };
 
 const implementation: ITestImplementation<I, O> = {
-  suites: { TheMothership: (x) => x },
+  suites: { TheMothership: "idk" },
   givens: { ItIsRunning: () => undefined },
   whens: {
     IClaimTheResource: (resource) => async (app, tr, pm) => {