@vikasitai/vikasit-code 2.0.6 → 2.0.8

package/test/util/flock.test.ts

@@ -1,383 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import fs from "fs/promises"
-import path from "path"
-import { Flock } from "../../src/util/flock"
-import { Hash } from "../../src/util/hash"
-import { Process } from "../../src/util/process"
-import { Filesystem } from "../../src/util/filesystem"
-import { tmpdir } from "../fixture/fixture"
-
-const root = path.join(import.meta.dir, "../..")
-const worker = path.join(import.meta.dir, "../fixture/flock-worker.ts")
-
-type Msg = {
-  key: string
-  dir: string
-  staleMs?: number
-  timeoutMs?: number
-  baseDelayMs?: number
-  maxDelayMs?: number
-  holdMs?: number
-  ready?: string
-  active?: string
-  done?: string
-}
-
-function lock(dir: string, key: string) {
-  return path.join(dir, Hash.fast(key) + ".lock")
-}
-
-function sleep(ms: number) {
-  return new Promise<void>((resolve) => {
-    setTimeout(resolve, ms)
-  })
-}
-
-async function exists(file: string) {
-  return fs
-    .stat(file)
-    .then(() => true)
-    .catch(() => false)
-}
-
-async function wait(file: string, timeout = 3_000) {
-  const stop = Date.now() + timeout
-  while (Date.now() < stop) {
-    if (await exists(file)) return
-    await sleep(20)
-  }
-
-  throw new Error(`Timed out waiting for file: ${file}`)
-}
-
-function run(msg: Msg) {
-  return Process.run([process.execPath, worker, JSON.stringify(msg)], {
-    cwd: root,
-    nothrow: true,
-  })
-}
-
-function spawn(msg: Msg) {
-  return Process.spawn([process.execPath, worker, JSON.stringify(msg)], {
-    cwd: root,
-    stdin: "ignore",
-    stdout: "pipe",
-    stderr: "pipe",
-  })
-}
-
-describe("util.flock", () => {
-  test("enforces mutual exclusion under process contention", async () => {
-    await using tmp = await tmpdir()
-    const dir = path.join(tmp.path, "locks")
-    const done = path.join(tmp.path, "done.log")
-    const active = path.join(tmp.path, "active")
-    const key = "flock:stress"
-    const n = 16
-
-    const out = await Promise.all(
-      Array.from({ length: n }, () =>
-        run({
-          key,
-          dir,
-          done,
-          active,
-          holdMs: 30,
-          staleMs: 1_000,
-          timeoutMs: 15_000,
-        }),
-      ),
-    )
-
-    expect(out.map((x) => x.code)).toEqual(Array.from({ length: n }, () => 0))
-    expect(out.map((x) => x.stderr.toString()).filter(Boolean)).toEqual([])
-
-    const lines = (await fs.readFile(done, "utf8"))
-      .split("\n")
-      .map((x) => x.trim())
-      .filter(Boolean)
-    expect(lines.length).toBe(n)
-  }, 20_000)
-
-  test("times out while waiting when lock is still healthy", async () => {
-    await using tmp = await tmpdir()
-    const dir = path.join(tmp.path, "locks")
-    const key = "flock:timeout"
-    const ready = path.join(tmp.path, "ready")
-    const proc = spawn({
-      key,
-      dir,
-      ready,
-      holdMs: 20_000,
-      staleMs: 10_000,
-      timeoutMs: 30_000,
-    })
-
-    try {
-      await wait(ready, 5_000)
-      const seen: string[] = []
-      const err = await Flock.withLock(key, async () => {}, {
-        dir,
-        staleMs: 10_000,
-        timeoutMs: 1_000,
-        onWait: (tick) => {
-          seen.push(tick.key)
-        },
-      }).catch((err) => err)
-
-      expect(err).toBeInstanceOf(Error)
-      if (!(err instanceof Error)) throw err
-      expect(err.message).toContain("Timed out waiting for lock")
-      expect(seen.length).toBeGreaterThan(0)
-      expect(seen.every((x) => x === key)).toBe(true)
-    } finally {
-      await Process.stop(proc).catch(() => undefined)
-      await proc.exited.catch(() => undefined)
-    }
-  }, 15_000)
-
-  test("recovers after a crashed lock owner", async () => {
-    await using tmp = await tmpdir()
-    const dir = path.join(tmp.path, "locks")
-    const key = "flock:crash"
-    const ready = path.join(tmp.path, "ready")
-    const proc = spawn({
-      key,
-      dir,
-      ready,
-      holdMs: 20_000,
-      staleMs: 500,
-      timeoutMs: 30_000,
-    })
-
-    await wait(ready, 5_000)
-    await Process.stop(proc)
-    await proc.exited.catch(() => undefined)
-
-    let hit = false
-    await Flock.withLock(
-      key,
-      async () => {
-        hit = true
-      },
-      {
-        dir,
-        staleMs: 500,
-        timeoutMs: 8_000,
-      },
-    )
-
-    expect(hit).toBe(true)
-  }, 20_000)
-
-  test("breaks stale lock dirs when heartbeat is missing", async () => {
-    await using tmp = await tmpdir()
-    const dir = path.join(tmp.path, "locks")
-    const key = "flock:missing-heartbeat"
-    const lockDir = lock(dir, key)
-
-    await fs.mkdir(lockDir, { recursive: true })
-    const old = new Date(Date.now() - 2_000)
-    await fs.utimes(lockDir, old, old)
-
-    let hit = false
-    await Flock.withLock(
-      key,
-      async () => {
-        hit = true
-      },
-      {
-        dir,
-        staleMs: 200,
-        timeoutMs: 3_000,
-      },
-    )
-
-    expect(hit).toBe(true)
-  })
-
-  test("recovers when a stale breaker claim was left behind", async () => {
-    await using tmp = await tmpdir()
-    const dir = path.join(tmp.path, "locks")
-    const key = "flock:stale-breaker"
-    const lockDir = lock(dir, key)
-    const breaker = lockDir + ".breaker"
-
-    await fs.mkdir(lockDir, { recursive: true })
-    await fs.mkdir(breaker)
-
-    const old = new Date(Date.now() - 2_000)
-    await fs.utimes(lockDir, old, old)
-    await fs.utimes(breaker, old, old)
-
-    let hit = false
-    await Flock.withLock(
-      key,
-      async () => {
-        hit = true
-      },
-      {
-        dir,
-        staleMs: 200,
-        timeoutMs: 3_000,
-      },
-    )
-
-    expect(hit).toBe(true)
-    expect(await exists(breaker)).toBe(false)
-  })
-
-  test("fails clearly if lock dir is removed while held", async () => {
-    await using tmp = await tmpdir()
-    const dir = path.join(tmp.path, "locks")
-    const key = "flock:compromised"
-    const lockDir = lock(dir, key)
-
-    const err = await Flock.withLock(
-      key,
-      async () => {
-        await fs.rm(lockDir, {
-          recursive: true,
-          force: true,
-        })
-      },
-      {
-        dir,
-        staleMs: 1_000,
-        timeoutMs: 3_000,
-      },
-    ).catch((err) => err)
-
-    expect(err).toBeInstanceOf(Error)
-    if (!(err instanceof Error)) throw err
-    expect(err.message).toContain("compromised")
-
-    let hit = false
-    await Flock.withLock(
-      key,
-      async () => {
-        hit = true
-      },
-      {
-        dir,
-        staleMs: 200,
-        timeoutMs: 3_000,
-      },
-    )
-    expect(hit).toBe(true)
-  })
-
-  test("writes owner metadata while lock is held", async () => {
-    await using tmp = await tmpdir()
-    const dir = path.join(tmp.path, "locks")
-    const key = "flock:meta"
-    const file = path.join(lock(dir, key), "meta.json")
-
-    await Flock.withLock(
-      key,
-      async () => {
-        const json = await Filesystem.readJson<{
-          token?: unknown
-          pid?: unknown
-          hostname?: unknown
-          createdAt?: unknown
-        }>(file)
-
-        expect(typeof json.token).toBe("string")
-        expect(typeof json.pid).toBe("number")
-        expect(typeof json.hostname).toBe("string")
-        expect(typeof json.createdAt).toBe("string")
-      },
-      {
-        dir,
-        staleMs: 1_000,
-        timeoutMs: 3_000,
-      },
-    )
-  })
-
-  test("supports acquire with await using", async () => {
-    await using tmp = await tmpdir()
-    const dir = path.join(tmp.path, "locks")
-    const key = "flock:acquire"
-    const lockDir = lock(dir, key)
-
-    {
-      await using _ = await Flock.acquire(key, {
-        dir,
-        staleMs: 1_000,
-        timeoutMs: 3_000,
-      })
-      expect(await exists(lockDir)).toBe(true)
-    }
-
-    expect(await exists(lockDir)).toBe(false)
-  })
-
-  test("refuses token mismatch release and recovers from stale", async () => {
-    await using tmp = await tmpdir()
-    const dir = path.join(tmp.path, "locks")
-    const key = "flock:token"
-    const lockDir = lock(dir, key)
-    const meta = path.join(lockDir, "meta.json")
-
-    const err = await Flock.withLock(
-      key,
-      async () => {
-        const json = await Filesystem.readJson<{ token?: string }>(meta)
-        json.token = "tampered"
-        await fs.writeFile(meta, JSON.stringify(json, null, 2))
-      },
-      {
-        dir,
-        staleMs: 500,
-        timeoutMs: 3_000,
-      },
-    ).catch((err) => err)
-
-    expect(err).toBeInstanceOf(Error)
-    if (!(err instanceof Error)) throw err
-    expect(err.message).toContain("token mismatch")
-    expect(await exists(lockDir)).toBe(true)
-
-    let hit = false
-    await Flock.withLock(
-      key,
-      async () => {
-        hit = true
-      },
-      {
-        dir,
-        staleMs: 500,
-        timeoutMs: 6_000,
-      },
-    )
-    expect(hit).toBe(true)
-  })
-
-  test("fails clearly on unwritable lock roots", async () => {
-    if (process.platform === "win32") return
-
-    await using tmp = await tmpdir()
-    const dir = path.join(tmp.path, "locks")
-    const key = "flock:perm"
-
-    await fs.mkdir(dir, { recursive: true })
-    await fs.chmod(dir, 0o500)
-
-    try {
-      const err = await Flock.withLock(key, async () => {}, {
-        dir,
-        staleMs: 100,
-        timeoutMs: 500,
-      }).catch((err) => err)
-
-      expect(err).toBeInstanceOf(Error)
-      if (!(err instanceof Error)) throw err
-      const text = err.message
-      expect(text.includes("EACCES") || text.includes("EPERM")).toBe(true)
-    } finally {
-      await fs.chmod(dir, 0o700)
-    }
-  })
-})

package/test/util/format.test.ts

@@ -1,59 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { formatDuration } from "../../src/util/format"
-
-describe("util.format", () => {
-  describe("formatDuration", () => {
-    test("returns empty string for zero or negative values", () => {
-      expect(formatDuration(0)).toBe("")
-      expect(formatDuration(-1)).toBe("")
-      expect(formatDuration(-100)).toBe("")
-    })
-
-    test("formats seconds under a minute", () => {
-      expect(formatDuration(1)).toBe("1s")
-      expect(formatDuration(30)).toBe("30s")
-      expect(formatDuration(59)).toBe("59s")
-    })
-
-    test("formats minutes under an hour", () => {
-      expect(formatDuration(60)).toBe("1m")
-      expect(formatDuration(61)).toBe("1m 1s")
-      expect(formatDuration(90)).toBe("1m 30s")
-      expect(formatDuration(120)).toBe("2m")
-      expect(formatDuration(330)).toBe("5m 30s")
-      expect(formatDuration(3599)).toBe("59m 59s")
-    })
-
-    test("formats hours under a day", () => {
-      expect(formatDuration(3600)).toBe("1h")
-      expect(formatDuration(3660)).toBe("1h 1m")
-      expect(formatDuration(7200)).toBe("2h")
-      expect(formatDuration(8100)).toBe("2h 15m")
-      expect(formatDuration(86399)).toBe("23h 59m")
-    })
-
-    test("formats days under a week", () => {
-      expect(formatDuration(86400)).toBe("~1 day")
-      expect(formatDuration(172800)).toBe("~2 days")
-      expect(formatDuration(259200)).toBe("~3 days")
-      expect(formatDuration(604799)).toBe("~6 days")
-    })
-
-    test("formats weeks", () => {
-      expect(formatDuration(604800)).toBe("~1 week")
-      expect(formatDuration(1209600)).toBe("~2 weeks")
-      expect(formatDuration(1609200)).toBe("~2 weeks")
-    })
-
-    test("handles boundary values correctly", () => {
-      expect(formatDuration(59)).toBe("59s")
-      expect(formatDuration(60)).toBe("1m")
-      expect(formatDuration(3599)).toBe("59m 59s")
-      expect(formatDuration(3600)).toBe("1h")
-      expect(formatDuration(86399)).toBe("23h 59m")
-      expect(formatDuration(86400)).toBe("~1 day")
-      expect(formatDuration(604799)).toBe("~6 days")
-      expect(formatDuration(604800)).toBe("~1 week")
-    })
-  })
-})

package/test/util/glob.test.ts

@@ -1,164 +0,0 @@
-import { describe, test, expect } from "bun:test"
-import path from "path"
-import fs from "fs/promises"
-import { Glob } from "../../src/util/glob"
-import { tmpdir } from "../fixture/fixture"
-
-describe("Glob", () => {
-  describe("scan()", () => {
-    test("finds files matching pattern", async () => {
-      await using tmp = await tmpdir()
-      await fs.writeFile(path.join(tmp.path, "a.txt"), "", "utf-8")
-      await fs.writeFile(path.join(tmp.path, "b.txt"), "", "utf-8")
-      await fs.writeFile(path.join(tmp.path, "c.md"), "", "utf-8")
-
-      const results = await Glob.scan("*.txt", { cwd: tmp.path })
-
-      expect(results.sort()).toEqual(["a.txt", "b.txt"])
-    })
-
-    test("returns absolute paths when absolute option is true", async () => {
-      await using tmp = await tmpdir()
-      await fs.writeFile(path.join(tmp.path, "file.txt"), "", "utf-8")
-
-      const results = await Glob.scan("*.txt", { cwd: tmp.path, absolute: true })
-
-      expect(results[0]).toBe(path.join(tmp.path, "file.txt"))
-    })
-
-    test("excludes directories by default", async () => {
-      await using tmp = await tmpdir()
-      await fs.mkdir(path.join(tmp.path, "subdir"))
-      await fs.writeFile(path.join(tmp.path, "file.txt"), "", "utf-8")
-
-      const results = await Glob.scan("*", { cwd: tmp.path })
-
-      expect(results).toEqual(["file.txt"])
-    })
-
-    test("excludes directories when include is 'file'", async () => {
-      await using tmp = await tmpdir()
-      await fs.mkdir(path.join(tmp.path, "subdir"))
-      await fs.writeFile(path.join(tmp.path, "file.txt"), "", "utf-8")
-
-      const results = await Glob.scan("*", { cwd: tmp.path, include: "file" })
-
-      expect(results).toEqual(["file.txt"])
-    })
-
-    test("includes directories when include is 'all'", async () => {
-      await using tmp = await tmpdir()
-      await fs.mkdir(path.join(tmp.path, "subdir"))
-      await fs.writeFile(path.join(tmp.path, "file.txt"), "", "utf-8")
-
-      const results = await Glob.scan("*", { cwd: tmp.path, include: "all" })
-
-      expect(results.sort()).toEqual(["file.txt", "subdir"])
-    })
-
-    test("handles nested patterns", async () => {
-      await using tmp = await tmpdir()
-      await fs.mkdir(path.join(tmp.path, "nested"), { recursive: true })
-      await fs.writeFile(path.join(tmp.path, "nested", "deep.txt"), "", "utf-8")
-
-      const results = await Glob.scan("**/*.txt", { cwd: tmp.path })
-
-      expect(results).toEqual([path.join("nested", "deep.txt")])
-    })
-
-    test("returns empty array for no matches", async () => {
-      await using tmp = await tmpdir()
-
-      const results = await Glob.scan("*.nonexistent", { cwd: tmp.path })
-
-      expect(results).toEqual([])
-    })
-
-    test("does not follow symlinks by default", async () => {
-      await using tmp = await tmpdir()
-      await fs.mkdir(path.join(tmp.path, "realdir"))
-      await fs.writeFile(path.join(tmp.path, "realdir", "file.txt"), "", "utf-8")
-      await fs.symlink(path.join(tmp.path, "realdir"), path.join(tmp.path, "linkdir"))
-
-      const results = await Glob.scan("**/*.txt", { cwd: tmp.path })
-
-      expect(results).toEqual([path.join("realdir", "file.txt")])
-    })
-
-    test("follows symlinks when symlink option is true", async () => {
-      await using tmp = await tmpdir()
-      await fs.mkdir(path.join(tmp.path, "realdir"))
-      await fs.writeFile(path.join(tmp.path, "realdir", "file.txt"), "", "utf-8")
-      await fs.symlink(path.join(tmp.path, "realdir"), path.join(tmp.path, "linkdir"))
-
-      const results = await Glob.scan("**/*.txt", { cwd: tmp.path, symlink: true })
-
-      expect(results.sort()).toEqual([path.join("linkdir", "file.txt"), path.join("realdir", "file.txt")])
-    })
-
-    test("includes dotfiles when dot option is true", async () => {
-      await using tmp = await tmpdir()
-      await fs.writeFile(path.join(tmp.path, ".hidden"), "", "utf-8")
-      await fs.writeFile(path.join(tmp.path, "visible"), "", "utf-8")
-
-      const results = await Glob.scan("*", { cwd: tmp.path, dot: true })
-
-      expect(results.sort()).toEqual([".hidden", "visible"])
-    })
-
-    test("excludes dotfiles when dot option is false", async () => {
-      await using tmp = await tmpdir()
-      await fs.writeFile(path.join(tmp.path, ".hidden"), "", "utf-8")
-      await fs.writeFile(path.join(tmp.path, "visible"), "", "utf-8")
-
-      const results = await Glob.scan("*", { cwd: tmp.path, dot: false })
-
-      expect(results).toEqual(["visible"])
-    })
-  })
-
-  describe("scanSync()", () => {
-    test("finds files matching pattern synchronously", async () => {
-      await using tmp = await tmpdir()
-      await fs.writeFile(path.join(tmp.path, "a.txt"), "", "utf-8")
-      await fs.writeFile(path.join(tmp.path, "b.txt"), "", "utf-8")
-
-      const results = Glob.scanSync("*.txt", { cwd: tmp.path })
-
-      expect(results.sort()).toEqual(["a.txt", "b.txt"])
-    })
-
-    test("respects options", async () => {
-      await using tmp = await tmpdir()
-      await fs.mkdir(path.join(tmp.path, "subdir"))
-      await fs.writeFile(path.join(tmp.path, "file.txt"), "", "utf-8")
-
-      const results = Glob.scanSync("*", { cwd: tmp.path, include: "all" })
-
-      expect(results.sort()).toEqual(["file.txt", "subdir"])
-    })
-  })
-
-  describe("match()", () => {
-    test("matches simple patterns", () => {
-      expect(Glob.match("*.txt", "file.txt")).toBe(true)
-      expect(Glob.match("*.txt", "file.js")).toBe(false)
-    })
-
-    test("matches directory patterns", () => {
-      expect(Glob.match("**/*.js", "src/index.js")).toBe(true)
-      expect(Glob.match("**/*.js", "src/index.ts")).toBe(false)
-    })
-
-    test("matches dot files", () => {
-      expect(Glob.match(".*", ".gitignore")).toBe(true)
-      expect(Glob.match("**/*.md", ".github/README.md")).toBe(true)
-    })
-
-    test("matches brace expansion", () => {
-      expect(Glob.match("*.{js,ts}", "file.js")).toBe(true)
-      expect(Glob.match("*.{js,ts}", "file.ts")).toBe(true)
-      expect(Glob.match("*.{js,ts}", "file.py")).toBe(false)
-    })
-  })
-})

package/test/util/iife.test.ts

@@ -1,36 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { iife } from "../../src/util/iife"
-
-describe("util.iife", () => {
-  test("should execute function immediately and return result", () => {
-    let called = false
-    const result = iife(() => {
-      called = true
-      return 42
-    })
-
-    expect(called).toBe(true)
-    expect(result).toBe(42)
-  })
-
-  test("should work with async functions", async () => {
-    let called = false
-    const result = await iife(async () => {
-      called = true
-      return "async result"
-    })
-
-    expect(called).toBe(true)
-    expect(result).toBe("async result")
-  })
-
-  test("should handle functions with no return value", () => {
-    let called = false
-    const result = iife(() => {
-      called = true
-    })
-
-    expect(called).toBe(true)
-    expect(result).toBeUndefined()
-  })
-})

package/test/util/lazy.test.ts

@@ -1,50 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { lazy } from "../../src/util/lazy"
-
-describe("util.lazy", () => {
-  test("should call function only once", () => {
-    let callCount = 0
-    const getValue = () => {
-      callCount++
-      return "expensive value"
-    }
-
-    const lazyValue = lazy(getValue)
-
-    expect(callCount).toBe(0)
-
-    const result1 = lazyValue()
-    expect(result1).toBe("expensive value")
-    expect(callCount).toBe(1)
-
-    const result2 = lazyValue()
-    expect(result2).toBe("expensive value")
-    expect(callCount).toBe(1)
-  })
-
-  test("should preserve the same reference", () => {
-    const obj = { value: 42 }
-    const lazyObj = lazy(() => obj)
-
-    const result1 = lazyObj()
-    const result2 = lazyObj()
-
-    expect(result1).toBe(obj)
-    expect(result2).toBe(obj)
-    expect(result1).toBe(result2)
-  })
-
-  test("should work with different return types", () => {
-    const lazyString = lazy(() => "string")
-    const lazyNumber = lazy(() => 123)
-    const lazyBoolean = lazy(() => true)
-    const lazyNull = lazy(() => null)
-    const lazyUndefined = lazy(() => undefined)
-
-    expect(lazyString()).toBe("string")
-    expect(lazyNumber()).toBe(123)
-    expect(lazyBoolean()).toBe(true)
-    expect(lazyNull()).toBe(null)
-    expect(lazyUndefined()).toBe(undefined)
-  })
-})