mirror of
https://github.com/clusterio/clusterio.git
synced 2026-11-14 23:24:52 +09:00
Danielv123
87d4f5c64e
Hosts join the cluster by running the installer, which shows a code and waits until the request is approved under Hosts > Add host in the web interface or with clusterioctl host approve. An admin can pass their user token to the installer to approve the host right away. The token is only used for that and is not saved. The controller only accepts hosts that have a record, and only approving a host creates one. Revoking a host deletes its record, so its token can no longer be used to reconnect. Hosts that have connected before keep working. Removes host generate-token, revoke-token and create-config from clusterioctl, bootstrap generate-host-token, the host token messages and the core.host.generate_token, revoke_token and create_config permissions, which are also stripped from stored roles. Adds clusterioctl host pending, approve, reject and revoke, and the core.host.approve and core.host.revoke permissions. Standalone installs add the host to the controller database directly, since the controller is not running during the install.
555 lines
21 KiB
JavaScript
555 lines
21 KiB
JavaScript
import assert from "node:assert/strict";
|
|
import fs from "node:fs/promises";
|
|
import os from "node:os";
|
|
import path from "node:path";
|
|
import * as lib from "@clusterio/lib";
|
|
|
|
import { Controller, ControlConnection } from "@clusterio/controller";
|
|
import { testMatrix, testRoundTripJsonSerialisable } from "../common.js";
|
|
import "../setup_logging.js";
|
|
|
|
describe("messages/controller", function() {
|
|
/** @type {Controller} */
|
|
let controller;
|
|
/** @type {ControlConnection} */
|
|
let controlConnection;
|
|
/** @type {lib.InstanceConfig} */
|
|
let instanceConfig;
|
|
|
|
beforeEach(function() {
|
|
const controllerConfig = new lib.ControllerConfig("controller");
|
|
const connection = new lib.VirtualConnector(
|
|
lib.Address.fromShorthand("controller"),
|
|
lib.Address.fromShorthand({ controlId: 1 }),
|
|
);
|
|
controller = new Controller(lib.logger, [], controllerConfig);
|
|
instanceConfig = new lib.InstanceConfig("controller");
|
|
controller.instances.createInstance(instanceConfig);
|
|
const user = controller.users.getOrCreateUser("test");
|
|
controlConnection = new ControlConnection({ version: "2.0.0" }, connection, controller, user, 1);
|
|
});
|
|
|
|
describe("ControllerMarkRestartRequiredRequest", function() {
|
|
it("runs", async function() {
|
|
await controlConnection.handleControllerMarkRestartRequiredRequest(
|
|
new lib.ControllerMarkRestartRequiredRequest()
|
|
);
|
|
assert.equal(controller.config.restartRequired, true);
|
|
});
|
|
});
|
|
|
|
describe("ControllerUpdateRequest", function() {
|
|
it("runs", async function() {
|
|
controller.config.set("controller.allow_remote_updates", true);
|
|
await controlConnection.handleControllerUpdateRequest(new lib.ControllerUpdateRequest());
|
|
});
|
|
it("rejects if updates are disabled", async function() {
|
|
controller.config.set("controller.allow_remote_updates", false);
|
|
await assert.rejects(
|
|
controlConnection.handleControllerUpdateRequest(new lib.ControllerUpdateRequest()),
|
|
/Remote updates are disabled on this machine/
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("ControllerConfigGetRequest", function() {
|
|
it("runs", async function() {
|
|
const config = await controlConnection.handleControllerConfigGetRequest(
|
|
new lib.ControllerConfigGetRequest()
|
|
);
|
|
assert.deepEqual(config, controller.config.toRemote("control"));
|
|
});
|
|
});
|
|
|
|
describe("ControllerConfigSetFieldRequest", function() {
|
|
it("is round trip json serialisable", function() {
|
|
testRoundTripJsonSerialisable(lib.ControllerConfigSetFieldRequest, testMatrix(
|
|
["controller.name", "invalid"], // field
|
|
["Foo Bar", "true", "5", "{}"], // value
|
|
));
|
|
});
|
|
it("runs", async function() {
|
|
await controlConnection.handleControllerConfigSetFieldRequest(
|
|
new lib.ControllerConfigSetFieldRequest("controller.name", "Foo Bar")
|
|
);
|
|
assert.equal(controller.config.get("controller.name"), "Foo Bar");
|
|
});
|
|
it("rejects if the field does not exist", async function() {
|
|
await assert.rejects(
|
|
controlConnection.handleControllerConfigSetFieldRequest(
|
|
new lib.ControllerConfigSetFieldRequest("invalid", "Foo Bar")
|
|
),
|
|
/No field named 'invalid'/
|
|
);
|
|
});
|
|
it("rejects if the field is inaccessible", async function() {
|
|
await assert.rejects(
|
|
controlConnection.handleControllerConfigSetFieldRequest(
|
|
new lib.ControllerConfigSetFieldRequest("controller.version", "2.0.0")
|
|
),
|
|
/Field 'controller.version' is not accessible from control/
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("ControllerConfigSetPropRequest", function() {
|
|
it("is round trip json serialisable", function() {
|
|
testRoundTripJsonSerialisable(lib.ControllerConfigSetPropRequest, testMatrix(
|
|
["controller.name", "invalid"], // field
|
|
["foo", "bar"], // prop
|
|
["Foo Bar", true, 5, {}], // value
|
|
));
|
|
});
|
|
it("runs", async function() {
|
|
this.skip(); // No object fields on controller
|
|
});
|
|
it("rejects if the field does not exist", async function() {
|
|
await assert.rejects(
|
|
controlConnection.handleControllerConfigSetPropRequest(
|
|
new lib.ControllerConfigSetPropRequest("invalid", "foo", "bar")
|
|
),
|
|
/No field named 'invalid'/
|
|
);
|
|
});
|
|
it("rejects if the field is not an object", async function() {
|
|
await assert.rejects(
|
|
controlConnection.handleControllerConfigSetPropRequest(
|
|
new lib.ControllerConfigSetPropRequest("controller.name", "foo", "bar")
|
|
),
|
|
/Cannot set property on non-object field 'controller\.name'/
|
|
);
|
|
});
|
|
it("rejects if the field is inaccessible", async function() {
|
|
await assert.rejects(
|
|
controlConnection.handleControllerConfigSetPropRequest(
|
|
new lib.ControllerConfigSetPropRequest("controller.version", "foo", "bar")
|
|
),
|
|
/Field 'controller\.version' is not accessible from control/
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("ControllerConfigSetRequest", function() {
|
|
it("is round trip json serialisable", function() {
|
|
testRoundTripJsonSerialisable(lib.ControllerConfigSetRequest, testMatrix(
|
|
[ // fields
|
|
{ "foo": "bar", "baz": { "cat": "dog" } },
|
|
{ "foo": "5", "baz": { "cat": "5" } },
|
|
{ "foo": "true", "baz": { "cat": "true" } },
|
|
{ "foo": "{}", "baz": { "cat": "{}" } },
|
|
],
|
|
));
|
|
});
|
|
it("runs", async function() {
|
|
await controlConnection.handleControllerConfigSetRequest(new lib.ControllerConfigSetRequest({
|
|
"controller.name": "Foo Bar",
|
|
"controller.mods_directory": "Bar Baz",
|
|
}));
|
|
assert.equal(controller.config.get("controller.name"), "Foo Bar");
|
|
assert.equal(controller.config.get("controller.mods_directory"), "Bar Baz");
|
|
});
|
|
it("rejects if the field does not exist", async function() {
|
|
await assert.rejects(
|
|
controlConnection.handleControllerConfigSetRequest(new lib.ControllerConfigSetRequest({
|
|
"controller.name": "Foo Bar",
|
|
"invalid": "Bar Baz",
|
|
})),
|
|
/No field named 'invalid'/
|
|
);
|
|
assert.equal(controller.config.get("controller.name"), "Your Cluster");
|
|
});
|
|
it("rejects if the field is not an object", async function() {
|
|
const prevDir = controller.config.get("controller.mods_directory");
|
|
await assert.rejects(
|
|
controlConnection.handleControllerConfigSetRequest(new lib.ControllerConfigSetRequest({
|
|
"controller.name": "Foo Bar",
|
|
"controller.mods_directory": {
|
|
"foo": "bar",
|
|
},
|
|
})),
|
|
/Cannot set property on non-object field 'controller\.mods_directory'/
|
|
);
|
|
assert.equal(controller.config.get("controller.name"), "Your Cluster");
|
|
assert.equal(controller.config.get("controller.mods_directory"), prevDir);
|
|
});
|
|
it("rejects if the field is inaccessible", async function() {
|
|
const prevVersion = controller.config.get("controller.version");
|
|
await assert.rejects(
|
|
controlConnection.handleControllerConfigSetRequest(new lib.ControllerConfigSetRequest({
|
|
"controller.name": "Foo Bar",
|
|
"controller.version": "2.0.0",
|
|
})),
|
|
/Field 'controller\.version' is not accessible from control/
|
|
);
|
|
assert.equal(controller.config.get("controller.name"), "Your Cluster");
|
|
assert.equal(controller.config.get("controller.version"), prevVersion);
|
|
});
|
|
});
|
|
|
|
describe("Host pairing", function() {
|
|
const details = [
|
|
new lib.HostPairingDetails("ABC-DEF", "Host A", "10.0.0.1", "2.0.0", 100, 200),
|
|
new lib.HostPairingDetails("GHJ-KMN", "Host B", "2001:db8::1", "", 0, 300, true),
|
|
];
|
|
|
|
it("defines the pairing messages for control links approving hosts", function() {
|
|
for (const Message of [
|
|
lib.HostPairingListRequest,
|
|
lib.HostPairingApproveRequest,
|
|
lib.HostPairingRejectRequest,
|
|
]) {
|
|
assert.equal(Message.type, "request", Message.name);
|
|
assert.equal(Message.src, "control", Message.name);
|
|
assert.equal(Message.dst, "controller", Message.name);
|
|
assert.equal(Message.permission, "core.host.approve", Message.name);
|
|
assert(lib.Link._requestsByClass.has(Message), `${Message.name} is not registered`);
|
|
}
|
|
assert.equal(lib.HostPairingUpdatesEvent.type, "event");
|
|
assert.equal(lib.HostPairingUpdatesEvent.src, "controller");
|
|
assert.equal(lib.HostPairingUpdatesEvent.dst, "control");
|
|
assert.equal(lib.HostPairingUpdatesEvent.permission, "core.host.approve");
|
|
assert(lib.Link._eventsByClass.has(lib.HostPairingUpdatesEvent));
|
|
});
|
|
it("removes the host token messages", function() {
|
|
for (const name of ["HostGenerateTokenRequest", "HostConfigCreateRequest", "HostRevokeTokensRequest"]) {
|
|
assert.equal(lib[name], undefined, `${name} is still exported`);
|
|
assert(!lib.Link._requestsByName.has(name), `${name} is still registered`);
|
|
}
|
|
});
|
|
it("defines the host permissions", function() {
|
|
for (const name of ["core.host.approve", "core.host.revoke"]) {
|
|
assert(lib.permissions.has(name), `${name} is not defined`);
|
|
assert.equal(lib.permissions.get(name).grantByDefault, false, `${name} is granted by default`);
|
|
}
|
|
for (const name of ["core.host.generate_token", "core.host.revoke_token", "core.host.create_config"]) {
|
|
assert.equal(lib.permissions.has(name), false, `${name} is still defined`);
|
|
}
|
|
});
|
|
it("round trips HostPairingListRequest responses", function() {
|
|
const validate = lib.compile(lib.HostPairingListRequest.Response.jsonSchema);
|
|
const json = JSON.parse(JSON.stringify(details));
|
|
assert(validate(json), JSON.stringify(validate.errors));
|
|
assert.deepEqual(lib.HostPairingListRequest.Response.fromJSON(json), details);
|
|
});
|
|
it("round trips HostPairingUpdatesEvent", function() {
|
|
testRoundTripJsonSerialisable(lib.HostPairingUpdatesEvent, [[[]], [details]]);
|
|
});
|
|
it("round trips HostPairingApproveRequest", function() {
|
|
testRoundTripJsonSerialisable(lib.HostPairingApproveRequest, testMatrix(
|
|
["ABC-DEF", "abcdef"], // code
|
|
[undefined, "Renamed"], // name
|
|
));
|
|
const validate = lib.compile(lib.HostPairingApproveRequest.Response.jsonSchema);
|
|
assert(validate(1234));
|
|
});
|
|
it("round trips HostPairingRejectRequest", function() {
|
|
testRoundTripJsonSerialisable(lib.HostPairingRejectRequest, [["ABC-DEF"], ["abcdef"]]);
|
|
});
|
|
it("approves a pending request", async function() {
|
|
controller.config.set("controller.auth_secret", Buffer.from("TestSecretDoNotUse").toString("base64"));
|
|
const { requestId, code } = controller.hostPairing.create("Host A", "", "10.0.0.1");
|
|
const list = await controlConnection.handleHostPairingListRequest(new lib.HostPairingListRequest());
|
|
assert.deepEqual(list.map(entry => entry.code), [code]);
|
|
const hostId = await controlConnection.handleHostPairingApproveRequest(
|
|
new lib.HostPairingApproveRequest(code)
|
|
);
|
|
assert.equal(controller.hosts.get(hostId).name, "Host A");
|
|
assert.equal(controller.hostPairing.poll(requestId).hostId, hostId);
|
|
});
|
|
it("rejects a pending request", async function() {
|
|
const { requestId, code } = controller.hostPairing.create("Host A", "", "10.0.0.1");
|
|
await controlConnection.handleHostPairingRejectRequest(new lib.HostPairingRejectRequest(code));
|
|
assert.throws(() => controller.hostPairing.poll(requestId), /Request was rejected/);
|
|
});
|
|
});
|
|
|
|
describe("InstanceConfigGetRequest", function() {
|
|
it("runs", async function() {
|
|
const config = await controlConnection.handleInstanceConfigGetRequest(
|
|
new lib.InstanceConfigGetRequest(instanceConfig.get("instance.id"))
|
|
);
|
|
assert.deepEqual(config, instanceConfig.toRemote("control"));
|
|
});
|
|
});
|
|
|
|
describe("InstanceConfigSetFieldRequest", function() {
|
|
it("is round trip json serialisable", function() {
|
|
testRoundTripJsonSerialisable(lib.InstanceConfigSetFieldRequest, testMatrix(
|
|
[1], // instance id
|
|
["controller.name", "invalid"], // field
|
|
["Foo Bar", "true", "5", "{}"], // value
|
|
));
|
|
});
|
|
it("runs", async function() {
|
|
await controlConnection.handleInstanceConfigSetFieldRequest(
|
|
new lib.InstanceConfigSetFieldRequest(instanceConfig.get("instance.id"), "instance.name", "Foo Bar")
|
|
);
|
|
assert.equal(instanceConfig.get("instance.name"), "Foo Bar");
|
|
});
|
|
it("rejects if the field does not exist", async function() {
|
|
await assert.rejects(
|
|
controlConnection.handleInstanceConfigSetFieldRequest(
|
|
new lib.InstanceConfigSetFieldRequest(instanceConfig.get("instance.id"), "invalid", "Foo Bar")
|
|
),
|
|
/No field named 'invalid'/
|
|
);
|
|
});
|
|
it("rejects if the field is inaccessible", async function() {
|
|
await assert.rejects(
|
|
controlConnection.handleInstanceConfigSetFieldRequest(
|
|
new lib.InstanceConfigSetFieldRequest(
|
|
instanceConfig.get("instance.id"), "factorio.host_assigned_game_port", "3000"
|
|
)
|
|
),
|
|
/Field 'factorio\.host_assigned_game_port' is not accessible from control/
|
|
);
|
|
});
|
|
it("rejects setting 'instance.assigned_host'", async function() {
|
|
await assert.rejects(
|
|
controlConnection.handleInstanceConfigSetFieldRequest(
|
|
new lib.InstanceConfigSetFieldRequest(
|
|
instanceConfig.get("instance.id"), "instance.assigned_host", 5
|
|
)
|
|
),
|
|
/instance\.assigned_host must be set through the assign-host interface/
|
|
);
|
|
});
|
|
it("rejects setting 'instance.id'", async function() {
|
|
await assert.rejects(
|
|
controlConnection.handleInstanceConfigSetFieldRequest(
|
|
new lib.InstanceConfigSetFieldRequest(
|
|
instanceConfig.get("instance.id"), "instance.id", 5
|
|
)
|
|
),
|
|
/Setting instance\.id is not supported/
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("InstanceConfigSetPropRequest", function() {
|
|
it("is round trip json serialisable", function() {
|
|
testRoundTripJsonSerialisable(lib.InstanceConfigSetPropRequest, testMatrix(
|
|
[1], // instance id
|
|
["controller.name", "invalid"], // field
|
|
["foo", "bar"], // prop
|
|
["Foo Bar", true, 5, {}], // value
|
|
));
|
|
});
|
|
it("runs", async function() {
|
|
controlConnection.handleInstanceConfigSetPropRequest(
|
|
new lib.InstanceConfigSetPropRequest(
|
|
instanceConfig.get("instance.id"), "factorio.settings", "name", "Foo Bar"
|
|
)
|
|
);
|
|
const { name, ...rest } = instanceConfig.get("factorio.settings");
|
|
assert.equal(name, "Foo Bar");
|
|
});
|
|
it("rejects if the field does not exist", async function() {
|
|
await assert.rejects(
|
|
controlConnection.handleInstanceConfigSetPropRequest(
|
|
new lib.InstanceConfigSetPropRequest(instanceConfig.get("instance.id"), "invalid", "foo", "bar")
|
|
),
|
|
/No field named 'invalid'/
|
|
);
|
|
});
|
|
it("rejects if the field is not an object", async function() {
|
|
await assert.rejects(
|
|
controlConnection.handleInstanceConfigSetPropRequest(
|
|
new lib.InstanceConfigSetPropRequest(
|
|
instanceConfig.get("instance.id"), "instance.name", "foo", "bar"
|
|
)
|
|
),
|
|
/Cannot set property on non-object field 'instance\.name'/
|
|
);
|
|
});
|
|
it("rejects if the field is inaccessible", async function() {
|
|
await assert.rejects(
|
|
controlConnection.handleInstanceConfigSetPropRequest(
|
|
new lib.InstanceConfigSetPropRequest(
|
|
instanceConfig.get("instance.id"), "factorio.host_assigned_game_port", "foo", "bar"
|
|
)
|
|
),
|
|
/Field 'factorio\.host_assigned_game_port' is not accessible from control/
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("InstanceConfigSetRequest", function() {
|
|
it("is round trip json serialisable", function() {
|
|
testRoundTripJsonSerialisable(lib.InstanceConfigSetRequest, testMatrix(
|
|
[1], // instance id
|
|
[ // fields
|
|
{ "foo": "bar", "baz": { "cat": "dog" } },
|
|
{ "foo": "5", "baz": { "cat": "5" } },
|
|
{ "foo": "true", "baz": { "cat": "true" } },
|
|
{ "foo": "{}", "baz": { "cat": "{}" } },
|
|
],
|
|
));
|
|
});
|
|
it("runs", async function() {
|
|
await controlConnection.handleInstanceConfigSetRequest(new lib.InstanceConfigSetRequest(
|
|
instanceConfig.get("instance.id"), {
|
|
"instance.name": "Foo Bar",
|
|
"factorio.executable_path": "Bar Baz",
|
|
})
|
|
);
|
|
assert.equal(instanceConfig.get("instance.name"), "Foo Bar");
|
|
assert.equal(instanceConfig.get("factorio.executable_path"), "Bar Baz");
|
|
});
|
|
it("rejects if the field does not exist", async function() {
|
|
await assert.rejects(
|
|
controlConnection.handleInstanceConfigSetRequest(new lib.InstanceConfigSetRequest(
|
|
instanceConfig.get("instance.id"), {
|
|
"instance.name": "Foo Bar",
|
|
"invalid": "Bar Baz",
|
|
})
|
|
),
|
|
/No field named 'invalid'/
|
|
);
|
|
assert.equal(instanceConfig.get("instance.name"), "New Instance");
|
|
});
|
|
it("rejects if the field is not an object", async function() {
|
|
const prevPath = instanceConfig.get("factorio.executable_path");
|
|
await assert.rejects(
|
|
controlConnection.handleInstanceConfigSetRequest(new lib.InstanceConfigSetRequest(
|
|
instanceConfig.get("instance.id"), {
|
|
"instance.name": "Foo Bar",
|
|
"factorio.executable_path": {
|
|
"foo": "bar",
|
|
},
|
|
})
|
|
),
|
|
/Cannot set property on non-object field 'factorio\.executable_path'/
|
|
);
|
|
assert.equal(instanceConfig.get("instance.name"), "New Instance");
|
|
assert.equal(instanceConfig.get("factorio.executable_path"), prevPath);
|
|
});
|
|
it("rejects if the field is inaccessible", async function() {
|
|
await assert.rejects(
|
|
controlConnection.handleInstanceConfigSetRequest(new lib.InstanceConfigSetRequest(
|
|
instanceConfig.get("instance.id"), {
|
|
"instance.name": "Foo Bar",
|
|
"factorio.host_assigned_game_port": "Bar Baz",
|
|
})
|
|
),
|
|
/Field 'factorio\.host_assigned_game_port' is not accessible from control/
|
|
);
|
|
assert.equal(instanceConfig.get("instance.name"), "New Instance");
|
|
// Can't check value of host_assigned_game_port as it is not accessible on controller
|
|
});
|
|
it("rejects setting 'instance.assigned_host'", async function() {
|
|
const prevHost = instanceConfig.get("instance.assigned_host");
|
|
await assert.rejects(
|
|
controlConnection.handleInstanceConfigSetRequest(new lib.InstanceConfigSetRequest(
|
|
instanceConfig.get("instance.id"), {
|
|
"instance.name": "Foo Bar",
|
|
"instance.assigned_host": 5,
|
|
})
|
|
),
|
|
/instance\.assigned_host must be set through the assign-host interface/
|
|
);
|
|
assert.equal(instanceConfig.get("instance.name"), "New Instance");
|
|
assert.equal(instanceConfig.get("instance.assigned_host"), prevHost);
|
|
});
|
|
it("rejects setting 'instance.id'", async function() {
|
|
const prevId = instanceConfig.get("instance.id");
|
|
await assert.rejects(
|
|
controlConnection.handleInstanceConfigSetRequest(new lib.InstanceConfigSetRequest(
|
|
instanceConfig.get("instance.id"), {
|
|
"instance.name": "Foo Bar",
|
|
"instance.id": 5,
|
|
})
|
|
),
|
|
/Setting instance\.id is not supported/
|
|
);
|
|
assert.equal(instanceConfig.get("instance.name"), "New Instance");
|
|
assert.equal(instanceConfig.get("instance.id"), prevId);
|
|
});
|
|
});
|
|
|
|
describe("External", function() {
|
|
it("runs", async function() {
|
|
let callCount = 0;
|
|
const versions = [
|
|
{ version: "1.2.3", stable: true, headlessUrl: "path/to/download" },
|
|
{ version: "1.2.4", stable: false, headlessUrl: "path/to/download" },
|
|
];
|
|
|
|
// Mock the cache to avoid needless fetches
|
|
controller.factorioVersions = new lib.ValueCache(async () => {
|
|
callCount += 1;
|
|
return versions;
|
|
});
|
|
|
|
// First call should result in a fetch
|
|
const versions1 = await controlConnection.handleFactorioVersionsRequest(
|
|
new lib.FactorioVersionsRequest()
|
|
);
|
|
|
|
assert.deepEqual(versions1, versions);
|
|
assert.equal(callCount, 1);
|
|
|
|
// Second call should not fetch due to default maxAgeMs being greater than 0
|
|
const versions2 = await controlConnection.handleFactorioVersionsRequest(
|
|
new lib.FactorioVersionsRequest()
|
|
);
|
|
|
|
assert.deepEqual(versions2, versions);
|
|
assert.equal(callCount, 1);
|
|
|
|
// Setting maxAgeMs to 0 should result in a new fetch
|
|
const versions3 = await controlConnection.handleFactorioVersionsRequest(
|
|
new lib.FactorioVersionsRequest(0)
|
|
);
|
|
|
|
assert.deepEqual(versions3, versions);
|
|
assert.equal(callCount, 2);
|
|
});
|
|
it("round trips LatestReleasesRequest", function() {
|
|
testRoundTripJsonSerialisable(lib.LatestReleasesRequest, [[], [0], [60000]]);
|
|
});
|
|
it("caches the latest releases and persists them for offline use", async function() {
|
|
const releases = {
|
|
stable: { headless: "2.0.77" },
|
|
experimental: { headless: "2.1.8" },
|
|
};
|
|
const databaseDirectory = await fs.mkdtemp(path.join(os.tmpdir(), "clusterio-test-"));
|
|
controller.config.set("controller.database_directory", databaseDirectory);
|
|
const cachePath = path.join(databaseDirectory, "latest-releases.json");
|
|
const originalFetch = global.fetch;
|
|
try {
|
|
let callCount = 0;
|
|
global.fetch = async () => {
|
|
callCount += 1;
|
|
return { ok: true, status: 200, statusText: "OK", json: async () => releases };
|
|
};
|
|
|
|
// First call fetches from the api and persists the result to disk
|
|
const fetched = await controlConnection.handleLatestReleasesRequest(
|
|
new lib.LatestReleasesRequest(0)
|
|
);
|
|
assert.deepEqual(fetched, releases);
|
|
assert.equal(callCount, 1);
|
|
assert.deepEqual(JSON.parse(await fs.readFile(cachePath, "utf8")), releases);
|
|
|
|
// When the api is unavailable the persisted copy is served instead
|
|
global.fetch = async () => { throw new Error("Network Error"); };
|
|
const cached = await controlConnection.handleLatestReleasesRequest(
|
|
new lib.LatestReleasesRequest(0)
|
|
);
|
|
assert.deepEqual(cached, releases);
|
|
|
|
// With no persisted copy and an unavailable api an empty object is returned
|
|
await fs.rm(cachePath);
|
|
const empty = await controlConnection.handleLatestReleasesRequest(
|
|
new lib.LatestReleasesRequest(0)
|
|
);
|
|
assert.deepEqual(empty, {});
|
|
} finally {
|
|
global.fetch = originalFetch;
|
|
await fs.rm(databaseDirectory, { recursive: true, force: true });
|
|
}
|
|
});
|
|
});
|
|
});
|