kennel 0.2.2 → 0.2.5

package/kernel/plugins/mail/test/flock.test.mjs

@@ -1,156 +0,0 @@
-import { mkdtemp, rm } from "node:fs/promises"
-import { tmpdir } from "node:os"
-import { join } from "node:path"
-import { describe, expect, test } from "bun:test"
-
-import { FlockTimeoutError, withFlock } from "../src/flock.ts"
-
-async function fixture() {
-  const base = await mkdtemp(join(tmpdir(), "kennel-flock-"))
-  return { base }
-}
-
-describe("withFlock", () => {
-  test("acquires, runs the critical section, and releases the lock", async () => {
-    const { base } = await fixture()
-    try {
-      const lockPath = join(base, ".locks", "d_x.md.lock")
-      let inSection = false
-      let saw = false
-      await withFlock(lockPath, 1000, async () => {
-        inSection = true
-        await Bun.sleep(10)
-        saw = true
-      })
-      expect(saw).toBe(true)
-      expect(inSection).toBe(true)
-    } finally {
-      await rm(base, { recursive: true, force: true })
-    }
-  })
-
-  test("serializes two callers and lets the second reacquire after release", async () => {
-    const { base } = await fixture()
-    try {
-      const lockPath = join(base, "l.lock")
-      const order = []
-      const [first, second] = await Promise.all([
-        withFlock(lockPath, 2000, async () => {
-          order.push("first-in")
-          await Bun.sleep(50)
-          order.push("first-out")
-        }),
-        (async () => {
-          await Bun.sleep(5)
-          return withFlock(lockPath, 2000, async () => {
-            order.push("second-in")
-          })
-        })(),
-      ])
-      expect(first).toBe(undefined)
-      expect(second).toBe(undefined)
-      expect(order).toEqual(["first-in", "first-out", "second-in"])
-    } finally {
-      await rm(base, { recursive: true, force: true })
-    }
-  })
-
-  test("times out when another process keeps holding the lock", async () => {
-    const { base } = await fixture()
-    let child = null
-    try {
-      const lockPath = join(base, "held.lock")
-      const childScript = `
-import { openSync } from "node:fs"
-import { dlopen } from "bun:ffi"
-const lib = dlopen(process.platform === "darwin" ? "/usr/lib/libSystem.B.dylib" : "libc.so.6", { flock: { args: ["int", "int"], returns: "int" } })
-const flock = lib.symbols.flock
-const fd = openSync(${JSON.stringify(lockPath)}, "a+", 0o600)
-flock(fd, 2)
-console.log("CHILD_LOCKED")
-await Bun.sleep(1000)
-flock(fd, 8)
-process.exit(0)
-`
-      child = Bun.spawn({
-        cmd: ["bun", "-e", childScript],
-        cwd: import.meta.dirname,
-        stdout: "pipe",
-        stderr: "pipe",
-      })
-      await waitForChildSignal(child, "CHILD_LOCKED")
-
-      await expect(
-        withFlock(lockPath, 150, async () => {}),
-      ).rejects.toBeInstanceOf(FlockTimeoutError)
-      expect(await childExitedBounded(child)).toBe(0)
-    } finally {
-      if (child) killIfRunning(child)
-      await rm(base, { recursive: true, force: true })
-    }
-  })
-})
-
-/**
- * Read a spawned child's stdout stream and resolve once the decoded,
- * accumulated text contains `marker`. Chunks are decoded incrementally with a
- * streaming TextDecoder and concatenated — checking `String(value)` on a
- * Uint8Array (comma-joined byte numbers) never matches, and partial markers
- * split across chunks only match once the text is fully accumulated. Bounded
- * so a silent child cannot hang the suite.
- */
-function waitForChildSignal(child, marker) {
-  return new Promise((resolveSignal, rejectSignal) => {
-    const reader = child.stdout.getReader()
-    const decoder = new TextDecoder()
-    let collected = ""
-    const failTimer = setTimeout(
-      () =>
-        rejectSignal(new Error(`timeout waiting for child marker ${marker}`)),
-      10_000,
-    )
-    void (async () => {
-      try {
-        for (;;) {
-          const { done, value } = await reader.read()
-          if (done) break
-          collected += decoder.decode(value, { stream: true })
-          if (collected.includes(marker)) {
-            clearTimeout(failTimer)
-            resolveSignal()
-            return
-          }
-        }
-        clearTimeout(failTimer)
-        rejectSignal(new Error(`child closed stdout without marker ${marker}`))
-      } catch (error) {
-        clearTimeout(failTimer)
-        rejectSignal(error)
-      }
-    })()
-  })
-}
-
-async function childExitedBounded(child, ms = 10_000) {
-  return Promise.race([
-    child.exited,
-    new Promise((_, rejectExited) =>
-      setTimeout(
-        () => rejectExited(new Error("child did not exit in time")),
-        ms,
-      ),
-    ),
-  ]).catch(async (error) => {
-    killIfRunning(child)
-    await child.exited.catch(() => undefined)
-    throw error
-  })
-}
-
-function killIfRunning(child) {
-  try {
-    if (child.exitCode === null) child.kill()
-  } catch {
-    // Already gone.
-  }
-}

package/kernel/plugins/mail/test/folders.test.mjs

@@ -1,138 +0,0 @@
-import { describe, expect, test } from "bun:test"
-
-import { folderChoices, folderLabel } from "../src/folders.ts"
-
-const WORKSPACE = "/tmp/kennel-example/example-workspace"
-const CLIENT_ONE = `${WORKSPACE}/clients/client-one`
-const CLIENT_TWO = `${WORKSPACE}/clients/client-two`
-const CLIENT_THREE = `${WORKSPACE}/clients/client-three`
-
-function items(folders) {
-  return folders.map((folder, index) => ({ folder, id: `d_${index}` }))
-}
-
-describe("folderLabel", () => {
-  test("root-owned drafts use the root folder basename", () => {
-    expect(folderLabel(WORKSPACE, WORKSPACE)).toBe("example-workspace")
-  })
-
-  test("descendant drafts use the relative path", () => {
-    expect(folderLabel(CLIENT_ONE, WORKSPACE)).toBe("clients/client-one")
-  })
-
-  test("null folder yields null", () => {
-    expect(folderLabel(null, WORKSPACE)).toBe(null)
-  })
-
-  test("unrelated or sibling-prefix folders yield null", () => {
-    expect(folderLabel("/tmp/kennel-other", WORKSPACE)).toBe(null)
-    expect(folderLabel(`${WORKSPACE}-x`, WORKSPACE)).toBe(null)
-  })
-
-  test("trailing slashes are normalized", () => {
-    expect(folderLabel(`${CLIENT_THREE}/`, `${WORKSPACE}/`)).toBe(
-      "clients/client-three",
-    )
-  })
-})
-
-describe("folderChoices", () => {
-  test("root first with counts, descendants alphabetical", () => {
-    const choices = folderChoices(
-      items([WORKSPACE, CLIENT_THREE, CLIENT_ONE, CLIENT_TWO, WORKSPACE]),
-      WORKSPACE,
-    )
-
-    expect(choices).toEqual([
-      {
-        count: 2,
-        folder: WORKSPACE,
-        label: "example-workspace",
-        relativePath: "",
-      },
-      {
-        count: 1,
-        folder: CLIENT_ONE,
-        label: "clients/client-one",
-        relativePath: "clients/client-one",
-      },
-      {
-        count: 1,
-        folder: CLIENT_THREE,
-        label: "clients/client-three",
-        relativePath: "clients/client-three",
-      },
-      {
-        count: 1,
-        folder: CLIENT_TWO,
-        label: "clients/client-two",
-        relativePath: "clients/client-two",
-      },
-    ])
-  })
-
-  test("duplicate leaf names stay distinct exact choices", () => {
-    const rootClientOne = `${WORKSPACE}/client-one`
-    const choices = folderChoices(
-      items([rootClientOne, CLIENT_ONE, rootClientOne]),
-      WORKSPACE,
-    )
-
-    expect(choices).toEqual([
-      {
-        count: 2,
-        folder: rootClientOne,
-        label: "client-one",
-        relativePath: "client-one",
-      },
-      {
-        count: 1,
-        folder: CLIENT_ONE,
-        label: "clients/client-one",
-        relativePath: "clients/client-one",
-      },
-    ])
-    // Exact-owner filter: selecting clients/client-one must not pull the
-    // root-level client-one draft even though both share a leaf name.
-    const filtered = items([rootClientOne, CLIENT_ONE]).filter(
-      (item) => item.folder === CLIENT_ONE,
-    )
-    expect(filtered.map((item) => item.id)).toEqual(["d_1"])
-  })
-
-  test("skips drafts without a folder", () => {
-    const choices = folderChoices(
-      [
-        { folder: null, id: "d_0" },
-        { folder: WORKSPACE, id: "d_1" },
-      ],
-      WORKSPACE,
-    )
-    expect(choices).toHaveLength(1)
-    expect(choices[0]).toEqual({
-      count: 1,
-      folder: WORKSPACE,
-      label: "example-workspace",
-      relativePath: "",
-    })
-  })
-
-  test("skips folders outside the viewed root", () => {
-    const choices = folderChoices(
-      items([WORKSPACE, `${WORKSPACE}-x`]),
-      WORKSPACE,
-    )
-    expect(choices).toEqual([
-      {
-        count: 1,
-        folder: WORKSPACE,
-        label: "example-workspace",
-        relativePath: "",
-      },
-    ])
-  })
-
-  test("no drafts yields no choices", () => {
-    expect(folderChoices([], WORKSPACE)).toEqual([])
-  })
-})