factorio-test-cli 1.0.6 → 2.0.1

package/cli.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import { program } from "commander";
 import "./run.js";
-program
+await program
     .name("factorio-test")
     .description("cli for factorio testing")
-    .addHelpCommand()
+    .helpCommand(true)
     .showHelpAfterError()
     .showSuggestionAfterError()
-    .parse();
+    .parseAsync();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "factorio-test-cli",
-  "version": "1.0.6",
+  "version": "2.0.1",
   "description": "A CLI to run FactorioTest.",
   "license": "MIT",
   "repository": "https://github.com/GlassBricks/FactorioTest",
@@ -15,14 +15,14 @@
     "*.js"
   ],
   "dependencies": {
-    "chalk": "^5.2.0",
-    "commander": "^10.0.1",
-    "factoriomod-debug": "^1.1.28"
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "factoriomod-debug": "^2.0.3"
   },
   "devDependencies": {
-    "@commander-js/extra-typings": "^10.0.3",
-    "del-cli": "^5.0.0",
-    "typescript": "^5.0.4"
+    "@commander-js/extra-typings": "^12.1.0",
+    "del-cli": "^6.0.0",
+    "typescript": "^5.7.2"
   },
   "scripts": {
     "build": "npm run clean && tsc",

package/run.js

@@ -6,17 +6,24 @@ import * as path from "path";
 import { spawn, spawnSync } from "child_process";
 import BufferLineSplitter from "./buffer-line-splitter.js";
 import chalk from "chalk";
+import * as process from "node:process";
+import * as https from "https";
+import * as readline from "readline";
+const FACTORIO_TEST_MOD_VERSION = "2.0.1";
 const thisCommand = program
     .command("run")
     .summary("Runs tests with Factorio test.")
     .description("Runs tests for the specified mod with Factorio test. Exits with code 0 only if all tests pass.\n")
-    .argument("[mod-path]", "The path to the mod to test (containing info.json). A symlink will be created in the mods folder to this folder. Alternatively, you can specify --mod-name for manual setup.")
-    .option("--mod-name <name>", "The name of the mod to test. If specified, the mod must already be present in the mods directory (sse --data-directory below). One of [mod-path] or --mod-name must be specified.")
-    .option("--factorio-path <path>", "The path to the factorio binary. If not specified, tries to auto-detect the factorio installation.")
-    .option("-d --data-directory <path>", 'The path to the data directory. The "config.ini" file and the "mods" folder will be in this directory.', "./factorio-test-data")
-    .option("--show-output", "Prints test output to stdout.", true)
-    .option("-v --verbose", "Enables more logging, and prints all outputs of the Factorio process to stdout (not just test output).")
-    .addHelpText("after", 'Options passed after "--" are passed as Factorio launch arguments.')
+    .argument("[mod-path]", "The path to the mod (folder containing info.json). A symlink will be created in the mods folder to this folder. Either this or --mod-name must be specified.")
+    .option("--mod-name <name>", "The name of the mod to test. To use this option, the mod must already be present in the mods directory (see --data-directory). Either this or [mod-path] must be specified.")
+    .option("--factorio-path <path>", "The path to the factorio binary. If not specified, attempts to auto-detect the path.")
+    .option("-d --data-directory <path>", 'The path to the factorio data directory that the testing instance will use. The "config.ini" file and the "mods" folder will be in this directory.', "./factorio-test-data-dir")
+    .option("--mods <mods...>", 'Adjust mods. By default, only the mod to test and "factorio-test" are enabled, and all others are disabled! ' +
+    'Same format as "fmtk mods adjust". Example: "--mods mod1 mod2=1.2.3" will enable mod1 any version, and mod2 version 1.2.3.')
+    .option("--show-output", "Print test output to stdout.", true)
+    .option("-v --verbose", "Enables more logging, and pipes the Factorio process output to stdout.")
+    .addHelpText("after", 'Arguments after "--" are passed to the Factorio process.')
+    .addHelpText("after", 'Suggested factorio arguments: "--cache-sprite-atlas", "--disable-audio"')
     .action((modPath, options) => runTests(modPath, options));
 async function runTests(modPath, options) {
     if (modPath !== undefined && options.modName !== undefined) {
@@ -31,9 +38,14 @@ async function runTests(modPath, options) {
     await fsp.mkdir(modsDir, { recursive: true });
     const modToTest = await configureModToTest(modsDir, modPath, options.modName);
     await installFactorioTest(modsDir);
+    const enableModsOptions = [
+        "factorio-test=true",
+        `${modToTest}=true`,
+        ...(options.mods?.map((m) => (m.includes("=") ? m : `${m}=true`)) ?? []),
+    ];
     if (options.verbose)
-        console.log("Enabling mods", modToTest, "and factorio-test");
-    await runScript("fmtk mods adjust", "--modsPath", modsDir, "factorio-test=true", modToTest + "=true");
+        console.log("Adjusting mods");
+    await runScript("fmtk mods adjust", "--modsPath", modsDir, "--disableExtra", ...enableModsOptions);
     await ensureConfigIni(dataDir);
     await setSettingsForAutorun(factorioPath, dataDir, modsDir, modToTest);
     let resultMessage;
@@ -108,12 +120,121 @@ async function checkModExists(modsDir, modName) {
 }
 async function installFactorioTest(modsDir) {
     await fsp.mkdir(modsDir, { recursive: true });
-    const testModName = "factorio-test";
-    // if not found, install it
-    const alreadyExists = await checkModExists(modsDir, testModName);
-    if (!alreadyExists) {
-        console.log(`Downloading ${testModName} from mod portal using fmtk. This may ask for factorio login credentials.`);
-        await runScript("fmtk mods install", "--modsPath", modsDir, testModName);
+    const modName = "factorio-test";
+    const version = FACTORIO_TEST_MOD_VERSION;
+    const expectedZipName = `${modName}_${version}.zip`;
+    const expectedZipPath = path.join(modsDir, expectedZipName);
+    if (fs.existsSync(expectedZipPath)) {
+        if (thisCommand.opts().verbose)
+            console.log(`${modName} version ${version} already installed`);
+        return;
+    }
+    console.log(`Downloading ${modName} version ${version} from mod portal...`);
+    await downloadModVersion(modName, version, expectedZipPath);
+}
+async function downloadModVersion(modName, version, destPath) {
+    const modInfo = await fetchJson(`https://mods.factorio.com/api/mods/${modName}`);
+    const release = modInfo.releases.find((r) => r.version === version);
+    if (!release) {
+        const availableVersions = modInfo.releases.map((r) => r.version).join(", ");
+        throw new Error(`Version ${version} not found for mod ${modName}. Available: ${availableVersions}`);
+    }
+    const credentials = await getFactorioCredentials();
+    const downloadUrl = `https://mods.factorio.com${release.download_url}?username=${encodeURIComponent(credentials.username)}&token=${encodeURIComponent(credentials.token)}`;
+    await downloadFile(downloadUrl, destPath);
+}
+async function fetchJson(url) {
+    return new Promise((resolve, reject) => {
+        https.get(url, (res) => {
+            if (res.statusCode !== 200) {
+                reject(new Error(`HTTP ${res.statusCode} fetching ${url}`));
+                return;
+            }
+            let data = "";
+            res.on("data", (chunk) => (data += chunk));
+            res.on("end", () => {
+                try {
+                    resolve(JSON.parse(data));
+                }
+                catch (e) {
+                    reject(new Error(`Failed to parse JSON from ${url}`, { cause: e }));
+                }
+            });
+            res.on("error", reject);
+        }).on("error", reject);
+    });
+}
+async function downloadFile(url, destPath) {
+    return new Promise((resolve, reject) => {
+        https.get(url, (res) => {
+            if (res.statusCode === 302 || res.statusCode === 301) {
+                const redirectUrl = res.headers.location;
+                if (!redirectUrl) {
+                    reject(new Error("Redirect without location header"));
+                    return;
+                }
+                downloadFile(redirectUrl, destPath).then(resolve, reject);
+                return;
+            }
+            if (res.statusCode !== 200) {
+                reject(new Error(`HTTP ${res.statusCode} downloading mod`));
+                return;
+            }
+            const fileStream = fs.createWriteStream(destPath);
+            res.pipe(fileStream);
+            fileStream.on("close", () => resolve());
+            fileStream.on("error", (err) => {
+                fs.unlink(destPath, () => { });
+                reject(err);
+            });
+        }).on("error", reject);
+    });
+}
+async function getFactorioCredentials() {
+    const playerDataPath = getPlayerDataPath();
+    if (playerDataPath && fs.existsSync(playerDataPath)) {
+        try {
+            const playerData = JSON.parse(await fsp.readFile(playerDataPath, "utf8"));
+            if (playerData["service-username"] && playerData["service-token"]) {
+                return {
+                    username: playerData["service-username"],
+                    token: playerData["service-token"],
+                };
+            }
+        }
+        catch {
+            // Fall through to prompt
+        }
+    }
+    console.log("Factorio credentials required for mod portal download.");
+    return promptForCredentials();
+}
+function getPlayerDataPath() {
+    const platform = os.platform();
+    if (platform === "linux") {
+        return path.join(os.homedir(), ".factorio", "player-data.json");
+    }
+    else if (platform === "darwin") {
+        return path.join(os.homedir(), "Library", "Application Support", "factorio", "player-data.json");
+    }
+    else if (platform === "win32") {
+        return path.join(os.homedir(), "AppData", "Roaming", "Factorio", "player-data.json");
+    }
+    return undefined;
+}
+async function promptForCredentials() {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const question = (prompt) => new Promise((resolve) => rl.question(prompt, resolve));
+    try {
+        const username = await question("Factorio username: ");
+        const token = await question("Factorio token (from https://factorio.com/profile): ");
+        return { username, token };
+    }
+    finally {
+        rl.close();
     }
 }
 async function ensureConfigIni(dataDir) {
@@ -131,6 +252,14 @@ write-data=${dataDir}
 locale=
 `);
     }
+    else {
+        // edit "^write-data=.*" to be dataDir
+        const content = await fsp.readFile(filePath, "utf8");
+        const newContent = content.replace(/^write-data=.*$/m, `write-data=${dataDir}`);
+        if (content !== newContent) {
+            await fsp.writeFile(filePath, newContent);
+        }
+    }
 }
 async function setSettingsForAutorun(factorioPath, dataDir, modsDir, modToTest) {
     // touch modsDir/mod-settings.dat
@@ -157,6 +286,7 @@ async function runFactorioTests(factorioPath, dataDir) {
     const actualArgs = [
         "--load-scenario",
         "factorio-test/Test",
+        "--disable-migration-window",
         "--mod-directory",
         path.join(dataDir, "mods"),
         "-c",
@@ -201,12 +331,12 @@ async function runFactorioTests(factorioPath, dataDir) {
         }
     });
     await new Promise((resolve, reject) => {
-        factorioProcess.on("exit", (code) => {
-            if (code === 0 || resultMessage !== undefined) {
+        factorioProcess.on("exit", (code, signal) => {
+            if (code === 0 && resultMessage !== undefined) {
                 resolve();
             }
             else {
-                reject(new Error(`Factorio exited with code ${code}`));
+                reject(new Error(`Factorio exited with code ${code}, signal ${signal}`));
             }
         });
     });