SessionControl.test.ts

import { describe, expect, it } from "vite-plus/test";

import { BrowserControlInterrupted, SessionControl } from "./SessionControl.ts";

describe("SessionControl", () => {
  it("replaces waiting hover work without changing the running action or delaying the following click", async () => {
    const control = new SessionControl("agent");
    await control.take("viewer");
    const started = Promise.withResolvers<void>();
    const finish = Promise.withResolvers<void>();
    const events: Array<number | string> = [];
    const running = control.humanLatest("viewer", "hover:0", undefined, async () => {
      events.push("running");
      started.resolve();
      await finish.promise;
    });
    await started.promise;
    const moves = Array.from({ length: 120 }, (_, position) =>
      control.humanLatest("viewer", "hover:0", undefined, async () => {
        events.push(position);
      }),
    );
    const click = control.human("viewer", async () => {
      events.push("click");
    });
    finish.resolve();
    await Promise.all([running, ...moves, click]);
    expect(events).toEqual(["running", 119, "click"]);
  });

  it.each(["human", "system", "modifiers"] as const)(
    "does not merge waiting hover work across a %s action",
    async (barrier) => {
      const control = new SessionControl("agent");
      await control.take("viewer");
      const finish = Promise.withResolvers<void>();
      const events: string[] = [];
      const running = control.human("viewer", () => finish.promise);
      const before = control.humanLatest("viewer", "hover:0", undefined, async () => {
        events.push("before");
      });
      const recordBarrier = async () => {
        events.push("barrier");
      };
      const between =
        barrier === "modifiers"
          ? control.humanLatest("viewer", "hover:2", undefined, recordBarrier)
          : barrier === "system"
            ? control.system(recordBarrier)
            : control.human("viewer", recordBarrier);
      const after = control.humanLatest("viewer", "hover:0", undefined, async () => {
        events.push("after");
      });
      finish.resolve();
      await Promise.all([running, before, between, after]);
      expect(events).toEqual(["before", "barrier", "after"]);
    },
  );

  it("does not let another viewer replace or split the owner's waiting hover", async () => {
    const control = new SessionControl("agent");
    await control.take("viewer");
    const finish = Promise.withResolvers<void>();
    const events: string[] = [];
    const running = control.human("viewer", () => finish.promise);
    const stale = control.humanLatest("viewer", "hover", undefined, async () => {
      events.push("stale");
    });
    await expect(
      control.humanLatest("other", "hover", undefined, async () => {
        events.push("other");
      }),
    ).rejects.toThrow(BrowserControlInterrupted);
    const latest = control.humanLatest("viewer", "hover", undefined, async () => {
      events.push("latest");
    });
    finish.resolve();
    await Promise.all([running, stale, latest]);
    expect(events).toEqual(["latest"]);
  });

  it.each(["release", "disconnect"] as const)(
    "does not revive waiting hover work after %s and retaking control",
    async (handoff) => {
      const control = new SessionControl("agent");
      await control.take("viewer");
      const started = Promise.withResolvers<void>();
      const finish = Promise.withResolvers<void>();
      const events: string[] = [];
      const running = control.human("viewer", () => {
        started.resolve();
        return finish.promise;
      });
      await started.promise;
      const stale = expect(
        control.humanLatest("viewer", "hover", undefined, async () => {
          events.push("stale");
        }),
      ).rejects.toThrow(BrowserControlInterrupted);
      const released = control[handoff]("viewer");
      const retaken = control.take("viewer");
      const fresh = control.humanLatest("viewer", "hover", undefined, async () => {
        events.push("fresh");
      });
      const latest = control.humanLatest("viewer", "hover", undefined, async () => {
        events.push("latest");
      });
      finish.resolve();
      await Promise.all([running, stale, released, retaken, fresh, latest]);
      expect(events).toEqual(["latest"]);
    },
  );

  it("rejects every caller of a merged hover when the tab closes", async () => {
    const control = new SessionControl("agent");
    await control.take("viewer");
    const started = Promise.withResolvers<void>();
    const finish = Promise.withResolvers<void>();
    const events: string[] = [];
    const running = control.human("viewer", () => {
      started.resolve();
      return finish.promise;
    });
    await started.promise;
    const waiting = [1, 2].map((position) =>
      expect(
        control.humanLatest("viewer", "hover", undefined, async () => {
          events.push(`hover ${position}`);
        }),
      ).rejects.toThrow("closed"),
    );
    const closed = control.close();
    await expect(
      control.humanLatest("viewer", "hover", undefined, async () => {
        events.push("after close");
      }),
    ).rejects.toThrow("closed");
    finish.resolve();
    await Promise.all([running, ...waiting, closed]);
    expect(events).toEqual([]);
  });

  it("shares a merged dispatch failure and accepts fresh hover work afterwards", async () => {
    const control = new SessionControl("agent");
    await control.take("viewer");
    const finish = Promise.withResolvers<void>();
    const events: string[] = [];
    const running = control.human("viewer", () => finish.promise);
    const first = expect(
      control.humanLatest("viewer", "hover", undefined, async () => {
        events.push("superseded");
      }),
    ).rejects.toThrow("dispatch failed");
    const last = expect(
      control.humanLatest("viewer", "hover", undefined, async () => {
        throw new Error("dispatch failed");
      }),
    ).rejects.toThrow("dispatch failed");
    finish.resolve();
    await Promise.all([running, first, last]);
    await control.humanLatest("viewer", "hover", undefined, async () => {
      events.push("recovered");
    });
    expect(events).toEqual(["recovered"]);
  });

  it("waits for tracked navigation before dispatching the latest human hover", async () => {
    const control = new SessionControl("agent");
    await control.take("viewer");
    const committed = Promise.withResolvers<void>();
    const events: string[] = [];
    const navigation = control.human("viewer", async () => {
      control.track(
        committed.promise.then(() => {
          events.push("navigation committed");
        }),
      );
      return "started";
    });
    const first = control.humanLatest("viewer", "hover", undefined, async () => {
      events.push("superseded");
    });
    const latest = control.humanLatest("viewer", "hover", undefined, async () => {
      events.push("latest");
    });
    await expect(navigation).resolves.toBe("started");
    expect(events).toEqual([]);
    committed.resolve();
    await Promise.all([first, latest]);
    expect(events).toEqual(["navigation committed", "latest"]);
  });

  it("returns an action result before tracked navigation but drains it before already queued actions", async () => {
    const control = new SessionControl("agent");
    const committed = Promise.withResolvers<void>();
    const events: string[] = [];
    const navigation = control.agent("agent", async () => {
      control.track(committed.promise.then(() => events.push("navigation committed")));
      return "started";
    });
    const next = control.agent("agent", async () => events.push("next action"));
    await expect(navigation).resolves.toBe("started");
    expect(events).toEqual([]);
    committed.resolve();
    await next;
    expect(events).toEqual(["navigation committed", "next action"]);
  });

  it("handles tracked navigation failures without poisoning the next action", async () => {
    const control = new SessionControl("agent");
    const committed = Promise.withResolvers<void>();
    await control.agent("agent", async () => control.track(committed.promise));
    committed.reject(new Error("navigation failed"));
    await expect(control.agent("agent", async () => "resumed")).resolves.toBe("resumed");
  });

  it("only lets the assigned agent act and restores that agent after human control", async () => {
    const control = new SessionControl("agent-a");
    await expect(control.agent("agent-b", async () => "wrong agent")).rejects.toThrow(
      BrowserControlInterrupted,
    );
    await expect(control.agent("agent-a", async () => "first")).resolves.toBe("first");
    await control.take("viewer-a");
    await expect(control.agent("agent-a", async () => "racing")).rejects.toThrow(
      BrowserControlInterrupted,
    );
    await expect(control.human("viewer-a", async () => "typed")).resolves.toBe("typed");
    await control.release("viewer-a");
    await expect(control.agent("agent-a", async () => "resumed")).resolves.toBe("resumed");
    await expect(control.agent("agent-b", async () => "wrong agent")).rejects.toThrow(
      BrowserControlInterrupted,
    );
  });

  it("drains running work before takeover and cancels previously queued agent actions", async () => {
    const control = new SessionControl("agent");
    const started = Promise.withResolvers<void>();
    const finish = Promise.withResolvers<void>();
    const events: string[] = [];
    const running = control.agent("agent", async () => {
      events.push("agent started");
      started.resolve();
      await finish.promise;
      events.push("agent finished");
    });
    await started.promise;
    const queued = expect(
      control.agent("agent", async () => events.push("stale agent action")),
    ).rejects.toThrow(BrowserControlInterrupted);
    const takeover = control.take("viewer");
    const typing = control.human("viewer", async () => events.push("human typed"));
    await expect(control.agent("agent", async () => "late action")).rejects.toThrow(
      BrowserControlInterrupted,
    );
    expect(events).toEqual(["agent started"]);
    finish.resolve();
    await Promise.all([running, queued, takeover, typing]);
    expect(events).toEqual(["agent started", "agent finished", "human typed"]);
  });

  it("does not let a second viewer steal, type, release, or disconnect the owner", async () => {
    const control = new SessionControl("agent");
    const takeover = control.take("viewer-a");
    await expect(control.take("viewer-b")).rejects.toThrow("Another viewer");
    await takeover;
    await expect(control.human("viewer-b", async () => "wrong viewer")).rejects.toThrow(
      BrowserControlInterrupted,
    );
    await expect(control.release("viewer-b")).rejects.toThrow("Only the controlling viewer");
    await control.disconnect("viewer-b");
    expect(control.controller).toBe("viewer-a");
    await expect(control.human("viewer-a", async () => "still controlled")).resolves.toBe(
      "still controlled",
    );
  });

  it("invalidates queued human actions and refs when a viewer disconnects", async () => {
    let invalidations = 0;
    const control = new SessionControl("agent", () => invalidations++);
    await control.take("viewer");
    const started = Promise.withResolvers<void>();
    const finish = Promise.withResolvers<void>();
    const events: string[] = [];
    const running = control.human("viewer", async () => {
      started.resolve();
      await finish.promise;
      events.push("human finished");
    });
    await started.promise;
    const queued = expect(
      control.human("viewer", async () => events.push("stale human action")),
    ).rejects.toThrow(BrowserControlInterrupted);
    const disconnected = control.disconnect("viewer");
    const resumed = control.agent("agent", async () => events.push("agent resumed"));
    expect(control.generation).toBe(2);
    expect(invalidations).toBe(2);
    finish.resolve();
    await Promise.all([running, queued, disconnected, resumed]);
    expect(events).toEqual(["human finished", "agent resumed"]);
  });

  it("does not revive stale actions when takeover is released before running work finishes", async () => {
    const control = new SessionControl("agent");
    const started = Promise.withResolvers<void>();
    const finish = Promise.withResolvers<void>();
    const running = control.agent("agent", async () => {
      started.resolve();
      await finish.promise;
    });
    await started.promise;
    const staleAgent = expect(control.agent("agent", async () => "stale")).rejects.toThrow(
      BrowserControlInterrupted,
    );
    const takeover = expect(control.take("viewer")).rejects.toThrow(BrowserControlInterrupted);
    const staleHuman = expect(control.human("viewer", async () => "stale")).rejects.toThrow(
      BrowserControlInterrupted,
    );
    const release = control.release("viewer");
    const resumed = control.agent("agent", async () => "fresh");
    finish.resolve();
    await Promise.all([running, staleAgent, takeover, staleHuman, release]);
    await expect(resumed).resolves.toBe("fresh");
  });

  it("closes after running work finishes and never runs queued or new actions", async () => {
    const control = new SessionControl("agent");
    const started = Promise.withResolvers<void>();
    const finish = Promise.withResolvers<void>();
    const running = control.agent("agent", async () => {
      started.resolve();
      await finish.promise;
      return "finished";
    });
    await started.promise;
    const queued = expect(control.agent("agent", async () => "stale")).rejects.toThrow("closed");
    const closed = control.close();
    await expect(control.take("viewer")).rejects.toThrow("closed");
    await expect(control.agent("agent", async () => "new")).rejects.toThrow("closed");
    finish.resolve();
    await expect(running).resolves.toBe("finished");
    await Promise.all([queued, closed]);
    await control.disconnect("viewer");
    await control.close();
    expect(control.generation).toBe(1);
  });

  it("lets any agent act on a tab no agent opened, but only while no human controls it", async () => {
    const control = new SessionControl(null);
    await expect(control.agent("agent-a", async () => "acted")).resolves.toBe("acted");
    await control.take("viewer-a");
    await expect(control.agent("agent-a", async () => "racing")).rejects.toMatchObject({
      reason: "humanControl",
    });
    await expect(control.observe(async () => "read")).resolves.toBe("read");
    await control.release("viewer-a");
    await expect(control.agent("agent-b", async () => "acted")).resolves.toBe("acted");
  });
});