testeranto 0.219.12 → 0.219.13

package/dist/module/src/Types.js

@@ -1 +1,62 @@
 export {};
+// export type ITestconfig = {
+//   httpPort: number;
+//   featureIngestor: (s: string) => Promise<string>;
+//   importPlugins: IPluginFactory[];
+//   ports: string[];
+//   src: string;
+//   check: string;
+//   java: {
+//     plugins: any[];
+//     tests: Record<string, { ports: number }>;
+//     loaders: Record<string, string>;
+//     checks: IChecks;
+//     dockerfile: string;
+//   };
+//   rust: {
+//     plugins: any[];
+//     tests: Record<string, { ports: number }>;
+//     loaders: Record<string, string>;
+//     checks: IChecks;
+//     dockerfile: string;
+//   };
+//   ruby: {
+//     plugins: any[];
+//     tests: Record<string, { ports: number }>;
+//     loaders: Record<string, string>;
+//     checks: IChecks;
+//     dockerfile: string;
+//   };
+//   golang: {
+//     plugins: any[];
+//     tests: Record<string, { ports: number }>;
+//     loaders: Record<string, string>;
+//     checks: IChecks;
+//     dockerfile: string;
+//   };
+//   python: {
+//     plugins: any[];
+//     tests: Record<string, { ports: number }>;
+//     loaders: Record<string, string>;
+//     checks: IChecks;
+//     dockerfile: string;
+//   };
+//   node: {
+//     plugins: any[];
+//     tests: Record<string, { ports: number }>;
+//     loaders: Record<string, string>;
+//     externals: string[];
+//     checks: IChecks;
+//     dockerfile: string;
+//   };
+//   web: {
+//     plugins: any[];
+//     tests: Record<string, { ports: number }>;
+//     loaders: Record<string, string>;
+//     externals: string[];
+//     checks: IChecks;
+//     dockerfile: string;
+//   };
+// };
+// export type IBuiltConfig = { buildDir: string } & ITestconfig;
+// export type IConfig = Map<string, [IRunTime, string, string, { tests: string[] }]>

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

@@ -1,3 +1,4 @@
+// import { ITestconfig } from "../Types";
 export default (config) => {
     return {
         // packages: "external",
@@ -8,7 +9,7 @@ export default (config) => {
         outbase: ".",
         jsx: "transform",
         bundle: true,
-        minify: config.minify === true,
+        // minify: config.minify === true,
         write: true,
         loader: {
             ".js": "jsx",

package/dist/module/src/server/runtimes/node/docker.js

@@ -1,4 +1,4 @@
-export const nodeDockerComposeFile = (config, container_name, fpath) => {
+export const nodeDockerComposeFile = (config, container_name, projectConfigPath, nodeConfigPath, testName) => {
     return {
         build: {
             context: process.cwd(),
@@ -13,21 +13,22 @@ export const nodeDockerComposeFile = (config, container_name, fpath) => {
             `${process.cwd()}/dist:/workspace/dist`,
             `${process.cwd()}/testeranto:/workspace/testeranto`,
         ],
-        command: nodeBuildCommand(fpath),
+        command: nodeBuildCommand(projectConfigPath, nodeConfigPath, testName),
     };
 };
 const externalTests = true;
-export const nodeBuildCommand = (fpath) => {
+export const nodeBuildCommand = (projectConfigPath, nodeConfigPath, testName) => {
     if (externalTests) {
-        console.log("external tests", process.cwd());
+        console.log("external tests", testName);
         // return `cat node_modules/testeranto/src/server/runtimes/node/esbuild.ts`
-        return `yarn tsx node_modules/testeranto/src/server/runtimes/node/node.ts ${fpath} testeranto/testeranto.yml`;
+        return `yarn tsx node_modules/testeranto/src/server/runtimes/node/node.ts /workspace/testeranto/testeranto.ts ${nodeConfigPath} ${testName}`;
         // return `cat node_modules/testeranto/src/server/runtimes/node/node.ts`
         // return ["sh", "-c", "cd /workspace && javac -cp \".:lib/*\" src/server/runtimes/java/main.java && java -cp \"src/server/runtimes/java:.\" main"]
     }
     else {
         console.log("not external tests");
-        return `yarn tsx src/server/runtimes/node/node.ts /workspace/${fpath}`;
+        // return `yarn tsx src/server/runtimes/node/node.ts /workspace/${fpath}`;
+        return `yarn tsx src/server/runtimes/node/node.ts /workspace/testeranto/testeranto.ts  /workspace/${nodeConfigPath} ${testName}`;
     }
 };
 export const nodeBddCommand = (fpath) => {

package/dist/module/src/server/runtimes/node/esbuild.js

@@ -2,34 +2,34 @@ import featuresPlugin from "../../../esbuildConfigs/featuresPlugin.js";
 import baseEsBuildConfig from "../../../esbuildConfigs/index.js";
 import inputFilesPlugin from "../../../esbuildConfigs/inputFilesPlugin.js";
 import rebuildPlugin from "../../../esbuildConfigs/rebuildPlugin.js";
-const absoluteBundlesDir = (c) => {
+const absoluteBundlesDir = () => {
     return "./testeranto/bundles/allTests/node/";
 };
-export default (projectConfig, testName) => {
-    var _a, _b, _c;
-    console.log("mark77", projectConfig);
+export default (nodeConfig, testName, projectConfig) => {
+    var _a;
+    console.log("esbuild", testName, projectConfig);
+    const entryPoints = projectConfig.runtimes[testName].tests;
     // Get entry points from config, or use a default
-    let entrypoints = [];
-    if ((_a = projectConfig.node) === null || _a === void 0 ? void 0 : _a.tests) {
-        entrypoints = Object.keys(projectConfig.node.tests);
-    }
-    else {
-        // console.log(projectConfig)
-        throw "projectConfig.node.tests should exist";
-        // Fallback to a reasonable default
-        // entrypoints = ["./example/Calculator.test.ts"];
-        // console.warn(`No node.tests found in config, using default entry point: ${entrypoints[0]}`);
-    }
+    // let entrypoints: string[] = [];
+    // if (nodeConfig) {
+    //   entrypoints = (projectConfig.tests);
+    // } else {
+    //   // console.log(projectConfig)
+    //   throw "projectConfig.node.tests should exist"
+    //   // Fallback to a reasonable default
+    //   // entrypoints = ["./example/Calculator.test.ts"];
+    //   // console.warn(`No node.tests found in config, using default entry point: ${entrypoints[0]}`);
+    // }
     const { inputFilesPluginFactory, register } = inputFilesPlugin("node", testName);
-    return Object.assign(Object.assign({}, baseEsBuildConfig(projectConfig)), { outdir: absoluteBundlesDir(projectConfig), outbase: ".", metafile: true, supported: {
+    return Object.assign(Object.assign({}, baseEsBuildConfig(nodeConfig)), { outdir: absoluteBundlesDir(), outbase: ".", metafile: true, supported: {
             "dynamic-import": true,
         }, define: {
             "process.env.FLUENTFFMPEG_COV": "0",
             ENV: `"node"`,
-        }, bundle: true, format: "esm", absWorkingDir: process.cwd(), platform: "node", packages: "external", entryPoints: entrypoints, plugins: [
+        }, bundle: true, format: "esm", absWorkingDir: process.cwd(), platform: "node", packages: "external", entryPoints, plugins: [
             featuresPlugin,
             inputFilesPluginFactory,
             rebuildPlugin("node"),
-            ...(((_c = (_b = projectConfig.node) === null || _b === void 0 ? void 0 : _b.plugins) === null || _c === void 0 ? void 0 : _c.map((p) => p(register, entrypoints))) || []),
+            ...(((_a = nodeConfig.plugins) === null || _a === void 0 ? void 0 : _a.map((p) => p(register, entryPoints))) || []),
         ] });
 };

package/dist/module/src/server/runtimes/node/node.js

@@ -1,20 +1,22 @@
 import esbuild from "esbuild";
-import nodeConfiger from "./esbuild";
 import { processMetafile } from "../common";
+import nodeConfiger from "./esbuild";
 console.log(`[NODE BUILDER] hello:  ${process.argv}`);
-const nodeConfigPath = process.argv[2];
-const projectConfigPath = process.argv[3];
-const testName = 'idk';
+const projectConfigPath = process.argv[2];
+const nodeConfigPath = process.argv[3];
+const testName = process.argv[4];
+console.log(`[NODE BUILDER] projectConfigPath:  ${projectConfigPath}`);
 console.log(`[NODE BUILDER] nodeConfig:  ${nodeConfigPath}`);
+console.log(`[NODE BUILDER] testName:  ${testName}`);
 // run esbuild in watch mode using esbuildConfigs. Write to fs the bundle and metafile
-async function startBundling(config) {
+async function startBundling(nodeConfigs, projectConfig) {
     console.log(`[NODE BUILDER] is now bundling:  ${testName}`);
-    const n = nodeConfiger(config, testName);
+    const n = nodeConfiger(nodeConfigs, testName, projectConfig);
     const buildResult = await esbuild.build(n);
     // const metafilesDir =
     //   process.env.METAFILES_DIR || "/workspace/testeranto/metafiles/node";
     if (buildResult.metafile) {
-        await processMetafile(config, buildResult.metafile, 'node');
+        await processMetafile(projectConfig, buildResult.metafile, 'node');
     }
     else {
         console.warn("No metafile generated by esbuild");
@@ -22,8 +24,9 @@ async function startBundling(config) {
 }
 async function main() {
     try {
-        const config = (await import(nodeConfigPath)).default;
-        await startBundling(config);
+        const nodeConfigs = (await import(nodeConfigPath)).default;
+        const projectConfigs = (await import(projectConfigPath)).default;
+        await startBundling(nodeConfigs, projectConfigs);
     }
     catch (error) {
         console.error("NODE BUILDER: Error importing config:", nodeConfigPath, error);

package/dist/module/src/server/serverClasees/Server_Base.js

@@ -2,9 +2,10 @@ export class Server_Base {
     constructor(configs, mode) {
         this.configs = configs;
         this.mode = mode;
+        console.log(`[Base] ${this.configs}`);
     }
     async start() {
-        console.log(`[Server_Base] start()`);
+        // console.log(`[Server_Base] start()`)
     }
     async stop() {
         console.log(`[Server_Base] stop()`);

package/dist/module/src/server/serverClasees/Server_Docker.js

@@ -36,15 +36,15 @@ export class Server_Docker extends Server_WS {
     staticTestDockerComposeFile(runtime, container_name, command) {
         // 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 {
             build: {
@@ -65,15 +65,15 @@ export class Server_Docker extends Server_WS {
     bddTestDockerComposeFile(runtime, container_name, command) {
         // 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 = {
             build: {
@@ -119,6 +119,7 @@ export class Server_Docker extends Server_WS {
     // config: IBuiltConfig,
     ) {
         const services = {};
+        console.log("mark1");
         // // Add browser service
         // services['browser'] = {
         //   build:
@@ -153,89 +154,66 @@ export class Server_Docker extends Server_WS {
             "java": [javaDockerComposeFile, javaBuildCommand, javaBddCommand]
         };
         // Iterate through each entry in the config Map
-        for (const [runtimeTestsName, runtimeTests] of this.configs.entries()) {
-            const runtime = runtimeTests[0];
-            const dockerfile = runtimeTests[1];
-            const runtimeConfig = runtimeTests[2];
-            const testsObj = runtimeTests[3];
-            const buildCommand = runTimeToCompose[runtime][1](runtimeConfig);
-            if (RUN_TIMES.includes(runtime)) {
-                // 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}`);
-                }
-                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: {} };
-                }
-            });
-            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);
+        for (const [runtimeTestsName, runtimeTests] of Object.entries(this.configs.runtimes)) {
+            const runtime = runtimeTests.runtime;
+            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}`);
+                        }
+                        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`);
+                        }
+                    }
+                    else {
+                        throw `unknown runtime ${runtime}`;
+                    }
                 }
-                // Always add aider service
-                services[`${uid}-aider`] = this.aiderDockerComposeFile(`${uid}-aider`);
             }
         }
         // Ensure all services use the same network configuration
@@ -463,10 +441,10 @@ ${x}
         console.log(`[Server_Docker] Waiting for browser container to be healthy...`);
         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 === null || testsObj === void 0 ? void 0 : 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)));
             for (const testName of tests) {
                 // Generate the UID exactly as DockerManager does
@@ -488,10 +466,14 @@ ${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 === null || testsObj === void 0 ? void 0 : 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(".", "-")}`;
                 const bddServiceName = `${uid}-bdd`;
@@ -517,7 +499,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 === null || testsObj === void 0 ? void 0 : testsObj.tests) || {};

package/dist/module/src/testeranto.js

@@ -1,6 +1,6 @@
 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";
 const mode = process.argv[3];
 if (mode !== "once" && mode !== "dev") {
@@ -8,32 +8,33 @@ if (mode !== "once" && mode !== "dev") {
     process.exit(-1);
 }
 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 = 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]);
-            const dockerfile = String(value[1]);
-            const script = String(value[2]);
-            // The fourth element should be an object with tests
-            let testsObj = { tests: [] };
-            const fourth = value[3];
-            if (fourth && typeof fourth === 'object' && fourth !== null) {
-                const testsData = fourth;
-                if (testsData.tests && Array.isArray(testsData.tests)) {
-                    testsObj.tests = testsData.tests.map((t) => 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 = (await import('../testeranto/testeranto.ts')).default;
+    console.log("mark123", config);
     await new Server(config, mode).start();
 };
 main();

package/dist/module/testeranto/runtimes/node/node.js

@@ -1,4 +1,5 @@
 // the esbuild configuration for testeranto/node
 export default {
-    loaders: []
+    loaders: [],
+    plugins: []
 };

package/dist/module/testeranto/testeranto.js

@@ -0,0 +1,68 @@
+const config = {
+    featureIngestor: function (s) {
+        throw new Error("Function not implemented.");
+    },
+    runtimes: {
+        nodetests: ({
+            runtime: "node",
+            tests: ["example/Calculator.test.ts"],
+            checks: [
+                (x) => `yarn eslint`,
+                (x) => `yarn tsc --noEmit`,
+            ],
+            dockerfile: `testeranto/runtimes/node/node.Dockerfile`,
+            buildOptions: `testeranto/runtimes/node/node.ts`
+        }),
+        webtests: ({
+            runtime: "web",
+            tests: ["example/Calculator.test.ts"],
+            checks: [
+                (x) => `yarn eslint`,
+                (x) => `yarn tsc --noEmit`,
+            ],
+            dockerfile: `testeranto/runtimes/web/web.Dockerfile`,
+            buildOptions: `testeranto/runtimes/web/web.ts`
+        }),
+        pythontests: ({
+            runtime: "python",
+            tests: ["example/Calculator.test.py"],
+            checks: [
+                (x) => `yarn eslint`,
+                (x) => `yarn tsc --noEmit`,
+            ],
+            dockerfile: `testeranto/runtimes/python/python.Dockerfile`,
+            buildOptions: `testeranto/runtimes/python/python.ts`
+        }),
+        golangtests: ({
+            runtime: "golang",
+            tests: ["example/Calculator.test.go"],
+            checks: [
+                (x) => `yarn eslint`,
+                (x) => `yarn tsc --noEmit`,
+            ],
+            dockerfile: `testeranto/runtimes/golang/golang.Dockerfile`,
+            buildOptions: `testeranto/runtimes/golang/golang.ts`
+        }),
+        rusttests: ({
+            runtime: "rust",
+            tests: ["example/Calculator.test.rs"],
+            checks: [
+                (x) => `yarn eslint`,
+                (x) => `yarn tsc --noEmit`,
+            ],
+            dockerfile: `testeranto/runtimes/rust/rust.Dockerfile`,
+            buildOptions: `testeranto/runtimes/rust/rust.ts`
+        }),
+        rubytests: ({
+            runtime: "ruby",
+            tests: ["example/Calculator.test.rb"],
+            checks: [
+                (x) => `yarn eslint`,
+                (x) => `yarn tsc --noEmit`,
+            ],
+            dockerfile: `testeranto/runtimes/ruby/ruby.Dockerfile`,
+            buildOptions: `testeranto/runtimes/ruby/ruby.ts`
+        }),
+    },
+};
+export default config;