as-test 0.5.3 → 1.0.0

package/bin/commands/init.js

@@ -0,0 +1,6 @@
+import { init } from "./init-core.js";
+export { init } from "./init-core.js";
+export async function executeInitCommand(rawArgs, deps) {
+    const commandTokens = deps.resolveCommandTokens(rawArgs, "init");
+    await init(commandTokens);
+}

package/bin/{run.js → commands/run-core.js}

@@ -1,12 +1,12 @@
 import chalk from "chalk";
 import { spawn } from "child_process";
 import { glob } from "glob";
-import { applyMode, getExec, loadConfig } from "./util.js";
+import { applyMode, getExec, loadConfig, tokenizeCommand } from "../util.js";
 import * as path from "path";
 import { pathToFileURL } from "url";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { createReporter as createDefaultReporter } from "./reporters/default.js";
-import { createTapReporter } from "./reporters/tap.js";
+import { createReporter as createDefaultReporter } from "../reporters/default.js";
+import { createTapReporter } from "../reporters/tap.js";
 const DEFAULT_CONFIG_PATH = path.join(process.cwd(), "./as-test.config.json");
 var MessageType;
 (function (MessageType) {
@@ -87,7 +87,7 @@ class Channel {
 Channel.MAGIC = Buffer.from("WIPC");
 Channel.HEADER_SIZE = 9;
 class SnapshotStore {
-    constructor(specFile, snapshotDir) {
+    constructor(specFile, snapshotDir, duplicateSpecBasenames = new Set()) {
         this.dirty = false;
         this.created = 0;
         this.updated = 0;
@@ -95,12 +95,22 @@ class SnapshotStore {
         this.failed = 0;
         this.warnedMissing = new Set();
         const base = path.basename(specFile, ".ts");
+        const disambiguator = resolveDisambiguator(specFile, duplicateSpecBasenames);
+        const snapshotBase = disambiguator.length
+            ? `${base}.${disambiguator}`
+            : base;
         const dir = path.join(process.cwd(), snapshotDir);
         if (!existsSync(dir))
             mkdirSync(dir, { recursive: true });
-        this.filePath = path.join(dir, `${base}.snap.json`);
-        this.data = existsSync(this.filePath)
-            ? JSON.parse(readFileSync(this.filePath, "utf8"))
+        this.filePath = path.join(dir, `${snapshotBase}.snap.json`);
+        const legacyFilePath = path.join(dir, `${base}.snap.json`);
+        const sourcePath = existsSync(this.filePath)
+            ? this.filePath
+            : existsSync(legacyFilePath)
+                ? legacyFilePath
+                : null;
+        this.data = sourcePath
+            ? JSON.parse(readFileSync(sourcePath, "utf8"))
             : {};
     }
     assert(key, actual, allowSnapshot, updateSnapshots) {
@@ -151,6 +161,7 @@ export async function run(flags = {}, configPath = DEFAULT_CONFIG_PATH, selector
     const config = mode.config;
     const inputPatterns = resolveInputPatterns(config.input, selectors);
     const inputFiles = (await glob(inputPatterns)).sort((a, b) => a.localeCompare(b));
+    const duplicateSpecBasenames = await resolveDuplicateSpecBasenames(config.input);
     const snapshotEnabled = flags.snapshot !== false;
     const updateSnapshots = Boolean(flags.updateSnapshots);
     const cleanOutput = Boolean(flags.clean);
@@ -169,7 +180,11 @@ export async function run(flags = {}, configPath = DEFAULT_CONFIG_PATH, selector
             stdout: process.stdout,
             stderr: process.stderr,
         }));
-    const command = runtimeCommand.split(" ")[0];
+    const runtimeTokens = tokenizeCommand(runtimeCommand);
+    if (!runtimeTokens.length) {
+        throw new Error("runtime command is empty");
+    }
+    const command = runtimeTokens[0];
     const execPath = getExec(command);
     if (!execPath) {
         const message = `${chalk.bgRed(" ERROR ")}${chalk.dim(":")} could not locate ${command} in PATH variable!`;
@@ -199,23 +214,25 @@ export async function run(flags = {}, configPath = DEFAULT_CONFIG_PATH, selector
     };
     for (let i = 0; i < inputFiles.length; i++) {
         const file = inputFiles[i];
-        const outFile = path.join(config.outDir, resolveArtifactFileName(file, config.buildOptions.target, options.modeName));
+        const outFile = path.join(config.outDir, resolveArtifactFileName(file, config.buildOptions.target, options.modeName, duplicateSpecBasenames));
         const fileBase = file
             .slice(file.lastIndexOf("/") + 1)
             .replace(".ts", "")
             .replace(".spec", "");
-        let cmd = runtimeCommand.replace(command, execPath);
-        cmd = cmd.replace("<name>", fileBase);
-        if (config.buildOptions.target == "bindings" && !cmd.includes("<file>")) {
-            cmd = cmd.replace("<file>", resolveBindingsHelperPath(outFile));
-        }
-        else {
-            cmd = cmd.replace("<file>", outFile);
-        }
-        const snapshotStore = new SnapshotStore(file, config.snapshotDir);
+        const fileToken = config.buildOptions.target == "bindings" &&
+            !runtimeTokens.some((token) => token.includes("<file>"))
+            ? resolveBindingsHelperPath(outFile)
+            : outFile;
+        const invocation = {
+            command: execPath,
+            args: runtimeTokens
+                .slice(1)
+                .map((token) => token.replace(/<name>/g, fileBase).replace(/<file>/g, fileToken)),
+        };
+        const snapshotStore = new SnapshotStore(file, config.snapshotDir, duplicateSpecBasenames);
         let report;
         try {
-            report = await runProcess(cmd, snapshotStore, snapshotEnabled, updateSnapshots, reporter, reporterKind == "tap", mode.env);
+            report = await runProcess(invocation, snapshotStore, snapshotEnabled, updateSnapshots, reporter, reporterKind == "tap", mode.env);
         }
         catch (error) {
             const modeLabel = options.modeName ?? "default";
@@ -360,7 +377,8 @@ function fallbackToDefaultRuntime(runtimeRun, target, emitWarnings) {
     if (!fallback)
         return runtimeRun;
     const resolvedFallbackPath = path.join(process.cwd(), fallback.scriptPath);
-    if (resolvedScriptPath == resolvedFallbackPath || scriptPath == fallback.scriptPath) {
+    if (resolvedScriptPath == resolvedFallbackPath ||
+        scriptPath == fallback.scriptPath) {
         return runtimeRun;
     }
     if (emitWarnings) {
@@ -521,15 +539,50 @@ try {
     }
     return null;
 }
-function resolveArtifactFileName(file, target, modeName) {
+function resolveArtifactFileName(file, target, modeName, duplicateSpecBasenames = new Set()) {
     const base = path
         .basename(file)
         .replace(/\.spec\.ts$/, "")
         .replace(/\.ts$/, "");
-    if (!modeName) {
-        return `${path.basename(file).replace(".ts", ".wasm")}`;
-    }
-    return `${base}.${modeName}.${target}.wasm`;
+    const legacy = !modeName
+        ? `${path.basename(file).replace(".ts", ".wasm")}`
+        : `${base}.${modeName}.${target}.wasm`;
+    if (!duplicateSpecBasenames.has(path.basename(file))) {
+        return legacy;
+    }
+    const disambiguator = resolveDisambiguator(file, duplicateSpecBasenames);
+    if (!disambiguator.length) {
+        return legacy;
+    }
+    const ext = path.extname(legacy);
+    const stem = ext.length ? legacy.slice(0, -ext.length) : legacy;
+    return `${stem}.${disambiguator}${ext}`;
+}
+async function resolveDuplicateSpecBasenames(configured) {
+    const patterns = Array.isArray(configured) ? configured : [configured];
+    const files = await glob(patterns);
+    const counts = new Map();
+    for (const file of files) {
+        const base = path.basename(file);
+        counts.set(base, (counts.get(base) ?? 0) + 1);
+    }
+    const duplicates = new Set();
+    for (const [base, count] of counts) {
+        if (count > 1)
+            duplicates.add(base);
+    }
+    return duplicates;
+}
+function resolveDisambiguator(file, duplicateSpecBasenames) {
+    if (!duplicateSpecBasenames.has(path.basename(file)))
+        return "";
+    const relDir = path.dirname(path.relative(process.cwd(), file));
+    if (!relDir.length || relDir == ".")
+        return "";
+    return relDir
+        .replace(/[\\/]+/g, "__")
+        .replace(/[^A-Za-z0-9._-]/g, "_")
+        .replace(/^_+|_+$/g, "");
 }
 function resolveBindingsHelperPath(wasmPath) {
     const bindingsPath = wasmPath.replace(/\.wasm$/, ".bindings.js");
@@ -541,7 +594,10 @@ function resolveBindingsHelperPath(wasmPath) {
     return bindingsPath;
 }
 function extractRuntimeScriptPath(runtimeRun) {
-    const tokens = runtimeRun.trim().split(/\s+/).filter((token) => token.length > 0);
+    const tokens = runtimeRun
+        .trim()
+        .split(/\s+/)
+        .filter((token) => token.length > 0);
     if (tokens.length < 2)
         return null;
     const execToken = path.basename(tokens[0]).toLowerCase();
@@ -614,7 +670,9 @@ function runtimeNameFromCommand(command) {
     return token && token.length ? token : "runtime";
 }
 function resolveInputPatterns(configured, selectors) {
-    const configuredInputs = Array.isArray(configured) ? configured : [configured];
+    const configuredInputs = Array.isArray(configured)
+        ? configured
+        : [configured];
     if (!selectors.length)
         return configuredInputs;
     const patterns = new Set();
@@ -871,16 +929,20 @@ function compareCoveragePoints(a, b) {
         return a.type.localeCompare(b.type);
     return a.hash.localeCompare(b.hash);
 }
-async function runProcess(cmd, snapshots, snapshotEnabled, updateSnapshots, reporter, tapMode = false, env = process.env) {
-    const child = spawn(cmd, {
+async function runProcess(invocation, snapshots, snapshotEnabled, updateSnapshots, reporter, tapMode = false, env = process.env) {
+    const child = spawn(invocation.command, invocation.args, {
         stdio: ["pipe", "pipe", "pipe"],
-        shell: true,
+        shell: false,
         env,
     });
     let report = null;
     let parseError = null;
     let stderrBuffer = "";
     let suppressTraceWarningLine = false;
+    let spawnError = null;
+    child.on("error", (error) => {
+        spawnError = error;
+    });
     child.stderr.on("data", (chunk) => {
         stderrBuffer += chunk.toString("utf8");
         let newline = stderrBuffer.indexOf("\n");
@@ -988,6 +1050,9 @@ async function runProcess(cmd, snapshots, snapshotEnabled, updateSnapshots, repo
             process.stderr.write(stderrBuffer);
         }
     }
+    if (spawnError) {
+        throw spawnError;
+    }
     if (parseError) {
         throw new Error(`could not parse report payload: ${parseError}`);
     }

package/bin/commands/run.js

@@ -0,0 +1,20 @@
+export { createRunReporter, run } from "./run-core.js";
+export async function executeRunCommand(rawArgs, flags, configPath, selectedModes, deps) {
+    const commandArgs = deps.resolveCommandArgs(rawArgs, "run");
+    const listFlags = deps.resolveListFlags(rawArgs, "run");
+    const featureToggles = deps.resolveFeatureToggles(rawArgs, "run");
+    const runFlags = {
+        snapshot: !flags.includes("--no-snapshot"),
+        updateSnapshots: flags.includes("--update-snapshots"),
+        clean: flags.includes("--clean"),
+        showCoverage: flags.includes("--show-coverage"),
+        verbose: flags.includes("--verbose"),
+        coverage: featureToggles.coverage,
+    };
+    const modeTargets = deps.resolveExecutionModes(configPath, selectedModes);
+    if (listFlags.list || listFlags.listModes) {
+        await deps.listExecutionPlan("run", configPath, commandArgs, modeTargets, listFlags);
+        return;
+    }
+    await deps.runRuntimeModes(runFlags, configPath, commandArgs, modeTargets);
+}

package/bin/commands/test.js

@@ -0,0 +1,23 @@
+export async function executeTestCommand(rawArgs, flags, configPath, selectedModes, deps) {
+    const commandArgs = deps.resolveCommandArgs(rawArgs, "test");
+    const listFlags = deps.resolveListFlags(rawArgs, "test");
+    const featureToggles = deps.resolveFeatureToggles(rawArgs, "test");
+    const buildFeatureToggles = {
+        tryAs: featureToggles.tryAs,
+        coverage: featureToggles.coverage,
+    };
+    const runFlags = {
+        snapshot: !flags.includes("--no-snapshot"),
+        updateSnapshots: flags.includes("--update-snapshots"),
+        clean: flags.includes("--clean"),
+        showCoverage: flags.includes("--show-coverage"),
+        verbose: flags.includes("--verbose"),
+        coverage: featureToggles.coverage,
+    };
+    const modeTargets = deps.resolveExecutionModes(configPath, selectedModes);
+    if (listFlags.list || listFlags.listModes) {
+        await deps.listExecutionPlan("test", configPath, commandArgs, modeTargets, listFlags);
+        return;
+    }
+    await deps.runTestModes(runFlags, configPath, commandArgs, modeTargets, buildFeatureToggles);
+}

package/bin/commands/types.js

@@ -0,0 +1 @@
+export {};