p2p-lockstep-kit-session 0.1.7 → 0.1.9

package/scripts/serialization-smoke.mjs

@@ -1,5 +1,5 @@
-import assert from "node:assert/strict";
-import { createSession } from "../dist/session/index.js";
+import assert from 'node:assert/strict';
+import { createSession } from '../dist/session/index.js';
 
 const waitForBus = () => new Promise((resolve) => setTimeout(resolve, 0));
 
@@ -14,7 +14,7 @@ class BoundaryClient {
 
   onStateChange(handler) {
     this.stateHandler = handler;
-    handler("passive");
+    handler('passive');
   }
 
   onRemoteStream() {}
@@ -24,7 +24,7 @@ class BoundaryClient {
   }
 
   connect() {
-    this.stateHandler?.("connected");
+    this.stateHandler?.('connected');
   }
 
   inbound(data) {
@@ -34,9 +34,9 @@ class BoundaryClient {
 
 const createConnectedSession = () => {
   const client = new BoundaryClient();
-  const session = createSession(client, "demo-room");
+  const session = createSession(client, 'demo-room');
 
-  session.net.setPeerIds({ local: "local", remote: "remote" });
+  session.net.setPeerIds({ local: 'local', remote: 'remote' });
   client.connect();
 
   return { client, session };
@@ -44,23 +44,51 @@ const createConnectedSession = () => {
 
 const startGame = async () => {
   const runtime = createConnectedSession();
-  runtime.client.inbound({ type: "READY", sid: "demo-room", from: "remote" });
+  runtime.client.inbound({ type: 'READY', sid: 'demo-room', from: 'remote' });
   await waitForBus();
   runtime.session.actions.start();
   await waitForBus();
 
+  assert.match(runtime.session.state.getState('local'), /^(turn|remote_turn)$/);
   assert.match(
-    runtime.session.state.getState("local"),
+    runtime.session.state.getState('remote'),
     /^(turn|remote_turn)$/,
   );
-  assert.match(
-    runtime.session.state.getState("remote"),
-    /^(turn|remote_turn)$/,
+
+  return runtime;
+};
+
+const startGameWithFirstPlayer = async (firstPlayer) => {
+  const runtime = createConnectedSession();
+  runtime.client.inbound({ type: 'READY', sid: 'demo-room', from: 'remote' });
+  await waitForBus();
+  runtime.session.state.setLastStart(
+    firstPlayer === 'local' ? 'remote' : 'local',
+  );
+  runtime.session.actions.start();
+  await waitForBus();
+
+  assert.equal(
+    runtime.session.state.getState('local'),
+    firstPlayer === 'local' ? 'turn' : 'remote_turn',
+  );
+  assert.equal(
+    runtime.session.state.getState('remote'),
+    firstPlayer === 'local' ? 'remote_turn' : 'turn',
   );
 
   return runtime;
 };
 
+const oneMoveWinPlugin = {
+  validateMove() {
+    return { valid: true };
+  },
+  checkWin(_gameState, history) {
+    return history.at(-1)?.player ?? null;
+  },
+};
+
 {
   const { client, session } = createConnectedSession();
   await waitForBus();
@@ -69,22 +97,22 @@ const startGame = async () => {
   await waitForBus();
 
   const sent = client.sent.at(-1);
-  assert.equal(typeof sent, "object");
-  assert.equal(sent.type, "READY");
-  assert.equal(sent.sid, "demo-room");
-  assert.equal(session.state.getState("local"), "ready");
-  assert.equal(session.state.getState("remote"), "could_start");
+  assert.equal(typeof sent, 'object');
+  assert.equal(sent.type, 'READY');
+  assert.equal(sent.sid, 'demo-room');
+  assert.equal(session.state.getState('local'), 'ready');
+  assert.equal(session.state.getState('remote'), 'could_start');
 }
 
 {
   const { client, session } = createConnectedSession();
   await waitForBus();
 
-  client.inbound({ type: "READY", sid: "demo-room", from: "remote" });
+  client.inbound({ type: 'READY', sid: 'demo-room', from: 'remote' });
   await waitForBus();
 
-  assert.equal(session.state.getState("local"), "could_start");
-  assert.equal(session.state.getState("remote"), "ready");
+  assert.equal(session.state.getState('local'), 'could_start');
+  assert.equal(session.state.getState('remote'), 'ready');
 }
 
 {
@@ -92,12 +120,12 @@ const startGame = async () => {
   await waitForBus();
 
   client.inbound(
-    JSON.stringify({ type: "READY", sid: "demo-room", from: "remote" }),
+    JSON.stringify({ type: 'READY', sid: 'demo-room', from: 'remote' }),
   );
   await waitForBus();
 
-  assert.equal(session.state.getState("local"), "could_start");
-  assert.equal(session.state.getState("remote"), "ready");
+  assert.equal(session.state.getState('local'), 'could_start');
+  assert.equal(session.state.getState('remote'), 'ready');
 }
 
 {
@@ -113,51 +141,319 @@ const startGame = async () => {
   session.actions.restart();
   await waitForBus();
 
-  assert.equal(session.state.getPendingAction(), "restart");
-  assert.equal(session.state.getState("local"), "waiting_approval");
-  assert.equal(session.state.getState("remote"), "approving");
+  assert.equal(session.state.getPendingAction(), 'restart');
+  assert.equal(session.state.getState('local'), 'waiting_approval');
+  assert.equal(session.state.getState('remote'), 'approving');
 
   client.inbound({
-    type: "APPROVE",
-    payload: { action: "restart" },
-    from: "remote",
+    type: 'APPROVE',
+    payload: { action: 'restart' },
+    from: 'remote',
   });
   await waitForBus();
 
   assert.equal(session.state.getPendingAction(), null);
-  assert.equal(session.state.getState("local"), "idle");
-  assert.equal(session.state.getState("remote"), "idle");
+  assert.equal(session.state.getState('local'), 'idle');
+  assert.equal(session.state.getState('remote'), 'idle');
   assert.equal(
     snapshots.some(
       (snapshot) =>
-        snapshot.localState === "idle" &&
-        snapshot.remoteState === "idle" &&
-        snapshot.pendingAction === "restart",
+        snapshot.localState === 'idle' &&
+        snapshot.remoteState === 'idle' &&
+        snapshot.pendingAction === 'restart',
     ),
     false,
   );
 }
 
+{
+  const { client, session } = await startGame();
+  const snapshots = [];
+  session.observer.subscribe({
+    onStateChange(snapshot) {
+      snapshots.push(snapshot);
+    },
+    onGameEvent() {},
+  });
+
+  if (session.state.getState('local') !== 'turn') {
+    client.inbound({
+      type: 'MOVE',
+      payload: { step: 'remote-first' },
+      from: 'remote',
+    });
+    await waitForBus();
+    snapshots.splice(0, snapshots.length);
+  }
+
+  const beforeHistory = session.state.getHistory().length;
+  session.actions.move({ step: 'local-move' });
+  await waitForBus();
+
+  assert.equal(session.state.getHistory().length, beforeHistory + 1);
+  assert.equal(
+    snapshots.some((snapshot) => snapshot.history.length === beforeHistory + 1),
+    true,
+  );
+}
+
+{
+  const { client, session } = await startGameWithFirstPlayer('local');
+  session.state.setGamePlugin(oneMoveWinPlugin);
+
+  session.actions.move({ step: 'winning-local-move' });
+  await waitForBus();
+
+  assert.equal(client.sent.at(-1).type, 'MOVE');
+  assert.equal(session.state.getState('local'), 'idle');
+  assert.equal(session.state.getState('remote'), 'idle');
+  assert.equal(session.state.getHistory().length, 1);
+  assert.equal(session.state.getHistory()[0].move.step, 'winning-local-move');
+}
+
+{
+  const { client, session } = await startGameWithFirstPlayer('remote');
+  session.state.setGamePlugin(oneMoveWinPlugin);
+
+  client.inbound({
+    type: 'MOVE',
+    payload: { step: 'winning-remote-move' },
+    from: 'remote',
+  });
+  await waitForBus();
+
+  assert.equal(session.state.getState('local'), 'idle');
+  assert.equal(session.state.getState('remote'), 'idle');
+  assert.equal(session.state.getHistory().length, 1);
+  assert.equal(session.state.getHistory()[0].move.step, 'winning-remote-move');
+}
+
+{
+  const { client, session } = await startGameWithFirstPlayer('local');
+  session.state.setGamePlugin(oneMoveWinPlugin);
+
+  session.actions.move({ step: 'winning-local-move' });
+  await waitForBus();
+  assert.equal(session.state.getHistory().length, 1);
+  assert.equal(session.state.getState('local'), 'idle');
+  assert.equal(session.state.getState('remote'), 'idle');
+
+  client.inbound({ type: 'READY', sid: 'demo-room', from: 'remote' });
+  await waitForBus();
+  session.actions.start();
+  await waitForBus();
+
+  assert.equal(session.state.getHistory().length, 0);
+  assert.match(session.state.getState('local'), /^(turn|remote_turn)$/);
+  assert.match(session.state.getState('remote'), /^(turn|remote_turn)$/);
+}
+
+{
+  const { client, session } = await startGameWithFirstPlayer('remote');
+  session.state.setGamePlugin(oneMoveWinPlugin);
+
+  client.inbound({
+    type: 'MOVE',
+    payload: { step: 'winning-remote-move' },
+    from: 'remote',
+  });
+  await waitForBus();
+  assert.equal(session.state.getHistory().length, 1);
+  assert.equal(session.state.getState('local'), 'idle');
+  assert.equal(session.state.getState('remote'), 'idle');
+
+  session.actions.ready();
+  await waitForBus();
+  client.inbound({
+    type: 'START',
+    payload: { starter: 'sender' },
+    from: 'remote',
+  });
+  await waitForBus();
+
+  assert.equal(session.state.getHistory().length, 0);
+  assert.equal(session.state.getState('local'), 'remote_turn');
+  assert.equal(session.state.getState('remote'), 'turn');
+}
+
+{
+  const { client, session } = await startGameWithFirstPlayer('local');
+
+  session.actions.move({ step: 'local-just-moved' });
+  await waitForBus();
+  assert.equal(session.state.getState('local'), 'remote_turn');
+  assert.equal(session.state.getHistory().length, 1);
+
+  session.actions.undo();
+  await waitForBus();
+
+  assert.equal(client.sent.at(-1).type, 'UNDO');
+  assert.equal(client.sent.at(-1).payload.count, 1);
+  assert.equal(session.state.getPendingUndoCount(), 1);
+
+  client.inbound({
+    type: 'APPROVE',
+    payload: { action: 'undo' },
+    from: 'remote',
+  });
+  await waitForBus();
+
+  assert.equal(session.state.getHistory().length, 0);
+  assert.equal(session.state.getState('local'), 'turn');
+  assert.equal(session.state.getState('remote'), 'remote_turn');
+}
+
+{
+  const { client, session } = await startGameWithFirstPlayer('local');
+
+  session.actions.move({ step: 'local-first' });
+  await waitForBus();
+  client.inbound({
+    type: 'MOVE',
+    payload: { step: 'remote-reply' },
+    from: 'remote',
+  });
+  await waitForBus();
+  assert.equal(session.state.getState('local'), 'turn');
+  assert.equal(session.state.getHistory().length, 2);
+
+  session.actions.undo();
+  await waitForBus();
+
+  assert.equal(client.sent.at(-1).type, 'UNDO');
+  assert.equal(client.sent.at(-1).payload.count, 2);
+  assert.equal(session.state.getPendingUndoCount(), 2);
+
+  client.inbound({
+    type: 'APPROVE',
+    payload: { action: 'undo' },
+    from: 'remote',
+  });
+  await waitForBus();
+
+  assert.equal(session.state.getHistory().length, 0);
+  assert.equal(session.state.getState('local'), 'turn');
+  assert.equal(session.state.getState('remote'), 'remote_turn');
+}
+
+{
+  const { client, session } = await startGameWithFirstPlayer('local');
+
+  session.actions.move({ step: 'local-just-moved' });
+  await waitForBus();
+  assert.equal(session.state.getState('local'), 'remote_turn');
+
+  session.actions.undo();
+  await waitForBus();
+  client.inbound({
+    type: 'REJECT',
+    payload: { action: 'undo' },
+    from: 'remote',
+  });
+  await waitForBus();
+
+  assert.equal(session.state.getHistory().length, 1);
+  assert.equal(session.state.getState('local'), 'remote_turn');
+  assert.equal(session.state.getState('remote'), 'turn');
+  assert.equal(
+    client.sent.some((message) => message.type === 'UNDO'),
+    true,
+  );
+}
+
+{
+  const { client } = createConnectedSession();
+  await waitForBus();
+
+  client.inbound({ type: 'UNDO', payload: { count: 3 }, from: 'remote' });
+  await waitForBus();
+  await waitForBus();
+
+  const sent = client.sent.at(-1);
+  assert.equal(sent.type, 'REJECT');
+  assert.equal(sent.payload.action, 'undo');
+  assert.equal(sent.payload.reason, 'invalid_state');
+}
+
+{
+  const { client, session } = createConnectedSession();
+  await waitForBus();
+
+  session.actions.ready();
+  await waitForBus();
+  client.inbound({ type: 'RESTART', from: 'remote' });
+  await waitForBus();
+  await waitForBus();
+
+  const sent = client.sent.at(-1);
+  assert.equal(sent.type, 'REJECT');
+  assert.equal(sent.payload.action, 'restart');
+  assert.equal(sent.payload.reason, 'invalid_state');
+}
+
 {
   const { client, session } = await startGame();
   const beforeRestart = {
-    local: session.state.getState("local"),
-    remote: session.state.getState("remote"),
+    local: session.state.getState('local'),
+    remote: session.state.getState('remote'),
   };
 
   session.actions.restart();
   await waitForBus();
 
   client.inbound({
-    type: "REJECT",
-    payload: { action: "restart" },
-    from: "remote",
+    type: 'REJECT',
+    payload: { action: 'restart' },
+    from: 'remote',
+  });
+  await waitForBus();
+
+  assert.equal(session.state.getPendingAction(), null);
+  assert.equal(session.state.getState('local'), beforeRestart.local);
+  assert.equal(session.state.getState('remote'), beforeRestart.remote);
+}
+
+{
+  const { client, session } = await startGame();
+  session.actions.restart();
+  await waitForBus();
+
+  assert.equal(session.state.getPendingAction(), 'restart');
+
+  session.bus.dispatch({ type: 'OFFLINE', from: 'local' });
+  await waitForBus();
+
+  assert.equal(session.state.getPendingAction(), null);
+  assert.equal(session.state.getState('local'), 'syncing');
+  assert.equal(session.state.getState('remote'), 'offline');
+
+  session.bus.dispatch({ type: 'ONLINE', from: 'local' });
+  await waitForBus();
+  await waitForBus();
+
+  assert.equal(session.state.getPendingAction(), null);
+  assert.equal(session.state.getState('local'), 'syncing');
+  assert.equal(session.state.getState('remote'), 'syncing');
+  assert.equal(client.sent.at(-1).type, 'SYNC_REQUEST');
+
+  client.inbound({
+    type: 'SYNC_STATE',
+    payload: {
+      history: [{ turn: 1, player: 'local', move: { step: 'peer-move' } }],
+      lastStart: 'local',
+      turn: 'local',
+      resumeTurn: 'local',
+    },
+    from: 'remote',
   });
   await waitForBus();
 
   assert.equal(session.state.getPendingAction(), null);
-  assert.equal(session.state.getState("local"), beforeRestart.local);
-  assert.equal(session.state.getState("remote"), beforeRestart.remote);
+  assert.equal(session.state.getState('local'), 'remote_turn');
+  assert.equal(session.state.getState('remote'), 'turn');
+  assert.equal(session.state.getHistory().length, 1);
+  assert.equal(session.state.getHistory()[0].player, 'remote');
+  assert.equal(session.state.getLastStart(), 'remote');
 }
 
 {
@@ -170,28 +466,28 @@ const startGame = async () => {
     onGameEvent() {},
   });
 
-  client.inbound({ type: "RESTART", from: "remote" });
+  client.inbound({ type: 'RESTART', from: 'remote' });
   await waitForBus();
 
-  assert.equal(session.state.getPendingAction(), "restart");
-  assert.equal(session.state.getState("local"), "approving");
-  assert.equal(session.state.getState("remote"), "waiting_approval");
+  assert.equal(session.state.getPendingAction(), 'restart');
+  assert.equal(session.state.getState('local'), 'approving');
+  assert.equal(session.state.getState('remote'), 'waiting_approval');
 
   session.actions.approve();
   await waitForBus();
 
   const sent = client.sent.at(-1);
-  assert.equal(sent.type, "APPROVE");
-  assert.equal(sent.payload.action, "restart");
+  assert.equal(sent.type, 'APPROVE');
+  assert.equal(sent.payload.action, 'restart');
   assert.equal(session.state.getPendingAction(), null);
-  assert.equal(session.state.getState("local"), "idle");
-  assert.equal(session.state.getState("remote"), "idle");
+  assert.equal(session.state.getState('local'), 'idle');
+  assert.equal(session.state.getState('remote'), 'idle');
   assert.equal(
     snapshots.some(
       (snapshot) =>
-        snapshot.localState === "idle" &&
-        snapshot.remoteState === "idle" &&
-        snapshot.pendingAction === "restart",
+        snapshot.localState === 'idle' &&
+        snapshot.remoteState === 'idle' &&
+        snapshot.pendingAction === 'restart',
     ),
     false,
   );
@@ -200,22 +496,92 @@ const startGame = async () => {
 {
   const { client, session } = await startGame();
   const beforeRestart = {
-    local: session.state.getState("local"),
-    remote: session.state.getState("remote"),
+    local: session.state.getState('local'),
+    remote: session.state.getState('remote'),
   };
 
-  client.inbound({ type: "RESTART", from: "remote" });
+  client.inbound({ type: 'RESTART', from: 'remote' });
   await waitForBus();
 
   session.actions.reject();
   await waitForBus();
 
   const sent = client.sent.at(-1);
-  assert.equal(sent.type, "REJECT");
-  assert.equal(sent.payload.action, "restart");
+  assert.equal(sent.type, 'REJECT');
+  assert.equal(sent.payload.action, 'restart');
+  assert.equal(session.state.getPendingAction(), null);
+  assert.equal(session.state.getState('local'), beforeRestart.local);
+  assert.equal(session.state.getState('remote'), beforeRestart.remote);
+}
+
+{
+  const { client, session } = await startGame();
+  client.inbound({ type: 'RESTART', from: 'remote' });
+  await waitForBus();
+
+  assert.equal(session.state.getPendingAction(), 'restart');
+
+  session.bus.dispatch({ type: 'OFFLINE', from: 'local' });
+  await waitForBus();
+
   assert.equal(session.state.getPendingAction(), null);
-  assert.equal(session.state.getState("local"), beforeRestart.local);
-  assert.equal(session.state.getState("remote"), beforeRestart.remote);
+  assert.equal(session.state.getState('local'), 'syncing');
+  assert.equal(session.state.getState('remote'), 'offline');
+
+  session.bus.dispatch({ type: 'ONLINE', from: 'local' });
+  await waitForBus();
+  await waitForBus();
+
+  assert.equal(session.state.getPendingAction(), null);
+  assert.equal(session.state.getState('local'), 'syncing');
+  assert.equal(session.state.getState('remote'), 'syncing');
+  assert.equal(client.sent.at(-1).type, 'SYNC_REQUEST');
+
+  client.inbound({
+    type: 'SYNC_STATE',
+    payload: {
+      history: [{ turn: 1, player: 'remote', move: { step: 'local-move' } }],
+      lastStart: 'remote',
+      turn: 'remote',
+      resumeTurn: 'remote',
+    },
+    from: 'remote',
+  });
+  await waitForBus();
+
+  assert.equal(session.state.getPendingAction(), null);
+  assert.equal(session.state.getState('local'), 'turn');
+  assert.equal(session.state.getState('remote'), 'remote_turn');
+  assert.equal(session.state.getHistory().length, 1);
+  assert.equal(session.state.getHistory()[0].player, 'local');
+  assert.equal(session.state.getLastStart(), 'local');
+}
+
+{
+  const { client, session } = await startGameWithFirstPlayer('local');
+  session.actions.move({ step: 'local-before-disconnect' });
+  await waitForBus();
+
+  assert.equal(session.state.getState('local'), 'remote_turn');
+  assert.equal(session.state.getState('remote'), 'turn');
+  assert.equal(session.state.getHistory().length, 1);
+
+  session.bus.dispatch({ type: 'OFFLINE', from: 'local' });
+  await waitForBus();
+
+  assert.equal(session.state.getState('local'), 'remote_turn');
+  assert.equal(session.state.getState('remote'), 'offline');
+
+  client.inbound({ type: 'SYNC_REQUEST', from: 'remote' });
+  await waitForBus();
+
+  const sent = client.sent.at(-1);
+  assert.equal(sent.type, 'SYNC_STATE');
+  assert.equal(sent.payload.resumeTurn, 'remote');
+  assert.equal(session.state.getState('local'), 'remote_turn');
+  assert.equal(session.state.getState('remote'), 'turn');
+  assert.equal(session.state.getHistory().length, 1);
+  assert.equal(session.state.getHistory()[0].player, 'local');
 }
 
-console.log("serialization smoke passed");
+console.log('serialization smoke passed');