@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 236 lines 7.73 KB
Raw
1 import { describe, expect, it } from "@effect/vitest";
2 import * as Deferred from "effect/Deferred";
3 import * as Effect from "effect/Effect";
4 import * as Exit from "effect/Exit";
5 import * as Fiber from "effect/Fiber";
6 import * as Layer from "effect/Layer";
7 import { AsyncResult, Atom, AtomRegistry } from "effect/reactivity";
8 import { vi } from "vite-plus/test";
9 import { ProviderInstanceId } from "@t3tools/contracts";
10 import { RegistryContext } from "@effect/atom-react";
11 import { createElement } from "react";
12 import { renderToString } from "react-dom/server";
13
14 vi.mock("expo-secure-store", () => ({
15 getItemAsync: vi.fn(),
16 setItemAsync: vi.fn(),
17 }));
18
19 vi.mock("react-native", () => ({
20 Platform: { OS: "ios" },
21 }));
22
23 vi.mock("../lib/runtime", async () => {
24 const Layer = await import("effect/Layer");
25 return {
26 runtime: { runPromise: vi.fn() },
27 layer: Layer.empty,
28 };
29 });
30
31 import { createMobilePreferencesState } from "./preferences";
32 import { useAtomCommand } from "./use-atom-command";
33 import * as MobilePreferences from "../persistence/mobile-preferences";
34
35 function deferred<A>() {
36 let resolve!: (value: A) => void;
37 const promise = new Promise<A>((resume) => {
38 resolve = resume;
39 });
40 return { promise, resolve } as const;
41 }
42
43 function makePreferencesState(
44 service: Omit<MobilePreferences.MobilePreferencesStore["Service"], "update"> &
45 Partial<Pick<MobilePreferences.MobilePreferencesStore["Service"], "update">>,
46 ) {
47 const completeService = MobilePreferences.MobilePreferencesStore.of({
48 ...service,
49 update:
50 service.update ??
51 ((transform) =>
52 service.load.pipe(
53 Effect.flatMap((current) => service.savePatch(transform(current))),
54 Effect.mapError((cause) =>
55 cause._tag === "MobilePreferencesSaveError"
56 ? cause
57 : new MobilePreferences.MobilePreferencesSaveError({ cause }),
58 ),
59 )),
60 });
61 return createMobilePreferencesState(
62 Atom.runtime(Layer.succeed(MobilePreferences.MobilePreferencesStore, completeService)),
63 );
64 }
65
66 describe("mobile preferences state", () => {
67 it.effect("preserves an optimistic patch when the initial load finishes later", () =>
68 Effect.gen(function* () {
69 const pendingLoad = deferred<MobilePreferences.Preferences>();
70 const savePatch = vi.fn((patch: Partial<MobilePreferences.Preferences>) =>
71 Effect.succeed(patch),
72 );
73 const state = makePreferencesState({
74 load: Effect.promise(() => pendingLoad.promise),
75 savePatch,
76 });
77 const registry = AtomRegistry.make();
78 const unmountPreferences = registry.mount(state.preferencesAtom);
79
80 const save = yield* Effect.forkChild(
81 Effect.exit(
82 state.savePreferences.run(registry, {
83 collapsedProjectGroups: ["project:new"],
84 }),
85 ),
86 { startImmediately: true },
87 );
88 pendingLoad.resolve({
89 baseFontSize: 18,
90 collapsedProjectGroups: ["project:old"],
91 });
92
93 const preferences = yield* AtomRegistry.getResult(registry, state.preferencesAtom, {
94 suspendOnWaiting: true,
95 });
96 const saveResult = yield* Fiber.join(save);
97 expect(preferences).toEqual({
98 baseFontSize: 18,
99 collapsedProjectGroups: ["project:new"],
100 });
101 expect(savePatch).toHaveBeenCalledWith({
102 collapsedProjectGroups: ["project:new"],
103 });
104 expect(Exit.isFailure(saveResult)).toBe(false);
105
106 unmountPreferences();
107 registry.dispose();
108 }),
109 );
110
111 it.effect("keeps both favorites when the React command sends updates before a render", () =>
112 Effect.gen(function* () {
113 let persisted: MobilePreferences.Preferences = { modelFavorites: [] };
114 const state = makePreferencesState({
115 load: Effect.succeed(persisted),
116 savePatch: (patch) =>
117 Effect.sync(() => {
118 persisted = { ...persisted, ...patch };
119 return persisted;
120 }),
121 update: (transform) =>
122 Effect.sync(() => {
123 persisted = { ...persisted, ...transform(persisted) };
124 return persisted;
125 }),
126 });
127 const registry = AtomRegistry.make();
128 const unmountPreferences = registry.mount(state.preferencesAtom);
129 yield* AtomRegistry.getResult(registry, state.preferencesAtom, { suspendOnWaiting: true });
130
131 function useSavePreferences() {
132 return useAtomCommand(state.savePreferences, { reportFailure: false });
133 }
134 const setters: Array<ReturnType<typeof useSavePreferences>> = [];
135 function CaptureSetter() {
136 setters.push(useSavePreferences());
137 return null;
138 }
139 renderToString(
140 createElement(RegistryContext.Provider, { value: registry }, createElement(CaptureSetter)),
141 );
142 const savePreferences = setters[0]!;
143 const provider = ProviderInstanceId.make("codex");
144 const first = savePreferences({
145 transform: (current) => ({
146 modelFavorites: [...(current.modelFavorites ?? []), { provider, model: "astra" }],
147 }),
148 });
149 const second = savePreferences({
150 transform: (current) => ({
151 modelFavorites: [...(current.modelFavorites ?? []), { provider, model: "sol" }],
152 }),
153 });
154 yield* Effect.promise(() => Promise.all([first, second]));
155
156 expect(persisted.modelFavorites).toEqual([
157 { provider, model: "astra" },
158 { provider, model: "sol" },
159 ]);
160
161 yield* Effect.promise(() =>
162 savePreferences({
163 transform: (current) => ({
164 modelFavorites: (current.modelFavorites ?? []).filter(
165 (favorite) => favorite.model !== "astra",
166 ),
167 }),
168 }),
169 );
170 expect(persisted.modelFavorites).toEqual([{ provider, model: "sol" }]);
171
172 unmountPreferences();
173 registry.dispose();
174 }),
175 );
176
177 it.effect("clears the optimistic patch when a save is interrupted", () =>
178 Effect.gen(function* () {
179 const started = yield* Deferred.make<void>();
180 const store = {
181 load: Effect.succeed({ baseFontSize: 16 }),
182 savePatch: () => Deferred.succeed(started, undefined).pipe(Effect.andThen(Effect.never)),
183 };
184 const state = makePreferencesState(store);
185 const registry = AtomRegistry.make();
186 const unmount = registry.mount(state.preferencesAtom);
187 yield* AtomRegistry.getResult(registry, state.preferencesAtom, { suspendOnWaiting: true });
188
189 const fiber = yield* Effect.forkChild(
190 state.save({ baseFontSize: 20 }, registry).pipe(
191 Effect.provide(
192 Layer.succeed(
193 MobilePreferences.MobilePreferencesStore,
194 MobilePreferences.MobilePreferencesStore.of({
195 ...store,
196 update: () => Effect.die("unexpected"),
197 }),
198 ),
199 ),
200 ),
201 );
202 yield* Deferred.await(started);
203 yield* Fiber.interrupt(fiber);
204
205 expect(AsyncResult.getOrElse(registry.get(state.preferencesAtom), () => ({}))).toEqual({
206 baseFontSize: 16,
207 });
208 unmount();
209 registry.dispose();
210 }),
211 );
212
213 it.effect("falls back to empty preferences when secure storage cannot be read", () =>
214 Effect.gen(function* () {
215 const state = makePreferencesState({
216 load: Effect.fail(
217 new MobilePreferences.MobilePreferencesLoadError({
218 cause: new Error("secure storage unavailable"),
219 }),
220 ),
221 savePatch: (patch) => Effect.succeed(patch),
222 });
223 const registry = AtomRegistry.make();
224 const unmount = registry.mount(state.preferencesAtom);
225
226 expect(
227 yield* AtomRegistry.getResult(registry, state.preferencesAtom, {
228 suspendOnWaiting: true,
229 }),
230 ).toEqual({});
231
232 unmount();
233 registry.dispose();
234 }),
235 );
236 });