115 lines
6.5 KiB
TypeScript
115 lines
6.5 KiB
TypeScript
// @dune-suite integration
|
|
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import { randomBytes, randomUUID } from 'node:crypto';
|
|
import type { GameView } from '../game/engine';
|
|
|
|
const base = process.env.DUNE_TEST_URL ?? 'http://localhost:3000';
|
|
const entry = () => ({ operationId: randomUUID(), sessionToken: randomBytes(32).toString('hex') });
|
|
async function request(path: string, cookie?: string, body?: unknown, selected?: string) {
|
|
const response = await fetch(base + path, {
|
|
method: body === undefined ? 'GET' : 'POST',
|
|
signal: AbortSignal.timeout(15_000),
|
|
headers: {
|
|
...(body === undefined ? {} : { 'Content-Type': 'application/json' }),
|
|
...(cookie ? { cookie } : {}),
|
|
...(selected ? { 'X-Dune-Seat': selected } : {}),
|
|
},
|
|
...(body === undefined ? {} : { body: JSON.stringify(body) }),
|
|
});
|
|
return { status: response.status, cookie: response.headers.get('set-cookie')?.split(';')[0],
|
|
data: await response.json() as GameView & { error?: string } };
|
|
}
|
|
|
|
void test('three-party deals require each authenticated faction seat and leave native play intact', async () => {
|
|
const host = await request('/api/rooms', undefined, {
|
|
name: 'Many-deal first', faction: 'atreides', advanced: false, expansions: [], entry: entry(),
|
|
});
|
|
assert.equal(host.status, 201, JSON.stringify(host.data));
|
|
assert.ok(host.cookie);
|
|
const path = `/api/rooms/${host.data.code}`;
|
|
const enabled = await request(path, host.cookie, { version: host.data.version, action: { type: 'twoPlayerMode', enabled: true } }, host.data.me);
|
|
assert.equal(enabled.status, 200, JSON.stringify(enabled.data));
|
|
const hostSecond = await request(path, host.cookie, { type: 'addControlledFaction', version: enabled.data.version,
|
|
name: 'Many-deal first', faction: 'emperor', entry: entry() }, host.data.me);
|
|
assert.equal(hostSecond.status, 200, JSON.stringify(hostSecond.data));
|
|
assert.ok(hostSecond.cookie);
|
|
const hostCookies = `${host.cookie}; ${hostSecond.cookie}`;
|
|
const guest = await request(path, undefined, { type: 'join', name: 'Many-deal second', faction: 'guild', entry: entry() });
|
|
assert.equal(guest.status, 200, JSON.stringify(guest.data));
|
|
assert.ok(guest.cookie);
|
|
const guestSecond = await request(path, guest.cookie, { type: 'addControlledFaction', version: guest.data.version,
|
|
name: 'Many-deal second', faction: 'harkonnen', entry: entry() }, guest.data.me);
|
|
assert.equal(guestSecond.status, 200, JSON.stringify(guestSecond.data));
|
|
assert.ok(guestSecond.cookie);
|
|
const guestCookies = `${guest.cookie}; ${guestSecond.cookie}`;
|
|
const seats = [
|
|
{ id: host.data.me, cookie: hostCookies }, { id: hostSecond.data.me, cookie: hostCookies },
|
|
{ id: guest.data.me, cookie: guestCookies }, { id: guestSecond.data.me, cookie: guestCookies },
|
|
];
|
|
let view = guestSecond.data;
|
|
const act = async (seat: typeof seats[number], action: object) => {
|
|
const next = await request(path, seat.cookie, { version: view.version, action }, seat.id);
|
|
assert.equal(next.status, 200, JSON.stringify(next.data));
|
|
view = next.data;
|
|
};
|
|
for (const seat of seats) await act(seat, { type: 'ready' });
|
|
await act(seats[0], { type: 'start' });
|
|
for (const seat of seats) {
|
|
const own = await request(path, seat.cookie, undefined, seat.id);
|
|
assert.equal(own.status, 200, JSON.stringify(own.data));
|
|
view = own.data;
|
|
const choices = own.data.players.find(player => player.id === seat.id)?.traitorChoices;
|
|
if (choices?.length) await act(seat, { type: 'traitor', leader: choices[0] });
|
|
}
|
|
assert.equal(view.status, 'playing');
|
|
assert.equal(view.phase, 0);
|
|
const baseline = { phase: view.phase, turn: view.turn, active: view.active, storm: view.storm,
|
|
stormDialers: view.stormDialers, stormSubmitted: view.stormSubmitted,
|
|
players: view.players.map(({ id, faction, ready }) => ({ id, faction, ready })),
|
|
controllers: view.twoPlayerControllers };
|
|
|
|
await act(seats[0], { type: 'dealOffer', targets: [seats[1].id, seats[2].id], terms: 'The three factions will share information.' });
|
|
const offer = view.deals.at(-1);
|
|
assert.ok(offer);
|
|
assert.deepEqual(offer.participants, [seats[0].id, seats[1].id, seats[2].id]);
|
|
assert.deepEqual(offer.acceptVotes, [seats[0].id]);
|
|
assert.equal(offer.status, 'offered');
|
|
for (const seat of seats) {
|
|
const read = await request(path, seat.cookie, undefined, seat.id);
|
|
assert.equal(read.status, 200, JSON.stringify(read.data));
|
|
assert.deepEqual(read.data.deals.find(deal => deal.id === offer.id), offer);
|
|
}
|
|
|
|
const yes = { version: view.version, action: { type: 'dealRespond', deal: offer.id, accept: true } };
|
|
// Another controller's seat selector is not a credential. The fourth seat
|
|
// is authenticated but is not one of this agreement's participants.
|
|
assert.equal((await request(path, hostCookies, yes, seats[2].id)).status, 409);
|
|
assert.equal((await request(path, guestCookies, yes, seats[3].id)).status, 409);
|
|
// The same controller's second faction still needs its own seat credential.
|
|
assert.equal((await request(path, host.cookie, yes, seats[1].id)).status, 409);
|
|
await act(seats[1], yes.action);
|
|
assert.equal(view.deals.at(-1)?.status, 'offered');
|
|
assert.deepEqual([...view.deals.at(-1)!.acceptVotes!].sort(), [seats[0].id, seats[1].id].sort());
|
|
await act(seats[2], yes.action);
|
|
assert.equal(view.deals.at(-1)?.status, 'active');
|
|
|
|
await act(seats[2], { type: 'dealRelease', deal: offer.id, agree: true });
|
|
await act(seats[1], { type: 'dealRelease', deal: offer.id, agree: true });
|
|
assert.equal(view.deals.at(-1)?.status, 'active');
|
|
await act(seats[0], { type: 'dealRelease', deal: offer.id, agree: true });
|
|
assert.equal(view.deals.at(-1)?.status, 'released');
|
|
const observer = await request(path, seats[3].cookie, undefined, seats[3].id);
|
|
assert.equal(observer.status, 200, JSON.stringify(observer.data));
|
|
assert.equal(observer.data.deals.find(deal => deal.id === offer.id)?.status, 'released');
|
|
assert.deepEqual({ phase: observer.data.phase, turn: observer.data.turn, active: observer.data.active,
|
|
storm: observer.data.storm, stormDialers: observer.data.stormDialers, stormSubmitted: observer.data.stormSubmitted,
|
|
players: observer.data.players.map(({ id, faction, ready }) => ({ id, faction, ready })),
|
|
controllers: observer.data.twoPlayerControllers }, baseline);
|
|
const dialer = seats.find(seat => observer.data.stormDialers.includes(seat.id));
|
|
assert.ok(dialer);
|
|
view = observer.data;
|
|
await act(dialer, { type: 'stormDial', amount: 0 });
|
|
assert.ok(view.stormSubmitted.includes(dialer.id) || view.phase !== 0);
|
|
});
|