ignore: refactoring and tests (#12460)

packages/app/src/context/global-sync.test.ts

@@ -0,0 +1,136 @@
+import { describe, expect, test } from "bun:test"
+import {
+  canDisposeDirectory,
+  estimateRootSessionTotal,
+  loadRootSessionsWithFallback,
+  pickDirectoriesToEvict,
+} from "./global-sync"
+
+describe("pickDirectoriesToEvict", () => {
+  test("keeps pinned stores and evicts idle stores", () => {
+    const now = 5_000
+    const picks = pickDirectoriesToEvict({
+      stores: ["a", "b", "c", "d"],
+      state: new Map([
+        ["a", { lastAccessAt: 1_000 }],
+        ["b", { lastAccessAt: 4_900 }],
+        ["c", { lastAccessAt: 4_800 }],
+        ["d", { lastAccessAt: 3_000 }],
+      ]),
+      pins: new Set(["a"]),
+      max: 2,
+      ttl: 1_500,
+      now,
+    })
+
+    expect(picks).toEqual(["d", "c"])
+  })
+})
+
+describe("loadRootSessionsWithFallback", () => {
+  test("uses limited roots query when supported", async () => {
+    const calls: Array<{ directory: string; roots: true; limit?: number }> = []
+    let fallback = 0
+
+    const result = await loadRootSessionsWithFallback({
+      directory: "dir",
+      limit: 10,
+      list: async (query) => {
+        calls.push(query)
+        return { data: [] }
+      },
+      onFallback: () => {
+        fallback += 1
+      },
+    })
+
+    expect(result.data).toEqual([])
+    expect(result.limited).toBe(true)
+    expect(calls).toEqual([{ directory: "dir", roots: true, limit: 10 }])
+    expect(fallback).toBe(0)
+  })
+
+  test("falls back to full roots query on limited-query failure", async () => {
+    const calls: Array<{ directory: string; roots: true; limit?: number }> = []
+    let fallback = 0
+
+    const result = await loadRootSessionsWithFallback({
+      directory: "dir",
+      limit: 25,
+      list: async (query) => {
+        calls.push(query)
+        if (query.limit) throw new Error("unsupported")
+        return { data: [] }
+      },
+      onFallback: () => {
+        fallback += 1
+      },
+    })
+
+    expect(result.data).toEqual([])
+    expect(result.limited).toBe(false)
+    expect(calls).toEqual([
+      { directory: "dir", roots: true, limit: 25 },
+      { directory: "dir", roots: true },
+    ])
+    expect(fallback).toBe(1)
+  })
+})
+
+describe("estimateRootSessionTotal", () => {
+  test("keeps exact total for full fetches", () => {
+    expect(estimateRootSessionTotal({ count: 42, limit: 10, limited: false })).toBe(42)
+  })
+
+  test("marks has-more for full-limit limited fetches", () => {
+    expect(estimateRootSessionTotal({ count: 10, limit: 10, limited: true })).toBe(11)
+  })
+
+  test("keeps exact total when limited fetch is under limit", () => {
+    expect(estimateRootSessionTotal({ count: 9, limit: 10, limited: true })).toBe(9)
+  })
+})
+
+describe("canDisposeDirectory", () => {
+  test("rejects pinned or inflight directories", () => {
+    expect(
+      canDisposeDirectory({
+        directory: "dir",
+        hasStore: true,
+        pinned: true,
+        booting: false,
+        loadingSessions: false,
+      }),
+    ).toBe(false)
+    expect(
+      canDisposeDirectory({
+        directory: "dir",
+        hasStore: true,
+        pinned: false,
+        booting: true,
+        loadingSessions: false,
+      }),
+    ).toBe(false)
+    expect(
+      canDisposeDirectory({
+        directory: "dir",
+        hasStore: true,
+        pinned: false,
+        booting: false,
+        loadingSessions: true,
+      }),
+    ).toBe(false)
+  })
+
+  test("accepts idle unpinned directory store", () => {
+    expect(
+      canDisposeDirectory({
+        directory: "dir",
+        hasStore: true,
+        pinned: false,
+        booting: false,
+        loadingSessions: false,
+      }),
+    ).toBe(true)
+  })
+})