Merge pull request #1014 from bbassie/feature/patched-scenario

Add create-scenario command to clusteriohost
This commit is contained in:
Cooldude2606 authored and GitHub committed 2026-10-06 16:37:16 +01:00
commit b07c25aa7e
11 files changed
+496 -36

No files matched your search

+190
View File
@@ -0,0 +1,190 @@
import assert from "node:assert/strict";
import fs from "node:fs/promises";
import JSZip from "jszip";
import path from "node:path";
import * as lib from "@clusterio/lib";
import {
createScenario, createScenarioCommand, handleCreateScenarioCommand,
} from "@clusterio/host/dist/node/src/create_scenario.js";
import { SaveModule, PatchInfo } from "@clusterio/host/dist/node/src/patch.js";
describe("host/create_scenario", function() {
const tempDir = path.join("temp", "test", "create_scenario");
const patchInfo = new PatchInfo(0, new lib.ModuleInfo("test", "1.0.0", [], ["scenario"]), []);
const scenarioFiles = new Map([
["scenario.lua", "-- scenario\n"],
["description.json", "{}\n"],
["locale/en/test.cfg", "test=Test\n"],
["clusterio.json", JSON.stringify(patchInfo)],
]);
const module = new SaveModule(
new lib.ModuleInfo("spam", "1.0.0", ["spam.lua"]),
new Map([["modules/spam/spam.lua", Buffer.from("return {}\n")]]),
);
async function readDir(dirPath) {
const files = new Map();
for (const entry of await fs.readdir(dirPath, { recursive: true, withFileTypes: true })) {
if (entry.isFile()) {
const fsPath = path.join(entry.parentPath, entry.name);
files.set(path.relative(dirPath, fsPath).split(path.sep).join("/"), await fs.readFile(fsPath, "utf8"));
}
}
return files;
}
function checkOutput(files) {
assert(files.get("control.lua").includes('event_handler.add_lib(require("modules/spam/spam"))'));
assert.equal(JSON.parse(files.get("clusterio.json")).patch_number, 1);
assert.equal(files.get("modules/spam/spam.lua"), "return {}\n");
for (const name of ["scenario.lua", "description.json", "locale/en/test.cfg"]) {
assert.equal(files.get(name), scenarioFiles.get(name));
}
assert.equal(files.size, scenarioFiles.size + 2);
}
before(async function() {
await fs.rm(tempDir, { recursive: true, force: true });
await fs.mkdir(path.join(tempDir, "scenario"), { recursive: true });
const zip = new JSZip();
for (const [name, content] of scenarioFiles) {
const fsPath = path.join(tempDir, "scenario", name);
await fs.mkdir(path.dirname(fsPath), { recursive: true });
await fs.writeFile(fsPath, content);
zip.file(`scenario/${name}`, content);
}
await fs.writeFile(path.join(tempDir, "scenario.zip"), await zip.generateAsync({ type: "nodebuffer" }));
});
it("should patch a scenario directory", async function() {
const output = path.join(tempDir, "from_dir");
await createScenario(path.join(tempDir, "scenario"), output, [module]);
checkOutput(await readDir(output));
});
it("should patch a zipped scenario", async function() {
const output = path.join(tempDir, "from_zip");
await createScenario(path.join(tempDir, "scenario.zip"), output, [module]);
checkOutput(await readDir(output));
});
it("should write a zip file when asked to", async function() {
const output = path.join(tempDir, "zipped.zip");
await createScenario(path.join(tempDir, "scenario"), output, [module], true);
const zip = await JSZip.loadAsync(await fs.readFile(output));
const files = new Map();
for (const file of Object.values(zip.files)) {
if (!file.dir) {
files.set(file.name.replace(/^scenario\//, ""), await file.async("string"));
}
}
checkOutput(files);
});
it("should not modify the input scenario", async function() {
const files = await readDir(path.join(tempDir, "scenario"));
assert.deepEqual(files, scenarioFiles);
});
it("should throw if the output already exists", async function() {
const output = path.join(tempDir, "from_dir");
await assert.rejects(
createScenario(path.join(tempDir, "scenario"), output, [module]),
new Error(`${output} already exists`),
);
});
it("should throw on unknown scenario", async function() {
await fs.mkdir(path.join(tempDir, "unknown"));
await fs.writeFile(path.join(tempDir, "unknown", "control.lua"), "-- unknown\n");
await assert.rejects(
createScenario(path.join(tempDir, "unknown"), path.join(tempDir, "from_unknown"), [module]),
new Error("Unable to patch save, unknown scenario (3acc3be3861144e55604f5ac2f2555071885ebc4)")
);
});
describe("createScenarioCommand()", function() {
it("should define the output positional and options", function() {
const positionals = [];
const options = [];
const yargs = {
positional(name) { positionals.push(name); return yargs; },
option(name) { options.push(name); return yargs; },
};
createScenarioCommand(yargs);
assert.deepEqual(positionals, ["output"]);
assert.deepEqual(options, ["zip", "scenario", "factorio-version", "plugins"]);
});
});
describe("handleCreateScenarioCommand()", function() {
const factorioDir = path.join(tempDir, "factorio");
const scenario = path.join(tempDir, "scenario");
let hostConfig;
let pluginInfos;
before(async function() {
// Fake install with the test scenario as freeplay
await fs.cp(path.join("test", "file", "factorio", "0.1.2"), factorioDir, { recursive: true });
const freeplay = path.join(factorioDir, "data", "base", "scenarios", "freeplay");
await fs.cp(scenario, freeplay, { recursive: true });
pluginInfos = await lib.loadPluginInfos(new Map([
["research_sync", path.resolve("plugins/research_sync")],
["test_plugin", path.resolve("test/file/test_plugin")],
]));
lib.addPluginConfigFields(pluginInfos);
hostConfig = new lib.HostConfig("host", { "host.factorio_directory": factorioDir });
});
it("should patch freeplay with the enabled plugins by default", async function() {
const output = path.join(tempDir, "default");
await handleCreateScenarioCommand({ output, factorioVersion: "latest" }, hostConfig, pluginInfos);
const files = await readDir(output);
assert.equal(files.get("scenario.lua"), scenarioFiles.get("scenario.lua"));
const info = JSON.parse(files.get("clusterio.json"));
assert.deepEqual(info.modules.map(m => m.name), ["clusterio", "research_sync"]);
});
it("should skip plugins disabled in the host config", async function() {
const output = path.join(tempDir, "disabled");
hostConfig.set("research_sync.load_plugin", false);
try {
await handleCreateScenarioCommand({ output, factorioVersion: "latest" }, hostConfig, pluginInfos);
} finally {
hostConfig.set("research_sync.load_plugin", true);
}
const info = JSON.parse((await readDir(output)).get("clusterio.json"));
assert.deepEqual(info.modules.map(m => m.name), ["clusterio"]);
});
it("should use the given scenario and plugins", async function() {
const output = path.join(tempDir, "selected");
await handleCreateScenarioCommand(
{ output, scenario, plugins: ["research_sync"] }, hostConfig, pluginInfos
);
const info = JSON.parse((await readDir(output)).get("clusterio.json"));
assert.deepEqual(info.modules.map(m => m.name), ["clusterio", "research_sync"]);
});
it("should throw on unknown plugin", async function() {
await assert.rejects(
handleCreateScenarioCommand(
{ output: path.join(tempDir, "unknown_plugin"), scenario, plugins: ["nope"] },
hostConfig,
pluginInfos,
),
new Error("Plugin nope is not in the plugin list")
);
});
it("should throw on invalid Factorio version", async function() {
await assert.rejects(
handleCreateScenarioCommand(
{ output: path.join(tempDir, "bad_version"), factorioVersion: "1..2" }, hostConfig, pluginInfos
),
new Error("Invalid Factorio version 1..2")
);
});
});
});
+35
View File
@@ -225,6 +225,41 @@ describe("host/patch", function() {
});
});
describe("loadModules()", function() {
it("should load the bundled clusterio module", async function() {
const modules = await patch.loadModules([]);
assert.deepEqual([...modules.keys()], ["clusterio"]);
assert(modules.get("clusterio").files.has("modules/clusterio/api.lua"));
});
it("should load modules from plugins", async function() {
const pluginInfos = await lib.loadPluginInfos(
new Map([["research_sync", path.resolve("plugins/research_sync")]])
);
const modules = await patch.loadModules(pluginInfos);
assert.deepEqual([...modules.keys()], ["research_sync", "clusterio"]);
assert(modules.get("research_sync").files.has("modules/research_sync/sync.lua"));
});
it("should skip plugins without a module", async function() {
const pluginInfos = await lib.loadPluginInfos(
new Map([["test_plugin", path.resolve("test/file/test_plugin")]])
);
const modules = await patch.loadModules(pluginInfos);
assert.deepEqual([...modules.keys()], ["clusterio"]);
});
it("should throw on a plugin module named like a bundled module", async function() {
const pluginDir = path.join("temp", "test", "clusterio_plugin");
await fs.mkdir(path.join(pluginDir, "module"), { recursive: true });
await fs.writeFile(path.join(pluginDir, "package.json"), "{}");
await fs.writeFile(path.join(pluginDir, "module", "module.json"), "{}");
await assert.rejects(
patch.loadModules([{
name: "clusterio", version: "1.0.0", packagePath: path.resolve(pluginDir, "package.json"),
}]),
new Error("Module with name clusterio already exists in a plugin")
);
});
});
describe("patch()", function() {
it("should throw on unknown scenario", async function() {
let zip = new JSZip();
+9 -9
View File
@@ -41,26 +41,26 @@ describe("host/server", function() {
describe("direct install", function() {
it("should search given directory for latest Factorio install", async function() {
const installDir = path.join("test", "file", "factorio", "0.1.2");
const [dir, version] = await hostServer._findVersion(installDir, "latest");
const [dir, version] = await hostServer.findVersion(installDir, "latest");
assert.equal(dir, path.join(installDir, "data"));
assert.equal(version, "0.1.2");
});
it("should search given directory for given Factorio install", async function() {
const installDir = path.join("test", "file", "factorio", "0.1.1");
const [dir, version] = await hostServer._findVersion(installDir, "0.1.1");
const [dir, version] = await hostServer.findVersion(installDir, "0.1.1");
assert.equal(dir, path.join(installDir, "data"));
assert.equal(version, "0.1.1");
});
it("should search given directory for partly given Factorio install", async function() {
const installDir = path.join("test", "file", "factorio", "0.1.2");
const [dir, version] = await hostServer._findVersion(installDir, "0.1");
const [dir, version] = await hostServer.findVersion(installDir, "0.1");
assert.equal(dir, path.join(installDir, "data"));
assert.equal(version, "0.1.2");
});
it("should reject if the version does not match", async function() {
let installDir = path.join("test", "file", "factorio", "0.1.1");
await assert.rejects(
hostServer._findVersion(installDir, "0.1.2"),
hostServer.findVersion(installDir, "0.1.2"),
new Error(
`Unable to find Factorio version 0.1.2: ${installDir} is a direct (single-version) ` +
`install of 0.1.1. Use a versioned layout, where ${installDir} contains a subdirectory ` +
@@ -73,33 +73,33 @@ describe("host/server", function() {
it("should reject if no factorio install with the given version was found", async function() {
let installDir = path.join("test", "file", "factorio");
await assert.rejects(
hostServer._findVersion(installDir, "0.1.3"),
hostServer.findVersion(installDir, "0.1.3"),
new Error("Unable to find Factorio version 0.1.3")
);
});
it("should search given directory for given Factorio install", async function() {
const installDir = path.join("test", "file", "factorio");
const [dir, version] = await hostServer._findVersion(installDir, "0.1.1");
const [dir, version] = await hostServer.findVersion(installDir, "0.1.1");
assert.equal(dir, path.join(installDir, "0.1.1", "data"));
assert.equal(version, "0.1.1");
});
it("should search given directory for partly given Factorio install", async function() {
const installDir = path.join("test", "file", "factorio");
const [dir, version] = await hostServer._findVersion(installDir, "0.1");
const [dir, version] = await hostServer.findVersion(installDir, "0.1");
assert.equal(dir, path.join(installDir, "0.1.2", "data"));
assert.equal(version, "0.1.2");
});
it("should reject if no factorio install with the given version was found", async function() {
let installDir = path.join("test", "file", "factorio");
await assert.rejects(
hostServer._findVersion(installDir, "0.1.3"),
hostServer.findVersion(installDir, "0.1.3"),
new Error("Unable to find Factorio version 0.1.3")
);
});
it("should reject if no factorio install was found", async function() {
let installDir = path.join("test", "file");
await assert.rejects(
hostServer._findVersion(installDir, "0.0.0"),
hostServer.findVersion(installDir, "0.0.0"),
new Error(`Unable to find any Factorio install in ${installDir}`)
);
});
+13
View File
@@ -263,6 +263,19 @@ describe("Integration of Clusterio", function() {
});
describe("clusteriohost", function() {
describe("create-scenario", function() {
it("should create a patched scenario", async function() {
slowTest(this);
requiresFactorio(this);
const output = path.join("temp", "test", "patched-scenario");
await fs.rm(output, { recursive: true, force: true });
await execHost("create-scenario patched-scenario --plugins research_sync");
const control = await fs.readFile(path.join(output, "control.lua"), "utf8");
assert(control.includes('require("modules/research_sync/sync")'));
await fs.access(path.join(output, "scenario.lua"));
});
});
describe("hostUpdateEventHandler()", function() {
it("should trigger when a new host is added", async function() {
slowTest(this);