mirror of
https://github.com/clusterio/clusterio.git
synced 2026-11-23 00:13:13 +09:00
Merge remote-tracking branch 'upstream/master' into feature/wait-for-plugin
This commit is contained in:
commit
7f688d2ed0
77 files changed
+2006
-693
No files matched your search
@@ -365,6 +365,50 @@ describe("controller/src/Controller", function() {
|
||||
await assert.rejects(Controller.loadJsonObject(path.join(dir, "invalid.json")), SyntaxError);
|
||||
});
|
||||
});
|
||||
describe(".downloadRequiredMods()", function() {
|
||||
let ctrl, resolveCalls, downloadCalls, resolved;
|
||||
function modInfo(name, version) {
|
||||
return lib.ModInfo.fromJSON({ name, version, factorio_version: "2.0" });
|
||||
}
|
||||
beforeEach(function() {
|
||||
const config = new ControllerConfig("controller", { "controller.version": controllerVersion });
|
||||
ctrl = new Controller({}, [
|
||||
{ name: "foo", title: "Foo", requiredMods: ["foo_mod >= 1.0.0"] },
|
||||
{ name: "bar", title: "Bar" },
|
||||
], config);
|
||||
const modPack = ModPack.fromJSON({ id: 7, name: "default", factorio_version: "2.0.10" });
|
||||
ctrl.modPacks.set(modPack);
|
||||
config.set("controller.default_mod_pack_id", 7);
|
||||
resolveCalls = [];
|
||||
downloadCalls = [];
|
||||
resolved = [modInfo("foo_mod", "1.2.0"), modInfo("dep_mod", "0.1.0")];
|
||||
ctrl.resolveModDependencies = async (mods, factorioVersion) => {
|
||||
resolveCalls.push([mods.map(mod => mod.spec), factorioVersion]);
|
||||
return new lib.ModDependencyResolveRequest.Response(resolved, new Map());
|
||||
};
|
||||
ctrl.downloadModsFromPortal = async (mods, factorioVersion) => {
|
||||
downloadCalls.push([mods.map(mod => `${mod.name} ${mod.version}`), factorioVersion]);
|
||||
};
|
||||
});
|
||||
|
||||
it("should download required mods and their dependencies for the default mod pack", async function() {
|
||||
await ctrl.downloadRequiredMods();
|
||||
assert.deepEqual(resolveCalls, [[["foo_mod >= 1.0.0"], "2.0"]]);
|
||||
assert.deepEqual(downloadCalls, [[["foo_mod = 1.2.0", "dep_mod = 0.1.0"], "2.0"]]);
|
||||
});
|
||||
|
||||
it("should skip mods already in the mod store", async function() {
|
||||
ctrl.modStore = new lib.ModStore("mods", new Map(resolved.map(info => [info.filename, info])));
|
||||
await ctrl.downloadRequiredMods();
|
||||
assert.deepEqual(downloadCalls, []);
|
||||
});
|
||||
|
||||
it("should do nothing when no plugin requires mods", async function() {
|
||||
ctrl.pluginInfos = [{ name: "bar", title: "Bar" }];
|
||||
await ctrl.downloadRequiredMods();
|
||||
assert.deepEqual(resolveCalls, []);
|
||||
});
|
||||
});
|
||||
describe(".loggableHeaders()", function() {
|
||||
it("should redact credentials and keep other headers", function() {
|
||||
const headers = {
|
||||
|
||||
@@ -0,0 +1,95 @@
|
||||
import assert from "node:assert/strict";
|
||||
import * as lib from "@clusterio/lib";
|
||||
import { CommandOutput, errorToJson, pickFields, toPlain } from "@clusterio/ctl/dist/node/src/command_ops.js";
|
||||
|
||||
/** Run fn and return the lines it printed with console.log */
|
||||
function captureLog(fn) {
|
||||
const lines = [];
|
||||
const originalLog = console.log; // eslint-disable-line no-console
|
||||
console.log = (...args) => lines.push(args.join(" ")); // eslint-disable-line no-console
|
||||
try {
|
||||
fn();
|
||||
} finally {
|
||||
console.log = originalLog; // eslint-disable-line no-console
|
||||
}
|
||||
return lines;
|
||||
}
|
||||
|
||||
describe("ctl/command_ops", function() {
|
||||
describe("toPlain()", function() {
|
||||
it("converts Sets, Maps and Dates", function() {
|
||||
assert.deepEqual(
|
||||
toPlain({ set: new Set([1, 2]), map: new Map([[3, { a: new Set(["b"]) }]]), date: new Date(0) }),
|
||||
{ set: [1, 2], map: { 3: { a: ["b"] } }, date: "1970-01-01T00:00:00.000Z" },
|
||||
);
|
||||
});
|
||||
it("uses own properties instead of toJSON", function() {
|
||||
const role = new lib.Role(1, "name", "desc", new Set(["core.admin"]));
|
||||
assert.deepEqual(toPlain(role).permissions, ["core.admin"]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("pickFields()", function() {
|
||||
it("keeps only the given fields unless all is given", function() {
|
||||
assert.deepEqual(pickFields({ a: 1, b: 2 }, ["a"]), { a: 1 });
|
||||
assert.deepEqual(pickFields({ a: 1, b: 2 }, ["all"]), { a: 1, b: 2 });
|
||||
});
|
||||
});
|
||||
|
||||
describe("errorToJson()", function() {
|
||||
it("uses the class name of the error", function() {
|
||||
assert.deepEqual(errorToJson(new lib.NotFoundError("gone")), { error: "NotFoundError", message: "gone" });
|
||||
assert.deepEqual(errorToJson("text"), { error: "Error", message: "text" });
|
||||
});
|
||||
});
|
||||
|
||||
describe("class CommandOutput", function() {
|
||||
it("calls the human formatter in human mode", function() {
|
||||
const output = new CommandOutput("human");
|
||||
const human = () => console.log("human"); // eslint-disable-line no-console
|
||||
assert.deepEqual(captureLog(() => output.result({ a: 1 }, human)), ["human"]);
|
||||
assert.deepEqual(captureLog(() => output.finish()), []);
|
||||
});
|
||||
it("prints a success line in human mode for commands without a result", function() {
|
||||
assert.deepEqual(captureLog(() => new CommandOutput("human").finish()), ["Command ran successfully"]);
|
||||
});
|
||||
it("prints one line of JSON per result in json mode", function() {
|
||||
const output = new CommandOutput("json");
|
||||
const lines = captureLog(() => {
|
||||
output.result({ a: new Set([1]) }, () => assert.fail("called human formatter"));
|
||||
output.table([{ b: 2 }]);
|
||||
output.finish();
|
||||
});
|
||||
assert.deepEqual(lines, ['{"a":[1]}', '[{"b":2}]']);
|
||||
});
|
||||
it("prints the toJSON format in wire mode", function() {
|
||||
const output = new CommandOutput("wire");
|
||||
const role = new lib.Role(1, "name", "desc", new Set(["core.admin"]));
|
||||
const lines = captureLog(() => output.result({ role, set: new Set([1]), map: new Map([["a", 2]]) }));
|
||||
assert.deepEqual(JSON.parse(lines[0]), { role: JSON.parse(JSON.stringify(role)), set: [1], map: { a: 2 } });
|
||||
});
|
||||
it("prints success for commands without a result", function() {
|
||||
assert.deepEqual(captureLog(() => new CommandOutput("json").finish()), ['{"success":true}']);
|
||||
const streaming = new CommandOutput("json");
|
||||
streaming.streamingLog = true;
|
||||
assert.deepEqual(captureLog(() => streaming.finish()), []);
|
||||
});
|
||||
it("prints errors as JSON", function() {
|
||||
const output = new CommandOutput("json");
|
||||
const lines = captureLog(() => {
|
||||
output.error(new lib.CommandError("failed"), () => assert.fail("called human formatter"));
|
||||
output.finish();
|
||||
});
|
||||
assert.deepEqual(lines, ['{"error":"CommandError","message":"failed"}']);
|
||||
});
|
||||
it("calls the human error reporter in human mode", function() {
|
||||
const output = new CommandOutput("human");
|
||||
const human = () => console.log("failed"); // eslint-disable-line no-console
|
||||
const lines = captureLog(() => {
|
||||
output.error(new lib.CommandError("failed"), human);
|
||||
output.finish();
|
||||
});
|
||||
assert.deepEqual(lines, ["failed"]);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,88 @@
|
||||
import assert from "node:assert/strict";
|
||||
import * as lib from "@clusterio/lib";
|
||||
import { modCommands } from "@clusterio/ctl/dist/node/src/commands_mod.js";
|
||||
import { modPackCommands } from "@clusterio/ctl/dist/node/src/commands_mod_pack.js";
|
||||
import { userCommands } from "@clusterio/ctl/dist/node/src/commands_user.js";
|
||||
import { CommandOutput } from "@clusterio/ctl/dist/node/src/command_ops.js";
|
||||
|
||||
/** Run fn and return the lines it printed with console.log */
|
||||
async function captureLog(fn) {
|
||||
const lines = [];
|
||||
const originalLog = console.log; // eslint-disable-line no-console
|
||||
console.log = (...args) => lines.push(args.join(" ")); // eslint-disable-line no-console
|
||||
try {
|
||||
await fn();
|
||||
} finally {
|
||||
console.log = originalLog; // eslint-disable-line no-console
|
||||
}
|
||||
return lines;
|
||||
}
|
||||
|
||||
/** Mock ctl answering requests by their class */
|
||||
function mockCtl(responses) {
|
||||
return {
|
||||
output: new CommandOutput(),
|
||||
async send(message) {
|
||||
return responses.get(message.constructor)(message);
|
||||
},
|
||||
async sendTo(destination, message) {
|
||||
return this.send(message);
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
describe("ctl/commands", function() {
|
||||
describe("mod show", function() {
|
||||
const show = modCommands.get("show");
|
||||
it("prints list fields one entry per line", async function() {
|
||||
const ctl = mockCtl(new Map([
|
||||
[lib.ModGetRequest, () => ({ name: "a_mod", dependencies: ["base", "? other"] })],
|
||||
]));
|
||||
const lines = await captureLog(() => show.run({ name: "a_mod", modVersion: "1.0.0" }, ctl));
|
||||
assert.deepEqual(lines, ["name: a_mod", "dependencies:", " base", " ? other"]);
|
||||
});
|
||||
it("rejects an invalid version", async function() {
|
||||
await assert.rejects(
|
||||
show.run({ name: "a_mod", modVersion: "latest" }, mockCtl(new Map())),
|
||||
new lib.CommandError("mod-version must match format digit.digit.digit"),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe("mod-pack show", function() {
|
||||
it("marks missing mods and checksum mismatches and lists export assets", async function() {
|
||||
const modPack = lib.ModPack.fromJSON({ id: 7, name: "pack" });
|
||||
modPack.mods.set("gone", { name: "gone", enabled: true, version: "1.0.0" });
|
||||
modPack.mods.set("changed", { name: "changed", enabled: false, version: "1.0.0", sha1: "aaa" });
|
||||
modPack.exportManifest = { assets: { settings: "settings.json" } };
|
||||
const ctl = mockCtl(new Map([
|
||||
[lib.ModListRequest, () => [{ id: "changed_1.0.0", sha1: "bbb" }]],
|
||||
[lib.ModPackListRequest, () => [modPack]],
|
||||
[lib.ModPackGetRequest, () => modPack],
|
||||
]));
|
||||
const lines = await captureLog(() => modPackCommands.get("show").run({ modPack: "pack" }, ctl));
|
||||
assert(lines.includes(" ? gone 1.0.0"), lines.join("\n"));
|
||||
assert(lines.includes(" ! (disabled) changed 1.0.0 (aaa)"), lines.join("\n"));
|
||||
assert(lines.includes(" settings: settings.json"), lines.join("\n"));
|
||||
});
|
||||
});
|
||||
|
||||
describe("user show", function() {
|
||||
const show = userCommands.get("show");
|
||||
it("prints stats per instance", async function() {
|
||||
const stats = new lib.PlayerStats();
|
||||
stats.joinCount = 2;
|
||||
const user = new lib.UserDetails("alice");
|
||||
user.instanceStats = new Map([[1, stats], [2, stats]]);
|
||||
user.recalculatePlayerStats();
|
||||
const ctl = mockCtl(new Map([
|
||||
[lib.UserGetRequest, () => user],
|
||||
[lib.InstanceDetailsListRequest, () => [{ id: 1, name: "one" }]],
|
||||
]));
|
||||
const lines = await captureLog(() => show.run({ name: "alice", instanceStats: true }, ctl));
|
||||
assert(lines.includes("Instance one (1):"), lines.join("\n"));
|
||||
assert(lines.includes("Instance <deleted> (2):"), lines.join("\n"));
|
||||
assert(lines.some(line => /joinCount +\| 4/.test(line)), lines.join("\n"));
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,91 @@
|
||||
import assert from "node:assert/strict";
|
||||
import * as lib from "@clusterio/lib";
|
||||
import { instanceCommands } from "@clusterio/ctl/dist/node/src/commands_instance.js";
|
||||
import { CommandOutput } from "@clusterio/ctl/dist/node/src/command_ops.js";
|
||||
|
||||
/** Run fn and return the lines it printed with console.log */
|
||||
async function captureLog(fn) {
|
||||
const lines = [];
|
||||
const originalLog = console.log; // eslint-disable-line no-console
|
||||
console.log = (...args) => lines.push(args.join(" ")); // eslint-disable-line no-console
|
||||
try {
|
||||
await fn();
|
||||
} finally {
|
||||
console.log = originalLog; // eslint-disable-line no-console
|
||||
}
|
||||
return lines;
|
||||
}
|
||||
|
||||
describe("ctl/commands_instance", function() {
|
||||
let instances;
|
||||
let sentTo;
|
||||
const ctl = {
|
||||
output: new CommandOutput(),
|
||||
async send(message) {
|
||||
assert(message instanceof lib.InstanceDetailsListRequest);
|
||||
return instances;
|
||||
},
|
||||
async sendTo(destination, message) {
|
||||
sentTo.push([destination.instanceId, message.constructor.name]);
|
||||
if (destination.instanceId === 2) {
|
||||
throw new lib.CommandError("broken");
|
||||
}
|
||||
},
|
||||
};
|
||||
beforeEach(function() {
|
||||
sentTo = [];
|
||||
instances = [
|
||||
{ id: 1, name: "one", status: "stopped", excludeFromStartAll: false },
|
||||
{ id: 2, name: "two", status: "stopped", excludeFromStartAll: false },
|
||||
{ id: 3, name: "three", status: "stopped", excludeFromStartAll: true },
|
||||
{ id: 4, name: "four", status: "running", excludeFromStartAll: false },
|
||||
];
|
||||
});
|
||||
|
||||
describe("start-all", function() {
|
||||
const startAll = instanceCommands.get("start-all");
|
||||
it("starts stopped instances and reports each one", async function() {
|
||||
ctl.output = new CommandOutput("human");
|
||||
const lines = await captureLog(() => startAll.run({ force: false }, ctl));
|
||||
assert.deepEqual(sentTo, [[1, "InstanceStartRequest"], [2, "InstanceStartRequest"]]);
|
||||
assert(lines.includes("✓ Started one"), lines.join("\n"));
|
||||
assert(lines.some(line => line.startsWith("✗ Failed to start two")), lines.join("\n"));
|
||||
});
|
||||
it("prints an entry per instance in json mode", async function() {
|
||||
ctl.output = new CommandOutput("json");
|
||||
const lines = await captureLog(() => startAll.run({ force: true }, ctl));
|
||||
assert.deepEqual(JSON.parse(lines[0]), [
|
||||
{ id: 1, name: "one" },
|
||||
{ id: 2, name: "two", error: { error: "CommandError", message: "broken" } },
|
||||
{ id: 3, name: "three" },
|
||||
]);
|
||||
});
|
||||
it("reports when there is nothing to start", async function() {
|
||||
instances = [];
|
||||
ctl.output = new CommandOutput("human");
|
||||
assert.deepEqual(await captureLog(() => startAll.run({ force: false }, ctl)), ["No instances to start."]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("stop-all", function() {
|
||||
const stopAll = instanceCommands.get("stop-all");
|
||||
it("stops running instances and reports each one", async function() {
|
||||
instances[1].status = "running";
|
||||
ctl.output = new CommandOutput("human");
|
||||
const lines = await captureLog(() => stopAll.run({}, ctl));
|
||||
assert.deepEqual(sentTo, [[2, "InstanceStopRequest"], [4, "InstanceStopRequest"]]);
|
||||
assert(lines.includes("✓ Stopped four"), lines.join("\n"));
|
||||
assert(lines.some(line => line.startsWith("✗ Failed to stop two")), lines.join("\n"));
|
||||
});
|
||||
it("prints an entry per instance in json mode", async function() {
|
||||
ctl.output = new CommandOutput("json");
|
||||
const lines = await captureLog(() => stopAll.run({}, ctl));
|
||||
assert.deepEqual(JSON.parse(lines[0]), [{ id: 4, name: "four" }]);
|
||||
});
|
||||
it("reports when there is nothing to stop", async function() {
|
||||
instances = [];
|
||||
ctl.output = new CommandOutput("human");
|
||||
assert.deepEqual(await captureLog(() => stopAll.run({}, ctl)), ["No instances to stop."]);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,56 @@
|
||||
import assert from "node:assert/strict";
|
||||
import * as lib from "@clusterio/lib";
|
||||
import { Ctl } from "@clusterio/ctl/dist/node/ctl.js";
|
||||
import { CommandOutput } from "@clusterio/ctl/dist/node/src/command_ops.js";
|
||||
|
||||
/** Run fn and return the lines it printed with console.log */
|
||||
async function captureLog(fn) {
|
||||
const lines = [];
|
||||
const originalLog = console.log; // eslint-disable-line no-console
|
||||
console.log = (...args) => lines.push(args.join(" ")); // eslint-disable-line no-console
|
||||
try {
|
||||
await fn();
|
||||
} finally {
|
||||
console.log = originalLog; // eslint-disable-line no-console
|
||||
}
|
||||
return lines;
|
||||
}
|
||||
|
||||
describe("ctl/ctl", function() {
|
||||
describe("class Ctl", function() {
|
||||
let ctl;
|
||||
beforeEach(function() {
|
||||
const connector = new lib.VirtualConnector(
|
||||
lib.Address.fromShorthand({ controlId: 1 }),
|
||||
lib.Address.fromShorthand("controller"),
|
||||
);
|
||||
ctl = new Ctl(connector, new lib.CtlConfig("control"));
|
||||
});
|
||||
|
||||
it("prints log events as JSON lines only when streaming the log", async function() {
|
||||
const info = { level: "info", message: "hello" };
|
||||
ctl.output = new CommandOutput("json");
|
||||
const logged = await captureLog(() => ctl.handleLogMessageEvent(new lib.LogMessageEvent({ ...info })));
|
||||
assert(logged.every(line => !line.startsWith("{")), "log event printed as a result");
|
||||
ctl.output.streamingLog = true;
|
||||
assert.deepEqual(
|
||||
await captureLog(() => ctl.handleLogMessageEvent(new lib.LogMessageEvent({ ...info, timestamp: 1 }))),
|
||||
['{"level":"info","message":"hello","timestamp":1}'],
|
||||
);
|
||||
});
|
||||
it("logs log events in human mode", async function() {
|
||||
ctl.output.streamingLog = true;
|
||||
const info = { level: "verbose", message: "hello" };
|
||||
assert.deepEqual(await captureLog(() => ctl.handleLogMessageEvent(new lib.LogMessageEvent(info))), []);
|
||||
});
|
||||
it("prints debug WebSocket messages", async function() {
|
||||
const event = new lib.DebugWsMessageEvent("in", "content");
|
||||
assert.deepEqual(await captureLog(() => ctl.handleDebugWsMessageEvent(event)), ["WS in content"]);
|
||||
ctl.output = new CommandOutput("json");
|
||||
assert.deepEqual(
|
||||
await captureLog(() => ctl.handleDebugWsMessageEvent(event)),
|
||||
['{"direction":"in","content":"content"}'],
|
||||
);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -336,6 +336,49 @@ describe("class Instance", function() {
|
||||
});
|
||||
});
|
||||
|
||||
describe(".checkRequiredMods()", function() {
|
||||
beforeEach(function() {
|
||||
instance.loadedPlugins = new Set([
|
||||
{ name: "foo", requiredMods: ["foo_mod", "bar_mod >= 1.1.0", "bar_mod < 2.0.0"] },
|
||||
{ name: "bar" },
|
||||
]);
|
||||
});
|
||||
function modPack(mods) {
|
||||
return lib.ModPack.fromJSON({ name: "pack", mods });
|
||||
}
|
||||
|
||||
it("should accept a mod pack with the required mods", function() {
|
||||
instance.checkRequiredMods(modPack([
|
||||
{ name: "foo_mod", enabled: true, version: "1.0.0" },
|
||||
{ name: "bar_mod", enabled: true, version: "1.1.0" },
|
||||
]));
|
||||
});
|
||||
|
||||
it("should reject missing, disabled and out of range mods", function() {
|
||||
const expected = (unmet) => new lib.ConflictError(
|
||||
"Mod pack pack does not have the mods required by the loaded plugins. " +
|
||||
`Plugin foo requires ${unmet}. ` +
|
||||
"Add the mods to the mod pack or set <plugin>.load_plugin to false for this instance."
|
||||
);
|
||||
assert.throws(
|
||||
() => instance.checkRequiredMods(modPack([{ name: "bar_mod", enabled: true, version: "1.0.0" }])),
|
||||
expected("foo_mod (missing), bar_mod >= 1.1.0 (found 1.0.0)"),
|
||||
);
|
||||
assert.throws(
|
||||
() => instance.checkRequiredMods(modPack([
|
||||
{ name: "foo_mod", enabled: false, version: "1.0.0" },
|
||||
{ name: "bar_mod", enabled: true, version: "2.0.0" },
|
||||
])),
|
||||
expected("foo_mod (disabled), bar_mod < 2.0.0 (found 2.0.0)"),
|
||||
);
|
||||
});
|
||||
|
||||
it("should ignore plugins that are not loaded", function() {
|
||||
instance.loadedPlugins = new Set([{ name: "bar" }]);
|
||||
instance.checkRequiredMods(modPack([]));
|
||||
});
|
||||
});
|
||||
|
||||
describe("save name checks", function() {
|
||||
it("should reject a start save outside the saves directory", async function() {
|
||||
await assert.rejects(
|
||||
|
||||
@@ -2064,6 +2064,9 @@ describe("Integration of Clusterio", function() {
|
||||
const roundtrip = lib.ModPack.fromModPackString(result.stdout.trim());
|
||||
roundtrip.id = reference.id;
|
||||
assert.deepEqual(roundtrip, reference);
|
||||
const shown = await execCtlOutput("mod-pack show imported-pack");
|
||||
assert.match(shown, /empty_mod 1\.0\.0/);
|
||||
assert.match(shown, /MyDouble: 12\.25/);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -2119,6 +2122,7 @@ describe("Integration of Clusterio", function() {
|
||||
|
||||
describe("mod show", function() {
|
||||
it("gives details of a mod", async function() {
|
||||
assert.match(await execCtlOutput("mod show empty_mod 1.0.0"), /name: empty_mod/);
|
||||
let result = await execCtlProcess("mod show empty_mod 1.0.0");
|
||||
let hash = await lib.hashFile(path.join("temp", "test", "mods", "empty_mod_1.0.0.zip"));
|
||||
let stat = await fs.stat(path.join("temp", "test", "mods", "empty_mod_1.0.0.zip"));
|
||||
@@ -2317,6 +2321,126 @@ describe("Integration of Clusterio", function() {
|
||||
});
|
||||
});
|
||||
|
||||
describe("config edit", function() {
|
||||
/** Write an editor script that replaces the edited file with content */
|
||||
async function writeEditor(content) {
|
||||
const file = path.resolve("temp", "test", "editor.sh");
|
||||
await fs.writeFile(file, `#!/bin/sh\ncat > "$1" <<'EOF'\n${content}\nEOF\n`, { mode: 0o755 });
|
||||
return file;
|
||||
}
|
||||
before(function() {
|
||||
if (process.platform === "win32") {
|
||||
this.skip();
|
||||
}
|
||||
});
|
||||
|
||||
it("sets controller config fields and reports failed ones", async function() {
|
||||
const config = await getControl().send(new lib.ControllerConfigGetRequest());
|
||||
const name = config["controller.name"];
|
||||
const editor = await writeEditor("controller.name = Edited-Cluster\ncontroller.no_such_field = 1");
|
||||
await execCtl(`controller config edit ${editor}`);
|
||||
const edited = await getControl().send(new lib.ControllerConfigGetRequest());
|
||||
assert.equal(edited["controller.name"], "Edited-Cluster");
|
||||
await execCtl(`controller config set controller.name ${name}`);
|
||||
});
|
||||
it("sets host config fields and reports failed ones", async function() {
|
||||
const config = await getControl().sendTo({ hostId }, new lib.HostConfigGetRequest());
|
||||
const editor = await writeEditor(`host.name = ${config["host.name"]}\nhost.no_such_field = 1`);
|
||||
await execCtl(`host config edit ${hostId} ${editor}`);
|
||||
});
|
||||
it("sets instance config fields and reports failed ones", async function() {
|
||||
const { id } = JSON.parse(await execCtlOutput("--output json instance create config-edit"));
|
||||
try {
|
||||
const editor = await writeEditor("instance.auto_start = true\ninstance.no_such_field = 1");
|
||||
await execCtl(`instance config edit ${id} ${editor}`);
|
||||
const config = await getControl().send(new lib.InstanceConfigGetRequest(id));
|
||||
assert.equal(config["instance.auto_start"], true);
|
||||
} finally {
|
||||
await execCtl(`instance delete ${id}`);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe("--output json", function() {
|
||||
it("prints lists as an array of objects", async function() {
|
||||
const roles = JSON.parse(await execCtlOutput("--output json role list"));
|
||||
assert.deepEqual(roles.find(role => role.id === 0).permissions, ["core.admin"]);
|
||||
});
|
||||
it("prints single results as an object", async function() {
|
||||
const { id } = JSON.parse(await execCtlOutput("--output json role create json-role"));
|
||||
const roles = await getControl().send(new lib.RoleListRequest());
|
||||
assert.equal(roles.find(role => role.id === id)?.name, "json-role");
|
||||
assert.equal(await execCtlOutput(`--output json role delete ${id}`), '{"success":true}');
|
||||
});
|
||||
it("prints the toJSON format in wire mode", async function() {
|
||||
const [jsonUser] = JSON.parse(await execCtlOutput("--output json user list"));
|
||||
const [wireUser] = JSON.parse(await execCtlOutput("--output wire user list"));
|
||||
assert("roleIds" in jsonUser);
|
||||
assert(!("roleIds" in wireUser));
|
||||
assert.equal(wireUser.name, jsonUser.name);
|
||||
});
|
||||
it("prints a success line for commands without a result", async function() {
|
||||
const { id } = JSON.parse(await execCtlOutput("--output json role create human-role"));
|
||||
assert.equal(await execCtlOutput(`role delete ${id}`), "Command ran successfully");
|
||||
});
|
||||
it("prints whole objects for lists that hide fields in human mode", async function() {
|
||||
const [mod] = JSON.parse(await execCtlOutput("--output json mod list"));
|
||||
assert("sha1" in mod);
|
||||
const [wireMod] = JSON.parse(await execCtlOutput("--output wire mod list"));
|
||||
assert("factorio_version" in wireMod);
|
||||
const [modPack] = JSON.parse(await execCtlOutput("--output wire mod-pack list"));
|
||||
assert("mods" in modPack);
|
||||
const user = JSON.parse(await execCtlOutput("--output wire user show test --instance-stats"));
|
||||
assert.equal(user.name, "test");
|
||||
});
|
||||
it("prints the user and instance stats in human mode", async function() {
|
||||
const output = await execCtlOutput("user show test --instance-stats");
|
||||
assert.match(output, /name +\| test/);
|
||||
});
|
||||
it("prints the result of human mode commands with more options", async function() {
|
||||
assert.match(await execCtlOutput("user list --stats --attributes"), /isAdmin/);
|
||||
const exchange = JSON.parse(await execCtlOutput(
|
||||
`--output json debug parse-exchange-string ${testStrings.default.replace(/\s/g, "")}`
|
||||
));
|
||||
assert.equal(typeof exchange, "object");
|
||||
});
|
||||
it("follows the log without a final result", async function() {
|
||||
try {
|
||||
assert.equal(await execCtlOutput("--output json log follow --controller"), "");
|
||||
} finally {
|
||||
getControl().keepOpen = false;
|
||||
}
|
||||
});
|
||||
it("prints log queries in human mode", async function() {
|
||||
assert.notEqual(await execCtlOutput("log query --controller --limit 1"), "");
|
||||
});
|
||||
it("prints pending host requests in human mode", async function() {
|
||||
assert.notEqual(await execCtlOutput("host pending"), "");
|
||||
});
|
||||
it("prints log queries as an array", async function() {
|
||||
const log = JSON.parse(await execCtlOutput("--output json log query --controller --limit 1"));
|
||||
assert.equal(log.length, 1);
|
||||
assert.equal(typeof log[0].message, "string");
|
||||
});
|
||||
it("prints errors as JSON with a non-zero exit code", async function() {
|
||||
await assert.rejects(
|
||||
execCtlProcess("--output json instance stop no-such-instance"),
|
||||
err => {
|
||||
assert.equal(err.code, 1);
|
||||
assert.deepEqual(
|
||||
JSON.parse(err.stdout),
|
||||
{ error: "CommandError", message: "No instance named no-such-instance" },
|
||||
);
|
||||
return true;
|
||||
},
|
||||
);
|
||||
await assert.rejects(
|
||||
execCtlProcess("--output json user set-admin no-such-user"),
|
||||
err => JSON.parse(err.stdout).error === "NotFoundError",
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe("user list", function() {
|
||||
it("prints roles and instances as lists", async function() {
|
||||
const output = await execCtlOutput("user list");
|
||||
|
||||
@@ -10,7 +10,7 @@ import events from "node:events";
|
||||
import * as lib from "@clusterio/lib";
|
||||
import { LineSplitter, logger } from "@clusterio/lib";
|
||||
|
||||
import { selectTargetCommand, initialize as initializeCtl } from "@clusterio/ctl";
|
||||
import { runCommand, initialize as initializeCtl } from "@clusterio/ctl";
|
||||
import { _listFactorioVersions } from "@clusterio/host/dist/node/src/server.js";
|
||||
import { pairHost } from "@clusterio/host";
|
||||
|
||||
@@ -242,8 +242,7 @@ export async function execCtl(command) {
|
||||
}
|
||||
|
||||
control.config = initArgs.ctlConfig;
|
||||
const targetCommand = selectTargetCommand(initArgs.args, initArgs.rootCommands);
|
||||
await targetCommand.run(initArgs.args, control);
|
||||
await runCommand(initArgs.args, initArgs.rootCommands, control);
|
||||
} finally {
|
||||
process.chdir("../..");
|
||||
inExecCtl = false;
|
||||
@@ -353,6 +352,22 @@ before(async function() {
|
||||
sourceDir: "packages/host/lua/clusterio_lib",
|
||||
outputDir: modsDir,
|
||||
});
|
||||
// Stand-in for the mod required by the subspace_storage plugin
|
||||
const subspaceStorageDir = path.join("temp", "test", "subspace_storage");
|
||||
await fs.rm(subspaceStorageDir, { force: true, recursive: true });
|
||||
await fs.mkdir(subspaceStorageDir, { recursive: true });
|
||||
await fs.writeFile(path.join(subspaceStorageDir, "info.json"), JSON.stringify({
|
||||
name: "subspace_storage",
|
||||
variants: [
|
||||
{ version: "2.3.11", factorio_version: "1.1" },
|
||||
{ version: "2.3.20", factorio_version: "2.0" },
|
||||
{ version: "2.3.21", factorio_version: "2.1" },
|
||||
],
|
||||
title: "Subspace Storage test stub",
|
||||
author: "Clusterio Team",
|
||||
dependencies: ["base", "clusterio_lib"],
|
||||
}));
|
||||
await lib.build({ build: true, pack: true, sourceDir: subspaceStorageDir, outputDir: modsDir });
|
||||
|
||||
console.log("Setting Controller Config");
|
||||
await execController("config create");
|
||||
@@ -410,6 +425,9 @@ before(async function() {
|
||||
|
||||
const [major, minor] = lib.normaliseMajorMinorVersion(latestFactorioVersion).split(".");
|
||||
testPack.mods.set("clusterio_lib", { name: "clusterio_lib", enabled: true, version: `2.1.${major}${minor}` });
|
||||
testPack.mods.set(
|
||||
"subspace_storage", { name: "subspace_storage", enabled: true, version: `2.3.${major}${minor}` }
|
||||
);
|
||||
|
||||
await control.sendTo("controller", new lib.ModPackCreateRequest(testPack));
|
||||
await control.sendTo(
|
||||
|
||||
@@ -6,7 +6,8 @@ import stream from "node:stream";
|
||||
// Capture native fetch before any potential mocks are applied
|
||||
const nativeFetch = global.fetch;
|
||||
|
||||
import { ModStore, ModInfo, ModVersionEquality, zipOutputStream } from "@clusterio/lib";
|
||||
import { ModStore, ModInfo, ModVersionEquality, zipOutputStream, hashFile } from "@clusterio/lib";
|
||||
import * as libBuildMod from "@clusterio/lib/build_mod.js";
|
||||
import { externalTest, createZip, createZipBuffer } from "../common.js";
|
||||
import "../setup_logging.js";
|
||||
|
||||
@@ -706,6 +707,38 @@ describe("lib/ModStore", function () {
|
||||
});
|
||||
|
||||
// === Instance Methods ===
|
||||
describe("readModInfo (static)", function () {
|
||||
it("should load from a mod zip file", async function () {
|
||||
await libBuildMod.build({
|
||||
build: true,
|
||||
pack: true,
|
||||
sourceDir: path.join("test", "file", "empty_mod"),
|
||||
outputDir: path.join("temp", "test"),
|
||||
});
|
||||
const filePath = path.join("temp", "test", "empty_mod_1.0.0.zip");
|
||||
const hash = await hashFile(filePath);
|
||||
const stat = await fs.stat(filePath);
|
||||
const mod = await ModStore.readModInfo(filePath);
|
||||
assert.deepEqual(
|
||||
mod,
|
||||
ModInfo.fromJSON({
|
||||
name: "empty_mod",
|
||||
version: "1.0.0",
|
||||
title: "An Empty Mod",
|
||||
author: "Me",
|
||||
description: "An empty mod for testing",
|
||||
factorio_version: "1.1",
|
||||
dependencies: [],
|
||||
filename: "empty_mod_1.0.0.zip",
|
||||
size: stat.size,
|
||||
mtime_ms: stat.mtimeMs,
|
||||
updated_at_ms: stat.mtimeMs,
|
||||
sha1: hash,
|
||||
})
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe("Instance Methods", function () {
|
||||
let modStore;
|
||||
let testMod1Name = "test-mod-1";
|
||||
|
||||
@@ -1,9 +1,6 @@
|
||||
import assert from "node:assert/strict";
|
||||
import fs from "node:fs/promises";
|
||||
import path from "node:path";
|
||||
|
||||
import * as lib from "@clusterio/lib";
|
||||
import * as libBuildMod from "@clusterio/lib/build_mod.js";
|
||||
import { ModInfo, ModDependency } from "@clusterio/lib";
|
||||
|
||||
import { testMatrix, testRoundTripJsonSerialisable } from "../../common.js";
|
||||
@@ -413,35 +410,6 @@ describe("lib/data/ModInfo", function() {
|
||||
["UltraMod", "SuperLib >= 1.00", "! bad-mod"].map(dep => new ModDependency(dep))
|
||||
);
|
||||
});
|
||||
it("should load from a mod zip file", async function() {
|
||||
await libBuildMod.build({
|
||||
build: true,
|
||||
pack: true,
|
||||
sourceDir: path.join("test", "file", "empty_mod"),
|
||||
outputDir: path.join("temp", "test"),
|
||||
});
|
||||
const filePath = path.join("temp", "test", "empty_mod_1.0.0.zip");
|
||||
const hash = await lib.hashFile(filePath);
|
||||
const stat = await fs.stat(filePath);
|
||||
const mod = await ModInfo.fromModFile(filePath);
|
||||
assert.deepEqual(
|
||||
mod,
|
||||
ModInfo.fromJSON({
|
||||
name: "empty_mod",
|
||||
version: "1.0.0",
|
||||
title: "An Empty Mod",
|
||||
author: "Me",
|
||||
description: "An empty mod for testing",
|
||||
factorio_version: "1.1",
|
||||
dependencies: [],
|
||||
filename: "empty_mod_1.0.0.zip",
|
||||
size: stat.size,
|
||||
mtime_ms: stat.mtimeMs,
|
||||
updated_at_ms: stat.mtimeMs,
|
||||
sha1: hash,
|
||||
})
|
||||
);
|
||||
});
|
||||
describe("checkDependencySatisfaction()", function() {
|
||||
it("should return undefined when satisfied", function() {
|
||||
const mod = ModInfo.fromJSON({ dependencies: ["! a", "b = 1.0.0", "? c = 2.0.0"] });
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
import assert from "node:assert/strict";
|
||||
import fs from "node:fs/promises";
|
||||
import os from "node:os";
|
||||
import path from "node:path";
|
||||
|
||||
import { testLines } from "./factorio/lines.js";
|
||||
@@ -66,6 +67,77 @@ describe("lib/logging_utils.js", function() {
|
||||
});
|
||||
});
|
||||
|
||||
describe("class DailyFileTransport", function() {
|
||||
let tempDir = path.join("temp", "test", "daily_file");
|
||||
beforeEach(async function() {
|
||||
await fs.rm(tempDir, { recursive: true, force: true });
|
||||
});
|
||||
|
||||
function create(now, dirname = tempDir) {
|
||||
return new lib.DailyFileTransport({ dirname, prefix: "test", now });
|
||||
}
|
||||
function write(transport, message) {
|
||||
transport.log({ [Symbol.for("message")]: JSON.stringify({ message }) }, () => {});
|
||||
}
|
||||
async function close(transport) {
|
||||
await new Promise(resolve => transport.close(resolve));
|
||||
}
|
||||
async function read(file) {
|
||||
let content = await fs.readFile(path.join(tempDir, file), "utf8");
|
||||
assert(content.endsWith(os.EOL));
|
||||
return content.split(os.EOL).slice(0, -1).map(line => JSON.parse(line).message);
|
||||
}
|
||||
|
||||
it("should create the directory and write lines to the file for the UTC date", async function() {
|
||||
let transport = create(() => Date.parse("2026-11-19T12:00:00Z"), path.join(tempDir, "nested"));
|
||||
write(transport, "first");
|
||||
write(transport, "second");
|
||||
await close(transport);
|
||||
assert.deepEqual(await read(path.join("nested", "test-2026-11-19.log")), ["first", "second"]);
|
||||
});
|
||||
|
||||
it("should append to an existing file", async function() {
|
||||
await fs.mkdir(tempDir, { recursive: true });
|
||||
await fs.writeFile(path.join(tempDir, "test-2026-11-19.log"), `{"message":"old"}${os.EOL}`);
|
||||
let transport = create(() => Date.parse("2026-11-19T12:00:00Z"));
|
||||
write(transport, "new");
|
||||
await close(transport);
|
||||
assert.deepEqual(await read("test-2026-11-19.log"), ["old", "new"]);
|
||||
});
|
||||
|
||||
it("should switch files when the UTC date changes", async function() {
|
||||
let time = Date.parse("2026-11-19T23:59:59.999Z");
|
||||
let transport = create(() => time);
|
||||
write(transport, "before");
|
||||
time += 1;
|
||||
write(transport, "after");
|
||||
await close(transport);
|
||||
assert.deepEqual((await fs.readdir(tempDir)).sort(), ["test-2026-11-19.log", "test-2026-11-20.log"]);
|
||||
assert.deepEqual(await read("test-2026-11-19.log"), ["before"]);
|
||||
assert.deepEqual(await read("test-2026-11-20.log"), ["after"]);
|
||||
});
|
||||
|
||||
it("should use the UTC date rather than the local one", async function() {
|
||||
let transport = create(() => Date.parse("2026-11-20T00:30:00+02:00"));
|
||||
write(transport, "message");
|
||||
await close(transport);
|
||||
assert.deepEqual(await fs.readdir(tempDir), ["test-2026-11-19.log"]);
|
||||
});
|
||||
|
||||
it("should emit write errors", async function() {
|
||||
await fs.mkdir(path.join(tempDir, "test-2026-11-19.log"), { recursive: true });
|
||||
let transport = create(() => Date.parse("2026-11-19T12:00:00Z"));
|
||||
let error = new Promise(resolve => transport.once("error", resolve));
|
||||
write(transport, "message");
|
||||
assert.equal((await error).code, "EISDIR");
|
||||
});
|
||||
|
||||
it("should close when nothing was written", async function() {
|
||||
await close(create(Date.now));
|
||||
assert.deepEqual(await fs.readdir(tempDir), []);
|
||||
});
|
||||
});
|
||||
|
||||
describe("deleteOldLogs", function() {
|
||||
let tempDir = path.join("temp", "test", "log_retention");
|
||||
let files = [
|
||||
|
||||
@@ -24,4 +24,22 @@ describe("lib/plugin", function() {
|
||||
}
|
||||
});
|
||||
});
|
||||
describe("pluginRequiredMods()", function() {
|
||||
it("should parse dependency strings", function() {
|
||||
const mods = lib.pluginRequiredMods({
|
||||
name: "foo", title: "Foo", requiredMods: ["bar", "baz >= 1.2.0", "baz < 2.0.0"],
|
||||
});
|
||||
assert.deepEqual(mods.map(mod => [mod.name, mod.version?.toString()]), [
|
||||
["bar", undefined], ["baz", ">= 1.2.0"], ["baz", "< 2.0.0"],
|
||||
]);
|
||||
});
|
||||
it("should return an empty list without requiredMods", function() {
|
||||
assert.deepEqual(lib.pluginRequiredMods({ name: "foo", title: "Foo" }), []);
|
||||
});
|
||||
it("should reject dependency prefixes and invalid versions", function() {
|
||||
for (const spec of ["? bar", "! bar", "~ bar", "bar >= 1..2"]) {
|
||||
assert.throws(() => lib.pluginRequiredMods({ name: "foo", title: "Foo", requiredMods: [spec] }));
|
||||
}
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,25 @@
|
||||
/* eslint-disable node/no-sync */
|
||||
import assert from "node:assert/strict";
|
||||
import zlib from "node:zlib";
|
||||
|
||||
import * as browserZlib from "../../packages/lib/src/zlib_sync.browser.ts";
|
||||
|
||||
describe("lib/zlib_sync.browser", function() {
|
||||
const text = JSON.stringify({ name: "pack", mods: [{ name: "base", version: "2.0.0" }] });
|
||||
|
||||
it("should inflate data deflated by node:zlib", function() {
|
||||
const inflated = browserZlib.inflateSync(zlib.deflateSync(text));
|
||||
assert.equal(Buffer.from(inflated).toString(), text);
|
||||
});
|
||||
it("should deflate data node:zlib can inflate", function() {
|
||||
assert.equal(zlib.inflateSync(browserZlib.deflateSync(text)).toString(), text);
|
||||
const bytes = Buffer.from(text);
|
||||
assert.equal(zlib.inflateSync(browserZlib.deflateSync(bytes)).toString(), text);
|
||||
});
|
||||
it("should throw with a Z_ code on invalid data", function() {
|
||||
assert.throws(
|
||||
() => browserZlib.inflateSync(Buffer.from("not zlib data")),
|
||||
err => err.code === "Z_DATA_ERROR"
|
||||
);
|
||||
});
|
||||
});
|
||||
Reference in new issue
Block a user