Files
burrow-server/test/harness.js
T
SnipzilandClaude Opus 5.5 63dc43ebb3 test: bring the test suite up to date, and let it run on Windows
The smoke, features, account and qol tests had fallen behind the server
and failed before reaching their end. Each now checks what the server
does on purpose today:

- harness: the chat filter messages the server sends unasked ("xfl"
  after every login, "xfa" on the first room) are set aside like "zs".
- smoke: a banned account's sign-in is refused with "account_banned", so
  the login-choices check uses a fresh account instead of the banned Carol.
- features: a shop's name comes from its room file, read the first time
  anyone goes in (the first visitor sees a name made from the path). A
  scout goes in first until the file is read, so the check no longer
  depends on what an earlier run left in cache/.
- account: a deleted account's name is held for NAME_HELD_DAYS, so taking
  it again right away is "username_taken".
- qol: the commands page sets what to type in italics.

And on Windows: withServer waits for the server process to exit before
removing its data directory, and retries; the database stays locked until
the process is gone, and the cleanup's EPERM hid the test's own result.

All seven test files pass (smoke, features, account, qol, buddygames,
restored, and staff in the next commit).

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-16 22:42:36 -04:00

183 lines
5.8 KiB
JavaScript

"use strict";
// what the end-to-end tests share: a game client that speaks the SWF's
// socket protocol, and a real server process on ports and a database of its
// own that is thrown away afterwards.
const assert = require("assert");
const {spawn} = require("child_process");
const fs = require("fs");
const net = require("net");
const os = require("os");
const path = require("path");
class GameClient {
constructor(gamePort) {
this.gamePort = gamePort;
this.queue = [];
this.varUpdates = [];
this.askedForGames = 0;
this.unaskedGames = [];
this.waiters = [];
this.buffer = Buffer.alloc(0);
}
connect() {
return new Promise((resolve, reject) => {
this.socket = net.connect(this.gamePort, "127.0.0.1", resolve);
this.socket.once("error", reject);
this.socket.on("data", chunk => {
this.buffer = Buffer.concat([this.buffer, chunk]);
let end;
while ((end = this.buffer.indexOf(0)) !== -1) {
this.queue.push(this.buffer.toString("utf8", 0, end));
if (process.env.AJ_TEST_TRACE) {
console.log(`<- ${this.queue[this.queue.length - 1].slice(0, 300)}`);
}
this.buffer = this.buffer.subarray(end + 1);
}
this.flush();
});
});
}
flush() {
while (this.queue.length && this.waiters.length) {
this.waiters.shift()(this.queue.shift());
}
}
send(message) {
if (process.env.AJ_TEST_TRACE) {
console.log(`-> ${message.slice(0, 300)}`);
}
this.socket.write(message + "\0");
}
xt(cmd, roomId, ...params) {
if (cmd === "mi") {
this.askedForGames++;
}
this.send(`%xt%o%${[cmd, roomId, ...params].join("%")}%`);
}
// the server describes the buddy games to a player who has just arrived
// without being asked ("mi"). is this message that, rather than the
// answer to a request of ours?
unasked(fields) {
if (fields[0] !== "mi") {
return false;
}
if (this.askedForGames === 0) {
this.unaskedGames.push(fields);
return true;
}
this.askedForGames--;
return false;
}
next() {
// made here, not in the timer, so that its stack says which line waited.
const timedOut = new Error("timed out waiting for a server message");
return new Promise((resolve, reject) => {
const timer = setTimeout(() => reject(timedOut), 5000);
this.waiters.push(message => {
clearTimeout(timer);
resolve(message);
});
this.flush();
});
}
// next raw extension message as [cmd, roomId, ...params]. user var
// updates ("zs") turn up between other messages whenever a counter the
// server keeps moves; they are set aside in `this.varUpdates` unless asked
// for, and the unasked list of buddy games in `this.unaskedGames`.
async nextXt(cmd) {
for (;;) {
const fields = (await this.next()).split("%").slice(2, -1);
if (fields[0] === "zs" && cmd !== "zs") {
this.varUpdates.push(fields);
continue;
}
// the chat filter settings ("xfl", after every login) and the one-time
// question which filter to use ("xfa", on the first room) come unasked.
if ((fields[0] === "xfl" || fields[0] === "xfa") && cmd !== fields[0]) {
continue;
}
if (this.unasked(fields)) {
continue;
}
assert.strictEqual(fields[0], cmd);
return fields;
}
}
// skips other messages until the next raw extension message for `cmd`.
async untilXt(cmd) {
for (;;) {
const fields = (await this.next()).split("%").slice(2, -1);
if (this.unasked(fields)) {
continue;
}
if (fields[0] === cmd) {
return fields;
}
}
}
async logIn(username, token) {
this.send("<msg t='sys'><body action='verChk' r='0'><ver v='165' /></body></msg>");
assert.match(await this.next(), /action='apiOK'/);
this.send("<msg t='sys'><body action='rndK' r='-1'></body></msg>");
assert.match(await this.next(), /<k>[0-9a-f]+<\/k>/);
const nick = `${username}%%0%1830%electron%1.5.7%win%df`;
this.send(`<msg t='sys' h='x'><body action='login' r='0'><login z='sbiLogin'><nick><![CDATA[${nick}]]></nick><pword><![CDATA[${token}]]></pword></login></body></msg>`);
return JSON.parse(await this.next()).b.o;
}
}
const postJson = (url, body) => fetch(url, {
method: "POST",
headers: {"Content-Type": "application/json", "Origin": "null"},
body: JSON.stringify(body),
});
// starts a server on the given ports with an empty database, runs `run`
// against it, and prints `name` passed or the server's output on failure.
const withServer = async (name, httpPort, gamePort, run) => {
const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), "aj-test-"));
const server = spawn(process.execPath, [path.join(__dirname, "..", "server.js")], {
env: {...process.env, AJ_HTTP_PORT: httpPort, AJ_GAME_PORT: gamePort, AJ_DATA_DIR: dataDir, AJ_QUIET: "1"},
stdio: ["ignore", "pipe", "inherit"],
});
let output = "";
try {
await new Promise((resolve, reject) => {
server.stdout.on("data", chunk => {
output += chunk;
if (output.includes("[server] ready")) {
resolve();
}
});
server.once("exit", code => reject(new Error(`server exited early (${code})\n${output}`)));
});
await run();
console.log(`${name} passed`);
}
catch (err) {
console.error(output);
throw err;
}
finally {
// on Windows the database stays locked until the process has gone, so
// wait for it before throwing its files away.
const exited = server.exitCode !== null ? Promise.resolve() : new Promise(resolve => server.once("exit", resolve));
server.kill();
await exited;
fs.rmSync(dataDir, {recursive: true, force: true, maxRetries: 10, retryDelay: 200});
}
};
module.exports = {GameClient, postJson, withServer};