factorio-test-cli 3.0.5 → 3.1.1

package/README.md

@@ -9,60 +9,3 @@ If using an npm package, you can install `factorio-test-cli` to your dev depende
 ```bash
 npm install --save-dev factorio-test-cli
 ```
-
-## Configuration Architecture
-
-### Config Categories
-
-| Category | Casing | Location | Example Fields |
-|----------|--------|----------|----------------|
-| CLI-only | camelCase | `cli-config.ts` | `config`, `graphics`, `watch` |
-| File+CLI | camelCase | `cli-config.ts` | `modPath`, `factorioPath`, `verbose`, `forbidOnly` |
-| Test | snake_case | `types/config.d.ts` | `test_pattern`, `game_speed`, `bail` |
-
-- **CLI-only**: Options only available via command line, not in config files
-- **File+CLI**: Options that can be set in `factorio-test.json` or via command line (CLI overrides file)
-- **Test**: Runner configuration passed to the Factorio mod; uses snake_case for Lua compatibility
-
-### Type Hierarchy
-
-```
-types/config.d.ts
-└── TestRunnerConfig        # CLI-passable fields (source of truth)
-        │
-        ├── Extended by: FactorioTest.Config (types/index.d.ts)
-        │                 └── Adds mod-only fields: default_ticks_between_tests,
-        │                     before_test_run, after_test_run, sound_effects
-        │
-        └── Validated by: testRunnerConfigSchema (cli/config/test-config.ts)
-                          └── Zod schema for runtime validation
-```
-
-### Data Flow
-
-```
-CLI args ─────────────────┐
-                          ▼
-factorio-test.json ──► loadConfig() ──► mergeCliConfig() ──► RunOptions
-                                              │
-                                              ▼
-                                        buildTestConfig() ──► TestRunnerConfig ──► Factorio mod
-```
-
-1. `loadConfig()` reads `factorio-test.json` (or `package.json["factorio-test"]`)
-2. `mergeCliConfig()` merges file config with CLI options (CLI wins)
-3. `buildTestConfig()` extracts test runner options, combining patterns with OR logic
-
-### File Organization
-
-```
-types/
-├── config.d.ts       # TestRunnerConfig interface (source of truth for CLI-passable test options)
-└── index.d.ts        # FactorioTest.Config extends TestRunnerConfig with mod-only fields
-
-cli/config/
-├── index.ts          # Re-exports all public APIs
-├── test-config.ts    # Zod schema validating TestRunnerConfig + CLI registration
-├── cli-config.ts     # CliConfig + CliOnlyOptions schemas + CLI registration
-└── loader.ts         # Config loading, path resolution, merging, RunOptions type
-```

package/cli.js

@@ -1,11 +1,14 @@
 #!/usr/bin/env node
 import chalk from "chalk";
 import { program } from "commander";
+import { readFileSync } from "fs";
 import { CliError } from "./cli-error.js";
 import "./run.js";
+const { version } = JSON.parse(readFileSync(new URL("package.json", import.meta.url), "utf8"));
 try {
     await program
         .name("factorio-test")
+        .version(version)
         .description("cli for factorio testing")
         .helpCommand(true)
         .showHelpAfterError()

package/mod-setup.js

@@ -5,6 +5,7 @@ import { runScript, runProcess } from "./process-utils.js";
 import { getFactorioPlayerDataPath } from "./factorio-process.js";
 import { CliError } from "./cli-error.js";
 const MIN_FACTORIO_TEST_VERSION = "3.0.0";
+const BUILTIN_MODS = new Set(["base", "quality", "elevated-rails", "space-age"]);
 function parseVersion(version) {
     const parts = version.split(".").map(Number);
     return [parts[0] ?? 0, parts[1] ?? 0, parts[2] ?? 0];
@@ -118,12 +119,12 @@ export async function installFactorioTest(modsDir) {
     const playerDataPath = getFactorioPlayerDataPath();
     let version = await getInstalledModVersion(modsDir, "factorio-test");
     if (!version) {
-        console.log("Downloading factorio-test from mod portal using fmtk.");
+        console.log("Downloading mod: factorio-test");
         await runScript("fmtk", "mods", "install", "--modsPath", modsDir, "--playerData", playerDataPath, "factorio-test");
         version = await getInstalledModVersion(modsDir, "factorio-test");
     }
     else if (compareVersions(version, MIN_FACTORIO_TEST_VERSION) < 0) {
-        console.log(`factorio-test ${version} is outdated, downloading latest version.`);
+        console.log(`Updating mod: factorio-test (${version} is below minimum ${MIN_FACTORIO_TEST_VERSION})`);
         await runScript("fmtk", "mods", "install", "--force", "--modsPath", modsDir, "--playerData", playerDataPath, "factorio-test");
         version = await getInstalledModVersion(modsDir, "factorio-test");
     }
@@ -179,22 +180,54 @@ export async function resetAutorunSettings(modsDir, verbose) {
         console.log("Disabling auto-start settings");
     await runScript("fmtk", "settings", "set", "startup", "factorio-test-auto-start-config", "{}", "--modsPath", modsDir);
 }
+export function parseModRequirement(spec) {
+    const trimmed = spec.trim();
+    if (trimmed.startsWith("?") || trimmed.startsWith("!") || trimmed.startsWith("(?)")) {
+        return undefined;
+    }
+    const withoutPrefix = trimmed.startsWith("~") ? trimmed.slice(1).trim() : trimmed;
+    const match = withoutPrefix.match(/^(\S+)(?:\s*>=?\s*(\d+\.\d+\.\d+))?/);
+    if (!match)
+        return undefined;
+    const name = match[1];
+    if (!name || BUILTIN_MODS.has(name))
+        return undefined;
+    return { name, minVersion: match[2] };
+}
 export function parseRequiredDependencies(dependencies) {
     const result = [];
     for (const dep of dependencies) {
-        const trimmed = dep.trim();
-        if (trimmed.startsWith("?") || trimmed.startsWith("!") || trimmed.startsWith("(?)")) {
-            continue;
+        const req = parseModRequirement(dep);
+        if (req)
+            result.push(req);
+    }
+    return result;
+}
+export async function installMods(modsDir, mods) {
+    const playerDataPath = getFactorioPlayerDataPath();
+    for (const { name, minVersion } of mods) {
+        const installedVersion = await getInstalledModVersion(modsDir, name);
+        if (installedVersion) {
+            if (!minVersion || compareVersions(installedVersion, minVersion) >= 0)
+                continue;
+            console.log(`Updating mod: ${name} (${installedVersion} is below required ${minVersion})`);
+        }
+        else {
+            console.log(`Downloading mod: ${name}`);
         }
-        const withoutPrefix = trimmed.startsWith("~") ? trimmed.slice(1).trim() : trimmed;
-        const modName = withoutPrefix.split(/\s/)[0];
-        if (modName && modName !== "base") {
-            result.push(modName);
+        try {
+            const args = ["fmtk", "mods", "install", "--modsPath", modsDir, "--playerData", playerDataPath];
+            if (installedVersion)
+                args.push("--force");
+            args.push(name);
+            await runScript(...args);
+        }
+        catch {
+            console.log(`Could not download mod: ${name}`);
         }
     }
-    return result;
 }
-export async function installModDependencies(modsDir, modPath, verbose) {
+export async function installModDependencies(modsDir, modPath) {
     const infoJsonPath = path.join(modPath, "info.json");
     let infoJson;
     try {
@@ -207,16 +240,8 @@ export async function installModDependencies(modsDir, modPath, verbose) {
     if (!Array.isArray(dependencies))
         return [];
     const required = parseRequiredDependencies(dependencies);
-    const playerDataPath = getFactorioPlayerDataPath();
-    for (const modName of required) {
-        const exists = await checkModExists(modsDir, modName);
-        if (exists)
-            continue;
-        if (verbose)
-            console.log(`Installing dependency: ${modName}`);
-        await runScript("fmtk", "mods", "install", "--modsPath", modsDir, "--playerData", playerDataPath, modName);
-    }
-    return required;
+    await installMods(modsDir, required);
+    return required.map((r) => r.name);
 }
 export async function resolveModWatchTarget(modsDir, modPath, modName) {
     if (modPath) {

package/mod-setup.test.js

@@ -3,15 +3,16 @@ import { parseRequiredDependencies } from "./mod-setup.js";
 describe("parseRequiredDependencies", () => {
     it.each([
         [[], []],
-        [["some-mod"], ["some-mod"]],
-        [["some-mod >= 1.0.0"], ["some-mod"]],
-        [["~ some-mod >= 1.0.0"], ["some-mod"]],
+        [["some-mod"], [{ name: "some-mod" }]],
+        [["some-mod >= 1.0.0"], [{ name: "some-mod", minVersion: "1.0.0" }]],
+        [["~ some-mod >= 1.0.0"], [{ name: "some-mod", minVersion: "1.0.0" }]],
         [["? optional-mod >= 1.0.0"], []],
         [["! incompatible-mod"], []],
         [["(?) hidden-optional >= 1.0.0"], []],
         [["base >= 1.1.0"], []],
-        [["  mod-name  >=  1.0.0  "], ["mod-name"]],
-        [["~  soft-mod"], ["soft-mod"]],
+        [["quality >= 1.0.0"], []],
+        [["  mod-name  >=  1.0.0  "], [{ name: "mod-name", minVersion: "1.0.0" }]],
+        [["~  soft-mod"], [{ name: "soft-mod" }]],
         [
             [
                 "base >= 1.1.0",
@@ -22,7 +23,11 @@ describe("parseRequiredDependencies", () => {
                 "~ soft-required >= 1.0.0",
                 "another-required",
             ],
-            ["required-mod", "soft-required", "another-required"],
+            [
+                { name: "required-mod", minVersion: "2.0.0" },
+                { name: "soft-required", minVersion: "1.0.0" },
+                { name: "another-required" },
+            ],
         ],
     ])("parseRequiredDependencies(%j) => %j", (input, expected) => {
         expect(parseRequiredDependencies(input)).toEqual(expected);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "factorio-test-cli",
-  "version": "3.0.5",
+  "version": "3.1.1",
   "description": "A CLI to run FactorioTest.",
   "license": "MIT",
   "repository": {

package/process-utils.js

@@ -5,7 +5,7 @@ export function setVerbose(v) {
     verbose = v;
 }
 export function runScript(...command) {
-    return runProcess(true, "npx", ...command);
+    return runProcess(verbose, "npx", ...command);
 }
 export function runProcess(inheritStdio, command, ...args) {
     if (verbose)

package/run.js

@@ -8,7 +8,7 @@ import { buildTestConfig, loadConfig, mergeCliConfig, registerAllCliOptions, } f
 import { autoDetectFactorioPath } from "./factorio-process.js";
 import { getHeadlessSavePath, runFactorioTestsGraphics, runFactorioTestsHeadless, } from "./factorio-process.js";
 import { watchDirectory, watchFile } from "./file-watcher.js";
-import { configureModToTest, ensureConfigIni, installFactorioTest, installModDependencies, resetAutorunSettings, resolveModWatchTarget, setSettingsForAutorun, } from "./mod-setup.js";
+import { configureModToTest, ensureConfigIni, installFactorioTest, installModDependencies, installMods, parseModRequirement, resetAutorunSettings, resolveModWatchTarget, setSettingsForAutorun, } from "./mod-setup.js";
 import { runScript, setVerbose } from "./process-utils.js";
 import { getDefaultOutputPath, readPreviousFailedTests, writeResultsFile } from "./test-results.js";
 const thisCommand = program
@@ -48,15 +48,20 @@ async function setupTestRun(patterns, options) {
     const modsDir = path.join(dataDir, "mods");
     await fsp.mkdir(modsDir, { recursive: true });
     const modToTest = await configureModToTest(modsDir, options.modPath, options.modName, options.verbose);
-    const modDependencies = options.modPath
-        ? await installModDependencies(modsDir, path.resolve(options.modPath), options.verbose)
-        : [];
+    const modDependencies = options.modPath ? await installModDependencies(modsDir, path.resolve(options.modPath)) : [];
     await installFactorioTest(modsDir);
+    const configModRequirements = options.mods
+        ?.filter((m) => !m.match(/^\S+=(?:true|false)$/))
+        .map(parseModRequirement)
+        .filter((r) => r != null) ?? [];
+    if (configModRequirements.length > 0) {
+        await installMods(modsDir, configModRequirements);
+    }
     const enableModsOptions = [
         "factorio-test=true",
         `${modToTest}=true`,
         ...modDependencies.map((m) => `${m}=true`),
-        ...(options.mods?.map((m) => (m.includes("=") ? m : `${m}=true`)) ?? []),
+        ...(options.mods?.map((m) => (m.match(/^\S+=(?:true|false)$/) ? m : `${m.split(/\s/)[0]}=true`)) ?? []),
     ];
     if (options.verbose)
         console.log("Adjusting mods");