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

import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
import { BatchSubmitter } from "../src/submitter.js";
import { ResolvedConfig } from "../src/config.js";
import {
  TaskCompletionEvent,
  TaskType,
  Complexity,
  Harness,
  Provider,
  Outcome,
} from "../src/types/events.js";

function makeConfig(overrides: Partial<ResolvedConfig> = {}): ResolvedConfig {
  return {
    serverUrl: "https://tel.example.com",
    apiKey: "a".repeat(64),
    instanceId: "test-instance-id",
    enabled: true,
    submitIntervalMs: 300_000,
    maxQueueSize: 1000,
    batchSize: 100,
    requestTimeoutMs: 10_000,
    predictionCacheTtlMs: 21_600_000,
    dryRun: false,
    maxRetries: 3,
    onError: () => {},
    ...overrides,
  };
}

function makeEvent(id = "evt-1"): TaskCompletionEvent {
  return {
    instance_id: "test-instance-id",
    event_id: id,
    schema_version: "1.0",
    timestamp: new Date().toISOString(),
    task_duration_ms: 5000,
    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("BatchSubmitter", () => {
  let fetchSpy: ReturnType<typeof vi.fn>;

  beforeEach(() => {
    vi.useFakeTimers();
    fetchSpy = vi.fn();
    vi.stubGlobal("fetch", fetchSpy);
  });

  afterEach(() => {
    vi.useRealTimers();
    vi.unstubAllGlobals();
  });

  it("should submit a batch successfully", async () => {
    const responseBody = {
      accepted: 1,
      rejected: 0,
      results: [{ event_id: "evt-1", status: "accepted" }],
    };
    fetchSpy.mockResolvedValueOnce({
      ok: true,
      status: 202,
      json: () => Promise.resolve(responseBody),
    });

    const submitter = new BatchSubmitter(makeConfig());
    const result = await submitter.submit([makeEvent()]);

    expect(result.success).toBe(true);
    expect(result.response).toEqual(responseBody);
    expect(fetchSpy).toHaveBeenCalledTimes(1);

    const [url, options] = fetchSpy.mock.calls[0];
    expect(url).toBe("https://tel.example.com/v1/events/batch");
    expect(options.method).toBe("POST");
    expect(options.headers["Authorization"]).toBe(`Bearer ${"a".repeat(64)}`);
  });

  it("should handle 429 with Retry-After header", async () => {
    const headers = new Map([["Retry-After", "1"]]);
    fetchSpy.mockResolvedValueOnce({
      ok: false,
      status: 429,
      headers: { get: (name: string) => headers.get(name) ?? null },
    });

    // After retry, succeed
    const responseBody = {
      accepted: 1,
      rejected: 0,
      results: [{ event_id: "evt-1", status: "accepted" }],
    };
    fetchSpy.mockResolvedValueOnce({
      ok: true,
      status: 202,
      json: () => Promise.resolve(responseBody),
    });

    const submitter = new BatchSubmitter(makeConfig({ maxRetries: 1 }));

    // Run submit in background and advance timers
    const submitPromise = submitter.submit([makeEvent()]);

    // Advance enough to cover Retry-After (1s) + backoff with jitter (~1-1.5s)
    await vi.advanceTimersByTimeAsync(10_000);

    const result = await submitPromise;
    expect(result.success).toBe(true);
    expect(fetchSpy).toHaveBeenCalledTimes(2);
  });

  it("should handle 403 error", async () => {
    fetchSpy.mockResolvedValueOnce({
      ok: false,
      status: 403,
      statusText: "Forbidden",
    });

    const submitter = new BatchSubmitter(makeConfig({ maxRetries: 0 }));
    const result = await submitter.submit([makeEvent()]);

    expect(result.success).toBe(false);
    expect(result.error?.message).toContain("Forbidden");
    expect(result.error?.message).toContain("403");
  });

  it("should retry on network error with backoff", async () => {
    fetchSpy.mockRejectedValueOnce(new Error("Network error"));
    fetchSpy.mockResolvedValueOnce({
      ok: true,
      status: 202,
      json: () =>
        Promise.resolve({
          accepted: 1,
          rejected: 0,
          results: [{ event_id: "evt-1", status: "accepted" }],
        }),
    });

    const submitter = new BatchSubmitter(makeConfig({ maxRetries: 1 }));
    const submitPromise = submitter.submit([makeEvent()]);

    // Advance past backoff delay
    await vi.advanceTimersByTimeAsync(5000);

    const result = await submitPromise;
    expect(result.success).toBe(true);
    expect(fetchSpy).toHaveBeenCalledTimes(2);
  });

  it("should fail after max retries exhausted", async () => {
    fetchSpy.mockRejectedValue(new Error("Network error"));

    const submitter = new BatchSubmitter(makeConfig({ maxRetries: 2 }));
    const submitPromise = submitter.submit([makeEvent()]);

    // Advance timers to allow all retries
    await vi.advanceTimersByTimeAsync(120_000);

    const result = await submitPromise;
    expect(result.success).toBe(false);
    expect(result.error?.message).toBe("Network error");
  });

  it("should not call fetch in dryRun mode", async () => {
    const submitter = new BatchSubmitter(makeConfig({ dryRun: true }));
    const result = await submitter.submit([
      makeEvent("evt-1"),
      makeEvent("evt-2"),
    ]);

    expect(result.success).toBe(true);
    expect(result.response?.accepted).toBe(2);
    expect(result.response?.rejected).toBe(0);
    expect(fetchSpy).not.toHaveBeenCalled();
  });

  it("should handle request timeout via AbortController", async () => {
    fetchSpy.mockImplementation(
      (_url: string, options: { signal: AbortSignal }) =>
        new Promise((_resolve, reject) => {
          options.signal.addEventListener("abort", () => {
            reject(
              new DOMException("The operation was aborted.", "AbortError"),
            );
          });
        }),
    );

    const submitter = new BatchSubmitter(
      makeConfig({ requestTimeoutMs: 1000, maxRetries: 0 }),
    );
    const submitPromise = submitter.submit([makeEvent()]);

    await vi.advanceTimersByTimeAsync(2000);

    const result = await submitPromise;
    expect(result.success).toBe(false);
    expect(result.error?.message).toContain("aborted");
  });
});