quake2ts 0.0.565 → 0.0.567

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

@@ -659,6 +659,52 @@ async function simulateHandshake(client, server) {
   return true;
 }
 
+// src/server/mocks/commands.ts
+import { vi as vi5 } from "vitest";
+function createMockServerConsole(overrides) {
+  const outputBuffer = [];
+  const commandBuffer = [];
+  return {
+    exec: vi5.fn((cmd) => {
+      commandBuffer.push(cmd);
+      return `Executed: ${cmd}`;
+    }),
+    print: vi5.fn((text) => {
+      outputBuffer.push(text);
+    }),
+    broadcast: vi5.fn((text) => {
+      outputBuffer.push(`Broadcast: ${text}`);
+    }),
+    commandBuffer,
+    outputBuffer,
+    ...overrides
+  };
+}
+function createMockRConClient(password = "") {
+  return {
+    connected: false,
+    lastCommand: "",
+    lastResponse: "",
+    connect: vi5.fn(async (address, port, pwd) => {
+      return pwd === password;
+    }),
+    sendCommand: vi5.fn(async (cmd) => {
+      return `RCON Response for: ${cmd}`;
+    }),
+    disconnect: vi5.fn()
+  };
+}
+function simulateServerCommand(server, command) {
+  if (server.executeBuffer) {
+    server.executeBuffer(command);
+    return "Executed";
+  }
+  if (server.exec) {
+    return server.exec(command);
+  }
+  return "Unknown command handler";
+}
+
 // src/server/helpers/multiplayer.ts
 import { ClientState as ClientState3 } from "@quake2ts/server";
 function createMultiplayerTestScenario(numPlayers = 2) {
@@ -1287,193 +1333,67 @@ function createMockImage(width, height, src) {
   return img;
 }
 
-// src/setup/node.ts
-function setupNodeEnvironment(options = {}) {
-  if (options.polyfillFetch && typeof global.fetch === "undefined") {
-  }
-}
-
-// src/setup/storage.ts
-import "fake-indexeddb/auto";
-function createMockLocalStorage(initialData = {}) {
-  const storage = new Map(Object.entries(initialData));
+// src/engine/mocks/webgpu.ts
+import { vi as vi6 } from "vitest";
+function createMockGPUAdapter() {
   return {
-    getItem: (key) => storage.get(key) || null,
-    setItem: (key, value) => storage.set(key, value),
-    removeItem: (key) => storage.delete(key),
-    clear: () => storage.clear(),
-    key: (index) => Array.from(storage.keys())[index] || null,
-    get length() {
-      return storage.size;
-    }
+    requestDevice: vi6.fn().mockResolvedValue(createMockGPUDevice()),
+    features: /* @__PURE__ */ new Set(),
+    limits: {}
   };
 }
-function createMockSessionStorage(initialData = {}) {
-  return createMockLocalStorage(initialData);
-}
-function createMockIndexedDB() {
-  if (typeof indexedDB === "undefined") {
-    throw new Error("IndexedDB mock not found. Ensure fake-indexeddb is loaded.");
-  }
-  return indexedDB;
+function createMockGPUDevice() {
+  return {
+    features: /* @__PURE__ */ new Set(),
+    limits: {},
+    queue: {
+      submit: vi6.fn(),
+      writeBuffer: vi6.fn(),
+      writeTexture: vi6.fn(),
+      copyExternalImageToTexture: vi6.fn()
+    },
+    createCommandEncoder: vi6.fn().mockReturnValue({
+      beginRenderPass: vi6.fn().mockReturnValue({
+        setPipeline: vi6.fn(),
+        draw: vi6.fn(),
+        end: vi6.fn()
+      }),
+      finish: vi6.fn()
+    }),
+    createRenderPipeline: vi6.fn(),
+    createShaderModule: vi6.fn(),
+    createBindGroup: vi6.fn(),
+    createBindGroupLayout: vi6.fn(),
+    createBuffer: vi6.fn(),
+    createTexture: vi6.fn(),
+    createSampler: vi6.fn()
+  };
 }
-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();
+function createMockGPUCanvasContext() {
   return {
-    storage,
-    populate(data) {
-      Object.entries(data).forEach(([k, v]) => storage.setItem(k, v));
-    },
-    verify(key, value) {
-      return storage.getItem(key) === value;
-    }
+    configure: vi6.fn(),
+    unconfigure: vi6.fn(),
+    getCurrentTexture: vi6.fn()
   };
 }
-
-// src/setup/audio.ts
-function createMockAudioContext() {
-  const context = {
-    createGain: () => ({
-      connect: () => {
-      },
-      gain: { value: 1, setValueAtTime: () => {
-      } }
-    }),
-    createOscillator: () => ({
-      connect: () => {
-      },
-      start: () => {
-      },
-      stop: () => {
-      },
-      frequency: { value: 440 }
-    }),
-    createBufferSource: () => ({
-      connect: () => {
-      },
-      start: () => {
-      },
-      stop: () => {
-      },
-      buffer: null,
-      playbackRate: { value: 1 },
-      loop: false
-    }),
-    destination: {},
-    currentTime: 0,
-    state: "running",
-    resume: async () => {
-    },
-    suspend: async () => {
-    },
-    close: async () => {
-    },
-    decodeAudioData: async (buffer) => ({
-      duration: 1,
-      length: 44100,
-      sampleRate: 44100,
-      numberOfChannels: 2,
-      getChannelData: () => new Float32Array(44100)
-    }),
-    createBuffer: (channels, length, sampleRate) => ({
-      duration: length / sampleRate,
-      length,
-      sampleRate,
-      numberOfChannels: channels,
-      getChannelData: () => new Float32Array(length)
-    }),
-    // Helper to track events if needed
-    _events: []
+function setupWebGPUMocks() {
+  const mockAdapter = createMockGPUAdapter();
+  const mockGpu = {
+    requestAdapter: vi6.fn().mockResolvedValue(mockAdapter),
+    getPreferredCanvasFormat: vi6.fn().mockReturnValue("bgra8unorm")
   };
-  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;
-    }
+  Object.defineProperty(global.navigator, "gpu", {
+    value: mockGpu,
+    writable: true,
+    configurable: true
   });
-}
-function setupMockAudioContext() {
-  if (typeof global.AudioContext === "undefined" && typeof global.window !== "undefined") {
-    global.AudioContext = class {
-      constructor() {
-        return createMockAudioContext();
-      }
-    };
-    global.window.AudioContext = global.AudioContext;
-    global.window.webkitAudioContext = global.AudioContext;
-  }
-}
-function teardownMockAudioContext() {
-  if (global.AudioContext && global.AudioContext.toString().includes("class")) {
-    delete global.AudioContext;
-    delete global.window.AudioContext;
-    delete global.window.webkitAudioContext;
-  }
-}
-function captureAudioEvents(context) {
-  return context._events || [];
+  global.GPUTextureUsage = {
+    COPY_SRC: 1,
+    COPY_DST: 2,
+    TEXTURE_BINDING: 4,
+    STORAGE_BINDING: 8,
+    RENDER_ATTACHMENT: 16
+  };
 }
 
 // src/setup/timing.ts
@@ -1660,6 +1580,195 @@ function simulateFramesWithMock(mock, count, frameTimeMs = 16.6, callback) {
   }
 }
 
+// src/setup/node.ts
+function setupNodeEnvironment(options = {}) {
+  if (options.polyfillFetch && typeof global.fetch === "undefined") {
+  }
+}
+
+// src/setup/storage.ts
+import "fake-indexeddb/auto";
+function createMockLocalStorage(initialData = {}) {
+  const storage = new Map(Object.entries(initialData));
+  return {
+    getItem: (key) => storage.get(key) || null,
+    setItem: (key, value) => storage.set(key, value),
+    removeItem: (key) => storage.delete(key),
+    clear: () => storage.clear(),
+    key: (index) => Array.from(storage.keys())[index] || null,
+    get length() {
+      return storage.size;
+    }
+  };
+}
+function createMockSessionStorage(initialData = {}) {
+  return createMockLocalStorage(initialData);
+}
+function createMockIndexedDB() {
+  if (typeof indexedDB === "undefined") {
+    throw new Error("IndexedDB mock not found. Ensure fake-indexeddb is loaded.");
+  }
+  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,
+    populate(data) {
+      Object.entries(data).forEach(([k, v]) => storage.setItem(k, v));
+    },
+    verify(key, value) {
+      return storage.getItem(key) === value;
+    }
+  };
+}
+
+// src/setup/audio.ts
+function createMockAudioContext() {
+  const context = {
+    createGain: () => ({
+      connect: () => {
+      },
+      gain: { value: 1, setValueAtTime: () => {
+      } }
+    }),
+    createOscillator: () => ({
+      connect: () => {
+      },
+      start: () => {
+      },
+      stop: () => {
+      },
+      frequency: { value: 440 }
+    }),
+    createBufferSource: () => ({
+      connect: () => {
+      },
+      start: () => {
+      },
+      stop: () => {
+      },
+      buffer: null,
+      playbackRate: { value: 1 },
+      loop: false
+    }),
+    destination: {},
+    currentTime: 0,
+    state: "running",
+    resume: async () => {
+    },
+    suspend: async () => {
+    },
+    close: async () => {
+    },
+    decodeAudioData: async (buffer) => ({
+      duration: 1,
+      length: 44100,
+      sampleRate: 44100,
+      numberOfChannels: 2,
+      getChannelData: () => new Float32Array(44100)
+    }),
+    createBuffer: (channels, length, sampleRate) => ({
+      duration: length / sampleRate,
+      length,
+      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") {
+    global.AudioContext = class {
+      constructor() {
+        return createMockAudioContext();
+      }
+    };
+    global.window.AudioContext = global.AudioContext;
+    global.window.webkitAudioContext = global.AudioContext;
+  }
+}
+function teardownMockAudioContext() {
+  if (global.AudioContext && global.AudioContext.toString().includes("class")) {
+    delete global.AudioContext;
+    delete global.window.AudioContext;
+    delete global.window.webkitAudioContext;
+  }
+}
+function captureAudioEvents(context) {
+  return context._events || [];
+}
+
 // src/e2e/playwright.ts
 import { chromium } from "playwright";
 import { createServer } from "http";
@@ -1898,6 +2007,9 @@ export {
   createMockCanvasContext2D,
   createMockConnection,
   createMockEngine,
+  createMockGPUAdapter,
+  createMockGPUCanvasContext,
+  createMockGPUDevice,
   createMockGame,
   createMockGameState,
   createMockHandshake,
@@ -1908,8 +2020,10 @@ export {
   createMockNetworkAddress,
   createMockPerformance,
   createMockRAF,
+  createMockRConClient,
   createMockServer,
   createMockServerClient,
+  createMockServerConsole,
   createMockServerState,
   createMockServerStatic,
   createMockSessionStorage,
@@ -1939,6 +2053,7 @@ export {
   setupBrowserEnvironment,
   setupMockAudioContext,
   setupNodeEnvironment,
+  setupWebGPUMocks,
   simulateFrames,
   simulateFramesWithMock,
   simulateHandshake,
@@ -1946,6 +2061,7 @@ export {
   simulatePlayerInput,
   simulatePlayerJoin,
   simulatePlayerLeave,
+  simulateServerCommand,
   simulateServerTick,
   simulateSnapshotDelivery,
   stairTrace,