factorio-test-cli 3.0.0 → 3.0.1

package/config/cli-config.js

@@ -0,0 +1,142 @@
+import { z } from "zod";
+import { testRunnerConfigSchema, registerTestConfigOptions } from "./test-config.js";
+export const DEFAULT_DATA_DIRECTORY = "./factorio-test-data-dir";
+const cliConfigFields = {
+    modPath: {
+        schema: z.string().optional(),
+        cli: {
+            flags: "-p --mod-path <path>",
+            description: "[one required] Path to the mod folder (containing info.json). Will create a symlink from mods folder to here.",
+        },
+    },
+    modName: {
+        schema: z.string().optional(),
+        cli: {
+            flags: "--mod-name <name>",
+            description: "[one required] Name of a mod already in the configured data directory.",
+        },
+    },
+    factorioPath: {
+        schema: z.string().optional(),
+        cli: {
+            flags: "--factorio-path <path>",
+            description: "Path to the Factorio binary. If not specified, will attempt to be auto-detected.",
+        },
+    },
+    dataDirectory: {
+        schema: z.string().optional(),
+        cli: {
+            flags: "-d --data-directory <path>",
+            description: "Factorio data directory, where mods, saves, config etc. will be.",
+            default: DEFAULT_DATA_DIRECTORY,
+        },
+    },
+    save: {
+        schema: z.string().optional(),
+        cli: {
+            flags: "--save <path>",
+            description: "Path to save file. Default: uses a bundled save with empty lab-tile world.",
+        },
+    },
+    mods: {
+        schema: z.array(z.string()).optional(),
+        cli: {
+            flags: "--mods <mods...>",
+            description: "Additional mods to enable besides the mod under test (e.g., --mods mod1 mod2=1.2.3).",
+        },
+    },
+    factorioArgs: {
+        schema: z.array(z.string()).optional(),
+        cli: {
+            flags: "--factorio-args <args...>",
+            description: "Additional arguments to pass to Factorio process.",
+        },
+    },
+    verbose: {
+        schema: z.boolean().optional(),
+        cli: {
+            flags: "-v --verbose",
+            description: "Enable verbose logging; pipe Factorio output to stdout.",
+        },
+    },
+    quiet: {
+        schema: z.boolean().optional(),
+        cli: {
+            flags: "-q --quiet",
+            description: "Suppress per-test output, show only final result.",
+        },
+    },
+    outputFile: {
+        schema: z.string().optional(),
+        cli: {
+            flags: "--output-file <path>",
+            description: "Path for test results JSON file. Used to reorder failed tests first on subsequent runs.",
+        },
+    },
+    forbidOnly: {
+        schema: z.boolean().optional(),
+        cli: {
+            flags: "--forbid-only",
+            description: "Fail if .only tests are present (default: enabled). Useful for CI.",
+            negatable: true,
+        },
+    },
+    watchPatterns: {
+        schema: z.array(z.string()).optional(),
+        cli: {
+            flags: "--watch-patterns <patterns...>",
+            description: "Glob patterns to watch (default: info.json, **/*.lua).",
+        },
+    },
+    udpPort: {
+        schema: z.number().int().positive().optional(),
+        cli: {
+            flags: "--udp-port <port>",
+            description: "UDP port to use for --graphics --watch mode reload trigger (default: 14434).",
+            parseArg: (v) => parseInt(v, 10),
+        },
+    },
+};
+export const cliConfigSchema = z.object({
+    ...Object.fromEntries(Object.entries(cliConfigFields).map(([k, v]) => [k, v.schema])),
+    test: testRunnerConfigSchema.optional(),
+});
+function addOption(command, cli) {
+    if (cli.parseArg) {
+        command.option(cli.flags, cli.description, cli.parseArg, cli.default);
+    }
+    else if ("default" in cli && cli.default !== undefined) {
+        command.option(cli.flags, cli.description, cli.default);
+    }
+    else {
+        command.option(cli.flags, cli.description);
+    }
+    if (cli.negatable) {
+        const flagName = cli.flags
+            .split(" ")[0]
+            .replace(/^-+/, "")
+            .replace(/^[a-z] --/, "");
+        command.option(`--no-${flagName}`, `Disable ${flagName}`);
+    }
+}
+export function registerAllCliOptions(command) {
+    const f = cliConfigFields;
+    command.option("-c --config <path>", "Path to config file (default: factorio-test.json, or 'factorio-test' key in package.json)");
+    command.option("-g --graphics", "Launch Factorio with graphics (interactive mode) instead of headless");
+    command.option("-w --watch", "Watch for file changes and rerun tests");
+    addOption(command, f.modPath.cli);
+    addOption(command, f.modName.cli);
+    addOption(command, f.factorioPath.cli);
+    addOption(command, f.dataDirectory.cli);
+    addOption(command, f.save.cli);
+    addOption(command, f.mods.cli);
+    addOption(command, f.factorioArgs.cli);
+    registerTestConfigOptions(command);
+    addOption(command, f.verbose.cli);
+    addOption(command, f.quiet.cli);
+    addOption(command, f.outputFile.cli);
+    command.option("--no-output-file", "Disable writing test results file");
+    addOption(command, f.forbidOnly.cli);
+    addOption(command, f.watchPatterns.cli);
+    addOption(command, f.udpPort.cli);
+}

package/config/index.js

@@ -0,0 +1,3 @@
+export { testRunnerConfigSchema, parseCliTestOptions } from "./test-config.js";
+export { cliConfigSchema, registerAllCliOptions } from "./cli-config.js";
+export { loadConfig, mergeTestConfig, mergeCliConfig, buildTestConfig } from "./loader.js";

package/config/loader.js

@@ -0,0 +1,72 @@
+import * as fs from "fs";
+import * as path from "path";
+import { CliError } from "../cli-error.js";
+import { cliConfigSchema, DEFAULT_DATA_DIRECTORY } from "./cli-config.js";
+import { parseCliTestOptions } from "./test-config.js";
+function formatZodError(error, filePath) {
+    const issues = error.issues.map((issue) => {
+        const pathStr = issue.path.join(".");
+        return `  - ${pathStr ? `"${pathStr}": ` : ""}${issue.message}`;
+    });
+    return `Invalid config in ${filePath}:\n${issues.join("\n")}`;
+}
+export function loadConfig(configPath) {
+    const paths = configPath
+        ? [path.resolve(configPath)]
+        : [path.resolve("factorio-test.json"), path.resolve("package.json")];
+    for (const filePath of paths) {
+        if (!fs.existsSync(filePath))
+            continue;
+        const content = JSON.parse(fs.readFileSync(filePath, "utf8"));
+        const rawConfig = filePath.endsWith("package.json") ? content["factorio-test"] : content;
+        if (!rawConfig)
+            continue;
+        const result = cliConfigSchema.strict().safeParse(rawConfig);
+        if (!result.success) {
+            throw new CliError(formatZodError(result.error, filePath));
+        }
+        return resolveConfigPaths(result.data, path.dirname(filePath));
+    }
+    return {};
+}
+function resolveConfigPaths(config, configDir) {
+    return {
+        ...config,
+        modPath: config.modPath ? path.resolve(configDir, config.modPath) : undefined,
+        factorioPath: config.factorioPath ? path.resolve(configDir, config.factorioPath) : undefined,
+        dataDirectory: path.resolve(configDir, config.dataDirectory ?? DEFAULT_DATA_DIRECTORY),
+        save: config.save ? path.resolve(configDir, config.save) : undefined,
+    };
+}
+export function mergeTestConfig(configFile, cliOptions) {
+    return {
+        ...configFile,
+        test_pattern: cliOptions.test_pattern ?? configFile?.test_pattern,
+        tag_whitelist: cliOptions.tag_whitelist ?? configFile?.tag_whitelist,
+        tag_blacklist: cliOptions.tag_blacklist ?? configFile?.tag_blacklist,
+        default_timeout: cliOptions.default_timeout ?? configFile?.default_timeout,
+        game_speed: cliOptions.game_speed ?? configFile?.game_speed,
+        log_passed_tests: cliOptions.log_passed_tests ?? configFile?.log_passed_tests,
+        log_skipped_tests: cliOptions.log_skipped_tests ?? configFile?.log_skipped_tests,
+        reorder_failed_first: cliOptions.reorder_failed_first ?? configFile?.reorder_failed_first,
+        bail: cliOptions.bail ?? configFile?.bail,
+    };
+}
+export function mergeCliConfig(fileConfig, options) {
+    options.modPath ??= fileConfig.modPath;
+    options.modName ??= fileConfig.modName;
+    options.factorioPath ??= fileConfig.factorioPath;
+    options.dataDirectory ??= fileConfig.dataDirectory ?? DEFAULT_DATA_DIRECTORY;
+    options.mods ??= fileConfig.mods;
+    options.factorioArgs ??= fileConfig.factorioArgs;
+    options.verbose ??= fileConfig.verbose;
+    options.quiet ??= fileConfig.quiet;
+    return options;
+}
+export function buildTestConfig(fileConfig, options, patterns) {
+    const cliTestOptions = parseCliTestOptions(options);
+    const testPattern = patterns.length > 0
+        ? patterns.map((p) => `(${p})`).join("|")
+        : (cliTestOptions.test_pattern ?? fileConfig.test?.test_pattern);
+    return mergeTestConfig(fileConfig.test, { ...cliTestOptions, test_pattern: testPattern });
+}

package/config/test-config.js

@@ -0,0 +1,104 @@
+import { z } from "zod";
+const testConfigFields = {
+    test_pattern: {
+        schema: z.string().optional(),
+        cli: {
+            flags: "--test-pattern <pattern>",
+            description: "Filter tests by name pattern.",
+        },
+    },
+    tag_whitelist: {
+        schema: z.array(z.string()).optional(),
+        cli: {
+            flags: "--tag-whitelist <tags...>",
+            description: "Only run tests with these tags.",
+        },
+    },
+    tag_blacklist: {
+        schema: z.array(z.string()).optional(),
+        cli: {
+            flags: "--tag-blacklist <tags...>",
+            description: "Skip tests with these tags.",
+        },
+    },
+    default_timeout: {
+        schema: z.number().int().positive().optional(),
+        cli: {
+            flags: "--default-timeout <ticks>",
+            description: "Default async test timeout in ticks.",
+            parseArg: parseInt,
+        },
+    },
+    game_speed: {
+        schema: z.number().int().positive().optional(),
+        cli: {
+            flags: "--game-speed <speed>",
+            description: "Game speed multiplier.",
+            parseArg: parseInt,
+        },
+    },
+    bail: {
+        schema: z.number().int().positive().optional(),
+        cli: {
+            flags: "-b --bail [count]",
+            description: "Stop after n failures (default: 1 when flag present).",
+            parseArg: (v) => (v === undefined ? 1 : parseInt(v)),
+        },
+    },
+    reorder_failed_first: {
+        schema: z.boolean().optional(),
+        cli: {
+            flags: "--reorder-failed-first",
+            description: "Run previously failed tests first (default: enabled).",
+            negatable: true,
+        },
+    },
+    log_passed_tests: {
+        schema: z.boolean().optional(),
+        cli: {
+            flags: "--log-passed-tests",
+            description: "Log passed test names (default: enabled).",
+            negatable: true,
+        },
+    },
+    log_skipped_tests: {
+        schema: z.boolean().optional(),
+        cli: {
+            flags: "--log-skipped-tests",
+            description: "Log skipped test names.",
+        },
+    },
+};
+export const testRunnerConfigSchema = z.strictObject(Object.fromEntries(Object.entries(testConfigFields).map(([k, v]) => [k, v.schema])));
+export function registerTestConfigOptions(command) {
+    for (const field of Object.values(testConfigFields)) {
+        const cli = field.cli;
+        if (cli.parseArg) {
+            command.option(cli.flags, cli.description, cli.parseArg);
+        }
+        else {
+            command.option(cli.flags, cli.description);
+        }
+        if (cli.negatable) {
+            const flagName = cli.flags.split(" ")[0].replace("--", "");
+            command.option(`--no-${flagName}`, `Disable ${cli.description.toLowerCase().replace(/\.$/, "")}`);
+        }
+    }
+}
+function snakeToCamel(str) {
+    return str.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+export function parseCliTestOptions(opts) {
+    const result = {};
+    for (const snake of Object.keys(testConfigFields)) {
+        const camel = snakeToCamel(snake);
+        let value = opts[camel];
+        if (value !== undefined) {
+            if (snake === "bail" && value === true) {
+                value = 1;
+            }
+            result[snake] = value;
+        }
+    }
+    return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "factorio-test-cli",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "A CLI to run FactorioTest.",
   "license": "MIT",
   "repository": {
@@ -15,7 +15,7 @@
     "node": ">=18.0.0"
   },
   "files": [
-    "*.js",
+    "**/*.js",
     "headless-save.zip"
   ],
   "dependencies": {