telemetry-client-js/tests/queue.test.ts

import { describe, it, expect } from "vitest";
import { EventQueue } from "../src/queue.js";
import {
  TaskType,
  Complexity,
  Harness,
  Provider,
  Outcome,
  TaskCompletionEvent,
} from "../src/types/events.js";

function makeEvent(id: string): TaskCompletionEvent {
  return {
    instance_id: "test-instance",
    event_id: id,
    schema_version: "1.0",
    timestamp: new Date().toISOString(),
    task_duration_ms: 1000,
    task_type: TaskType.IMPLEMENTATION,
    complexity: Complexity.MEDIUM,
    harness: Harness.CLAUDE_CODE,
    model: "claude-3-opus",
    provider: Provider.ANTHROPIC,
    estimated_input_tokens: 1000,
    estimated_output_tokens: 500,
    actual_input_tokens: 1100,
    actual_output_tokens: 550,
    estimated_cost_usd_micros: 50000,
    actual_cost_usd_micros: 55000,
    quality_gate_passed: true,
    quality_gates_run: [],
    quality_gates_failed: [],
    context_compactions: 0,
    context_rotations: 0,
    context_utilization_final: 0.5,
    outcome: Outcome.SUCCESS,
    retry_count: 0,
  };
}

describe("EventQueue", () => {
  it("should enqueue and drain events", () => {
    const queue = new EventQueue(10);
    const event = makeEvent("e1");

    queue.enqueue(event);
    expect(queue.size).toBe(1);
    expect(queue.isEmpty).toBe(false);

    const drained = queue.drain(10);
    expect(drained).toHaveLength(1);
    expect(drained[0].event_id).toBe("e1");
    expect(queue.isEmpty).toBe(true);
  });

  it("should respect maxSize with FIFO eviction", () => {
    const queue = new EventQueue(3);

    queue.enqueue(makeEvent("e1"));
    queue.enqueue(makeEvent("e2"));
    queue.enqueue(makeEvent("e3"));
    expect(queue.size).toBe(3);

    // Adding a 4th should evict the oldest (e1)
    queue.enqueue(makeEvent("e4"));
    expect(queue.size).toBe(3);

    const drained = queue.drain(10);
    expect(drained.map((e) => e.event_id)).toEqual(["e2", "e3", "e4"]);
  });

  it("should drain up to maxItems", () => {
    const queue = new EventQueue(10);
    queue.enqueue(makeEvent("e1"));
    queue.enqueue(makeEvent("e2"));
    queue.enqueue(makeEvent("e3"));

    const drained = queue.drain(2);
    expect(drained).toHaveLength(2);
    expect(drained.map((e) => e.event_id)).toEqual(["e1", "e2"]);
    expect(queue.size).toBe(1);
  });

  it("should remove drained items from the queue", () => {
    const queue = new EventQueue(10);
    queue.enqueue(makeEvent("e1"));
    queue.enqueue(makeEvent("e2"));

    queue.drain(1);
    expect(queue.size).toBe(1);

    const remaining = queue.drain(10);
    expect(remaining[0].event_id).toBe("e2");
  });

  it("should report isEmpty correctly", () => {
    const queue = new EventQueue(5);
    expect(queue.isEmpty).toBe(true);

    queue.enqueue(makeEvent("e1"));
    expect(queue.isEmpty).toBe(false);

    queue.drain(1);
    expect(queue.isEmpty).toBe(true);
  });

  it("should report size correctly", () => {
    const queue = new EventQueue(10);
    expect(queue.size).toBe(0);

    queue.enqueue(makeEvent("e1"));
    expect(queue.size).toBe(1);

    queue.enqueue(makeEvent("e2"));
    expect(queue.size).toBe(2);

    queue.drain(1);
    expect(queue.size).toBe(1);
  });

  it("should return empty array when draining empty queue", () => {
    const queue = new EventQueue(5);
    const drained = queue.drain(10);
    expect(drained).toEqual([]);
  });

  it("should prepend events to the front of the queue", () => {
    const queue = new EventQueue(10);
    queue.enqueue(makeEvent("e3"));

    queue.prepend([makeEvent("e1"), makeEvent("e2")]);
    expect(queue.size).toBe(3);

    const drained = queue.drain(10);
    expect(drained.map((e) => e.event_id)).toEqual(["e1", "e2", "e3"]);
  });

  it("should respect maxSize when prepending", () => {
    const queue = new EventQueue(3);
    queue.enqueue(makeEvent("e3"));
    queue.enqueue(makeEvent("e4"));

    // Only 1 slot available, so only first event should be prepended
    queue.prepend([makeEvent("e1"), makeEvent("e2")]);
    expect(queue.size).toBe(3);

    const drained = queue.drain(10);
    expect(drained.map((e) => e.event_id)).toEqual(["e1", "e3", "e4"]);
  });
});