120 lines
8.6 KiB
TypeScript
120 lines
8.6 KiB
TypeScript
import { afterEach, beforeEach, expect, it, vi } from 'vitest';
|
|
import { newFixture, type Fixture } from '../helpers/fixture.js';
|
|
import { zombieMaps } from '../../src/lib/map-aliases.js';
|
|
import { prepareNativeHost } from '../helpers/native-host.js';
|
|
|
|
vi.mock('../../src/lib/server/integrations/rcon.js', () => ({ rconGetPlayerCount: vi.fn(async () => 0) }));
|
|
let fixture: Fixture;
|
|
beforeEach(async () => { vi.resetModules(); fixture = await newFixture([]); });
|
|
afterEach(async () => { vi.useRealTimers(); await fixture.cleanup(); vi.restoreAllMocks(); });
|
|
const names = ['t6_zombie_town_1', 't6_zombie_town_2'];
|
|
const settings = { game: 't6', mapSlug: 'town', maximum: 2, mode: 'create-destroy', emptyMinutes: 1, cooldownMinutes: 1 };
|
|
|
|
async function setup(gameWide = false) {
|
|
const servers = gameWide ? [...names, ...zombieMaps('t6').filter(m => m.slug !== 'town').map(m => `t6_zombie_${m.slug}_1`)] : names;
|
|
const policySettings = { ...settings, mapSlug: gameWide ? '*' : settings.mapSlug };
|
|
const host = await prepareNativeHost(servers);
|
|
const { db } = await import('../../src/lib/server/db/index.js');
|
|
const scaling = await import('../../src/lib/server/autoscaling/index.js');
|
|
const authorization = await import('../../src/lib/server/autoscaling/authorization.js');
|
|
db().prepare("UPDATE ec_hosts SET inventory=json_set(inventory,'$.capabilities',json(?)) WHERE id=?").run(JSON.stringify([authorization.autoscalingRemovalCapability]), host.host.id);
|
|
const base = Date.now(); vi.useFakeTimers({ toFake: ['Date'] }); vi.setSystemTime(base);
|
|
for (const name of servers) {
|
|
const map = zombieMaps('t6').find(m => name === `t6_zombie_${m.slug}_1` || name === `t6_zombie_${m.slug}_2`)!;
|
|
db().prepare("INSERT INTO servers(name,game,map,map_slug,container_state,last_players) VALUES(?,'t6',?,?,'running',0)").run(name, map.canonical, map.slug);
|
|
db().prepare('INSERT INTO server_keys(server_id,pluto_key) VALUES(?,?)').run(name, `key-${name}`);
|
|
}
|
|
if (gameWide) for (const map of zombieMaps('t6').filter(m => m.slug !== 'town')) {
|
|
db().prepare('INSERT INTO server_keys(server_id,pluto_key) VALUES(?,?)').run(`t6_zombie_${map.slug}_2`, `key-${map.slug}-2`);
|
|
}
|
|
const fresh = (offset: number) => {
|
|
vi.setSystemTime(base + offset); const at = new Date().toISOString();
|
|
db().prepare('UPDATE servers SET container_checked_at=?,last_seen_at=?,last_checked_at=?').run(at, at, at);
|
|
db().prepare('UPDATE ec_hosts SET last_heartbeat=?').run(at);
|
|
};
|
|
fresh(0);
|
|
const saved = scaling.saveScaling(policySettings, undefined, undefined, scaling.previewScaling(policySettings).token);
|
|
for (const offset of [0, 30_000, 60_000]) { fresh(offset); await scaling.runAutoscaling(); }
|
|
const intent = db().prepare('SELECT operation_id FROM autoscaling_decisions WHERE resolved=0').get() as { operation_id: string };
|
|
expect(intent?.operation_id).toBeTruthy();
|
|
const backend = await import('../../src/lib/server/backends/native.js');
|
|
vi.spyOn(backend, 'nativeRequest').mockResolvedValue({ healthy: true, state: 'running', exists: true } as never);
|
|
const { processProvisioning } = await import('../../src/lib/server/provisioning/worker.js');
|
|
const dispatch = async () => {
|
|
await processProvisioning();
|
|
const row = db().prepare('SELECT operation_id FROM native_provisioning WHERE deployment_id=?').get(intent.operation_id) as { operation_id: string };
|
|
expect(row.operation_id).toBeTruthy();
|
|
const { getHostOperation } = await import('../../src/lib/server/hosts/index.js');
|
|
const command = getHostOperation(row.operation_id)!;
|
|
return { id: row.operation_id, payload: command.payload.autoscaling as Record<string, unknown> };
|
|
};
|
|
return { db, scaling, authorization, policy: saved, operationId: intent.operation_id, hostId: host.host.id, fresh, dispatch, processProvisioning };
|
|
}
|
|
|
|
it('removes only after a full observed empty interval and claims authorization once', async () => {
|
|
const s = await setup();
|
|
const { enableSafetyOverride } = await import('../../src/lib/server/provisioning/safety-override.js');
|
|
expect(enableSafetyOverride(s.operationId, { id: 'admin', username: 'admin' }).ok).toBe(false);
|
|
const command = await s.dispatch();
|
|
expect(s.authorization.claimRemovalAuthorization('wrong-host', command.id, command.payload).authorized).toBe(false);
|
|
expect(s.authorization.claimRemovalAuthorization(s.hostId, command.id, command.payload)).toMatchObject({ authorized: true, validForMs: 5000 });
|
|
expect(s.authorization.claimRemovalAuthorization(s.hostId, command.id, command.payload).authorized).toBe(false);
|
|
});
|
|
|
|
it('withdraws a queued removal when a player arrives and restarts the empty interval', async () => {
|
|
const s = await setup();
|
|
s.db().prepare('UPDATE servers SET last_players=1 WHERE name=?').run(names[0]);
|
|
await s.scaling.runAutoscaling();
|
|
expect(s.db().prepare('SELECT state FROM server_deployments WHERE id=?').get(s.operationId)).toEqual({ state: 'cancelled' });
|
|
s.db().prepare('UPDATE servers SET last_players=0').run();
|
|
s.fresh(90_000); await s.scaling.runAutoscaling();
|
|
expect(s.db().prepare('SELECT COUNT(*) AS n FROM autoscaling_decisions WHERE resolved=0').get()).toEqual({ n: 0 });
|
|
});
|
|
|
|
it('rechecks controller occupancy after the async probe even before monitoring refreshes', async () => {
|
|
const s = await setup();
|
|
const rcon = await import('../../src/lib/server/integrations/rcon.js');
|
|
vi.mocked(rcon.rconGetPlayerCount).mockResolvedValueOnce(1);
|
|
await s.processProvisioning();
|
|
expect(s.db().prepare('SELECT state FROM server_deployments WHERE id=?').get(s.operationId)).toEqual({ state: 'cancelled' });
|
|
expect(s.db().prepare('SELECT COUNT(*) AS n FROM autoscaling_authorizations').get()).toEqual({ n: 0 });
|
|
});
|
|
|
|
it('revokes a delivered removal on policy pause without claiming it was undone', async () => {
|
|
const s = await setup(); const command = await s.dispatch();
|
|
s.db().prepare('UPDATE ec_host_operations SET last_delivered_at=? WHERE id=?').run(new Date().toISOString(), command.id);
|
|
const off = { ...settings, mode: 'off' };
|
|
s.scaling.saveScaling(off, s.policy.id, s.policy.revision, s.scaling.previewScaling(off, s.policy.id, s.policy.revision).token);
|
|
expect(s.authorization.claimRemovalAuthorization(s.hostId, command.id, command.payload).authorized).toBe(false);
|
|
expect(s.db().prepare('SELECT owns_map FROM autoscaling_policies').get()).toEqual({ owns_map: 1 });
|
|
expect(s.db().prepare('SELECT state FROM server_deployments WHERE id=?').get(s.operationId)).toEqual({ state: 'running' });
|
|
expect(s.scaling.scalingReport().policies[0]).toMatchObject({ ownsMap: true, unsettled: [{ id: s.operationId, state: 'running' }] });
|
|
});
|
|
|
|
it('withdraws undelivered commands and reconciles invalidation without a retry or failure pause', async () => {
|
|
const s = await setup(); const command = await s.dispatch();
|
|
s.scaling.setScalingGlobalPause(true);
|
|
expect(s.db().prepare('SELECT state FROM ec_host_operations WHERE id=?').get(command.id)).toEqual({ state: 'failed' });
|
|
await s.processProvisioning(); await s.scaling.runAutoscaling();
|
|
expect(s.db().prepare('SELECT state FROM server_deployments WHERE id=?').get(s.operationId)).toEqual({ state: 'cancelled' });
|
|
expect(s.scaling.getScalingPolicy(s.policy.id)?.pausedReason).toBeNull();
|
|
expect(s.db().prepare('SELECT COUNT(*) AS n FROM autoscaling_decisions WHERE resolved=0').get()).toEqual({ n: 0 });
|
|
});
|
|
|
|
it('rejects expired, changed revision, and newly protected removal authorizations', async () => {
|
|
const s = await setup(); const command = await s.dispatch();
|
|
expect(s.authorization.claimRemovalAuthorization(s.hostId, command.id, { ...command.payload, revision: 999 }).authorized).toBe(false);
|
|
s.db().prepare("INSERT INTO maintenance_jobs(server,requested_at) VALUES(?,?)").run(names[1], new Date().toISOString());
|
|
expect(s.authorization.claimRemovalAuthorization(s.hostId, command.id, command.payload).authorized).toBe(false);
|
|
s.db().prepare('DELETE FROM maintenance_jobs').run();
|
|
s.fresh(130_000);
|
|
expect(s.authorization.claimRemovalAuthorization(s.hostId, command.id, command.payload).authorized).toBe(false);
|
|
});
|
|
|
|
it('authorizes a game-wide removal without trimming any map below its targets', async () => {
|
|
const s = await setup(true);
|
|
expect(s.db().prepare("SELECT server FROM server_deployments WHERE id=?").get(s.operationId)).toEqual({ server: names[0] });
|
|
const command = await s.dispatch();
|
|
expect(s.authorization.claimRemovalAuthorization(s.hostId, command.id, command.payload).authorized).toBe(true);
|
|
});
|