testeranto 0.129.0 → 0.135.0

package/src/Node.ts

@@ -4,21 +4,37 @@ import {
   ITTestResourceConfiguration,
   ITTestResourceRequest,
 } from "./lib/index.js";
-import type {
-  INodeTestInterface,
-  IT,
+import type {} from // INodeTestInterface,
+// IT,
+// ITestImplementation,
+// ITestInterface,
+// ITestSpecification,
+// OT,
+"./Types.js";
+import { PM_Node } from "./PM/node.js";
+import {
+  ITestSpecification,
   ITestImplementation,
   ITestInterface,
-  ITestSpecification,
-  OT,
-} from "./Types.js";
-import { PM_Node } from "./PM/node.js";
+  Ibdd_in,
+  Ibdd_out,
+} from "./CoreTypes.js";
+
+let ipcfile;
 
-export class NodeTesteranto<I extends IT, O extends OT, M> extends Testeranto<
-  I,
-  O,
+export class NodeTesteranto<
+  I extends Ibdd_in<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown
+  >,
+  O extends Ibdd_out,
   M
-> {
+> extends Testeranto<I, O, M> {
   constructor(
     input: I["iinput"],
     testSpecification: ITestSpecification<I, O>,
@@ -40,7 +56,7 @@ export class NodeTesteranto<I extends IT, O extends OT, M> extends Testeranto<
 
   async receiveTestResourceConfig(partialTestResource: string) {
     const t: ITTestResourceConfiguration = JSON.parse(partialTestResource);
-    const pm = new PM_Node(t);
+    const pm = new PM_Node(t, ipcfile);
     return await this.testJobs[0].receiveTestResourceConfig(pm);
     // const { failed, artifacts, logPromise, features } =
     //   await this.testJobs[0].receiveTestResourceConfig(pm);
@@ -67,16 +83,17 @@ const testeranto = async <I extends IT, O extends OT, M>(
   process.on("unhandledRejection", (reason, promise) => {
     console.error("Unhandled Rejection at:", promise, "reason:", reason);
     // Optionally, terminate the process or perform cleanup
+    // t.registerUncaughtPromise(reason, promise);
   });
 
   try {
-    console.log(process.argv);
+    ipcfile = process.argv[3];
     const f = await t.receiveTestResourceConfig(process.argv[2]);
 
-    console.error("goodbye node error", f.fails);
+    console.error("goodbye node with failures", f.fails);
     process.exit(f.fails);
   } catch (e) {
-    console.error("goodbye node error", e);
+    console.error("goodbye node with caught error", e);
     process.exit(-1);
 
     // fs.writeFileSync(`tests.json`, JSON.stringify(t.,

package/src/NodeSidecar.ts

@@ -0,0 +1,22 @@
+import { Sidecar } from "./lib/Sidecar";
+import { PM_Node_Sidecar } from "./PM/nodeSidecar";
+
+export abstract class NodeSidecar extends Sidecar {
+  pm: PM_Node_Sidecar;
+
+  constructor(t) {
+    super();
+    this.pm = new PM_Node_Sidecar(t);
+    this.pm.start(this.stop).then(() => {
+      this.start(JSON.parse(process.argv[2]));
+    });
+  }
+  // start(t: ITTestResourceConfiguration) {
+  //   throw new Error("Method not implemented.");
+  // }
+  // stop() {
+  //   console.log("NewSideCar stop");
+  //   // process.exit();
+  //   throw new Error("STOP not implemented.");
+  // }
+}

package/src/PM/PM_WithEslintAndTsc.ts

@@ -0,0 +1,315 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* eslint-disable no-async-promise-executor */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+import ts from "typescript";
+import fs from "fs";
+import path from "path";
+import ansiC from "ansi-colors";
+import { ESLint } from "eslint";
+import tsc from "tsc-prog";
+
+import { lintPather, promptPather, tscPather } from "../utils";
+import { IBuiltConfig, IRunTime, ISummary } from "../Types.js";
+
+import { PM_Base } from "./base.js";
+
+const eslint = new ESLint();
+const formatter = await eslint.loadFormatter(
+  "./node_modules/testeranto/dist/prebuild/esbuildConfigs/eslint-formatter-testeranto.mjs"
+);
+
+export abstract class PM_WithEslintAndTsc extends PM_Base {
+  name: string;
+  mode: "once" | "dev";
+  summary: ISummary = {};
+
+  constructor(configs: IBuiltConfig, name: string, mode: "once" | "dev") {
+    super(configs);
+
+    this.name = name;
+    this.mode = mode;
+
+    this.configs.tests.forEach(([t, rt, tr, sidecars]) => {
+      this.summary[t] = {
+        runTimeError: "?",
+        typeErrors: "?",
+        staticErrors: "?",
+        prompt: "?",
+        failingFeatures: {},
+      };
+      sidecars.forEach(([t]) => {
+        this.summary[t] = {
+          // runTimeError: "?",
+          typeErrors: "?",
+          staticErrors: "?",
+          // prompt: "?",
+          // failingFeatures: {},
+        };
+      });
+    });
+  }
+
+  tscCheck = async ({
+    entrypoint,
+    addableFiles,
+    platform,
+  }: {
+    platform: IRunTime;
+    entrypoint: string;
+    addableFiles: string[];
+  }) => {
+    console.log(ansiC.green(ansiC.inverse(`tsc < ${entrypoint}`)));
+    this.typeCheckIsRunning(entrypoint);
+
+    const program = tsc.createProgramFromConfig({
+      basePath: process.cwd(), // always required, used for relative paths
+      configFilePath: "tsconfig.json", // config to inherit from (optional)
+      compilerOptions: {
+        outDir: tscPather(entrypoint, platform, this.name),
+        // declaration: true,
+        // skipLibCheck: true,
+        noEmit: true,
+      },
+      include: addableFiles, //["src/**/*"],
+      // exclude: ["node_modules", "../testeranto"],
+      // exclude: ["**/*.test.ts", "**/*.spec.ts"],
+    });
+    const tscPath = tscPather(entrypoint, platform, this.name);
+
+    const allDiagnostics = program.getSemanticDiagnostics();
+
+    const results: string[] = [];
+    allDiagnostics.forEach((diagnostic) => {
+      if (diagnostic.file) {
+        const { line, character } = ts.getLineAndCharacterOfPosition(
+          diagnostic.file,
+          diagnostic.start!
+        );
+        const message = ts.flattenDiagnosticMessageText(
+          diagnostic.messageText,
+          "\n"
+        );
+        results.push(
+          `${diagnostic.file.fileName} (${line + 1},${
+            character + 1
+          }): ${message}`
+        );
+      } else {
+        results.push(
+          ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n")
+        );
+      }
+    });
+
+    fs.writeFileSync(tscPath, results.join("\n"));
+
+    this.typeCheckIsNowDone(entrypoint, results.length);
+  };
+
+  eslintCheck = async (
+    entrypoint: string,
+    platform: IRunTime,
+    addableFiles: string[]
+  ) => {
+    console.log(ansiC.green(ansiC.inverse(`eslint < ${entrypoint}`)));
+    this.lintIsRunning(entrypoint);
+
+    const results = (await eslint.lintFiles(addableFiles))
+      .filter((r) => r.messages.length)
+      .filter((r) => {
+        return r.messages[0].ruleId !== null;
+      })
+      .map((r) => {
+        delete r.source;
+        return r;
+      });
+
+    fs.writeFileSync(
+      lintPather(entrypoint, platform, this.name),
+      await formatter.format(results)
+    );
+    this.lintIsNowDone(entrypoint, results.length);
+  };
+
+  makePrompt = async (
+    entryPoint: string,
+    addableFiles: string[],
+    platform: IRunTime
+  ) => {
+    this.summary[entryPoint].prompt = "?";
+    const promptPath = promptPather(entryPoint, platform, this.name);
+
+    const testPaths = path.join(
+      "testeranto",
+      "reports",
+      this.name,
+      entryPoint.split(".").slice(0, -1).join("."),
+      platform,
+      `tests.json`
+    );
+
+    const featuresPath = path.join(
+      "testeranto",
+      "reports",
+      this.name,
+      platform,
+      entryPoint.split(".").slice(0, -1).join("."),
+      `featurePrompt.txt`
+    );
+
+    const logPath = path.join(
+      "testeranto",
+      "reports",
+      this.name,
+      entryPoint.split(".").slice(0, -1).join("."),
+      platform,
+      `console_log.txt`
+    );
+
+    const lintPath = path.join(
+      "testeranto",
+      "reports",
+      this.name,
+      entryPoint.split(".").slice(0, -1).join("."),
+      platform,
+      `lint_errors.json`
+    );
+
+    const typePath = path.join(
+      "testeranto",
+      "reports",
+      this.name,
+      entryPoint.split(".").slice(0, -1).join("."),
+      platform,
+      `type_errors.txt`
+    );
+
+    const messagePath = path.join(
+      "testeranto",
+      "reports",
+      this.name,
+      entryPoint.split(".").slice(0, -1).join("."),
+      platform,
+      `message`
+    );
+
+    fs.writeFileSync(
+      promptPath,
+      `
+${addableFiles
+  .map((x) => {
+    return `/add ${x}`;
+  })
+  .join("\n")}
+
+/read ${testPaths}
+/read ${logPath}
+/read ${typePath}
+/read ${lintPath}
+`
+    );
+
+    fs.writeFileSync(
+      messagePath,
+      `Fix the failing tests described in ${testPaths} and ${logPath}. DO NOT refactor beyond what is necessary. Always prefer minimal changes, focusing mostly on keeping the BDD tests passing`
+    );
+
+    this.summary[
+      entryPoint
+    ].prompt = `aider --model deepseek/deepseek-chat --load testeranto/${
+      this.name
+    }/reports/${platform}/${entryPoint
+      .split(".")
+      .slice(0, -1)
+      .join(".")}/prompt.txt`;
+    this.checkForShutdown();
+  };
+
+  typeCheckIsRunning = (src: string) => {
+    this.summary[src].typeErrors = "?";
+  };
+
+  typeCheckIsNowDone = (src: string, failures: number) => {
+    this.summary[src].typeErrors = failures;
+    this.writeBigBoard();
+    this.checkForShutdown();
+  };
+
+  lintIsRunning = (src: string) => {
+    this.summary[src].staticErrors = "?";
+    this.writeBigBoard();
+  };
+
+  lintIsNowDone = (src: string, failures: number) => {
+    this.summary[src].staticErrors = failures;
+    this.writeBigBoard();
+    this.checkForShutdown();
+  };
+
+  bddTestIsRunning = (src: string) => {
+    this.summary[src].runTimeError = "?";
+    this.writeBigBoard();
+  };
+
+  bddTestIsNowDone = (src: string, failures: number) => {
+    this.summary[src].runTimeError = failures;
+    this.writeBigBoard();
+    this.checkForShutdown();
+  };
+
+  writeBigBoard = () => {
+    fs.writeFileSync(
+      `./testeranto/reports/${this.name}/summary.json`,
+      JSON.stringify(this.summary, null, 2)
+    );
+  };
+
+  checkForShutdown = () => {
+    console.log(ansiC.inverse(`checkForShutdown`));
+
+    this.writeBigBoard();
+
+    if (this.mode === "dev") return;
+
+    let inflight = false;
+
+    Object.keys(this.summary).forEach((k) => {
+      if (this.summary[k].prompt === "?") {
+        console.log(ansiC.blue(ansiC.inverse(`🕕 prompt ${k}`)));
+        inflight = true;
+      }
+    });
+
+    Object.keys(this.summary).forEach((k) => {
+      if (this.summary[k].runTimeError === "?") {
+        console.log(ansiC.blue(ansiC.inverse(`🕕 runTimeError ${k}`)));
+        inflight = true;
+      }
+    });
+
+    Object.keys(this.summary).forEach((k) => {
+      if (this.summary[k].staticErrors === "?") {
+        console.log(ansiC.blue(ansiC.inverse(`🕕 staticErrors ${k}`)));
+        inflight = true;
+      }
+    });
+
+    Object.keys(this.summary).forEach((k) => {
+      if (this.summary[k].typeErrors === "?") {
+        console.log(ansiC.blue(ansiC.inverse(`🕕 typeErrors ${k}`)));
+        inflight = true;
+      }
+    });
+
+    this.writeBigBoard();
+
+    if (!inflight) {
+      this.browser.disconnect().then(() => {
+        console.log(ansiC.inverse(`${this.name} has been tested. Goodbye.`));
+        process.exit();
+      });
+    }
+  };
+}

package/src/PM/__tests__/nodeSidecar.testeranto.ts

@@ -0,0 +1,173 @@
+import net from "net";
+import { ITTestResourceConfiguration } from "../../lib";
+import { PM_Node_Sidecar } from "../nodeSidecar";
+import Testeranto from "../../Node";
+import {
+  Ibdd_out,
+  ITestSpecification,
+  IT,
+  ITestImplementation,
+  Ibdd_in,
+  IPartialNodeInterface,
+} from "../../Types";
+
+type I = Ibdd_in<
+  PM_Node_Sidecar,
+  PM_Node_Sidecar,
+  unknown,
+  unknown,
+  unknown,
+  unknown,
+  unknown
+>;
+
+type O = Ibdd_out<
+  {
+    SidecarInitialized: [null];
+  },
+  {
+    SidecarReady: [];
+  },
+  {
+    SendTestMessage: [string];
+    VerifyCleanup: [];
+  },
+  {
+    MessageReceived: [string];
+    ListenersCleaned: [];
+  },
+  {
+    SidecarState: unknown;
+  }
+>;
+
+const specification: ITestSpecification<IT, O> = (Suite, Given, When, Then) => {
+  return [
+    Suite.SidecarInitialized(
+      "Sidecar message passing works correctly",
+      {
+        basicSend: Given.SidecarReady(
+          ["can send and receive messages"],
+          [When.SendTestMessage("test-message")],
+          [Then.MessageReceived("test-message")]
+        ),
+        cleanup: Given.SidecarReady(
+          ["cleans up listeners after message"],
+          [When.VerifyCleanup()],
+          [Then.ListenersCleaned()]
+        ),
+      },
+      []
+    ),
+  ];
+};
+
+const implementation: ITestImplementation<I, O> = {
+  suites: { SidecarInitialized: (x) => x },
+  givens: {
+    SidecarReady: () => {
+      const config: ITTestResourceConfiguration = {
+        name: "test-sidecar",
+        fs: "/tmp",
+        ports: [3001],
+        browserWSEndpoint: "",
+      };
+      return new PM_Node_Sidecar(config);
+    },
+  },
+  whens: {
+    SendTestMessage: (message) => async (sidecar: PM_Node_Sidecar) => {
+      let callbackFn: Function;
+      const mockProcess = {
+        on: (event: string, callback: Function) => {
+          if (event === "message") {
+            callbackFn = callback;
+            callback(
+              JSON.stringify({
+                key: "mock-key", 
+                payload: message,
+              })
+            );
+          }
+          return mockProcess;
+        },
+        addListener: () => mockProcess,
+        removeListener: () => mockProcess
+      } as unknown as NodeJS.Process;
+      
+      process = mockProcess;
+
+      let writeCalled = false;
+      sidecar.client.write = (data: string) => {
+        writeCalled = true;
+        return true;
+      };
+
+      await sidecar.send("test-command", message);
+      return { writeCalled, callbackFn };
+    },
+    VerifyCleanup: () => async (sidecar: PM_Node_Sidecar) => {
+      let addListenerCalled = false;
+      let removeListenerCalled = false;
+
+      const mockProcess = {
+        addListener: () => {
+          addListenerCalled = true;
+          return mockProcess;
+        },
+        removeListener: () => {
+          removeListenerCalled = true;
+          return mockProcess;
+        }
+      } as unknown as NodeJS.Process;
+      process = mockProcess;
+
+      await sidecar.send("test-command", "test");
+      return { addListenerCalled, removeListenerCalled };
+    },
+  },
+  thens: {
+    MessageReceived: (expected) => (actual) => {
+      if (actual !== expected) {
+        throw new Error(`Expected "${expected}" but got "${actual}"`);
+      }
+      return actual;
+    },
+    ListenersCleaned:
+      () =>
+      (result, { removeListenerCalled }) => {
+        if (!removeListenerCalled) {
+          throw new Error("Expected removeListener to be called");
+        }
+        return result;
+      },
+  },
+  checks: { SidecarState: () => "unknown" },
+};
+
+const testInterface: IPartialNodeInterface<I> = {
+  beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+    const sidecar = initializer();
+    sidecar.client = {
+      write: () => true,
+      end: () => {},
+      on: () => {},
+    } as unknown as net.Socket;
+    return sidecar;
+  },
+  andWhen: async (store, whenCB, testResource, pm) => {
+    try {
+      await whenCB(store, testResource, pm);
+    } catch (e) {
+      console.error("Error in andWhen:", e);
+      throw e;
+    }
+  },
+};
+
+export default Testeranto(
+  () => new PM_Node_Sidecar({} as ITTestResourceConfiguration),
+  specification,
+  implementation,
+  testInterface
+);