Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

6.9 KB
Raw Blame
import { describe, expect, it, vi } from "vite-plus/test";
import {
  createReplyPlaybackController,
  type ReplyAudioEvents,
  type ReplyPlaybackRequest,
} from "./controller.ts";

const identity = {
  environmentId: "remote",
  threadId: "chat",
  messageId: "reply",
  contentVersion: "v1",
  provider: "speech",
  voice: "voice",
};

const request: ReplyPlaybackRequest = { identity, text: "Stored reply", automatic: false };

const context = { ...identity, connected: true, mediaBlocked: false };

function deferred<T>() {
  let resolve!: (value: T) => void;
  let reject!: (error: Error) => void;

  const promise = new Promise<T>((yes, no) => {
    resolve = yes;
    reject = no;
  });

  return { promise, resolve, reject };
}

function setup() {
  const handle = () => ({ play: vi.fn(async () => {}), pause: vi.fn(), dispose: vi.fn() });
  const handles: ReturnType<typeof handle>[] = [];
  const events: ReplyAudioEvents[] = [];
  const signals: AbortSignal[] = [];

  const prepare = vi.fn(
    async (_request: ReplyPlaybackRequest, signal: AbortSignal, next: ReplyAudioEvents) => {
      signals.push(signal);
      events.push(next);
      const audio = handle();
      handles.push(audio);

      return audio;
    },
  );

  const controller = createReplyPlaybackController(prepare);
  controller.setContext(context);

  return { controller, handles, events, signals, prepare, handle };
}

describe("reply playback ownership", () => {
  it("plays the supplied stored text, pauses, resumes, stops and replays", async () => {
    const { controller, prepare, handles } = setup();
    await controller.start(request);
    expect(prepare.mock.calls[0]?.[0]).toEqual(request);
    expect(controller.getSnapshot().status).toBe("playing");
    controller.pause();
    expect(controller.getSnapshot().status).toBe("paused");
    expect(handles[0]?.pause).toHaveBeenCalledOnce();
    await controller.resume();
    expect(handles[0]?.play).toHaveBeenCalledTimes(2);
    controller.stop();
    expect(handles[0]?.dispose).toHaveBeenCalledOnce();
    expect(controller.getSnapshot()).toEqual({ status: "idle" });
    await controller.start(request);
    expect(prepare).toHaveBeenCalledTimes(2);
  });

  it("disposes late generation without playing it after replacement", async () => {
    const { controller, prepare, handle, signals } = setup();
    const pending = deferred<ReturnType<typeof handle>>();
    prepare.mockImplementationOnce(async (_request, signal) => {
      signals.push(signal);

      return pending.promise;
    });
    const first = controller.start(request);
    await controller.start({ ...request, identity: { ...identity, messageId: "second" } });
    expect(signals[0]?.aborted).toBe(true);
    const stale = handle();
    pending.resolve(stale);
    await first;
    expect(stale.play).not.toHaveBeenCalled();
    expect(stale.dispose).toHaveBeenCalledOnce();
    expect(controller.getSnapshot()).toMatchObject({
      status: "playing",
      identity: { messageId: "second" },
    });
  });

  it.each([
    { ...context, threadId: "elsewhere" },
    { ...context, environmentId: "another-server" },
    { ...context, provider: "other-provider" },
    { ...context, voice: "other-voice" },
    { ...context, connected: false },
    { ...context, mediaBlocked: true },
    null,
  ])("stops on navigation, settings, disconnect, call/dictation or logout: %j", async (next) => {
    const { controller, handles, signals } = setup();
    await controller.start(request);
    controller.setContext(next);
    expect(controller.getSnapshot().status).toBe("idle");
    expect(handles[0]?.dispose).toHaveBeenCalledOnce();
    expect(signals[0]?.aborted).toBe(true);
    await controller.start(request);
    expect(controller.getSnapshot().status).toBe("idle");
  });

  it("invalidates edited or deleted content and ignores stale callbacks", async () => {
    const { controller, events, handles } = setup();
    await controller.start(request);
    controller.reconcileMessages(new Map([[identity.messageId, "edited"]]));
    expect(handles[0]?.dispose).toHaveBeenCalledOnce();
    await controller.start({ ...request, identity: { ...identity, contentVersion: "edited" } });
    events[0]?.onEnded();
    events[0]?.onError();
    expect(controller.getSnapshot().status).toBe("playing");
    controller.reconcileMessages(new Map());
    expect(controller.getSnapshot().status).toBe("idle");
  });

  it("exposes safe retry after generation failure without leaking the error", async () => {
    const { controller, prepare } = setup();
    prepare.mockRejectedValueOnce(new Error("secret credential and private transcript"));
    await controller.start(request);
    expect(controller.getSnapshot()).toEqual({
      status: "error",
      identity,
      automatic: false,
      error: "generation",
    });
    await controller.retry();
    expect(controller.getSnapshot().status).toBe("playing");
  });

  it("releases failed autoplay audio and offers an explicit retry", async () => {
    const { controller, prepare, handle } = setup();
    const audio = handle();
    audio.play.mockRejectedValueOnce(new Error("NotAllowedError"));
    prepare.mockResolvedValueOnce(audio);
    await controller.start(request);
    expect(controller.getSnapshot()).toMatchObject({ status: "error", error: "playback" });
    expect(audio.dispose).toHaveBeenCalledOnce();
    await controller.retry();
    expect(controller.getSnapshot().status).toBe("playing");
  });

  it("still goes idle when native disposal throws", async () => {
    const { controller, handles } = setup();
    await controller.start(request);
    handles[0]?.dispose.mockImplementation(() => {
      throw new Error("Native player already released.");
    });
    controller.stop();
    expect(controller.getSnapshot()).toEqual({ status: "idle" });
  });

  it.each(["onEnded", "onInterrupted"] as const)("releases media on %s", async (event) => {
    const { controller, events, handles } = setup();
    await controller.start(request);
    events[0]?.[event]();
    expect(controller.getSnapshot().status).toBe("idle");
    expect(handles[0]?.dispose).toHaveBeenCalledOnce();
  });

  it("disabling automatic readout stops only automatic playback", async () => {
    const { controller } = setup();
    await controller.start({ ...request, automatic: true });
    controller.disableAutomaticReadout();
    expect(controller.getSnapshot().status).toBe("idle");
    await controller.start(request);
    controller.disableAutomaticReadout();
    expect(controller.getSnapshot().status).toBe("playing");
  });

  it("cancels pending resume and rejects playback after disposal", async () => {
    const { controller, handles } = setup();
    await controller.start(request);
    controller.pause();
    const pending = deferred<void>();
    handles[0]?.play.mockReturnValueOnce(pending.promise);
    const resume = controller.resume();
    controller.dispose();
    pending.resolve();
    await resume;
    await controller.start(request);
    expect(controller.getSnapshot().status).toBe("idle");
  });
});