test(app): verify session diff recovery flow

Author: jeanibarz

packages/app/src/context/sync-session-diff.test.ts

@@ -1,44 +1,11 @@
-import { beforeAll, describe, expect, mock, test } from "bun:test"
+import { describe, expect, mock, test } from "bun:test"
 import { createRoot } from "solid-js"
 import { createStore } from "solid-js/store"
 import type { FileDiff } from "@opencode-ai/sdk/v2/client"
 import type { State } from "./global-sync/types"
+import { createSyncContextValue } from "./sync"
 
-type SyncValue = {
-  session: {
-    diff: (sessionID: string, opts?: { force?: boolean }) => Promise<void> | undefined
-  }
-}
-
-let initSyncForTest: () => SyncValue
-let currentGlobalSync: unknown
-let currentSDK: unknown
-
-beforeAll(async () => {
-  let capturedInit: (() => SyncValue) | undefined
-
-  mock.module("@opencode-ai/ui/context", () => ({
-    createSimpleContext: (input: { init: () => SyncValue }) => {
-      capturedInit = input.init
-      return {
-        use: () => undefined,
-        provider: () => undefined,
-      }
-    },
-  }))
-
-  mock.module("./global-sync", () => ({
-    useGlobalSync: () => currentGlobalSync,
-  }))
-
-  mock.module("./sdk", () => ({
-    useSDK: () => currentSDK,
-  }))
-
-  await import("./sync")
-  if (!capturedInit) throw new Error("Failed to capture sync context init")
-  initSyncForTest = capturedInit
-})
+type SyncDeps = Parameters<typeof createSyncContextValue>[0]
 
 function baseState(): State {
   return {
@@ -84,7 +51,7 @@ describe("sync session diff recovery", () => {
       return count === 1 ? ({ data: {} } as const) : ({ data: valid } as const)
     })
 
-    currentGlobalSync = {
+    const globalSync = {
       child: () => [store, setStore],
       data: {
         project: [],
@@ -95,7 +62,7 @@ describe("sync session diff recovery", () => {
       },
     }
 
-    currentSDK = {
+    const sdk = {
       directory: "/tmp/project",
       client: {
         session: {
@@ -106,7 +73,10 @@ describe("sync session diff recovery", () => {
 
     await new Promise<void>((resolve, reject) => {
       createRoot((dispose) => {
-        const sync = initSyncForTest()
+        const sync = createSyncContextValue({
+          globalSync: globalSync as unknown as SyncDeps["globalSync"],
+          sdk: sdk as unknown as SyncDeps["sdk"],
+        })
         void (async () => {
           try {
             await sync.session.diff(sessionID)

packages/app/src/context/sync.tsx

@@ -166,109 +166,109 @@ function setOptimisticRemove(setStore: (...args: unknown[]) => void, input: Opti
   })
 }
 
-export const { use: useSync, provider: SyncProvider } = createSimpleContext({
-  name: "Sync",
-  init: () => {
-    const globalSync = useGlobalSync()
-    const sdk = useSDK()
+export function createSyncContextValue(input: {
+  globalSync: ReturnType<typeof useGlobalSync>
+  sdk: ReturnType<typeof useSDK>
+}) {
+  const { globalSync, sdk } = input
+
+  type Child = ReturnType<(typeof globalSync)["child"]>
+  type Setter = Child[1]
+
+  const current = createMemo(() => globalSync.child(sdk.directory))
+  const target = (directory?: string) => {
+    if (!directory || directory === sdk.directory) return current()
+    return globalSync.child(directory)
+  }
+  const absolute = (path: string) => (current()[0].path.directory + "/" + path).replace("//", "/")
+  const initialMessagePageSize = 80
+  const historyMessagePageSize = 200
+  const inflight = new Map<string, Promise<void>>()
+  const inflightDiff = new Map<string, Promise<void>>()
+  const inflightTodo = new Map<string, Promise<void>>()
+  const optimistic = new Map<string, Map<string, OptimisticItem>>()
+  const maxDirs = 30
+  const seen = new Map<string, Set<string>>()
+  const [meta, setMeta] = createStore({
+    limit: {} as Record<string, number>,
+    cursor: {} as Record<string, string | undefined>,
+    complete: {} as Record<string, boolean>,
+    loading: {} as Record<string, boolean>,
+  })
 
-    type Child = ReturnType<(typeof globalSync)["child"]>
-    type Setter = Child[1]
+  const getSession = (sessionID: string) => {
+    const store = current()[0]
+    const match = Binary.search(store.session, sessionID, (s) => s.id)
+    if (match.found) return store.session[match.index]
+    return undefined
+  }
 
-    const current = createMemo(() => globalSync.child(sdk.directory))
-    const target = (directory?: string) => {
-      if (!directory || directory === sdk.directory) return current()
-      return globalSync.child(directory)
+  const setOptimistic = (directory: string, sessionID: string, item: OptimisticItem) => {
+    const key = keyFor(directory, sessionID)
+    const list = optimistic.get(key)
+    if (list) {
+      list.set(item.message.id, { message: item.message, parts: sortParts(item.parts) })
+      return
     }
-    const absolute = (path: string) => (current()[0].path.directory + "/" + path).replace("//", "/")
-    const initialMessagePageSize = 80
-    const historyMessagePageSize = 200
-    const inflight = new Map<string, Promise<void>>()
-    const inflightDiff = new Map<string, Promise<void>>()
-    const inflightTodo = new Map<string, Promise<void>>()
-    const optimistic = new Map<string, Map<string, OptimisticItem>>()
-    const maxDirs = 30
-    const seen = new Map<string, Set<string>>()
-    const [meta, setMeta] = createStore({
-      limit: {} as Record<string, number>,
-      cursor: {} as Record<string, string | undefined>,
-      complete: {} as Record<string, boolean>,
-      loading: {} as Record<string, boolean>,
-    })
+    optimistic.set(key, new Map([[item.message.id, { message: item.message, parts: sortParts(item.parts) }]]))
+  }
 
-    const getSession = (sessionID: string) => {
-      const store = current()[0]
-      const match = Binary.search(store.session, sessionID, (s) => s.id)
-      if (match.found) return store.session[match.index]
-      return undefined
+  const clearOptimistic = (directory: string, sessionID: string, messageID?: string) => {
+    const key = keyFor(directory, sessionID)
+    if (!messageID) {
+      optimistic.delete(key)
+      return
     }
 
-    const setOptimistic = (directory: string, sessionID: string, item: OptimisticItem) => {
-      const key = keyFor(directory, sessionID)
-      const list = optimistic.get(key)
-      if (list) {
-        list.set(item.message.id, { message: item.message, parts: sortParts(item.parts) })
-        return
-      }
-      optimistic.set(key, new Map([[item.message.id, { message: item.message, parts: sortParts(item.parts) }]]))
-    }
+    const list = optimistic.get(key)
+    if (!list) return
+    list.delete(messageID)
+    if (list.size === 0) optimistic.delete(key)
+  }
 
-    const clearOptimistic = (directory: string, sessionID: string, messageID?: string) => {
-      const key = keyFor(directory, sessionID)
-      if (!messageID) {
-        optimistic.delete(key)
-        return
-      }
+  const getOptimistic = (directory: string, sessionID: string) => [
+    ...(optimistic.get(keyFor(directory, sessionID))?.values() ?? []),
+  ]
 
-      const list = optimistic.get(key)
-      if (!list) return
-      list.delete(messageID)
-      if (list.size === 0) optimistic.delete(key)
+  const seenFor = (directory: string) => {
+    const existing = seen.get(directory)
+    if (existing) {
+      seen.delete(directory)
+      seen.set(directory, existing)
+      return existing
     }
-
-    const getOptimistic = (directory: string, sessionID: string) => [
-      ...(optimistic.get(keyFor(directory, sessionID))?.values() ?? []),
-    ]
-
-    const seenFor = (directory: string) => {
-      const existing = seen.get(directory)
-      if (existing) {
-        seen.delete(directory)
-        seen.set(directory, existing)
-        return existing
-      }
-      const created = new Set<string>()
-      seen.set(directory, created)
-      while (seen.size > maxDirs) {
-        const first = seen.keys().next().value
-        if (!first) break
-        const stale = [...(seen.get(first) ?? [])]
-        seen.delete(first)
-        const [, setStore] = globalSync.child(first, { bootstrap: false })
-        evict(first, setStore, stale)
-      }
-      return created
+    const created = new Set<string>()
+    seen.set(directory, created)
+    while (seen.size > maxDirs) {
+      const first = seen.keys().next().value
+      if (!first) break
+      const stale = [...(seen.get(first) ?? [])]
+      seen.delete(first)
+      const [, setStore] = globalSync.child(first, { bootstrap: false })
+      evict(first, setStore, stale)
     }
+    return created
+  }
 
-    const clearMeta = (directory: string, sessionIDs: string[]) => {
-      if (sessionIDs.length === 0) return
-      for (const sessionID of sessionIDs) {
-        clearOptimistic(directory, sessionID)
-      }
-      setMeta(
-        produce((draft) => {
-          for (const sessionID of sessionIDs) {
-            const key = keyFor(directory, sessionID)
-            delete draft.limit[key]
-            delete draft.cursor[key]
-            delete draft.complete[key]
-            delete draft.loading[key]
-          }
-        }),
-      )
+  const clearMeta = (directory: string, sessionIDs: string[]) => {
+    if (sessionIDs.length === 0) return
+    for (const sessionID of sessionIDs) {
+      clearOptimistic(directory, sessionID)
     }
+    setMeta(
+      produce((draft) => {
+        for (const sessionID of sessionIDs) {
+          const key = keyFor(directory, sessionID)
+          delete draft.limit[key]
+          delete draft.cursor[key]
+          delete draft.complete[key]
+          delete draft.loading[key]
+        }
+      }),
+    )
+  }
 
-    const evict = (directory: string, setStore: Setter, sessionIDs: string[]) => {
+  const evict = (directory: string, setStore: Setter, sessionIDs: string[]) => {
       if (sessionIDs.length === 0) return
       clearSessionPrefetch(directory, sessionIDs)
       for (const sessionID of sessionIDs) {
@@ -282,7 +282,7 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
       clearMeta(directory, sessionIDs)
     }
 
-    const touch = (directory: string, setStore: Setter, sessionID: string) => {
+  const touch = (directory: string, setStore: Setter, sessionID: string) => {
       const stale = pickSessionCacheEvictions({
         seen: seenFor(directory),
         keep: sessionID,
@@ -291,7 +291,7 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
       evict(directory, setStore, stale)
     }
 
-    const fetchMessages = async (input: {
+  const fetchMessages = async (input: {
       client: typeof sdk.client
       sessionID: string
       limit: number
@@ -312,9 +312,9 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
       }
     }
 
-    const tracked = (directory: string, sessionID: string) => seen.get(directory)?.has(sessionID) ?? false
+  const tracked = (directory: string, sessionID: string) => seen.get(directory)?.has(sessionID) ?? false
 
-    const loadMessages = async (input: {
+  const loadMessages = async (input: {
       directory: string
       client: typeof sdk.client
       setStore: Setter
@@ -368,26 +368,26 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
         })
     }
 
-    return {
-      get data() {
-        return current()[0]
-      },
-      get set(): Setter {
-        return current()[1]
-      },
-      get status() {
-        return current()[0].status
-      },
-      get ready() {
-        return current()[0].status !== "loading"
-      },
-      get project() {
-        const store = current()[0]
-        const match = Binary.search(globalSync.data.project, store.project, (p) => p.id)
-        if (match.found) return globalSync.data.project[match.index]
-        return undefined
-      },
-      session: {
+  return {
+    get data() {
+      return current()[0]
+    },
+    get set(): Setter {
+      return current()[1]
+    },
+    get status() {
+      return current()[0].status
+    },
+    get ready() {
+      return current()[0].status !== "loading"
+    },
+    get project() {
+      const store = current()[0]
+      const match = Binary.search(globalSync.data.project, store.project, (p) => p.id)
+      if (match.found) return globalSync.data.project[match.index]
+      return undefined
+    },
+    session: {
         get: getSession,
         optimistic: {
           add(input: { directory?: string; sessionID: string; message: Message; parts: Part[] }) {
@@ -614,10 +614,19 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
           )
         },
       },
-      absolute,
-      get directory() {
-        return current()[0].path.directory
-      },
-    }
+    absolute,
+    get directory() {
+      return current()[0].path.directory
+    },
+  }
+}
+
+export const { use: useSync, provider: SyncProvider } = createSimpleContext({
+  name: "Sync",
+  init: () => {
+    return createSyncContextValue({
+      globalSync: useGlobalSync(),
+      sdk: useSDK(),
+    })
   },
 })