quake2ts 0.0.562 → 0.0.564

package/packages/test-utils/dist/index.cjs

@@ -30,24 +30,31 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  HandshakeStage: () => HandshakeStage,
   InputInjector: () => InputInjector,
   MockPointerLock: () => MockPointerLock,
   MockTransport: () => MockTransport,
   captureAudioEvents: () => captureAudioEvents,
   captureCanvasDrawCalls: () => captureCanvasDrawCalls,
+  captureGameScreenshot: () => captureGameScreenshot,
   captureGameState: () => captureGameState,
+  compareScreenshots: () => compareScreenshots,
   createBinaryStreamMock: () => createBinaryStreamMock,
   createBinaryWriterMock: () => createBinaryWriterMock,
   createControlledTimer: () => createControlledTimer,
+  createCustomNetworkCondition: () => createCustomNetworkCondition,
+  createDeltaSnapshot: () => createDeltaSnapshot,
   createEntity: () => createEntity,
   createEntityStateFactory: () => createEntityStateFactory,
   createGameStateSnapshotFactory: () => createGameStateSnapshotFactory,
   createMockAudioContext: () => createMockAudioContext,
   createMockCanvas: () => createMockCanvas,
   createMockCanvasContext2D: () => createMockCanvasContext2D,
+  createMockConnection: () => createMockConnection,
   createMockEngine: () => createMockEngine,
   createMockGame: () => createMockGame,
   createMockGameState: () => createMockGameState,
+  createMockHandshake: () => createMockHandshake,
   createMockImage: () => createMockImage,
   createMockImageData: () => createMockImageData,
   createMockIndexedDB: () => createMockIndexedDB,
@@ -62,13 +69,17 @@ __export(index_exports, {
   createMockSessionStorage: () => createMockSessionStorage,
   createMockTransport: () => createMockTransport,
   createMockUDPSocket: () => createMockUDPSocket,
+  createMockUserInfo: () => createMockUserInfo,
   createMockWebGL2Context: () => createMockWebGL2Context,
+  createMultiplayerTestScenario: () => createMultiplayerTestScenario,
   createNetChanMock: () => createNetChanMock,
   createPlayerStateFactory: () => createPlayerStateFactory,
   createPlaywrightTestClient: () => createPlaywrightTestClient,
+  createServerSnapshot: () => createServerSnapshot,
   createSpawnContext: () => createSpawnContext,
   createStorageTestScenario: () => createStorageTestScenario,
   createTestContext: () => createTestContext,
+  createVisualTestScenario: () => createVisualTestScenario,
   intersects: () => import_shared3.intersects,
   ladderTrace: () => import_shared3.ladderTrace,
   makeAxisBrush: () => makeAxisBrush,
@@ -78,14 +89,24 @@ __export(index_exports, {
   makeLeafModel: () => makeLeafModel,
   makeNode: () => makeNode,
   makePlane: () => makePlane,
+  serializeUserInfo: () => serializeUserInfo,
   setupBrowserEnvironment: () => setupBrowserEnvironment,
   setupMockAudioContext: () => setupMockAudioContext,
   setupNodeEnvironment: () => setupNodeEnvironment,
   simulateFrames: () => simulateFrames,
   simulateFramesWithMock: () => simulateFramesWithMock,
+  simulateHandshake: () => simulateHandshake,
+  simulateNetworkCondition: () => simulateNetworkCondition,
+  simulatePlayerInput: () => simulatePlayerInput,
+  simulatePlayerJoin: () => simulatePlayerJoin,
+  simulatePlayerLeave: () => simulatePlayerLeave,
+  simulateServerTick: () => simulateServerTick,
+  simulateSnapshotDelivery: () => simulateSnapshotDelivery,
   stairTrace: () => import_shared3.stairTrace,
   teardownBrowserEnvironment: () => teardownBrowserEnvironment,
   teardownMockAudioContext: () => teardownMockAudioContext,
+  throttleBandwidth: () => throttleBandwidth,
+  verifySnapshotConsistency: () => verifySnapshotConsistency,
   waitForGameReady: () => waitForGameReady
 });
 module.exports = __toCommonJS(index_exports);
@@ -692,6 +713,214 @@ function createMockServer(overrides) {
   };
 }
 
+// src/server/mocks/connection.ts
+var import_server2 = require("@quake2ts/server");
+var HandshakeStage = /* @__PURE__ */ ((HandshakeStage2) => {
+  HandshakeStage2[HandshakeStage2["None"] = 0] = "None";
+  HandshakeStage2[HandshakeStage2["Challenge"] = 1] = "Challenge";
+  HandshakeStage2[HandshakeStage2["Connect"] = 2] = "Connect";
+  HandshakeStage2[HandshakeStage2["Info"] = 3] = "Info";
+  HandshakeStage2[HandshakeStage2["Active"] = 4] = "Active";
+  return HandshakeStage2;
+})(HandshakeStage || {});
+function serializeUserInfo(info) {
+  return Object.entries(info).reduce((acc, [key, value]) => {
+    if (value !== void 0) {
+      return `${acc}\\${key}\\${value}`;
+    }
+    return acc;
+  }, "");
+}
+function createMockUserInfo(overrides) {
+  return {
+    name: "Player",
+    skin: "male/grunt",
+    model: "male/grunt",
+    fov: 90,
+    hand: 0,
+    rate: 25e3,
+    msg: 1,
+    ...overrides
+  };
+}
+function createMockConnection(state = import_server2.ClientState.Connected, overrides) {
+  return createMockServerClient(0, {
+    state,
+    userInfo: serializeUserInfo(createMockUserInfo()),
+    challenge: Math.floor(Math.random() * 1e5),
+    ...overrides
+  });
+}
+function createMockHandshake(stage = 0 /* None */) {
+  return {
+    stage,
+    clientNum: -1,
+    challenge: 0,
+    qport: Math.floor(Math.random() * 65536)
+  };
+}
+async function simulateHandshake(client, server) {
+  const challenge = Math.floor(Math.random() * 1e5);
+  client.challenge = challenge;
+  if (server && server.clients) {
+  }
+  client.state = import_server2.ClientState.Connected;
+  client.state = import_server2.ClientState.Active;
+  return true;
+}
+
+// src/server/helpers/multiplayer.ts
+var import_server3 = require("@quake2ts/server");
+function createMultiplayerTestScenario(numPlayers = 2) {
+  const baseServer = createMockServerState();
+  const clients = [];
+  const entities = [];
+  const server = {
+    ...baseServer,
+    clients: new Array(numPlayers).fill(null),
+    entities: []
+  };
+  for (let i = 0; i < numPlayers; i++) {
+    const client = createMockServerClient(i, {
+      state: import_server3.ClientState.Active,
+      userInfo: serializeUserInfo(createMockUserInfo({ name: `Player${i}` }))
+    });
+    const entity = {
+      classname: "player",
+      s: { origin: { x: 0, y: 0, z: 0 }, number: i + 1 },
+      client
+    };
+    client.edict = entity;
+    server.clients[i] = client;
+    clients.push(client);
+    entities.push(entity);
+  }
+  server.entities = entities;
+  return {
+    server,
+    clients,
+    entities
+  };
+}
+async function simulatePlayerJoin(server, userInfo) {
+  const index = server.clients.findIndex((c) => !c || c.state === import_server3.ClientState.Free);
+  if (index === -1) {
+    throw new Error("Server full");
+  }
+  const client = createMockServerClient(index, {
+    state: import_server3.ClientState.Connected,
+    userInfo: serializeUserInfo(createMockUserInfo(userInfo))
+  });
+  server.clients[index] = client;
+  client.state = import_server3.ClientState.Active;
+  const entity = {
+    classname: "player",
+    s: { origin: { x: 0, y: 0, z: 0 }, number: index + 1 },
+    client
+  };
+  client.edict = entity;
+  if (server.entities && Array.isArray(server.entities)) {
+    server.entities[index + 1] = entity;
+  }
+  return client;
+}
+function simulatePlayerLeave(server, clientNum) {
+  const client = server.clients[clientNum];
+  if (client) {
+    client.state = import_server3.ClientState.Free;
+    client.edict = null;
+  }
+}
+function simulateServerTick(server, deltaTime = 0.1) {
+  server.time += deltaTime;
+  server.frame++;
+  server.clients.forEach((client) => {
+    if (client && client.state === import_server3.ClientState.Active) {
+    }
+  });
+}
+function simulatePlayerInput(client, input) {
+  const cmd = {
+    msec: 100,
+    buttons: 0,
+    angles: { x: 0, y: 0, z: 0 },
+    forwardmove: 0,
+    sidemove: 0,
+    upmove: 0,
+    sequence: client.lastCmd.sequence + 1,
+    lightlevel: 0,
+    impulse: 0,
+    ...input
+  };
+  client.lastCmd = cmd;
+  client.commandQueue.push(cmd);
+  client.commandCount++;
+}
+
+// src/server/helpers/snapshot.ts
+function createServerSnapshot(serverState, clientNum) {
+  const visibleEntities = [];
+  if (serverState.baselines) {
+    serverState.baselines.forEach((ent, index) => {
+      if (ent && index !== clientNum + 1) {
+        visibleEntities.push({ ...ent });
+      }
+    });
+  }
+  return {
+    serverTime: serverState.time,
+    playerState: {
+      origin: { x: 0, y: 0, z: 0 },
+      viewangles: { x: 0, y: 0, z: 0 },
+      pm_type: 0
+    },
+    entities: visibleEntities
+  };
+}
+function createDeltaSnapshot(oldSnapshot, newSnapshot) {
+  const deltaEntities = [];
+  const removedEntities = [];
+  const oldMap = new Map(oldSnapshot.entities.map((e) => [e.number, e]));
+  const newMap = new Map(newSnapshot.entities.map((e) => [e.number, e]));
+  newSnapshot.entities.forEach((newEnt) => {
+    const oldEnt = oldMap.get(newEnt.number);
+    if (!oldEnt) {
+      deltaEntities.push(newEnt);
+    } else if (JSON.stringify(newEnt) !== JSON.stringify(oldEnt)) {
+      deltaEntities.push(newEnt);
+    }
+  });
+  oldSnapshot.entities.forEach((oldEnt) => {
+    if (!newMap.has(oldEnt.number)) {
+      removedEntities.push(oldEnt.number);
+    }
+  });
+  return {
+    snapshot: newSnapshot,
+    deltaEntities,
+    removedEntities
+  };
+}
+function verifySnapshotConsistency(snapshots) {
+  const report = { valid: true, errors: [] };
+  if (snapshots.length < 2) return report;
+  for (let i = 1; i < snapshots.length; i++) {
+    const prev = snapshots[i - 1];
+    const curr = snapshots[i];
+    if (curr.serverTime <= prev.serverTime) {
+      report.valid = false;
+      report.errors.push(`Snapshot ${i} has time ${curr.serverTime} <= prev ${prev.serverTime}`);
+    }
+  }
+  return report;
+}
+async function simulateSnapshotDelivery(snapshot, reliability = 1) {
+  if (Math.random() > reliability) {
+    return null;
+  }
+  return snapshot;
+}
+
 // src/setup/browser.ts
 var import_jsdom = require("jsdom");
 var import_canvas = require("@napi-rs/canvas");
@@ -1169,8 +1398,8 @@ function createMockImage(width, height, src) {
 }
 
 // src/setup/node.ts
-function setupNodeEnvironment() {
-  if (typeof global.fetch === "undefined") {
+function setupNodeEnvironment(options = {}) {
+  if (options.polyfillFetch && typeof global.fetch === "undefined") {
   }
 }
 
@@ -1199,6 +1428,61 @@ function createMockIndexedDB() {
   return indexedDB;
 }
 function createStorageTestScenario(storageType = "local") {
+  if (storageType === "indexed") {
+    const dbName = `test-db-${Math.random().toString(36).substring(7)}`;
+    const storeName = "test-store";
+    const storage2 = createMockIndexedDB();
+    return {
+      storage: storage2,
+      populate: async (data) => {
+        return new Promise((resolve, reject) => {
+          const req = storage2.open(dbName, 1);
+          req.onupgradeneeded = (e) => {
+            const db = e.target.result;
+            db.createObjectStore(storeName);
+          };
+          req.onsuccess = (e) => {
+            const db = e.target.result;
+            const tx = db.transaction(storeName, "readwrite");
+            const store = tx.objectStore(storeName);
+            Object.entries(data).forEach(([k, v]) => store.put(v, k));
+            tx.oncomplete = () => {
+              db.close();
+              resolve();
+            };
+            tx.onerror = () => reject(tx.error);
+          };
+          req.onerror = () => reject(req.error);
+        });
+      },
+      verify: async (key, value) => {
+        return new Promise((resolve, reject) => {
+          const req = storage2.open(dbName, 1);
+          req.onsuccess = (e) => {
+            const db = e.target.result;
+            if (!db.objectStoreNames.contains(storeName)) {
+              db.close();
+              resolve(false);
+              return;
+            }
+            const tx = db.transaction(storeName, "readonly");
+            const store = tx.objectStore(storeName);
+            const getReq = store.get(key);
+            getReq.onsuccess = () => {
+              const result = getReq.result === value;
+              db.close();
+              resolve(result);
+            };
+            getReq.onerror = () => {
+              db.close();
+              resolve(false);
+            };
+          };
+          req.onerror = () => reject(req.error);
+        });
+      }
+    };
+  }
   const storage = storageType === "local" ? createMockLocalStorage() : createMockSessionStorage();
   return {
     storage,
@@ -1213,7 +1497,7 @@ function createStorageTestScenario(storageType = "local") {
 
 // src/setup/audio.ts
 function createMockAudioContext() {
-  return {
+  const context = {
     createGain: () => ({
       connect: () => {
       },
@@ -1262,8 +1546,23 @@ function createMockAudioContext() {
       sampleRate,
       numberOfChannels: channels,
       getChannelData: () => new Float32Array(length)
-    })
+    }),
+    // Helper to track events if needed
+    _events: []
   };
+  return new Proxy(context, {
+    get(target, prop, receiver) {
+      if (prop === "_events") return target._events;
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === "function") {
+        return (...args) => {
+          target._events.push({ type: String(prop), args });
+          return Reflect.apply(value, target, args);
+        };
+      }
+      return value;
+    }
+  });
 }
 function setupMockAudioContext() {
   if (typeof global.AudioContext === "undefined" && typeof global.window !== "undefined") {
@@ -1284,7 +1583,7 @@ function teardownMockAudioContext() {
   }
 }
 function captureAudioEvents(context) {
-  return [];
+  return context._events || [];
 }
 
 // src/setup/timing.ts
@@ -1576,26 +1875,143 @@ async function captureGameState(page) {
     return {};
   });
 }
+
+// src/e2e/network.ts
+var CONDITIONS = {
+  "good": {
+    offline: false,
+    downloadThroughput: 10 * 1024 * 1024,
+    // 10 Mbps
+    uploadThroughput: 5 * 1024 * 1024,
+    // 5 Mbps
+    latency: 20
+  },
+  "slow": {
+    offline: false,
+    downloadThroughput: 500 * 1024,
+    // 500 Kbps
+    uploadThroughput: 500 * 1024,
+    latency: 400
+  },
+  "unstable": {
+    offline: false,
+    downloadThroughput: 1 * 1024 * 1024,
+    uploadThroughput: 1 * 1024 * 1024,
+    latency: 100
+  },
+  "offline": {
+    offline: true,
+    downloadThroughput: 0,
+    uploadThroughput: 0,
+    latency: 0
+  }
+};
+function simulateNetworkCondition(condition) {
+  const config = CONDITIONS[condition];
+  return createCustomNetworkCondition(config.latency, 0, 0, config);
+}
+function createCustomNetworkCondition(latency, jitter = 0, packetLoss = 0, baseConfig) {
+  return {
+    async apply(page) {
+      const client = await page.context().newCDPSession(page);
+      await client.send("Network.enable");
+      await client.send("Network.emulateNetworkConditions", {
+        offline: baseConfig?.offline || false,
+        latency: latency + Math.random() * jitter,
+        downloadThroughput: baseConfig?.downloadThroughput || -1,
+        uploadThroughput: baseConfig?.uploadThroughput || -1
+      });
+    },
+    async clear(page) {
+      const client = await page.context().newCDPSession(page);
+      await client.send("Network.emulateNetworkConditions", {
+        offline: false,
+        latency: 0,
+        downloadThroughput: -1,
+        uploadThroughput: -1
+      });
+    }
+  };
+}
+async function throttleBandwidth(page, bytesPerSecond) {
+  const simulator = createCustomNetworkCondition(0, 0, 0, {
+    offline: false,
+    latency: 0,
+    downloadThroughput: bytesPerSecond,
+    uploadThroughput: bytesPerSecond
+  });
+  await simulator.apply(page);
+}
+
+// src/e2e/visual.ts
+var import_path = __toESM(require("path"), 1);
+var import_promises = __toESM(require("fs/promises"), 1);
+async function captureGameScreenshot(page, name, options = {}) {
+  const dir = options.dir || "__screenshots__";
+  const screenshotPath = import_path.default.join(dir, `${name}.png`);
+  await import_promises.default.mkdir(dir, { recursive: true });
+  return await page.screenshot({
+    path: screenshotPath,
+    fullPage: options.fullPage ?? false,
+    animations: "disabled",
+    caret: "hide"
+  });
+}
+async function compareScreenshots(baseline, current, threshold = 0.1) {
+  if (baseline.equals(current)) {
+    return { pixelDiff: 0, matched: true };
+  }
+  return {
+    pixelDiff: -1,
+    // Unknown magnitude
+    matched: false
+  };
+}
+function createVisualTestScenario(page, sceneName) {
+  return {
+    async capture(snapshotName) {
+      return await captureGameScreenshot(page, `${sceneName}-${snapshotName}`);
+    },
+    async compare(snapshotName, baselineDir) {
+      const name = `${sceneName}-${snapshotName}`;
+      const current = await captureGameScreenshot(page, name, { dir: "__screenshots__/current" });
+      try {
+        const baselinePath = import_path.default.join(baselineDir, `${name}.png`);
+        const baseline = await import_promises.default.readFile(baselinePath);
+        return await compareScreenshots(baseline, current);
+      } catch (e) {
+        return { pixelDiff: -1, matched: false };
+      }
+    }
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  HandshakeStage,
   InputInjector,
   MockPointerLock,
   MockTransport,
   captureAudioEvents,
   captureCanvasDrawCalls,
+  captureGameScreenshot,
   captureGameState,
+  compareScreenshots,
   createBinaryStreamMock,
   createBinaryWriterMock,
   createControlledTimer,
+  createCustomNetworkCondition,
+  createDeltaSnapshot,
   createEntity,
   createEntityStateFactory,
   createGameStateSnapshotFactory,
   createMockAudioContext,
   createMockCanvas,
   createMockCanvasContext2D,
+  createMockConnection,
   createMockEngine,
   createMockGame,
   createMockGameState,
+  createMockHandshake,
   createMockImage,
   createMockImageData,
   createMockIndexedDB,
@@ -1610,13 +2026,17 @@ async function captureGameState(page) {
   createMockSessionStorage,
   createMockTransport,
   createMockUDPSocket,
+  createMockUserInfo,
   createMockWebGL2Context,
+  createMultiplayerTestScenario,
   createNetChanMock,
   createPlayerStateFactory,
   createPlaywrightTestClient,
+  createServerSnapshot,
   createSpawnContext,
   createStorageTestScenario,
   createTestContext,
+  createVisualTestScenario,
   intersects,
   ladderTrace,
   makeAxisBrush,
@@ -1626,14 +2046,24 @@ async function captureGameState(page) {
   makeLeafModel,
   makeNode,
   makePlane,
+  serializeUserInfo,
   setupBrowserEnvironment,
   setupMockAudioContext,
   setupNodeEnvironment,
   simulateFrames,
   simulateFramesWithMock,
+  simulateHandshake,
+  simulateNetworkCondition,
+  simulatePlayerInput,
+  simulatePlayerJoin,
+  simulatePlayerLeave,
+  simulateServerTick,
+  simulateSnapshotDelivery,
   stairTrace,
   teardownBrowserEnvironment,
   teardownMockAudioContext,
+  throttleBandwidth,
+  verifySnapshotConsistency,
   waitForGameReady
 });
 //# sourceMappingURL=index.cjs.map