refactor(tests): decentralize monolithic unit.spec.ts and add state boundary tests (#141)

Co-authored-by: yukun.wu <yukun.wu@justcoglobal.com>

tests/openpath-intercept.spec.ts

@@ -0,0 +1,144 @@
+import { describe, expect, it } from 'vitest'
+import { registerOpenPathInterception } from '../src/client/intercept.tsx'
+import { wrapOpenPath, type OpenPathInterceptDeps, type OpenPathService } from '../src/client/openpath-intercept.ts'
+import { createSidebarStore } from '../src/client/state.ts'
+import type { Context } from '../src/context-types.ts'
+
+describe('open-path interception', () => {
+  /** A minimal fake of the workspaces.openPath service method. */
+  const service = (): OpenPathService & { calls: string[]; opened: string[] } => {
+    const fake = {
+      calls: [] as string[],
+      opened: [] as string[],
+      async openPath(path: string): Promise<void> {
+        this.calls.push(path)
+        this.opened.push(path)
+      },
+    }
+    return fake
+  }
+
+  const deps = (overrides: Partial<OpenPathInterceptDeps> = {}): OpenPathInterceptDeps & {
+    sidebar: string[]
+  } => {
+    const sidebar: string[] = []
+    return {
+      sidebar,
+      takeoverEnabled: () => true,
+      currentSessionId: () => 's1',
+      openInSidebar: (path, sessionId) => { sidebar.push(`${sessionId}:${path}`) },
+      ...overrides,
+    }
+  }
+
+  it('routes an intercepted open into the sidebar and resolves without the original call', async () => {
+    const ws = service()
+    const d = deps()
+    const restore = wrapOpenPath(ws, d)
+    await expect(ws.openPath('/abs/a.ts')).resolves.toBeUndefined()
+    expect(ws.calls).toEqual([])
+    expect(d.sidebar).toEqual(['s1:/abs/a.ts'])
+    restore()
+  })
+
+  it('falls through to the original when the takeover is disabled', async () => {
+    const ws = service()
+    const d = deps({ takeoverEnabled: () => false })
+    const restore = wrapOpenPath(ws, d)
+    await ws.openPath('/abs/a.ts')
+    expect(ws.opened).toEqual(['/abs/a.ts'])
+    expect(d.sidebar).toEqual([])
+    restore()
+  })
+
+  it('falls through when no session is current (nothing to scope the editor load to)', async () => {
+    const ws = service()
+    const d = deps({ currentSessionId: () => undefined })
+    const restore = wrapOpenPath(ws, d)
+    await ws.openPath('/abs/a.ts')
+    expect(ws.opened).toEqual(['/abs/a.ts'])
+    expect(d.sidebar).toEqual([])
+    restore()
+  })
+
+  it('passes the current session into the sidebar opener', async () => {
+    const ws = service()
+    let current = 's1'
+    const d = deps({ currentSessionId: () => current })
+    const restore = wrapOpenPath(ws, d)
+    await ws.openPath('/abs/a.ts')
+    current = 's2'
+    await ws.openPath('/abs/b.ts')
+    expect(d.sidebar).toEqual(['s1:/abs/a.ts', 's2:/abs/b.ts'])
+    restore()
+  })
+
+  it('restores the original method on dispose (HMR-safe)', async () => {
+    const ws = service()
+    const d = deps()
+    const original = ws.openPath
+    const restore = wrapOpenPath(ws, d)
+    expect(ws.openPath).not.toBe(original)
+    restore()
+    expect(ws.openPath).toBe(original)
+    await ws.openPath('/abs/a.ts')
+    expect(ws.opened).toEqual(['/abs/a.ts'])
+  })
+
+  it('treats a rejected promise like the original would (no swallowing)', async () => {
+    const failing: OpenPathService = {
+      async openPath() { throw new Error('host refused') },
+    }
+    const d = deps({ takeoverEnabled: () => false })
+    const restore = wrapOpenPath(failing, d)
+    await expect(failing.openPath('/abs/a.ts')).rejects.toThrow('host refused')
+    restore()
+  })
+})
+
+describe('open-path interception wiring', () => {
+  it('registerOpenPathInterception routes chat opens into the editor tab and restores on dispose', async () => {
+    // A realistic client-context fake: the sessions list feed (current + cwd),
+    // the workspaces funnel, and the sidebar service the editor goes through.
+    const opened: Array<Record<string, unknown>> = []
+    const funnel = { openPath: async (): Promise<void> => {} }
+    const ctx = {
+      sessions: {
+        list: { getSnapshot: () => ({ current: 's1', byId: { s1: { cwd: '/w' } } }) },
+      },
+      workspaces: funnel,
+      betterSidebar: { openTab: (seed: unknown) => { opened.push(seed as Record<string, unknown>) } },
+    } as unknown as Context
+    const store = createSidebarStore()
+    const original = ctx.workspaces.openPath
+    const restore = registerOpenPathInterception(ctx, store)
+
+    // Default prefs: the takeover routes the open into the sidebar editor
+    // with the session-scoped absolute path (chat already resolved it).
+    await ctx.workspaces.openPath('/w/src/a.ts')
+    expect(opened).toEqual([{
+      type: 'editor',
+      title: 'a.ts',
+      path: '/w/src/a.ts',
+      id: 'editor:/w/src/a.ts',
+    }])
+
+    // The interceptOpenPath pref off → the original funnel runs untouched.
+    store.setPrefs({ ...store.getPrefs(), interceptOpenPath: false })
+    const calls: string[] = []
+    ctx.workspaces.openPath = async (path: string) => { calls.push(path) }
+    await ctx.workspaces.openPath('/w/src/b.ts')
+    expect(calls).toEqual(['/w/src/b.ts'])
+    expect(opened).toHaveLength(1)
+
+    // The editor tab disabled → falls through too (an editor that cannot
+    // open must not swallow opens).
+    store.setPrefs({ ...store.getPrefs(), interceptOpenPath: true, tabsEnabled: { editor: false } })
+    await ctx.workspaces.openPath('/w/src/c.ts')
+    expect(calls).toEqual(['/w/src/b.ts', '/w/src/c.ts'])
+
+    // Disposal restores the raw original method (HMR-safe).
+    restore()
+    expect(ctx.workspaces.openPath).toBe(original)
+  })
+})