@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
ts 182 lines 5.73 KB
Raw
1 import { afterEach, describe, expect, it, vi } from "vite-plus/test";
2 import type { AtomCommandResult } from "@t3tools/client-runtime/state/runtime";
3 import * as Cause from "effect/Cause";
4 import { AsyncResult } from "effect/reactivity";
5
6 import { FileSaveCoordinator } from "./fileSaveCoordinator";
7
8 function deferred() {
9 let resolve!: (result: AtomCommandResult<void, never>) => void;
10 const promise = new Promise<AtomCommandResult<void, never>>((resolvePromise) => {
11 resolve = resolvePromise;
12 });
13 return { promise, resolve };
14 }
15
16 describe("FileSaveCoordinator", () => {
17 afterEach(() => {
18 vi.useRealTimers();
19 });
20
21 it("keeps pending state until an edit made during a write is also saved", async () => {
22 vi.useFakeTimers();
23 const firstWrite = deferred();
24 const persist = vi
25 .fn<(contents: string) => Promise<AtomCommandResult<void, never>>>()
26 .mockReturnValueOnce(firstWrite.promise)
27 .mockResolvedValueOnce(AsyncResult.success(undefined));
28 const onPendingChange = vi.fn();
29 const coordinator = new FileSaveCoordinator({
30 debounceMs: 500,
31 persist,
32 onPendingChange,
33 onConfirmed: vi.fn(),
34 });
35
36 coordinator.change("first");
37 await vi.advanceTimersByTimeAsync(500);
38 coordinator.change("latest");
39 await vi.advanceTimersByTimeAsync(500);
40 expect(persist).toHaveBeenCalledTimes(1);
41
42 firstWrite.resolve(AsyncResult.success(undefined));
43 await vi.runAllTimersAsync();
44 expect(persist).toHaveBeenCalledTimes(2);
45 expect(persist).toHaveBeenLastCalledWith("latest");
46 expect(onPendingChange.mock.calls.at(-1)).toEqual([false]);
47 });
48
49 it("saves an edit made inside the debounce window when the editor closes", async () => {
50 vi.useFakeTimers();
51 const persist = vi
52 .fn<(contents: string) => Promise<AtomCommandResult<void, never>>>()
53 .mockResolvedValue(AsyncResult.success(undefined));
54 const coordinator = new FileSaveCoordinator({
55 debounceMs: 500,
56 persist,
57 onPendingChange: vi.fn(),
58 onConfirmed: vi.fn(),
59 });
60
61 coordinator.change("unsaved");
62 coordinator.dispose();
63 await vi.runAllTimersAsync();
64
65 expect(persist).toHaveBeenCalledOnce();
66 expect(persist).toHaveBeenCalledWith("unsaved");
67 });
68
69 it.each([false, true])(
70 "keeps an edit pending after write permission is removed (closing=%s)",
71 async (closeEditor) => {
72 vi.useFakeTimers();
73 let canWrite = true;
74 const persist = vi.fn().mockResolvedValue(AsyncResult.success(undefined));
75 const onPendingChange = vi.fn();
76 const coordinator = new FileSaveCoordinator({
77 debounceMs: 500,
78 canPersist: () => canWrite,
79 persist,
80 onPendingChange,
81 onConfirmed: vi.fn(),
82 });
83
84 coordinator.change("unsaved");
85 canWrite = false;
86 if (closeEditor) coordinator.dispose();
87 await vi.runAllTimersAsync();
88
89 expect(persist).not.toHaveBeenCalled();
90 expect(onPendingChange).toHaveBeenLastCalledWith(true);
91 },
92 );
93
94 it("flushes an edit made while a write was in flight when the editor closes", async () => {
95 vi.useFakeTimers();
96 const inFlight = deferred();
97 const persist = vi
98 .fn<(contents: string) => Promise<AtomCommandResult<void, never>>>()
99 .mockReturnValueOnce(inFlight.promise)
100 .mockResolvedValue(AsyncResult.success(undefined));
101 const coordinator = new FileSaveCoordinator({
102 debounceMs: 500,
103 persist,
104 onPendingChange: vi.fn(),
105 onConfirmed: vi.fn(),
106 });
107
108 coordinator.change("first");
109 await vi.advanceTimersByTimeAsync(500);
110 coordinator.change("latest");
111 coordinator.dispose();
112 inFlight.resolve(AsyncResult.success(undefined));
113 await vi.runAllTimersAsync();
114
115 expect(persist).toHaveBeenCalledTimes(2);
116 expect(persist).toHaveBeenLastCalledWith("latest");
117 });
118
119 it("retries a failed write when the editor closes", async () => {
120 vi.useFakeTimers();
121 const persist = vi
122 .fn()
123 .mockResolvedValueOnce(AsyncResult.failure(Cause.fail(new Error("write failed"))))
124 .mockResolvedValue(AsyncResult.success(undefined));
125 const coordinator = new FileSaveCoordinator({
126 debounceMs: 500,
127 persist,
128 onPendingChange: vi.fn(),
129 onConfirmed: vi.fn(),
130 });
131
132 coordinator.change("latest");
133 await vi.advanceTimersByTimeAsync(500);
134 expect(persist).toHaveBeenCalledOnce();
135
136 coordinator.dispose();
137 await vi.runAllTimersAsync();
138
139 expect(persist).toHaveBeenCalledTimes(2);
140 expect(persist).toHaveBeenLastCalledWith("latest");
141 });
142
143 it("leaves the file pending when the latest write fails", async () => {
144 vi.useFakeTimers();
145 const onPendingChange = vi.fn();
146 const coordinator = new FileSaveCoordinator({
147 debounceMs: 500,
148 persist: vi
149 .fn()
150 .mockResolvedValue(AsyncResult.failure(Cause.fail(new Error("write failed")))),
151 onPendingChange,
152 onConfirmed: vi.fn(),
153 });
154
155 coordinator.change("latest");
156 await vi.advanceTimersByTimeAsync(500);
157 await Promise.resolve();
158 expect(onPendingChange).toHaveBeenCalledWith(true);
159 expect(onPendingChange).not.toHaveBeenCalledWith(false);
160 });
161
162 it("ignores editor changes emitted after disposal", async () => {
163 vi.useFakeTimers();
164 const persist = vi
165 .fn<(contents: string) => Promise<AtomCommandResult<void, never>>>()
166 .mockResolvedValue(AsyncResult.success(undefined));
167 const onPendingChange = vi.fn();
168 const coordinator = new FileSaveCoordinator({
169 debounceMs: 500,
170 persist,
171 onPendingChange,
172 onConfirmed: vi.fn(),
173 });
174
175 coordinator.dispose();
176 coordinator.change("stale contents");
177 await vi.runAllTimersAsync();
178
179 expect(persist).not.toHaveBeenCalled();
180 expect(onPendingChange).not.toHaveBeenCalled();
181 });
182 });