sailfork / t3code-github / apps/ web/ src/ components/ files/ fileSaveSessions.test.ts

import { EnvironmentId } from "@t3tools/contracts";
import { Cause } from "effect";
import { AsyncResult } from "effect/reactivity";
import { describe, expect, it, vi } from "vite-plus/test";

import {
  createFileSaveSessions,
  type FileSaveSessionDeps,
  type FileSaveTarget,
} from "./fileSaveSessions";

const target: FileSaveTarget = {
  environmentId: EnvironmentId.make("file-save-sessions"),
  cwd: "/workspace",
  relativePath: "file.txt",
};

function setup() {
  vi.useFakeTimers();
  const state = {
    writable: true,
    unsaved: null as string | null,
    onWritable: [] as Array<() => void>,
  };
  const persist = vi.fn<FileSaveSessionDeps["persist"]>(async () => AsyncResult.success(undefined));
  const confirm = vi.fn((_target: FileSaveTarget, _contents: string) => true);
  const onPendingChange = vi.fn();
  const sessions = createFileSaveSessions({
    debounceMs: 500,
    canPersist: () => state.writable,
    subscribeWritable: (_target, onWritable) => {
      state.onWritable.push(onWritable);
      return () => {
        state.onWritable = state.onWritable.filter((listener) => listener !== onWritable);
      };
    },
    persist,
    confirm,
    readUnsaved: () => state.unsaved,
  });
  const writes = () => persist.mock.calls.map(([written, contents]) => [written, contents]);
  return {
    state,
    sessions,
    persist,
    confirm,
    onPendingChange,
    writes,
    [Symbol.dispose]: () => vi.useRealTimers(),
  };
}

describe("file save sessions", () => {
  it("debounces edits and clears the pending marker once confirmed", async () => {
    using h = setup();
    h.sessions.acquire(target, h.onPendingChange);
    h.sessions.change(target, "a");
    h.sessions.change(target, "ab");
    expect(h.onPendingChange).toHaveBeenLastCalledWith("file.txt", true);
    await vi.advanceTimersByTimeAsync(500);
    expect(h.writes()).toEqual([[target, "ab"]]);
    expect(h.onPendingChange).toHaveBeenLastCalledWith("file.txt", false);
  });

  it("flushes on the last release and drops edits from retired editors", async () => {
    using h = setup();
    const releaseFirst = h.sessions.acquire(target, h.onPendingChange);
    const releaseSecond = h.sessions.acquire(target, h.onPendingChange);
    h.sessions.change(target, "pending edit");
    releaseFirst();
    expect(h.persist).not.toHaveBeenCalled();
    releaseSecond();
    h.sessions.change(target, "stale editor contents");
    await vi.runAllTimersAsync();
    expect(h.writes()).toEqual([[target, "pending edit"]]);
    expect(h.onPendingChange).toHaveBeenLastCalledWith("file.txt", false);
  });

  it("gives a replaced file a fresh session and flushes the old one", async () => {
    using h = setup();
    const other = { ...target, relativePath: "other.txt" };
    const release = h.sessions.acquire(target, h.onPendingChange);
    h.sessions.change(target, "old file edit");
    release();
    h.sessions.acquire(other, h.onPendingChange);
    h.sessions.change(target, "stale editor contents");
    h.sessions.change(other, "new file edit");
    await vi.runAllTimersAsync();
    expect(h.writes()).toEqual([
      [target, "old file edit"],
      [other, "new file edit"],
    ]);
  });

  it("resumes an unsaved draft when a session is created", async () => {
    using h = setup();
    h.state.unsaved = "pending draft";
    h.sessions.acquire(target, h.onPendingChange);
    expect(h.onPendingChange).toHaveBeenLastCalledWith("file.txt", true);
    await vi.advanceTimersByTimeAsync(500);
    expect(h.writes()).toEqual([[target, "pending draft"]]);
  });

  it("does not queue a draft that a retired session is still writing", async () => {
    using h = setup();
    let finishWrite = () => {};
    h.persist.mockImplementationOnce(
      () =>
        new Promise((resolve) => {
          finishWrite = () => resolve(AsyncResult.success(undefined));
        }),
    );
    const release = h.sessions.acquire(target, h.onPendingChange);
    h.sessions.change(target, "draft");
    h.state.unsaved = "draft";
    release();
    // A StrictMode ref replay reacquires while the flush is in flight.
    h.sessions.acquire(target, h.onPendingChange);
    finishWrite();
    await vi.runAllTimersAsync();
    expect(h.writes()).toEqual([[target, "draft"]]);
  });

  it("writes a rejoining surface's edit last, over the released session's queued draft", async () => {
    using h = setup();
    let finishWrite = () => {};
    h.persist.mockImplementationOnce(
      () =>
        new Promise((resolve) => {
          finishWrite = () => resolve(AsyncResult.success(undefined));
        }),
    );
    const release = h.sessions.acquire(target, h.onPendingChange);
    h.sessions.change(target, "X");
    await vi.advanceTimersByTimeAsync(500);
    h.sessions.change(target, "Y");
    release();
    h.sessions.acquire(target, h.onPendingChange);
    h.sessions.change(target, "Z");
    await vi.advanceTimersByTimeAsync(500);
    finishWrite();
    await vi.runAllTimersAsync();
    expect(h.writes().at(-1)).toEqual([target, "Z"]);
  });

  it("tells a surface joining a session with an unsaved edit that the file is pending", () => {
    using h = setup();
    h.sessions.acquire(target, h.onPendingChange);
    h.sessions.change(target, "edit");
    const joiningListener = vi.fn();
    h.sessions.acquire(target, joiningListener);
    expect(joiningListener).toHaveBeenCalledWith("file.txt", true);
  });

  it("lets go of a released session that cannot write and recovers its draft later", async () => {
    using h = setup();
    const release = h.sessions.acquire(target, h.onPendingChange);
    h.state.writable = false;
    h.sessions.change(target, "draft");
    h.state.unsaved = "draft";
    release();
    expect(h.state.onWritable).toEqual([]);
    h.sessions.change(target, "retired editor contents");
    h.state.writable = true;
    h.sessions.acquire(target, h.onPendingChange);
    await vi.runAllTimersAsync();
    expect(h.writes()).toEqual([[target, "draft"]]);
  });

  it("recovers a draft that a retired session gave up on when write access dropped", async () => {
    using h = setup();
    let finishWrite = () => {};
    h.persist.mockImplementationOnce(
      () =>
        new Promise((resolve) => {
          finishWrite = () => resolve(AsyncResult.success(undefined));
        }),
    );
    const release = h.sessions.acquire(target, h.onPendingChange);
    h.sessions.change(target, "X");
    await vi.advanceTimersByTimeAsync(500);
    h.sessions.change(target, "Y");
    release();
    h.state.writable = false;
    finishWrite();
    await vi.runAllTimersAsync();
    h.state.unsaved = "Y";
    h.sessions.acquire(target, h.onPendingChange);
    h.state.writable = true;
    for (const onWritable of h.state.onWritable) onWritable();
    await vi.runAllTimersAsync();
    expect(h.writes()).toEqual([
      [target, "X"],
      [target, "Y"],
    ]);
  });

  it("stops notifying a surface's listener once it releases a shared session", async () => {
    using h = setup();
    const retiredListener = vi.fn();
    const release = h.sessions.acquire(target, retiredListener);
    h.sessions.acquire(target, h.onPendingChange);
    release();
    h.sessions.change(target, "edit");
    await vi.runAllTimersAsync();
    expect(retiredListener).not.toHaveBeenCalled();
    expect(h.onPendingChange).toHaveBeenLastCalledWith("file.txt", false);
  });

  it("requeues a draft whose retired flush failed on the live session", async () => {
    using h = setup();
    let failWrite = () => {};
    h.persist.mockImplementationOnce(
      () =>
        new Promise((resolve) => {
          failWrite = () => resolve(AsyncResult.failure(Cause.fail("offline")));
        }),
    );
    const release = h.sessions.acquire(target, h.onPendingChange);
    h.sessions.change(target, "draft");
    h.state.unsaved = "draft";
    release();
    h.sessions.acquire(target, h.onPendingChange);
    failWrite();
    await vi.runAllTimersAsync();
    expect(h.writes()).toEqual([
      [target, "draft"],
      [target, "draft"],
    ]);
    expect(h.onPendingChange).toHaveBeenLastCalledWith("file.txt", false);
  });

  it("keeps edits pending while unwritable and resumes them when access returns", async () => {
    using h = setup();
    h.sessions.acquire(target, h.onPendingChange);
    h.state.writable = false;
    h.sessions.change(target, "pending edit");
    h.state.unsaved = "pending edit";
    await vi.runAllTimersAsync();
    expect(h.persist).not.toHaveBeenCalled();
    expect(h.onPendingChange).toHaveBeenLastCalledWith("file.txt", true);

    h.state.writable = true;
    for (const onWritable of h.state.onWritable) onWritable();
    await vi.advanceTimersByTimeAsync(500);
    expect(h.writes()).toEqual([[target, "pending edit"]]);
    expect(h.onPendingChange).toHaveBeenLastCalledWith("file.txt", false);
  });

  it("skips recovery while unwritable and stops watching access after release", async () => {
    using h = setup();
    h.state.writable = false;
    h.state.unsaved = "pending draft";
    const release = h.sessions.acquire(target, h.onPendingChange);
    expect(h.onPendingChange).not.toHaveBeenCalled();
    release();
    expect(h.state.onWritable).toEqual([]);
    await vi.runAllTimersAsync();
    expect(h.persist).not.toHaveBeenCalled();
  });
});