309 lines
15 KiB
JavaScript
309 lines
15 KiB
JavaScript
import assert from "node:assert/strict";
|
|
import { mkdtempSync, rmSync } from "node:fs";
|
|
import { createServer } from "node:http";
|
|
import { tmpdir } from "node:os";
|
|
import { join } from "node:path";
|
|
import { after, before, test } from "node:test";
|
|
import { createGameApiHandler } from "./game-api.mjs";
|
|
|
|
const dataDirectory = mkdtempSync(join(tmpdir(), "iwt-heal-api-"));
|
|
const api = createGameApiHandler({ dataDirectory });
|
|
const server = createServer((request, response) => {
|
|
void api.handle(request, response, () => {
|
|
response.statusCode = 404;
|
|
response.end();
|
|
});
|
|
});
|
|
let baseUrl;
|
|
|
|
before(async () => {
|
|
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
|
|
const address = server.address();
|
|
baseUrl = `http://127.0.0.1:${address.port}`;
|
|
});
|
|
|
|
after(async () => {
|
|
await new Promise((resolve) => server.close(resolve));
|
|
api.close();
|
|
rmSync(dataDirectory, { recursive: true, force: true });
|
|
});
|
|
|
|
async function json(path, init = {}) {
|
|
const response = await fetch(`${baseUrl}${path}`, init);
|
|
const body = await response.json();
|
|
return { response, body };
|
|
}
|
|
|
|
function save(slotId, hunterName, bulldromeKills, highestRoguelikeRound, highestRogueTrialsEndlessKills, highestHockeyHealingReturns, longestHockeyHealingSecondsAtBest, hockeyHealingPvpWins = 0, hockeyHealingPvpLosses = 0, hockeyHealingPvpBossKills = 0, highestBlockbreakerBricks = 0, longestBlockbreakerSeconds = 0, highestBlockbreakerScore = 0, highestAetherAssaultScore = 0, highestAetherAssaultWaveAtBest = 0, longestAetherAssaultSecondsAtBest = 0) {
|
|
return {
|
|
schemaVersion: 6,
|
|
slotId,
|
|
hunterName,
|
|
stats: { bossKills: { bulldrome: bulldromeKills }, highestRoguelikeRound, highestRogueTrialsEndlessKills, highestHockeyHealingReturns, longestHockeyHealingSecondsAtBest, hockeyHealingPvpWins, hockeyHealingPvpLosses, hockeyHealingPvpBossKills, highestBlockbreakerBricks, longestBlockbreakerSeconds, highestBlockbreakerScore, highestAetherAssaultScore, highestAetherAssaultWaveAtBest, longestAetherAssaultSecondsAtBest },
|
|
};
|
|
}
|
|
|
|
test("health endpoint reports persistent database readiness", async () => {
|
|
const { response, body } = await json("/api/health");
|
|
assert.equal(response.status, 200);
|
|
assert.deepEqual(body, { ok: true, database: "ready" });
|
|
});
|
|
|
|
test("accounts, server saves, and top-five plus current rankings work end to end", async () => {
|
|
const players = [];
|
|
for (let index = 0; index < 6; index += 1) {
|
|
const username = `hunter_${index}`;
|
|
const registration = await json("/api/auth/register", {
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify({ username, password: `long-password-${index}` }),
|
|
});
|
|
assert.equal(registration.response.status, 201);
|
|
const token = registration.body.token;
|
|
const kills = 60 - index * 10;
|
|
const highestRound = 30 - index * 4;
|
|
const highestEndlessKills = 24 - index * 3;
|
|
const highestHockeyReturns = 30 - index * 4;
|
|
const hockeyDuration = 180 - index * 10;
|
|
const pvpWins = 30 - index * 4;
|
|
const pvpLosses = index + 1;
|
|
const pvpBossKills = 120 - index * 12;
|
|
const blockbreakerBricks = index < 2 ? 600 : 700 - index * 100;
|
|
const blockbreakerSeconds = 360 - index * 30;
|
|
const blockbreakerScore = 20_000 - index * 2_000;
|
|
const aetherScore = index < 2 ? 50_000 : 54_000 - index * 5_000;
|
|
const aetherWave = index < 2 ? 12 : 10 - index;
|
|
const aetherDuration = 300 - index * 20;
|
|
const upload = await json("/api/saves/1", {
|
|
method: "PUT",
|
|
headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
|
|
body: JSON.stringify({ save: save(1, `Hero ${index}`, kills, highestRound, highestEndlessKills, highestHockeyReturns, hockeyDuration, pvpWins, pvpLosses, pvpBossKills, blockbreakerBricks, blockbreakerSeconds, blockbreakerScore, aetherScore, aetherWave, aetherDuration) }),
|
|
});
|
|
assert.equal(upload.response.status, 200);
|
|
players.push({ token, kills, highestRound, highestEndlessKills, highestHockeyReturns, hockeyDuration, pvpWins, pvpLosses, pvpBossKills, blockbreakerBricks, blockbreakerSeconds, blockbreakerScore, aetherScore, aetherWave, aetherDuration });
|
|
}
|
|
|
|
const current = players[5];
|
|
const bossBoard = await json("/api/leaderboards/boss/bulldrome?slot=1", {
|
|
headers: { Authorization: `Bearer ${current.token}` },
|
|
});
|
|
assert.equal(bossBoard.body.top.length, 5);
|
|
assert.equal(bossBoard.body.top[0].value, 60);
|
|
assert.equal(bossBoard.body.current.rank, 6);
|
|
assert.equal(bossBoard.body.current.value, current.kills);
|
|
|
|
const rogueBoard = await json("/api/leaderboards/roguelike?slot=1", {
|
|
headers: { Authorization: `Bearer ${current.token}` },
|
|
});
|
|
assert.equal(rogueBoard.body.top.length, 5);
|
|
assert.equal(rogueBoard.body.current.rank, 6);
|
|
assert.equal(rogueBoard.body.current.value, current.highestRound);
|
|
|
|
const endlessBoard = await json("/api/leaderboards/rogue-trials-endless?slot=1", {
|
|
headers: { Authorization: `Bearer ${current.token}` },
|
|
});
|
|
assert.equal(endlessBoard.body.kind, "rogue-trials-endless");
|
|
assert.equal(endlessBoard.body.top.length, 5);
|
|
assert.equal(endlessBoard.body.top[0].value, 24);
|
|
assert.equal(endlessBoard.body.current.rank, 6);
|
|
assert.equal(endlessBoard.body.current.value, current.highestEndlessKills);
|
|
|
|
const hockeyBoard = await json("/api/leaderboards/hockey-healing?slot=1", {
|
|
headers: { Authorization: `Bearer ${current.token}` },
|
|
});
|
|
assert.equal(hockeyBoard.body.kind, "hockey-healing");
|
|
assert.equal(hockeyBoard.body.top.length, 5);
|
|
assert.equal(hockeyBoard.body.top[0].value, 30);
|
|
assert.equal(hockeyBoard.body.current.rank, 6);
|
|
assert.equal(hockeyBoard.body.current.value, current.highestHockeyReturns);
|
|
assert.equal(hockeyBoard.body.current.secondaryValue, current.hockeyDuration);
|
|
|
|
const pvpWinsBoard = await json("/api/leaderboards/hockey-pvp-wins?slot=1", {
|
|
headers: { Authorization: `Bearer ${current.token}` },
|
|
});
|
|
assert.equal(pvpWinsBoard.body.kind, "hockey-pvp-wins");
|
|
assert.equal(pvpWinsBoard.body.top[0].value, 30);
|
|
assert.equal(pvpWinsBoard.body.current.value, current.pvpWins);
|
|
assert.equal(pvpWinsBoard.body.current.secondaryValue, current.pvpLosses);
|
|
|
|
const pvpKillsBoard = await json("/api/leaderboards/hockey-pvp-boss-kills?slot=1", {
|
|
headers: { Authorization: `Bearer ${current.token}` },
|
|
});
|
|
assert.equal(pvpKillsBoard.body.kind, "hockey-pvp-boss-kills");
|
|
assert.equal(pvpKillsBoard.body.top[0].value, 120);
|
|
assert.equal(pvpKillsBoard.body.current.value, current.pvpBossKills);
|
|
|
|
const blockbreakerBricksBoard = await json("/api/leaderboards/blockbreaker-bricks?slot=1", {
|
|
headers: { Authorization: `Bearer ${current.token}` },
|
|
});
|
|
assert.equal(blockbreakerBricksBoard.body.kind, "blockbreaker-bricks");
|
|
assert.equal(blockbreakerBricksBoard.body.top.length, 5);
|
|
assert.equal(blockbreakerBricksBoard.body.top[0].value, 600);
|
|
assert.equal(blockbreakerBricksBoard.body.top[0].rank, 1);
|
|
assert.equal(blockbreakerBricksBoard.body.top[1].rank, 1);
|
|
assert.equal(blockbreakerBricksBoard.body.current.rank, 6);
|
|
assert.equal(blockbreakerBricksBoard.body.current.value, current.blockbreakerBricks);
|
|
|
|
const blockbreakerTimeBoard = await json("/api/leaderboards/blockbreaker-time?slot=1", {
|
|
headers: { Authorization: `Bearer ${current.token}` },
|
|
});
|
|
assert.equal(blockbreakerTimeBoard.body.kind, "blockbreaker-time");
|
|
assert.equal(blockbreakerTimeBoard.body.top[0].value, 360);
|
|
assert.equal(blockbreakerTimeBoard.body.current.value, current.blockbreakerSeconds);
|
|
|
|
const blockbreakerScoreBoard = await json("/api/leaderboards/blockbreaker-score?slot=1", {
|
|
headers: { Authorization: `Bearer ${current.token}` },
|
|
});
|
|
assert.equal(blockbreakerScoreBoard.body.kind, "blockbreaker-score");
|
|
assert.equal(blockbreakerScoreBoard.body.top[0].value, 20_000);
|
|
assert.equal(blockbreakerScoreBoard.body.current.value, current.blockbreakerScore);
|
|
|
|
const aetherBoard = await json("/api/leaderboards/aether-assault?slot=1", {
|
|
headers: { Authorization: `Bearer ${current.token}` },
|
|
});
|
|
assert.equal(aetherBoard.body.kind, "aether-assault");
|
|
assert.equal(aetherBoard.body.top.length, 5);
|
|
assert.equal(aetherBoard.body.top[0].value, 50_000);
|
|
assert.equal(aetherBoard.body.top[0].secondaryValue, 12);
|
|
assert.equal(aetherBoard.body.top[0].username, "hunter_0");
|
|
assert.equal(aetherBoard.body.top[0].rank, 1);
|
|
assert.equal(aetherBoard.body.top[1].value, 50_000);
|
|
assert.equal(aetherBoard.body.top[1].secondaryValue, 12);
|
|
assert.equal(aetherBoard.body.top[1].username, "hunter_1");
|
|
assert.equal(aetherBoard.body.top[1].rank, 2);
|
|
assert.equal(aetherBoard.body.current.rank, 6);
|
|
assert.equal(aetherBoard.body.current.value, current.aetherScore);
|
|
assert.equal(aetherBoard.body.current.secondaryValue, current.aetherWave);
|
|
|
|
const legacySnapshot = save(1, "Hero 5", current.kills, current.highestRound, current.highestEndlessKills, current.highestHockeyReturns, current.hockeyDuration, current.pvpWins, current.pvpLosses, current.pvpBossKills);
|
|
delete legacySnapshot.stats.highestBlockbreakerBricks;
|
|
delete legacySnapshot.stats.longestBlockbreakerSeconds;
|
|
delete legacySnapshot.stats.highestBlockbreakerScore;
|
|
delete legacySnapshot.stats.highestAetherAssaultScore;
|
|
delete legacySnapshot.stats.highestAetherAssaultWaveAtBest;
|
|
delete legacySnapshot.stats.longestAetherAssaultSecondsAtBest;
|
|
legacySnapshot.schemaVersion = 5;
|
|
const legacyUpload = await json("/api/saves/1", {
|
|
method: "PUT",
|
|
headers: { Authorization: `Bearer ${current.token}`, "Content-Type": "application/json" },
|
|
body: JSON.stringify({ save: legacySnapshot }),
|
|
});
|
|
assert.equal(legacyUpload.body.save.stats.highestBlockbreakerBricks, current.blockbreakerBricks);
|
|
assert.equal(legacyUpload.body.save.stats.longestBlockbreakerSeconds, current.blockbreakerSeconds);
|
|
assert.equal(legacyUpload.body.save.stats.highestBlockbreakerScore, current.blockbreakerScore);
|
|
assert.equal(legacyUpload.body.save.schemaVersion, 6);
|
|
assert.equal(legacyUpload.body.save.stats.highestAetherAssaultScore, current.aetherScore);
|
|
assert.equal(legacyUpload.body.save.stats.highestAetherAssaultWaveAtBest, current.aetherWave);
|
|
assert.equal(legacyUpload.body.save.stats.longestAetherAssaultSecondsAtBest, current.aetherDuration);
|
|
|
|
const download = await json("/api/saves/1", {
|
|
headers: { Authorization: `Bearer ${current.token}` },
|
|
});
|
|
assert.equal(download.body.save.hunterName, "Hero 5");
|
|
});
|
|
|
|
test("Healing Hockey PVP queue pairs players and relays match snapshots", async () => {
|
|
const registerPlayer = async (username) => {
|
|
const registration = await json("/api/auth/register", {
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify({ username, password: `long-password-${username}` }),
|
|
});
|
|
return registration.body.token;
|
|
};
|
|
const alphaToken = await registerPlayer("pvp_alpha");
|
|
const betaToken = await registerPlayer("pvp_beta");
|
|
const alphaQueue = await json("/api/hockey-pvp/queue", {
|
|
method: "POST",
|
|
headers: { Authorization: `Bearer ${alphaToken}`, "Content-Type": "application/json" },
|
|
body: JSON.stringify({ slotId: 1, hunterName: "Alpha" }),
|
|
});
|
|
assert.equal(alphaQueue.body.status, "waiting");
|
|
|
|
const betaQueue = await json("/api/hockey-pvp/queue", {
|
|
method: "POST",
|
|
headers: { Authorization: `Bearer ${betaToken}`, "Content-Type": "application/json" },
|
|
body: JSON.stringify({ slotId: 1, hunterName: "Beta" }),
|
|
});
|
|
assert.equal(betaQueue.body.status, "matched");
|
|
assert.equal(betaQueue.body.match.role, "guest");
|
|
assert.equal(betaQueue.body.match.opponentName, "Alpha");
|
|
assert.equal(betaQueue.body.match.generation, 1);
|
|
assert.ok(betaQueue.body.match.countdownEndsAtMs > Date.now());
|
|
|
|
const alphaMatched = await json(`/api/hockey-pvp/queue/${alphaQueue.body.ticketId}`, {
|
|
headers: { Authorization: `Bearer ${alphaToken}` },
|
|
});
|
|
assert.equal(alphaMatched.body.status, "matched");
|
|
assert.equal(alphaMatched.body.match.role, "host");
|
|
assert.equal(alphaMatched.body.match.id, betaQueue.body.match.id);
|
|
assert.equal(alphaMatched.body.match.seed, betaQueue.body.match.seed);
|
|
assert.equal(alphaMatched.body.match.generation, betaQueue.body.match.generation);
|
|
assert.equal(alphaMatched.body.match.countdownEndsAtMs, betaQueue.body.match.countdownEndsAtMs);
|
|
|
|
const hostSnapshot = { sequence: 1, party: [], puck: { goalSequence: 0 } };
|
|
await json(`/api/hockey-pvp/matches/${alphaMatched.body.match.id}/state`, {
|
|
method: "PUT",
|
|
headers: { Authorization: `Bearer ${alphaToken}`, "Content-Type": "application/json" },
|
|
body: JSON.stringify({ generation: 1, snapshot: hostSnapshot }),
|
|
});
|
|
const guestExchange = await json(`/api/hockey-pvp/matches/${alphaMatched.body.match.id}/state`, {
|
|
method: "PUT",
|
|
headers: { Authorization: `Bearer ${betaToken}`, "Content-Type": "application/json" },
|
|
body: JSON.stringify({ generation: 1, snapshot: { sequence: 1, party: [] } }),
|
|
});
|
|
assert.deepEqual(guestExchange.body.opponentSnapshot, hostSnapshot);
|
|
assert.deepEqual(guestExchange.body.hostSnapshot, hostSnapshot);
|
|
|
|
const alphaRematchWaiting = await json(`/api/hockey-pvp/matches/${alphaMatched.body.match.id}/rematch`, {
|
|
method: "POST",
|
|
headers: { Authorization: `Bearer ${alphaToken}`, "Content-Type": "application/json" },
|
|
body: JSON.stringify({ generation: 1 }),
|
|
});
|
|
assert.equal(alphaRematchWaiting.body.status, "waiting");
|
|
|
|
const betaRematchReady = await json(`/api/hockey-pvp/matches/${alphaMatched.body.match.id}/rematch`, {
|
|
method: "POST",
|
|
headers: { Authorization: `Bearer ${betaToken}`, "Content-Type": "application/json" },
|
|
body: JSON.stringify({ generation: 1 }),
|
|
});
|
|
assert.equal(betaRematchReady.body.status, "matched");
|
|
assert.equal(betaRematchReady.body.match.generation, 2);
|
|
assert.ok(betaRematchReady.body.match.countdownEndsAtMs > Date.now());
|
|
|
|
const alphaRematchReady = await json(`/api/hockey-pvp/matches/${alphaMatched.body.match.id}/rematch`, {
|
|
method: "POST",
|
|
headers: { Authorization: `Bearer ${alphaToken}`, "Content-Type": "application/json" },
|
|
body: JSON.stringify({ generation: 1 }),
|
|
});
|
|
assert.equal(alphaRematchReady.body.status, "matched");
|
|
assert.equal(alphaRematchReady.body.match.generation, 2);
|
|
assert.equal(alphaRematchReady.body.match.seed, betaRematchReady.body.match.seed);
|
|
assert.equal(alphaRematchReady.body.match.countdownEndsAtMs, betaRematchReady.body.match.countdownEndsAtMs);
|
|
|
|
const staleExchange = await json(`/api/hockey-pvp/matches/${alphaMatched.body.match.id}/state`, {
|
|
method: "PUT",
|
|
headers: { Authorization: `Bearer ${alphaToken}`, "Content-Type": "application/json" },
|
|
body: JSON.stringify({ generation: 1, snapshot: hostSnapshot }),
|
|
});
|
|
assert.equal(staleExchange.response.status, 409);
|
|
|
|
const freshExchange = await json(`/api/hockey-pvp/matches/${alphaMatched.body.match.id}/state`, {
|
|
method: "PUT",
|
|
headers: { Authorization: `Bearer ${alphaToken}`, "Content-Type": "application/json" },
|
|
body: JSON.stringify({ generation: 2, snapshot: hostSnapshot }),
|
|
});
|
|
assert.equal(freshExchange.response.status, 200);
|
|
});
|
|
|
|
test("invalid credentials cannot access server saves", async () => {
|
|
const login = await json("/api/auth/login", {
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify({ username: "hunter_0", password: "incorrect-password" }),
|
|
});
|
|
assert.equal(login.response.status, 401);
|
|
const saves = await json("/api/saves");
|
|
assert.equal(saves.response.status, 401);
|
|
});
|