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

main
ts 233 lines 7.66 KB
Raw
1 import { beforeEach, describe, expect, it, vi } from "vite-plus/test";
2
3 const mocks = vi.hoisted(() => {
4 const values = new Map<string, string>();
5 let preferencesJson: string | null = null;
6 let preferencesUpdatedAt = 0;
7 let loadPreferencesFails = false;
8 let savePreferencesFails = false;
9 return {
10 clear: () => {
11 values.clear();
12 preferencesJson = null;
13 preferencesUpdatedAt = 0;
14 loadPreferencesFails = false;
15 savePreferencesFails = false;
16 },
17 getStoredValue: (key: string) => values.get(key) ?? null,
18 getPreferencesJson: () => preferencesJson,
19 setPreferencesJson: (value: string, updatedAt: number) => {
20 preferencesJson = value;
21 preferencesUpdatedAt = updatedAt;
22 },
23 setDatabaseFailures: (load: boolean, save: boolean) => {
24 loadPreferencesFails = load;
25 savePreferencesFails = save;
26 },
27 getItemAsync: vi.fn((key: string) => Promise.resolve(values.get(key) ?? null)),
28 setItemAsync: vi.fn((key: string, value: string) => {
29 values.set(key, value);
30 return Promise.resolve();
31 }),
32 deleteItemAsync: vi.fn((key: string) => {
33 values.delete(key);
34 return Promise.resolve();
35 }),
36 database: {
37 closeAsync: vi.fn(() => Promise.resolve()),
38 execAsync: vi.fn(() => Promise.resolve()),
39 withExclusiveTransactionAsync: vi.fn(
40 (run: (transaction: { execAsync: () => Promise<void> }) => Promise<void>) =>
41 run({ execAsync: () => Promise.resolve() }),
42 ),
43 getFirstAsync: vi.fn((sql: string) => {
44 if (sql.includes("PRAGMA user_version")) {
45 return Promise.resolve({ user_version: 1 });
46 }
47 if (loadPreferencesFails) {
48 return Promise.reject(new Error("database unavailable"));
49 }
50 return Promise.resolve(
51 preferencesJson === null
52 ? null
53 : { payload: preferencesJson, updatedAt: preferencesUpdatedAt },
54 );
55 }),
56 runAsync: vi.fn((_sql: string, payload?: unknown, updatedAt?: unknown) => {
57 if (savePreferencesFails) {
58 return Promise.reject(new Error("database unavailable"));
59 }
60 if (typeof payload === "string") {
61 preferencesJson = payload;
62 }
63 if (typeof updatedAt === "number") {
64 preferencesUpdatedAt = updatedAt;
65 }
66 return Promise.resolve();
67 }),
68 },
69 };
70 });
71
72 vi.mock("expo", () => ({
73 requireOptionalNativeModule: () => null,
74 }));
75
76 vi.mock("expo-secure-store", () => ({
77 deleteItemAsync: mocks.deleteItemAsync,
78 getItemAsync: mocks.getItemAsync,
79 setItemAsync: mocks.setItemAsync,
80 }));
81
82 vi.mock("expo-sqlite", () => ({
83 openDatabaseAsync: vi.fn(() => Promise.resolve(mocks.database)),
84 }));
85
86 vi.mock("expo-crypto", () => ({
87 getRandomBytes: vi.fn(() => new Uint8Array(16)),
88 }));
89
90 vi.mock("expo-constants", () => ({
91 default: { expoConfig: { extra: {} } },
92 }));
93
94 vi.mock("react-native", () => ({
95 AppState: { currentState: "active" },
96 Platform: {
97 OS: "ios",
98 },
99 }));
100
101 import { loadPreferences, savePreferencesPatch } from "../persistence/imperative";
102
103 describe("mobile connection storage", () => {
104 beforeEach(() => {
105 mocks.clear();
106 vi.clearAllMocks();
107 });
108
109 it("persists tab order locally and retains it when another preference changes", async () => {
110 const navigationTabOrder = ["usage", "threads", "pullRequests"];
111 const hiddenNavigationTabs = ["issues", "home"];
112 await savePreferencesPatch({ navigationTabOrder, hiddenNavigationTabs });
113 await savePreferencesPatch({ baseFontSize: 19 });
114 await expect(loadPreferences()).resolves.toEqual({
115 navigationTabOrder,
116 hiddenNavigationTabs,
117 baseFontSize: 19,
118 });
119 });
120
121 it("ignores invalid tab-order entries without dropping other saved preferences", async () => {
122 mocks.setPreferencesJson(
123 JSON.stringify({
124 navigationTabOrder: ["usage", null, 4, "threads"],
125 hiddenNavigationTabs: ["home", null],
126 baseFontSize: 18,
127 }),
128 1,
129 );
130 await expect(loadPreferences()).resolves.toEqual({
131 navigationTabOrder: ["usage", "threads"],
132 hiddenNavigationTabs: ["home"],
133 baseFontSize: 18,
134 });
135 });
136
137 it("loads legacy preferences when SQLite is unavailable", async () => {
138 mocks.setDatabaseFailures(true, true);
139 await mocks.setItemAsync("t3code.preferences", JSON.stringify({ baseFontSize: 17 }));
140
141 await expect(loadPreferences()).resolves.toEqual({ baseFontSize: 17 });
142 });
143
144 it("falls back to secure storage when SQLite cannot save preferences", async () => {
145 mocks.setDatabaseFailures(true, true);
146 await expect(savePreferencesPatch({ baseFontSize: 19 })).resolves.toEqual({ baseFontSize: 19 });
147 const fallback = JSON.parse(mocks.getStoredValue("t3code.preferences.fallback") ?? "") as {
148 readonly payload: string;
149 readonly updatedAt: number;
150 };
151 expect(JSON.parse(fallback.payload)).toEqual({ baseFontSize: 19 });
152 expect(fallback.updatedAt).toEqual(expect.any(Number));
153 });
154
155 it("discards malformed saved PR and issue views without discarding other preferences", async () => {
156 const validView = {
157 id: "reviewing",
158 name: "Review queue",
159 environmentId: null,
160 query: "bug",
161 controls: { state: "open", involvement: "reviewing", filters: {}, sort: "updated" },
162 } as const;
163 const validIssueView = {
164 id: "assigned",
165 name: "Assigned",
166 query: "",
167 state: "open",
168 involvement: "assigned",
169 sort: "updated",
170 labels: ["bug"],
171 assignee: { login: "octocat", name: null },
172 } as const;
173 mocks.setPreferencesJson(
174 JSON.stringify({
175 baseFontSize: 17,
176 pullRequestSavedViews: [
177 validView,
178 {
179 ...validView,
180 id: "invalid",
181 name: "Broken",
182 controls: { ...validView.controls, sort: "unknown" },
183 },
184 ],
185 issueSavedViews: [validIssueView, { ...validIssueView, id: "invalid", involvement: "x" }],
186 }),
187 10,
188 );
189 expect(await loadPreferences()).toEqual({
190 baseFontSize: 17,
191 pullRequestSavedViews: [validView],
192 issueSavedViews: [validIssueView],
193 });
194 });
195
196 it("reconciles fallback preferences after SQLite recovers", async () => {
197 mocks.setPreferencesJson(JSON.stringify({ baseFontSize: 15 }), 10);
198 await mocks.setItemAsync(
199 "t3code.preferences.fallback",
200 JSON.stringify({
201 payload: JSON.stringify({ baseFontSize: 19 }),
202 updatedAt: 20,
203 }),
204 );
205
206 await expect(loadPreferences()).resolves.toEqual({ baseFontSize: 19 });
207 expect(JSON.parse(mocks.getPreferencesJson() ?? "")).toEqual({ baseFontSize: 19 });
208 expect(mocks.getStoredValue("t3code.preferences.fallback")).toBeNull();
209 });
210
211 it("ignores a stale fallback when its previous deletion failed", async () => {
212 mocks.setPreferencesJson(JSON.stringify({ baseFontSize: 21 }), 30);
213 await mocks.setItemAsync(
214 "t3code.preferences.fallback",
215 JSON.stringify({
216 payload: JSON.stringify({ baseFontSize: 19 }),
217 updatedAt: 20,
218 }),
219 );
220
221 await expect(loadPreferences()).resolves.toEqual({ baseFontSize: 21 });
222 expect(JSON.parse(mocks.getPreferencesJson() ?? "")).toEqual({ baseFontSize: 21 });
223 expect(mocks.getStoredValue("t3code.preferences.fallback")).toBeNull();
224 });
225
226 it("keeps SQLite authoritative when stale legacy preferences remain", async () => {
227 mocks.setPreferencesJson(JSON.stringify({ baseFontSize: 21 }), 30);
228 await mocks.setItemAsync("t3code.preferences", JSON.stringify({ baseFontSize: 19 }));
229
230 await expect(loadPreferences()).resolves.toEqual({ baseFontSize: 21 });
231 expect(JSON.parse(mocks.getPreferencesJson() ?? "")).toEqual({ baseFontSize: 21 });
232 });
233 });