@quake2ts/test-utils 0.0.1

package/src/engine/mocks/audio.ts

@@ -0,0 +1,152 @@
+import type {
+  AudioContextLike,
+  AudioDestinationNodeLike,
+  AudioNodeLike,
+  AudioParamLike,
+  AudioBufferSourceNodeLike,
+  AudioBufferLike,
+  GainNodeLike,
+  DynamicsCompressorNodeLike,
+  PannerNodeLike,
+  BiquadFilterNodeLike,
+} from '@quake2ts/engine';
+
+export class FakeAudioParam implements AudioParamLike {
+  constructor(public value: number) {}
+}
+
+export class FakeAudioNode implements AudioNodeLike {
+  readonly connections: AudioNodeLike[] = [];
+  connect(destination: AudioNodeLike): void {
+    this.connections.push(destination);
+  }
+}
+
+export class FakeGainNode extends FakeAudioNode implements GainNodeLike, DynamicsCompressorNodeLike {
+  gain = new FakeAudioParam(1);
+}
+
+export class FakePannerNode extends FakeAudioNode implements PannerNodeLike {
+  positionX = new FakeAudioParam(0);
+  positionY = new FakeAudioParam(0);
+  positionZ = new FakeAudioParam(0);
+  refDistance?: number;
+  maxDistance?: number;
+  rolloffFactor?: number;
+  distanceModel?: string;
+}
+
+export class FakeBiquadFilterNode extends FakeAudioNode implements BiquadFilterNodeLike {
+  frequency = new FakeAudioParam(0);
+  Q = new FakeAudioParam(0);
+  type = 'lowpass';
+}
+
+export class FakeBufferSource extends FakeAudioNode implements AudioBufferSourceNodeLike {
+  buffer: AudioBufferLike | null = null;
+  loop = false;
+  playbackRate = new FakeAudioParam(1);
+  onended: (() => void) | null = null;
+  startedAt?: number;
+  stoppedAt?: number;
+  start(when = 0, offset?: number, duration?: number): void {
+    this.startedAt = when;
+    this.offset = offset;
+    this.duration = duration;
+  }
+  stop(when = 0): void {
+    this.stoppedAt = when;
+    this.onended?.();
+  }
+  offset?: number;
+  duration?: number;
+}
+
+export class FakeDestination extends FakeAudioNode implements AudioDestinationNodeLike {}
+
+export class FakeAudioContext implements AudioContextLike {
+  readonly destination = new FakeDestination();
+  state: AudioContextLike['state'] = 'suspended';
+  currentTime = 0;
+  resumeCalls = 0;
+  readonly gains: GainNodeLike[] = [];
+  readonly sources: FakeBufferSource[] = [];
+  readonly panners: PannerNodeLike[] = [];
+  readonly filters: BiquadFilterNodeLike[] = [];
+  lastDecoded?: ArrayBuffer;
+  createPanner?: () => PannerNodeLike;
+
+  constructor(enablePanner = true) {
+    if (enablePanner) {
+      this.createPanner = () => {
+        const node = new FakePannerNode();
+        this.panners.push(node);
+        return node;
+      };
+    }
+  }
+
+  async resume(): Promise<void> {
+    this.state = 'running';
+    this.resumeCalls += 1;
+  }
+
+  async suspend(): Promise<void> {
+    this.state = 'suspended';
+  }
+
+  createGain(): GainNodeLike {
+    const node = new FakeGainNode();
+    this.gains.push(node);
+    return node;
+  }
+
+  createDynamicsCompressor(): DynamicsCompressorNodeLike {
+    const node = new FakeGainNode();
+    this.gains.push(node);
+    return node;
+  }
+
+  createBufferSource(): AudioBufferSourceNodeLike {
+    const node = new FakeBufferSource();
+    this.sources.push(node);
+    return node;
+  }
+
+  createBiquadFilter(): BiquadFilterNodeLike {
+    const node = new FakeBiquadFilterNode();
+    this.filters.push(node);
+    return node;
+  }
+
+  async decodeAudioData(data: ArrayBuffer): Promise<AudioBufferLike> {
+    this.lastDecoded = data;
+    return { duration: data.byteLength / 1000 };
+  }
+
+  advanceTime(seconds: number): void {
+    this.currentTime += seconds;
+  }
+}
+
+export const createMockAudioBuffer = (duration = 1, channels = 2, sampleRate = 44100): AudioBufferLike => ({ duration });
+
+export const createMockAudioContext = (overrides?: Partial<AudioContext>): FakeAudioContext => new FakeAudioContext();
+
+export const createMockPannerNode = (overrides?: Partial<PannerNode>): FakePannerNode => {
+    const node = new FakePannerNode();
+    if (overrides) {
+        Object.assign(node, overrides);
+    }
+    return node;
+}
+
+export const createMockBufferSource = (buffer?: AudioBuffer): FakeBufferSource => {
+    const node = new FakeBufferSource();
+    if (buffer) {
+        node.buffer = buffer;
+    }
+    return node;
+}
+
+export { FakeBufferSource as MockAudioBufferSourceNode };

package/src/engine/mocks/buffers.ts

@@ -0,0 +1,88 @@
+import { vi } from 'vitest';
+import { VertexBuffer, IndexBuffer, BufferUsage } from '@quake2ts/engine';
+import { ShaderProgram, ShaderSources } from '@quake2ts/engine';
+import { createMockWebGL2Context } from './webgl.js';
+
+// Export these for use in other mocks
+export { VertexBuffer, IndexBuffer, ShaderProgram };
+
+/**
+ * Creates a mock VertexBuffer with an optional data array.
+ */
+export function createMockVertexBuffer(data?: Float32Array, usage?: BufferUsage): VertexBuffer {
+  const gl = createMockWebGL2Context() as unknown as WebGL2RenderingContext;
+  const vb = new VertexBuffer(gl, usage ?? gl.STATIC_DRAW);
+
+  // Spy on methods to track calls
+  vi.spyOn(vb, 'bind');
+  vi.spyOn(vb, 'upload');
+  vi.spyOn(vb, 'update');
+  vi.spyOn(vb, 'dispose');
+
+  if (data) {
+    vb.upload(data as unknown as BufferSource, usage ?? gl.STATIC_DRAW);
+  }
+
+  return vb;
+}
+
+/**
+ * Creates a mock IndexBuffer with an optional data array.
+ */
+export function createMockIndexBuffer(data?: Uint16Array, usage?: BufferUsage): IndexBuffer {
+  const gl = createMockWebGL2Context() as unknown as WebGL2RenderingContext;
+  const ib = new IndexBuffer(gl, usage ?? gl.STATIC_DRAW);
+
+  // Spy on methods
+  vi.spyOn(ib, 'bind');
+  vi.spyOn(ib, 'upload');
+  vi.spyOn(ib, 'update');
+  vi.spyOn(ib, 'dispose');
+
+  if (data) {
+    ib.upload(data as unknown as BufferSource, usage ?? gl.STATIC_DRAW);
+  }
+
+  return ib;
+}
+
+/**
+ * Creates a mock ShaderProgram with optional overrides.
+ */
+export function createMockShaderProgram(overrides?: Partial<ShaderProgram>): ShaderProgram {
+  const gl = createMockWebGL2Context() as unknown as WebGL2RenderingContext;
+
+  // Create a minimal valid program using the static create method
+  const dummySources: ShaderSources = {
+    vertex: '#version 300 es\nvoid main() {}',
+    fragment: '#version 300 es\nvoid main() {}'
+  };
+
+  const program = ShaderProgram.create(gl, dummySources);
+
+  // Spy on methods
+  vi.spyOn(program, 'use');
+  vi.spyOn(program, 'getUniformLocation');
+  vi.spyOn(program, 'getAttributeLocation');
+  vi.spyOn(program, 'dispose');
+
+  // Apply overrides if provided
+  if (overrides) {
+    Object.assign(program, overrides);
+  }
+
+  return program;
+}
+
+/**
+ * Helper to create a mock ShaderProgram with custom source code.
+ */
+export function createMockShader(vertSource?: string, fragSource?: string): ShaderProgram {
+  const gl = createMockWebGL2Context() as unknown as WebGL2RenderingContext;
+  const sources: ShaderSources = {
+    vertex: vertSource ?? '#version 300 es\nvoid main() {}',
+    fragment: fragSource ?? '#version 300 es\nvoid main() {}'
+  };
+
+  return ShaderProgram.create(gl, sources);
+}

package/src/engine/mocks/lighting.ts

@@ -0,0 +1,64 @@
+import { vi } from 'vitest';
+import { Vec3 } from '@quake2ts/shared';
+import { DLight, DynamicLightManager } from '@quake2ts/engine';
+
+// Export types
+export { DLight, DynamicLightManager };
+
+// Mock Lightmap type since it's typically just a raw buffer or texture in the engine
+// But based on the task "Add createMockLightmap() factory", we'll create a simple structure.
+export interface Lightmap {
+  width: number;
+  height: number;
+  data: Uint8Array;
+}
+
+/**
+ * Creates a mock DLight with default values.
+ */
+export function createMockDLight(
+  position: Vec3 = { x: 0, y: 0, z: 0 },
+  color: Vec3 = { x: 1, y: 1, z: 1 },
+  intensity: number = 300
+): DLight {
+  return {
+    origin: { ...position },
+    color: { ...color },
+    intensity,
+    die: Number.MAX_SAFE_INTEGER,
+  };
+}
+
+/**
+ * Creates a mock DynamicLightManager with spy methods.
+ */
+export function createMockDLightManager(overrides?: Partial<DynamicLightManager>): DynamicLightManager {
+  // We can't easily spy on methods of a real instance if we just return an object literal
+  // that mimics the interface, unless we use the real class or a full mock.
+  // Since DynamicLightManager is a class with logic, let's create a real instance and spy on it,
+  // or return a complete mock object if we want to avoid logic.
+  // The task says "Add createMockDLightManager factory... Methods: addLight, removeLight, clear, getLights".
+
+  // Let's create a mock object that satisfies the public interface (structural typing).
+
+  const mockManager = {
+    addLight: vi.fn(),
+    clear: vi.fn(),
+    update: vi.fn(),
+    getActiveLights: vi.fn().mockReturnValue([]),
+    ...overrides
+  };
+
+  return mockManager as unknown as DynamicLightManager;
+}
+
+/**
+ * Creates a mock lightmap data structure.
+ */
+export function createMockLightmap(width: number = 128, height: number = 128): Lightmap {
+  return {
+    width,
+    height,
+    data: new Uint8Array(width * height * 3) // RGB
+  };
+}

package/src/engine/mocks/particles.ts

@@ -0,0 +1,76 @@
+import { vi } from 'vitest';
+import { Vec3 } from '@quake2ts/shared';
+import { ParticleSystem } from '@quake2ts/engine';
+
+// Mock types since Particle/ParticleEmitter are not exported
+export interface MockParticle {
+  position: Vec3;
+  velocity: Vec3;
+  color: [number, number, number, number];
+  size: number;
+  lifetime: number;
+  gravity: number;
+  damping: number;
+  bounce: number;
+  blendMode: 'alpha' | 'additive';
+  fade: boolean;
+}
+
+export interface MockParticleEmitter {
+  update: (dt: number) => void;
+  emit: () => void;
+}
+
+// Export types
+export { ParticleSystem };
+
+/**
+ * Creates a mock Particle with default values.
+ */
+export function createMockParticle(overrides?: Partial<MockParticle>): MockParticle {
+  return {
+    position: { x: 0, y: 0, z: 0 },
+    velocity: { x: 0, y: 0, z: 0 },
+    color: [1, 1, 1, 1],
+    size: 1,
+    lifetime: 1,
+    gravity: 0,
+    damping: 0,
+    bounce: 0,
+    blendMode: 'alpha',
+    fade: false,
+    ...overrides,
+  };
+}
+
+/**
+ * Creates a mock ParticleEmitter.
+ */
+export function createMockParticleEmitter(overrides?: Partial<MockParticleEmitter>): MockParticleEmitter {
+  return {
+    update: vi.fn(),
+    emit: vi.fn(),
+    ...overrides,
+  };
+}
+
+/**
+ * Creates a mock ParticleSystem.
+ */
+export function createMockParticleSystem(overrides?: Partial<ParticleSystem>): ParticleSystem {
+  return {
+    maxParticles: 1000,
+    rng: {
+      frandom: vi.fn().mockReturnValue(0.5), // Deterministic default
+      random: vi.fn().mockReturnValue(0.5),
+      seed: vi.fn(),
+    },
+    update: vi.fn(),
+    spawn: vi.fn(),
+    killAll: vi.fn(),
+    aliveCount: vi.fn().mockReturnValue(0),
+    getState: vi.fn(),
+    buildMesh: vi.fn(),
+    ...overrides,
+  } as unknown as ParticleSystem;
+}

package/src/engine/mocks/renderer.ts

@@ -0,0 +1,218 @@
+import { vi } from 'vitest';
+import {
+  Renderer,
+  FrameRenderer,
+  BspSurfacePipeline,
+  Md2Pipeline,
+  Md3Pipeline,
+  SpriteRenderer,
+  SkyboxPipeline,
+  RenderableEntity,
+  FrameRenderOptions,
+  RenderOptions,
+  FrameRenderStats,
+  SurfaceRenderState,
+  Md2MeshBuffers,
+  Md3SurfaceMesh,
+  Md3SurfaceMaterial,
+  SkyboxBindOptions,
+  BspSurfaceBindOptions,
+  Md2BindOptions,
+  RenderModeConfig,
+  Texture2D,
+  IndexBuffer
+} from '@quake2ts/engine';
+import { createMockWebGL2Context } from './webgl.js';
+
+export function createMockRenderer(overrides?: Partial<Renderer>): Renderer {
+  return {
+    width: 800,
+    height: 600,
+    collisionVis: {
+      render: vi.fn(),
+      clear: vi.fn(),
+      shaderSize: 0,
+      dispose: vi.fn(),
+    } as any,
+    debug: {
+      render: vi.fn(),
+      clear: vi.fn(),
+      drawLine: vi.fn(),
+      drawBoundingBox: vi.fn(),
+      drawAxes: vi.fn(),
+      getLabels: vi.fn().mockReturnValue([]),
+      shaderSize: 0,
+      dispose: vi.fn(),
+    } as any,
+    particleSystem: {
+        update: vi.fn(),
+        emit: vi.fn(),
+        clear: vi.fn(),
+        count: 0
+    } as any,
+    getPerformanceReport: vi.fn().mockReturnValue({}),
+    getMemoryUsage: vi.fn().mockReturnValue({}),
+    renderFrame: vi.fn(),
+    registerPic: vi.fn().mockResolvedValue({} as any),
+    registerTexture: vi.fn().mockReturnValue({} as any),
+    begin2D: vi.fn(),
+    end2D: vi.fn(),
+    drawPic: vi.fn(),
+    drawString: vi.fn(),
+    drawCenterString: vi.fn(),
+    drawfillRect: vi.fn(),
+    setEntityHighlight: vi.fn(),
+    clearEntityHighlight: vi.fn(),
+    highlightSurface: vi.fn(),
+    removeSurfaceHighlight: vi.fn(),
+    setDebugMode: vi.fn(),
+    setBrightness: vi.fn(),
+    setGamma: vi.fn(),
+    setFullbright: vi.fn(),
+    setAmbient: vi.fn(),
+    setLightStyle: vi.fn(),
+    setUnderwaterWarp: vi.fn(),
+    setBloom: vi.fn(),
+    setBloomIntensity: vi.fn(),
+    setLodBias: vi.fn(),
+    setAreaPortalState: vi.fn(),
+    renderInstanced: vi.fn(),
+    dispose: vi.fn(),
+    ...overrides,
+  };
+}
+
+export function createMockFrameRenderer(overrides?: Partial<FrameRenderer>): FrameRenderer {
+  return {
+    renderFrame: vi.fn().mockReturnValue({
+      batches: 0,
+      facesDrawn: 0,
+      drawCalls: 0,
+      skyDrawn: false,
+      viewModelDrawn: false,
+      fps: 60,
+      vertexCount: 0,
+    } as FrameRenderStats),
+    ...overrides,
+  };
+}
+
+export function createMockBspPipeline(overrides?: Partial<BspSurfacePipeline>): BspSurfacePipeline {
+  const gl = createMockWebGL2Context();
+  return {
+    gl,
+    program: {
+        use: vi.fn(),
+        dispose: vi.fn(),
+        sourceSize: 0,
+        getUniformLocation: vi.fn().mockReturnValue(null),
+    } as any,
+    shaderSize: 0,
+    bind: vi.fn().mockReturnValue({} as SurfaceRenderState),
+    draw: vi.fn(),
+    dispose: vi.fn(),
+    ...overrides,
+  } as unknown as BspSurfacePipeline;
+}
+
+export function createMockMd2Pipeline(overrides?: Partial<Md2Pipeline>): Md2Pipeline {
+  const gl = createMockWebGL2Context();
+  return {
+    gl,
+    program: {
+        use: vi.fn(),
+        dispose: vi.fn(),
+        sourceSize: 0,
+        getUniformLocation: vi.fn().mockReturnValue(null),
+    } as any,
+    shaderSize: 0,
+    bind: vi.fn(),
+    draw: vi.fn(),
+    dispose: vi.fn(),
+    ...overrides,
+  } as unknown as Md2Pipeline;
+}
+
+export function createMockMd3Pipeline(overrides?: Partial<Md3Pipeline>): Md3Pipeline {
+  const gl = createMockWebGL2Context();
+  return {
+    gl,
+    program: {
+        use: vi.fn(),
+        dispose: vi.fn(),
+        sourceSize: 0,
+        getUniformLocation: vi.fn().mockReturnValue(null),
+    } as any,
+    shaderSize: 0,
+    bind: vi.fn(),
+    drawSurface: vi.fn(),
+    dispose: vi.fn(),
+    ...overrides,
+  } as unknown as Md3Pipeline;
+}
+
+export function createMockSpritePipeline(overrides?: Partial<SpriteRenderer>): SpriteRenderer {
+  const gl = createMockWebGL2Context();
+  return {
+    gl,
+    program: {
+        use: vi.fn(),
+        dispose: vi.fn(),
+        sourceSize: 0,
+        getUniformLocation: vi.fn().mockReturnValue(null),
+    } as any,
+    shaderSize: 0,
+    vao: {
+        bind: vi.fn(),
+        dispose: vi.fn(),
+        configureAttributes: vi.fn()
+    } as any,
+    vbo: {
+        bind: vi.fn(),
+        dispose: vi.fn(),
+        upload: vi.fn()
+    } as any,
+    whiteTexture: {
+        bind: vi.fn(),
+        upload: vi.fn()
+    } as unknown as Texture2D,
+    begin: vi.fn(),
+    draw: vi.fn(),
+    drawRect: vi.fn(),
+    ...overrides,
+  } as unknown as SpriteRenderer;
+}
+
+export function createMockSkyboxPipeline(overrides?: Partial<SkyboxPipeline>): SkyboxPipeline {
+  const gl = createMockWebGL2Context();
+  return {
+    gl,
+    program: {
+        use: vi.fn(),
+        dispose: vi.fn(),
+        sourceSize: 0,
+        getUniformLocation: vi.fn().mockReturnValue(null),
+    } as any,
+    vao: {
+        bind: vi.fn(),
+        dispose: vi.fn(),
+        configureAttributes: vi.fn()
+    } as any,
+    vbo: {
+        bind: vi.fn(),
+        dispose: vi.fn(),
+        upload: vi.fn()
+    } as any,
+    cubemap: {
+        bind: vi.fn(),
+        dispose: vi.fn(),
+        setParameters: vi.fn(),
+        upload: vi.fn()
+    } as any,
+    shaderSize: 0,
+    bind: vi.fn(),
+    draw: vi.fn(),
+    dispose: vi.fn(),
+    ...overrides,
+  } as unknown as SkyboxPipeline;
+}