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 * as NodeCrypto from "@effect/platform-node/NodeCrypto"; |
| 2 | import * as NodeServices from "@effect/platform-node/NodeServices"; |
| 3 | import { it } from "@effect/vitest"; |
| 4 | import { type PreviewEvent, ThreadId } from "@t3tools/contracts"; |
| 5 | import * as Effect from "effect/Effect"; |
| 6 | import * as Layer from "effect/Layer"; |
| 7 | import * as PubSub from "effect/PubSub"; |
| 8 | import { expect } from "vite-plus/test"; |
| 9 | |
| 10 | import * as ServerConfig from "../config.ts"; |
| 11 | import * as PreviewManager from "./Manager.ts"; |
| 12 | |
| 13 | const DRAIN_LIMIT = 100; |
| 14 | |
| 15 | interface EventCollector { |
| 16 | readonly drain: Effect.Effect<ReadonlyArray<PreviewEvent>>; |
| 17 | } |
| 18 | |
| 19 | /** The shared live layer retains state between tests; counts need unique thread ids. */ |
| 20 | let nextThreadId = 0; |
| 21 | const freshThreadId = () => ThreadId.make(`thread-${++nextThreadId}`); |
| 22 | |
| 23 | /** Subscribe synchronously before publishing so the forked consumer cannot miss events. */ |
| 24 | const collectEvents = Effect.gen(function* () { |
| 25 | const manager = yield* PreviewManager.PreviewManager; |
| 26 | const subscription = yield* manager.subscribeEvents; |
| 27 | const collector: EventCollector = { |
| 28 | drain: PubSub.takeUpTo(subscription, DRAIN_LIMIT), |
| 29 | }; |
| 30 | return collector; |
| 31 | }).pipe(Effect.withSpan("preview.test.collectEvents")); |
| 32 | |
| 33 | const layer = PreviewManager.layer.pipe( |
| 34 | Layer.provide(ServerConfig.layerTest(process.cwd(), { prefix: "t3-preview-manager-" })), |
| 35 | Layer.provide(NodeCrypto.layer), |
| 36 | Layer.provide(NodeServices.layer), |
| 37 | ); |
| 38 | |
| 39 | it.layer(layer)("PreviewManager", (it) => { |
| 40 | it.effect("opens a session and emits opened with normalized URL", () => |
| 41 | Effect.gen(function* () { |
| 42 | const threadId = freshThreadId(); |
| 43 | const manager = yield* PreviewManager.PreviewManager; |
| 44 | const collector = yield* collectEvents; |
| 45 | |
| 46 | const snapshot = yield* manager.open({ threadId, url: "localhost:5173" }); |
| 47 | expect(snapshot.tabId.startsWith("tab_")).toBe(true); |
| 48 | expect(snapshot.navStatus._tag).toBe("Loading"); |
| 49 | if (snapshot.navStatus._tag === "Loading") { |
| 50 | expect(snapshot.navStatus.url).toBe("http://localhost:5173/"); |
| 51 | } |
| 52 | |
| 53 | const events = yield* collector.drain; |
| 54 | expect(events).toHaveLength(1); |
| 55 | expect(events[0]?.type).toBe("opened"); |
| 56 | if (events[0]?.type === "opened") { |
| 57 | expect(events[0].tabId).toBe(snapshot.tabId); |
| 58 | } |
| 59 | }), |
| 60 | ); |
| 61 | |
| 62 | it.effect("keeps the tab's profile across status reports", () => |
| 63 | Effect.gen(function* () { |
| 64 | const threadId = freshThreadId(); |
| 65 | const manager = yield* PreviewManager.PreviewManager; |
| 66 | |
| 67 | const opened = yield* manager.open({ threadId, profileId: "work" }); |
| 68 | expect(opened.profileId).toBe("work"); |
| 69 | |
| 70 | yield* manager.reportStatus({ |
| 71 | threadId, |
| 72 | tabId: opened.tabId, |
| 73 | navStatus: { _tag: "Success", url: "http://localhost:5173/", title: "Dev" }, |
| 74 | canGoBack: true, |
| 75 | canGoForward: false, |
| 76 | }); |
| 77 | const listed = yield* manager.list({ threadId }); |
| 78 | expect(listed.sessions.find((s) => s.tabId === opened.tabId)?.profileId).toBe("work"); |
| 79 | }), |
| 80 | ); |
| 81 | |
| 82 | it.effect("opens a server tab with the requested zoom and appearance", () => |
| 83 | Effect.gen(function* () { |
| 84 | const threadId = freshThreadId(); |
| 85 | const manager = yield* PreviewManager.PreviewManager; |
| 86 | const rendering = { zoomFactor: 0.8, colorScheme: "dark" } as const; |
| 87 | |
| 88 | const opened = yield* manager.open({ threadId, runtime: "server", ...rendering }); |
| 89 | |
| 90 | expect(opened).toMatchObject(rendering); |
| 91 | }), |
| 92 | ); |
| 93 | |
| 94 | it.effect("reissues presentation requests without replaying them on navigation", () => |
| 95 | Effect.gen(function* () { |
| 96 | const threadId = freshThreadId(); |
| 97 | const manager = yield* PreviewManager.PreviewManager; |
| 98 | const collector = yield* collectEvents; |
| 99 | const opened = yield* manager.open({ threadId, runtime: "server", reveal: false }); |
| 100 | yield* manager.requestReveal({ threadId, tabId: opened.tabId, force: true }); |
| 101 | const first = (yield* manager.list({ threadId })).sessions[0]; |
| 102 | expect(first?.reveal).toBe(true); |
| 103 | expect(first?.revealRequest?.force).toBe(true); |
| 104 | yield* manager.reportStatus({ |
| 105 | threadId, |
| 106 | tabId: opened.tabId, |
| 107 | serverControlled: true, |
| 108 | navStatus: { _tag: "Success", url: "http://localhost:5173/", title: "Dev" }, |
| 109 | canGoBack: false, |
| 110 | canGoForward: false, |
| 111 | }); |
| 112 | expect((yield* manager.list({ threadId })).sessions[0]?.revealRequest).toEqual( |
| 113 | first?.revealRequest, |
| 114 | ); |
| 115 | yield* manager.requestReveal({ threadId, tabId: opened.tabId, force: false }); |
| 116 | const second = (yield* manager.list({ threadId })).sessions[0]; |
| 117 | expect(second?.revealRequest?.id).not.toBe(first?.revealRequest?.id); |
| 118 | expect(second?.revealRequest?.force).toBe(false); |
| 119 | const events = yield* collector.drain; |
| 120 | const last = events.at(-1); |
| 121 | expect(last?.type).toBe("navigated"); |
| 122 | if (last?.type === "navigated") |
| 123 | expect(last.snapshot.revealRequest).toEqual(second?.revealRequest); |
| 124 | }), |
| 125 | ); |
| 126 | |
| 127 | it.effect("orders list snapshots and events with one monotonic revision", () => |
| 128 | Effect.gen(function* () { |
| 129 | const threadId = freshThreadId(); |
| 130 | const manager = yield* PreviewManager.PreviewManager; |
| 131 | const collector = yield* collectEvents; |
| 132 | const before = yield* manager.list({ threadId }); |
| 133 | |
| 134 | const opened = yield* manager.open({ threadId, url: "http://localhost:5173" }); |
| 135 | yield* manager.reportStatus({ |
| 136 | threadId, |
| 137 | tabId: opened.tabId, |
| 138 | navStatus: { _tag: "Success", url: "http://localhost:5173/ready", title: "Ready" }, |
| 139 | canGoBack: true, |
| 140 | canGoForward: false, |
| 141 | }); |
| 142 | |
| 143 | const events = yield* collector.drain; |
| 144 | const listed = yield* manager.list({ threadId }); |
| 145 | expect(events).toHaveLength(2); |
| 146 | expect(events[0]!.serverEpoch).toBe(listed.serverEpoch); |
| 147 | expect(events[1]!.serverEpoch).toBe(listed.serverEpoch); |
| 148 | expect(events[0]!.revision).toBeGreaterThan(before.revision); |
| 149 | expect(events[1]!.revision).toBeGreaterThan(events[0]!.revision); |
| 150 | expect(listed.revision).toBe(events[1]!.revision); |
| 151 | expect(listed.sessions).toHaveLength(1); |
| 152 | }), |
| 153 | ); |
| 154 | |
| 155 | it.effect("resizes a tab and preserves its viewport across navigation reports", () => |
| 156 | Effect.gen(function* () { |
| 157 | const threadId = freshThreadId(); |
| 158 | const manager = yield* PreviewManager.PreviewManager; |
| 159 | const collector = yield* collectEvents; |
| 160 | const opened = yield* manager.open({ threadId, url: "http://localhost:5173" }); |
| 161 | |
| 162 | const resized = yield* manager.resize({ |
| 163 | threadId, |
| 164 | tabId: opened.tabId, |
| 165 | viewport: { _tag: "freeform", width: 1024, height: 768 }, |
| 166 | }); |
| 167 | expect(resized.viewport).toEqual({ _tag: "freeform", width: 1024, height: 768 }); |
| 168 | |
| 169 | yield* manager.reportStatus({ |
| 170 | threadId, |
| 171 | tabId: opened.tabId, |
| 172 | navStatus: { _tag: "Success", url: "http://localhost:5173/resized", title: "Resized" }, |
| 173 | canGoBack: true, |
| 174 | canGoForward: false, |
| 175 | }); |
| 176 | const listed = yield* manager.list({ threadId }); |
| 177 | expect(listed.sessions[0]?.viewport).toEqual(resized.viewport); |
| 178 | |
| 179 | const events = yield* collector.drain; |
| 180 | expect(events.map((event) => event.type)).toEqual(["opened", "resized", "navigated"]); |
| 181 | }), |
| 182 | ); |
| 183 | |
| 184 | it.effect( |
| 185 | "rejects client status reports for server tabs without changing state or emitting events", |
| 186 | () => |
| 187 | Effect.gen(function* () { |
| 188 | const threadId = freshThreadId(); |
| 189 | const manager = yield* PreviewManager.PreviewManager; |
| 190 | const opened = yield* manager.open({ threadId, runtime: "server", reveal: false }); |
| 191 | const collector = yield* collectEvents; |
| 192 | const before = yield* manager.list({ threadId }); |
| 193 | const input = { |
| 194 | threadId, |
| 195 | tabId: opened.tabId, |
| 196 | navStatus: { |
| 197 | _tag: "Success" as const, |
| 198 | url: "http://localhost:5173/changed", |
| 199 | title: "Changed", |
| 200 | }, |
| 201 | canGoBack: true, |
| 202 | canGoForward: true, |
| 203 | }; |
| 204 | const rejected = yield* manager.reportStatus(input).pipe(Effect.flip); |
| 205 | expect(rejected._tag).toBe("PreviewControlRequiredError"); |
| 206 | expect(yield* manager.list({ threadId })).toEqual(before); |
| 207 | expect(yield* collector.drain).toEqual([]); |
| 208 | |
| 209 | yield* manager.reportStatus({ ...input, serverControlled: true }); |
| 210 | expect((yield* manager.list({ threadId })).sessions[0]).toMatchObject({ |
| 211 | navStatus: input.navStatus, |
| 212 | canGoBack: true, |
| 213 | canGoForward: true, |
| 214 | }); |
| 215 | const events = yield* collector.drain; |
| 216 | expect(events).toHaveLength(1); |
| 217 | expect(events[0]).toMatchObject({ |
| 218 | type: "navigated", |
| 219 | snapshot: { navStatus: input.navStatus }, |
| 220 | }); |
| 221 | }), |
| 222 | ); |
| 223 | |
| 224 | it.effect("gives every tab in a batch close its own monotonic revision", () => |
| 225 | Effect.gen(function* () { |
| 226 | const threadId = freshThreadId(); |
| 227 | const manager = yield* PreviewManager.PreviewManager; |
| 228 | yield* manager.open({ threadId, url: "http://localhost:5173" }); |
| 229 | yield* manager.open({ threadId, url: "http://localhost:3000" }); |
| 230 | const collector = yield* collectEvents; |
| 231 | |
| 232 | yield* manager.close({ threadId }); |
| 233 | |
| 234 | const events = yield* collector.drain; |
| 235 | const listed = yield* manager.list({ threadId }); |
| 236 | expect(events).toHaveLength(2); |
| 237 | expect(events.every((event) => event.type === "closed")).toBe(true); |
| 238 | expect(events[1]!.revision).toBeGreaterThan(events[0]!.revision); |
| 239 | expect(listed.revision).toBe(events[1]!.revision); |
| 240 | expect(listed.sessions).toHaveLength(0); |
| 241 | }), |
| 242 | ); |
| 243 | |
| 244 | it.effect("close with explicit tabId removes only that tab", () => |
| 245 | Effect.gen(function* () { |
| 246 | const threadId = freshThreadId(); |
| 247 | const manager = yield* PreviewManager.PreviewManager; |
| 248 | const a = yield* manager.open({ threadId, url: "http://localhost:5173" }); |
| 249 | const b = yield* manager.open({ threadId, url: "http://localhost:3000" }); |
| 250 | |
| 251 | yield* manager.close({ threadId, tabId: a.tabId }); |
| 252 | |
| 253 | const list = yield* manager.list({ threadId }); |
| 254 | expect(list.sessions.map((s) => s.tabId)).toEqual([b.tabId]); |
| 255 | }), |
| 256 | ); |
| 257 | }); |