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
| 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 | }); |