testeranto 0.219.11 → 0.219.13

package/src/server/serverClasees/Server_Docker.ts

@@ -5,7 +5,7 @@ import yaml from "js-yaml";
 import path from "path";
 import { promisify } from "util";
 import { RUN_TIMES } from "../../runtimes";
-import { IConfig, IRunTime } from "../../Types";
+import { ITestconfigV2, IRunTime } from "../../Types";
 import { golangBddCommand, golangBuildCommand, golangDockerComposeFile } from "../runtimes/golang/docker";
 import { javaBddCommand, javaBuildCommand, javaDockerComposeFile } from "../runtimes/java/docker";
 import { nodeBddCommand, nodeBuildCommand, nodeDockerComposeFile } from "../runtimes/node/docker";
@@ -28,7 +28,7 @@ export interface IDockerComposeResult {
 export class Server_Docker extends Server_WS {
   private logProcesses: Map<string, { process: any; serviceName: string }> = new Map();
 
-  constructor(configs: IConfig, mode: IMode) {
+  constructor(configs: ITestconfigV2, mode: IMode) {
     super(configs, mode);
   }
 
@@ -49,19 +49,18 @@ export class Server_Docker extends Server_WS {
   }
 
   staticTestDockerComposeFile(runtime: IRunTime, container_name: string, command: string) {
-
     // Find the dockerfile path from configs
     let dockerfilePath = '';
-    for (const [key, value] of this.configs.entries()) {
-      if (value[0] === runtime) {
-        dockerfilePath = value[1];
+    for (const [key, value] of Object.entries(this.configs.runtimes)) {
+      if (value.runtime === runtime) {
+        dockerfilePath = value.dockerfile;
         break;
       }
     }
 
     // If no dockerfile found, use a default based on runtime
     if (!dockerfilePath) {
-      throw (`no dockerfile found for ${dockerfilePath}`)
+      throw (`[Docker] [staticTestDockerComposeFile] no dockerfile found for ${dockerfilePath}, ${Object.entries(this.configs)}`)
     }
 
     return {
@@ -83,16 +82,16 @@ export class Server_Docker extends Server_WS {
   bddTestDockerComposeFile(runtime: IRunTime, container_name: string, command: string) {
     // Find the dockerfile path from configs
     let dockerfilePath = '';
-    for (const [key, value] of this.configs.entries()) {
-      if (value[0] === runtime) {
-        dockerfilePath = value[1];
+    for (const [key, value] of Object.entries(this.configs.runtimes)) {
+      if (value.runtime === runtime) {
+        dockerfilePath = value.dockerfile;
         break;
       }
     }
 
     // If no dockerfile found, use a default based on runtime
     if (!dockerfilePath) {
-      throw (`no dockerfile found for ${dockerfilePath}`)
+      throw (`[Docker] [bddTestDockerComposeFile] no dockerfile found for ${dockerfilePath}, ${Object.entries(this.configs)}`)
     }
 
     const service: any = {
@@ -141,6 +140,7 @@ export class Server_Docker extends Server_WS {
   ): Record<string, any> {
     const services: IService = {};
 
+    console.log("mark1")
     // // Add browser service
     // services['browser'] = {
 
@@ -172,12 +172,14 @@ export class Server_Docker extends Server_WS {
 
     const runTimeToCompose: Record<IRunTime, [
       (
-        config: IConfig,
+        config: ITestconfigV2,
         container_name: string,
-        fpath: string
+        projectConfigPath: string,
+        nodeConfigPath: string,
+        testName: string
       ) => object,
 
-      (fpath: string) => string,
+      (projectConfig: string, nodeConfigPath: string, testname: string) => string,
       (fpath: string) => string,
     ]> = {
       'node': [nodeDockerComposeFile, nodeBuildCommand, nodeBddCommand],
@@ -190,103 +192,88 @@ export class Server_Docker extends Server_WS {
     };
 
     // Iterate through each entry in the config Map
-    for (const [runtimeTestsName, runtimeTests] of this.configs.entries()) {
-      const runtime: IRunTime = runtimeTests[0];
-      const dockerfile = runtimeTests[1];
-      const runtimeConfig = runtimeTests[2];
-      const testsObj = runtimeTests[3];
+    for (const [runtimeTestsName, runtimeTests] of Object.entries(this.configs.runtimes)) {
+
+      const runtime: IRunTime = runtimeTests.runtime as IRunTime;
+      const dockerfile = runtimeTests.dockerfile;
+      const buildOptions = runtimeTests.buildOptions;
+      const testsObj = runtimeTests.tests
+
+      // loop over all suites which are of the right runtime
+      for (const [t, c] of Object.entries(this.configs.runtimes)) {
+        if (c.runtime === runtime) {
+          if (RUN_TIMES.includes(runtime)) {
+            const buildCommand = runTimeToCompose[runtime][1](
+              buildOptions,
+              c.buildOptions,
+              runtimeTestsName
+            )
+
+            // Add builder service for this runtime
+            const builderServiceName = `${runtime}-builder`;
+
+            // Ensure dockerfile path is valid and exists
+            let dockerfilePath = dockerfile;
+            const fullDockerfilePath = path.join(process.cwd(), dockerfilePath);
+            if (!fs.existsSync(fullDockerfilePath)) {
+              throw (`[Server_Docker] Dockerfile not found at ${fullDockerfilePath}`);
 
-      const buildCommand = runTimeToCompose[runtime][1](runtimeConfig)
+            }
 
-      if (RUN_TIMES.includes(runtime)) {
-        // Add builder service for this runtime
-        const builderServiceName = `${runtime}-builder`;
+            services[builderServiceName] = {
+              build: {
+                context: process.cwd(),
+                dockerfile: dockerfilePath,
+              },
+              container_name: builderServiceName,
+              environment: {},
+              working_dir: "/workspace",
+              volumes: [
+                `${process.cwd()}/src:/workspace/src`,
+                `${process.cwd()}/example:/workspace/example`,
+                `${process.cwd()}/dist:/workspace/dist`,
+                `${process.cwd()}/testeranto:/workspace/testeranto`,
+              ],
+              command: buildCommand,
+              networks: ["allTests_network"],
+            };
+
+
+            for (const tName of testsObj) {
+              // Clean the test name for use in container names
+              // Handle numeric test names (like '0') by converting to string
+              // const testNameStr = String(testName);
+              const cleanTestName = tName.toLowerCase()
+                .replaceAll("/", "_")
+                .replaceAll(".", "-")
+                .replace(/[^a-z0-9_-]/g, '');
+
+              // Generate UID using the runtimeTestsName (e.g., 'nodeTests') and clean test name
+              const uid = `${runtimeTestsName.toLowerCase()}-${cleanTestName}`;
+
+              // Add BDD service for this test
+              const bddCommandFunc = runTimeToCompose[runtime][2];
+              // TODO find filepath
+              // const filePath = "testeranto/bundles/allTests/ruby/example/Calculator.test.rb"
+
+              const filePath = `testeranto/bundles/allTests/${runtime}/${tName}`
+              const command = bddCommandFunc(filePath)
+              console.log("wtf command", command)
+
+              services[`${uid}-bdd`] = this.bddTestDockerComposeFile(runtime, `${uid}-bdd`, command);
+              services[`${uid}-aider`] = this.aiderDockerComposeFile(`${uid}-aider`);
+            }
 
-        // Ensure dockerfile path is valid and exists
-        let dockerfilePath = dockerfile;
-        const fullDockerfilePath = path.join(process.cwd(), dockerfilePath);
-        if (!fs.existsSync(fullDockerfilePath)) {
-          throw (`[Server_Docker] Dockerfile not found at ${fullDockerfilePath}`);
 
-        }
 
-        services[builderServiceName] = {
-          build: {
-            context: process.cwd(),
-            dockerfile: dockerfilePath,
-          },
-          container_name: builderServiceName,
-          environment: {},
-          working_dir: "/workspace",
-          volumes: [
-            `${process.cwd()}/src:/workspace/src`,
-            `${process.cwd()}/example:/workspace/example`,
-            `${process.cwd()}/dist:/workspace/dist`,
-            `${process.cwd()}/testeranto:/workspace/testeranto`,
-          ],
-          command: buildCommand,
-          networks: ["allTests_network"],
-        };
 
-      } else {
-        throw `unknown runtime ${runtime}`;
-      }
-
-      const testEntries = testsObj.tests.map(test => {
-        if (typeof test === 'string') {
-          return { name: test, config: {} };
-        } else if (test && typeof test === 'object') {
-          return {
-            name: test.name || test.testName || 'unknown',
-            config: test
-          };
-        } else {
-          return { name: String(test), config: {} };
-        }
-      });
+          } else {
+            throw `unknown runtime ${runtime}`;
+          }
 
-      for (const { name: testName, config: testConfig } of testEntries) {
-        // Clean the test name for use in container names
-        // Handle numeric test names (like '0') by converting to string
-        const testNameStr = String(testName);
-        const cleanTestName = testNameStr.toLowerCase()
-          .replaceAll("/", "_")
-          .replaceAll(".", "-")
-          .replace(/[^a-z0-9_-]/g, '');
-
-        // Generate UID using the runtimeTestsName (e.g., 'nodeTests') and clean test name
-        const uid = `${runtimeTestsName}-${cleanTestName}`;
-
-        // Add BDD service for this test
-        const bddCommandFunc = runTimeToCompose[runtime][2];
-        // TODO find filepath
-        // const filePath = "testeranto/bundles/allTests/ruby/example/Calculator.test.rb"
-
-        console.log("mark8", testName)
-        const filePath = `testeranto/bundles/allTests/${runtime}/${testName}`
-        console.log("mark4", filePath)
-
-        const command = bddCommandFunc(filePath)
-
-        // // Determine the file path to pass to bddCommandFunc
-        // let filePath = "";
-        // if (typeof testConfig === 'string') {
-        //   filePath = testConfig;
-        // } else if (testConfig && typeof testConfig === 'object') {
-        //   // Try to get path or entryPoint from test config
-        //   filePath = testConfig.path || testConfig.entryPoint || "";
-        // }
-
-        // const command = bddCommandFunc ? bddCommandFunc(filePath) : "";
-
-        // Only add BDD service if we have a command
-        if (command) {
-          services[`${uid}-bdd`] = this.bddTestDockerComposeFile(runtime, `${uid}-bdd`, command);
         }
-
-        // Always add aider service
-        services[`${uid}-aider`] = this.aiderDockerComposeFile(`${uid}-aider`);
       }
+
     }
 
     // Ensure all services use the same network configuration
@@ -553,10 +540,10 @@ ${x}
     await this.waitForContainerHealthy('browser-allTests', 60000); // 60 seconds max
 
     // Start aider services
-    for (const [configKey, configValue] of this.configs.entries()) {
-      const runtime = configValue[0];
-      const testsObj = configValue[3];
-      const tests = testsObj?.tests || {};
+    for (const [configKey, configValue] of Object.entries(this.configs.runtimes)) {
+      const runtime = configValue.runtime
+      // const testsObj = configValue[3];
+      const tests = configValue.tests
 
       console.log(`[Server_Docker] Found tests for ${runtime}:`, (JSON.stringify(tests)));
 
@@ -582,10 +569,17 @@ ${x}
 
     // Start BDD test services
     // TODO these logs  from these services should be saved into reports
-    for (const [configKey, configValue] of this.configs.entries()) {
-      const runtime = configValue[0];
-      const testsObj = configValue[3];
-      const tests = testsObj?.tests || {};
+    for (const [configKey, configValue] of Object.entries(this.configs.runtimes)) {
+
+      const runtime = configValue.runtime
+      // const testsObj = configValue[3];
+      const tests = configValue.tests
+
+      console.log(`[Server_Docker] Found tests for ${runtime}:`, (JSON.stringify(tests)));
+
+      // const runtime = configValue[0];
+      // const testsObj = configValue[3];
+      // const tests = testsObj?.tests || {};
 
       for (const testName of tests) {
         const uid = `${configKey}-${testName.toLowerCase().replaceAll("/", "_").replaceAll(".", "-")}`;
@@ -615,7 +609,7 @@ ${x}
 
     // Start static test services
     // TODO these logs  from these services should be saved into reports
-    for (const [configKey, configValue] of this.configs.entries()) {
+    for (const [configKey, configValue] of Object.entries(this.configs)) {
       const runtime = configValue[0];
       const testsObj = configValue[3];
       const tests = testsObj?.tests || {};

package/src/server/serverClasees/Server_HTTP.ts

@@ -13,7 +13,7 @@ import { IMode } from "../types";
 import { CONTENT_TYPES, getContentType } from "../serverManagers/tcp";
 import { HttpManager } from "../serverManagers/HttpManager";
 import { Server_Base } from "./Server_Base";
-import { IConfig } from "../../Types";
+import { ITestconfigV2 } from "../../Types";
 
 export abstract class Server_HTTP extends Server_Base {
 
@@ -21,7 +21,7 @@ export abstract class Server_HTTP extends Server_Base {
   protected httpServer: http.Server;
   routes: any;
 
-  constructor(configs: IConfig, mode: IMode) {
+  constructor(configs: ITestconfigV2, mode: IMode) {
     super(configs, mode);
     // this.http = new HttpManager();
     this.httpServer = http.createServer();

package/src/server/serverClasees/Server_WS.ts

@@ -4,14 +4,14 @@ import { WebSocket, WebSocketServer } from "ws";
 import { WsManager } from "../serverManagers/WsManager";
 import { IMode } from "../types";
 import { Server_HTTP } from "./Server_HTTP";
-import { IConfig } from "../../Types";
+import { ITestconfigV2 } from "../../Types";
 
 export class Server_WS extends Server_HTTP {
   protected ws: WebSocketServer;
   protected wsClients: Set<WebSocket> = new Set();
   wsManager: WsManager
 
-  constructor(configs: IConfig, mode: IMode) {
+  constructor(configs: ITestconfigV2, mode: IMode) {
     super(configs, mode);
 
     this.ws = new WebSocketServer({

package/src/testeranto.ts

@@ -1,8 +1,8 @@
 const fs = await import('fs/promises');
-const yaml = await import('yaml');
-import path from "path";
+// const yaml = await import('yaml');
+// import path from "path";
 import { Server } from "./server/serverClasees/Server";
-import { IConfig, IRunTime } from "./Types";
+import { IRunTime, ITestconfigV2 } from "./Types";
 
 const mode = process.argv[3] as "once" | "dev";
 if (mode !== "once" && mode !== "dev") {
@@ -11,35 +11,40 @@ if (mode !== "once" && mode !== "dev") {
 }
 
 const main = async () => {
-  const yamlPath = path.join(process.cwd(), 'testeranto/testeranto.yml');
-  const yamlContent = await fs.readFile(yamlPath, 'utf-8');
-  const parsed = yaml.parse(yamlContent);
-
-  const config: IConfig = new Map();
-  for (const [key, value] of Object.entries(parsed)) {
-    if (Array.isArray(value) && value.length >= 4) {
-      // The first three elements are runtime, dockerfile, script
-      const runtime = String(value[0]) as IRunTime;
-      const dockerfile = String(value[1]);
-      const script = String(value[2]);
-      
-      // The fourth element should be an object with tests
-      let testsObj = { tests: [] as string[] };
-      const fourth = value[3];
-      if (fourth && typeof fourth === 'object' && fourth !== null) {
-        const testsData = fourth as any;
-        if (testsData.tests && Array.isArray(testsData.tests)) {
-          testsObj.tests = testsData.tests.map((t: any) => String(t));
-        }
-      }
-      
-      config.set(key, [runtime, dockerfile, script, testsObj]);
-    } else {
-      console.warn(`Skipping entry ${key}: expected array with at least 4 elements, got`, value);
-    }
-  }
-
-  console.log('Parsed config:', Array.from(config.entries()));
+  // const yamlPath = path.join(process.cwd(), 'testeranto/testeranto.yml');
+  // const yamlContent = await fs.readFile(yamlPath, 'utf-8');
+  // const parsed = yaml.parse(yamlContent);
+
+  // const config: ITestconfigV2 = new Map();
+
+  // for (const [key, value] of Object.entries(parsed)) {
+  //   if (Array.isArray(value) && value.length >= 4) {
+  //     // The first three elements are runtime, dockerfile, script
+  //     const runtime = String(value[0]) as IRunTime;
+  //     const dockerfile = String(value[1]);
+  //     const script = String(value[2]);
+
+  //     // The fourth element should be an object with tests
+  //     let testsObj = { tests: [] as string[] };
+  //     const fourth = value[3];
+  //     if (fourth && typeof fourth === 'object' && fourth !== null) {
+  //       const testsData = fourth as any;
+  //       if (testsData.tests && Array.isArray(testsData.tests)) {
+  //         testsObj.tests = testsData.tests.map((t: any) => String(t));
+  //       }
+  //     }
+
+  //     config.set(key, [runtime, dockerfile, script, testsObj]);
+  //   } else {
+  //     console.warn(`Skipping entry ${key}: expected array with at least 4 elements, got`, value);
+  //   }
+  // }
+
+  // console.log('Parsed config:', Array.from(config.entries()));
+
+  const config: ITestconfigV2 = (await import('../testeranto/testeranto.ts')).default;
+
+  console.log("mark123", config)
   await new Server(config, mode).start();
 }
 

package/testeranto/bundles/allTests/node/{Node-JOOBJDHW.mjs → Node-MSIIDKGC.mjs}

@@ -8,15 +8,19 @@ import fs from "fs";
 
 // src/lib/tiposkripto/BaseGiven.ts
 var BaseGiven = class {
-  constructor(features, whens, thens, givenCB, initialValues) {
-    this.artifacts = [];
-    this.features = features;
-    this.whens = whens;
-    this.thens = thens;
-    this.givenCB = givenCB;
-    this.initialValues = initialValues;
-    this.fails = 0;
-  }
+  features;
+  whens;
+  thens;
+  error;
+  fail;
+  store;
+  recommendedFsPath;
+  givenCB;
+  initialValues;
+  key;
+  failed;
+  artifacts = [];
+  status;
   addArtifact(path) {
     if (typeof path !== "string") {
       throw new Error(
@@ -28,6 +32,14 @@ var BaseGiven = class {
     const normalizedPath = path.replace(/\\/g, "/");
     this.artifacts.push(normalizedPath);
   }
+  constructor(features, whens, thens, givenCB, initialValues) {
+    this.features = features;
+    this.whens = whens;
+    this.thens = thens;
+    this.givenCB = givenCB;
+    this.initialValues = initialValues;
+    this.fails = 0;
+  }
   beforeAll(store) {
     return store;
   }
@@ -105,17 +117,14 @@ var BaseGiven = class {
 
 // src/lib/tiposkripto/BaseSuite.ts
 var BaseSuite = class {
-  constructor(name, index, givens = {}) {
-    this.artifacts = [];
-    const suiteName = name || "testSuite";
-    if (!suiteName) {
-      throw new Error("BaseSuite requires a non-empty name");
-    }
-    this.name = suiteName;
-    this.index = index;
-    this.givens = givens;
-    this.fails = 0;
-  }
+  name;
+  givens;
+  store;
+  testResourceConfiguration;
+  index;
+  failed;
+  fails;
+  artifacts = [];
   addArtifact(path) {
     if (typeof path !== "string") {
       throw new Error(
@@ -127,6 +136,16 @@ var BaseSuite = class {
     const normalizedPath = path.replace(/\\/g, "/");
     this.artifacts.push(normalizedPath);
   }
+  constructor(name, index, givens = {}) {
+    const suiteName = name || "testSuite";
+    if (!suiteName) {
+      throw new Error("BaseSuite requires a non-empty name");
+    }
+    this.name = suiteName;
+    this.index = index;
+    this.givens = givens;
+    this.fails = 0;
+  }
   features() {
     try {
       const features = Object.keys(this.givens).map((k) => this.givens[k].features).flat().filter((value, index, array) => {
@@ -214,8 +233,12 @@ var BaseSuite = class {
 
 // src/lib/tiposkripto/BaseThen.ts
 var BaseThen = class {
+  name;
+  thenCB;
+  error;
+  artifacts = [];
+  status;
   constructor(name, thenCB) {
-    this.artifacts = [];
     this.name = name;
     this.thenCB = thenCB;
     this.error = false;
@@ -274,11 +297,11 @@ var BaseThen = class {
 
 // src/lib/tiposkripto/BaseWhen.ts
 var BaseWhen = class {
-  constructor(name, whenCB) {
-    this.artifacts = [];
-    this.name = name;
-    this.whenCB = whenCB;
-  }
+  name;
+  whenCB;
+  error;
+  artifacts = [];
+  status;
   addArtifact(path) {
     if (typeof path !== "string") {
       throw new Error(
@@ -290,6 +313,10 @@ var BaseWhen = class {
     const normalizedPath = path.replace(/\\/g, "/");
     this.artifacts.push(normalizedPath);
   }
+  constructor(name, whenCB) {
+    this.name = name;
+    this.whenCB = whenCB;
+  }
   toObj() {
     const obj = {
       name: this.name,
@@ -320,9 +347,18 @@ ${this.error.stack}` : null,
 
 // src/lib/tiposkripto/BaseTiposkripto.ts
 var BaseTiposkripto = class {
+  totalTests = 0;
+  artifacts = [];
+  assertThis;
+  givenOverrides;
+  specs;
+  suitesOverrides;
+  testJobs;
+  testResourceRequirement;
+  testSpecification;
+  thenOverrides;
+  whenOverrides;
   constructor(webOrNode, input, testSpecification, testImplementation, testResourceRequirement = defaultTestResourceRequirement, testAdapter = {}, testResourceConfiguration, wsPort = "3456", wsHost = "localhost") {
-    this.totalTests = 0;
-    this.artifacts = [];
     this.testResourceConfiguration = testResourceConfiguration;
     const fullAdapter = DefaultAdapter(testAdapter);
     if (!testImplementation.suites || typeof testImplementation.suites !== "object") {