aimyapi 1.0.8 → 1.0.10

package/src/log-tester.ts

@@ -0,0 +1,185 @@
+import { SandboxLog } from "./logger";
+import { dequal } from "./utils";
+
+/** Return true to pass. Returning a falsy value or throwing fails the check. */
+export type ArgumentsEvaluator = (args: any[]) => any;
+/** Return true to pass. Returning a falsy value or throwing fails the check. */
+export type ResultEvaluator = (result: any) => any;
+
+/**
+ * One step in a test sequence. Gets the logs and the current position, checks
+ * the entries there, and returns the position of the next unchecked entry.
+ * Throws TestFailed if the check fails.
+ */
+export type TestStep = (logs: SandboxLog[], index: number) => number;
+
+export class TestFailed extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = "TestFailed";
+    }
+}
+
+function describeEntry(entry: SandboxLog | undefined): string {
+    if (!entry) return "end of logs";
+    const short = (v: any) => JSON.stringify(v);
+    if (entry.type === "trace") {
+        return `trace ${entry.fnName}(${entry.fnArgs.map(short).join(", ")}) -> ${short(entry.result)}`;
+    }
+    return `${entry.type} [${entry.source}] ${entry.args.map(short).join(" ")}`;
+}
+
+function nameMatches(pattern: string, name: string): boolean {
+    return pattern === "*" || pattern === name;
+}
+
+/** Runs an evaluator and throws TestFailed if it returns falsy or throws. */
+function evaluate(evaluator: ((value: any) => any) | undefined, value: any, what: string, index: number, entry: SandboxLog) {
+    if (!evaluator) return;
+    let passed: any;
+    try {
+        passed = evaluator(value);
+    } catch (e: any) {
+        throw new TestFailed(`Log #${index}: ${what} check threw: ${e?.message ?? e}. Entry: ${describeEntry(entry)}`);
+    }
+    if (!passed) {
+        throw new TestFailed(`Log #${index}: ${what} check failed. Entry: ${describeEntry(entry)}`);
+    }
+}
+
+function checkTrace(logs: SandboxLog[], index: number, functionName: string, argumentsEvaluator?: ArgumentsEvaluator, resultEvaluator?: ResultEvaluator) {
+    const entry = logs[index];
+    if (!entry || entry.type !== "trace" || !nameMatches(functionName, entry.fnName)) {
+        throw new TestFailed(`Log #${index}: expected trace for "${functionName}", got ${describeEntry(entry)}`);
+    }
+    evaluate(argumentsEvaluator, entry.fnArgs, `arguments of "${entry.fnName}"`, index, entry);
+    evaluate(resultEvaluator, entry.result, `result of "${entry.fnName}"`, index, entry);
+}
+
+function expectEntryType(type: "log" | "error", argumentsEvaluator?: ArgumentsEvaluator): TestStep {
+    return (logs, index) => {
+        const entry = logs[index];
+        if (!entry || entry.type !== type) {
+            throw new TestFailed(`Log #${index}: expected ${type}, got ${describeEntry(entry)}`);
+        }
+        evaluate(argumentsEvaluator, entry.args, `${type} arguments`, index, entry);
+        return index + 1;
+    };
+}
+
+/**
+ * Checks the logs from a sandbox run against an expected sequence of entries.
+ *
+ * @example
+ * test.sequence(
+ *     test.expectTrace("getSalesData"),
+ *     test.expectTrace("display", (args) => args[0].includes("The month with the highest sales was")),
+ * );
+ */
+export class LogTester {
+    private source: SandboxLog[];
+
+    constructor(source: SandboxLog[]) {
+        this.source = source;
+    }
+
+    private get logs(): SandboxLog[] {
+        return this.source;
+    }
+
+    /**
+     * Runs the steps in order, starting at the first log entry. Throws TestFailed
+     * on the first failing step. Entries after the last step are ignored.
+     * Accepts steps as separate arguments or as one array.
+     */
+    sequence(...steps: (TestStep | TestStep[])[]): true {
+        const logs = this.logs;
+        let index = 0;
+        for (const step of steps.flat()) {
+            if (typeof step !== "function") {
+                throw new TestFailed(`sequence() expects test steps (e.g. test.expectTrace(...)), got ${typeof step}`);
+            }
+            index = step(logs, index);
+        }
+        return true;
+    }
+
+    /** Next entry must be a trace for `functionName` ("*" for any function). */
+    expectTrace(functionName: string, argumentsEvaluator?: ArgumentsEvaluator, resultEvaluator?: ResultEvaluator): TestStep {
+        return (logs, index) => {
+            checkTrace(logs, index, functionName, argumentsEvaluator, resultEvaluator);
+            return index + 1;
+        };
+    }
+
+    /** Next entry can be anything, but there must be one. */
+    expectAny(): TestStep {
+        return (logs, index) => {
+            if (index >= logs.length) {
+                throw new TestFailed(`Log #${index}: expected any entry, got end of logs`);
+            }
+            return index + 1;
+        };
+    }
+
+    /** Skips ahead to just before the next trace for `functionName` ("*" for any). Fails if there is none. */
+    skipToTrace(functionName: string): TestStep {
+        return (logs, index) => {
+            for (let i = index; i < logs.length; i++) {
+                const entry = logs[i];
+                if (entry.type === "trace" && nameMatches(functionName, entry.fnName)) {
+                    return i;
+                }
+            }
+            throw new TestFailed(`Log #${index}: no trace for "${functionName}" found from here to the end of the logs`);
+        };
+    }
+
+    /**
+     * Consecutive traces for `functionName` ("*" for any).
+     * With `num` > 0, exactly that many must be next (more are left for later steps).
+     * With `num` 0 or undefined, takes as many as are next, including none.
+     * The evaluators are checked against every matched trace.
+     */
+    expectMultipleTraces(functionName: string, num?: number, argumentsEvaluator?: ArgumentsEvaluator, resultEvaluator?: ResultEvaluator): TestStep {
+        return (logs, index) => {
+            if (num && num > 0) {
+                for (let n = 0; n < num; n++) {
+                    const entry = logs[index + n];
+                    if (!entry || entry.type !== "trace" || !nameMatches(functionName, entry.fnName)) {
+                        throw new TestFailed(`Log #${index + n}: expected ${num} traces for "${functionName}" but found ${n}. Got ${describeEntry(entry)}`);
+                    }
+                    checkTrace(logs, index + n, functionName, argumentsEvaluator, resultEvaluator);
+                }
+                return index + num;
+            }
+
+            let i = index;
+            while (i < logs.length) {
+                const entry = logs[i];
+                if (entry.type !== "trace" || !nameMatches(functionName, entry.fnName)) break;
+                checkTrace(logs, i, functionName, argumentsEvaluator, resultEvaluator);
+                i++;
+            }
+            return i;
+        };
+    }
+
+    /** Next entry must be a log (console.log etc). The evaluator gets the logged arguments. */
+    expectLog(argumentsEvaluator?: ArgumentsEvaluator): TestStep {
+        return expectEntryType("log", argumentsEvaluator);
+    }
+
+    /** Next entry must be an error. The evaluator gets the error arguments. */
+    expectError(argumentsEvaluator?: ArgumentsEvaluator): TestStep {
+        return expectEntryType("error", argumentsEvaluator);
+    }
+
+    /** Deep equality. Returns true if equal, otherwise throws TestFailed, so it works inside evaluators. */
+    equals(actual: any, expected: any): true {
+        if (!dequal(actual, expected)) {
+            throw new TestFailed(`Expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+        }
+        return true;
+    }
+}

package/src/logger.ts

@@ -0,0 +1,113 @@
+export type LogSource = "sandbox" | "compiler" | "runner";
+export type LogEntryType = "log" | "error" | "trace";
+
+export type SandboxLog = { 
+  type: "log" | "error"; 
+  args: any[]; 
+  source: LogSource 
+} | {
+  type: "trace";
+  fnName: string,
+  fnArgs: any[],
+  result: any
+};
+
+export class Logger {
+  private logs: SandboxLog[] = [];
+  debug: boolean = false;
+
+  constructor(debug: boolean = false) {
+    this.debug = debug;
+  }
+
+  getLogs() {
+    return this.logs;
+  }
+  
+  addEntry(type: "log" | "error", args: any, source: LogSource) {
+    if(Array.isArray(args)) {
+      this.logs.push({ type, args, source });
+    } else {      
+      this.logs.push({ type, args: [args], source });
+    }
+  }
+  log(args: any, source: LogSource) {
+    this.addEntry("log", args, source);
+    if (this.debug) {
+      console.log(`[${source}]:`, ...args);
+    }    
+  }
+  trace(fnName: string, fnArgs: any[], result: any) {
+    //this.addEntry("trace", Logger.limitObjectForLogs(args, 5, 5), source);
+    this.logs.push({ type: "trace", fnName, fnArgs, result })
+    if (this.debug) {
+      console.debug(`[sandbox]: ${fnName}(${fnArgs.map(arg => JSON.stringify(Logger.limitObjectForLogs(arg))).join(",")}) -> ${JSON.stringify(Logger.limitObjectForLogs(result))}`);
+    }    
+  }  
+  error(args: any, source: LogSource) {
+    this.addEntry("error", args, source);
+    
+    if (this.debug) {
+      console.error(`[${source}]:`, ...args);
+    }    
+  }
+
+  clear() {
+    this.logs = [];
+  }
+
+  getPrettyLogs() {
+    return this.logs.map(entry => Logger.limitObjectForLogs(entry))
+  }
+
+  /**
+   * Returns a trimmed copy of `value` that is safe to log.
+   * - Objects/arrays nested deeper than `maxDepth` become "[Object]" / "[Array(n)]".
+   * - Arrays longer than `maxArrayItems` keep the first items plus a "+N more items" string.
+   * - Circular references become "[Circular]".
+   */
+  static limitObjectForLogs(value: any, maxDepth: number = 3, maxArrayItems: number = 5): any {
+    const seen = new WeakSet<object>();
+
+    const trim = (val: any, depth: number): any => {
+      if (val === null || typeof val !== "object") {
+        if (typeof val === "function") return `[Function${val.name ? `: ${val.name}` : ""}]`;
+        if (typeof val === "bigint") return `${val}n`;
+        if (typeof val === "symbol") return val.toString();
+        return val;
+      }
+
+      if (val instanceof Date) return val.toISOString();
+      if (val instanceof Error) {
+        return { name: val.name, message: val.message, stack: val.stack };
+      }
+
+      if (seen.has(val)) return "[Circular]";
+
+      if (depth >= maxDepth) {
+        return Array.isArray(val) ? `[Array(${val.length})]` : "[Object]";
+      }
+
+      seen.add(val);
+      let result: any;
+
+      if (Array.isArray(val)) {
+        result = val.slice(0, maxArrayItems).map((item) => trim(item, depth + 1));
+        if (val.length > maxArrayItems) {
+          result.push(`+${val.length - maxArrayItems} more items`);
+        }
+      } else {
+        result = {};
+        for (const key of Object.keys(val)) {
+          result[key] = trim(val[key], depth + 1);
+        }
+      }
+
+      // Only track the current path, so shared (non-circular) references still print.
+      seen.delete(val);
+      return result;
+    };
+
+    return trim(value, 0);
+  }
+}