361 lines
11 KiB
TypeScript
361 lines
11 KiB
TypeScript
import { describe, test, expect, beforeEach } from "bun:test"
|
|
import path from "path"
|
|
import fs from "fs/promises"
|
|
import { FileTime } from "../../src/file/time"
|
|
import { Instance } from "../../src/project/instance"
|
|
import { tmpdir } from "../fixture/fixture"
|
|
|
|
describe("file/time", () => {
|
|
const sessionID = "test-session-123"
|
|
|
|
describe("read() and get()", () => {
|
|
test("stores read timestamp", async () => {
|
|
await using tmp = await tmpdir()
|
|
const filepath = path.join(tmp.path, "file.txt")
|
|
await fs.writeFile(filepath, "content", "utf-8")
|
|
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const before = FileTime.get(sessionID, filepath)
|
|
expect(before).toBeUndefined()
|
|
|
|
FileTime.read(sessionID, filepath)
|
|
|
|
const after = FileTime.get(sessionID, filepath)
|
|
expect(after).toBeInstanceOf(Date)
|
|
expect(after!.getTime()).toBeGreaterThan(0)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("tracks separate timestamps per session", async () => {
|
|
await using tmp = await tmpdir()
|
|
const filepath = path.join(tmp.path, "file.txt")
|
|
await fs.writeFile(filepath, "content", "utf-8")
|
|
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
FileTime.read("session1", filepath)
|
|
FileTime.read("session2", filepath)
|
|
|
|
const time1 = FileTime.get("session1", filepath)
|
|
const time2 = FileTime.get("session2", filepath)
|
|
|
|
expect(time1).toBeDefined()
|
|
expect(time2).toBeDefined()
|
|
},
|
|
})
|
|
})
|
|
|
|
test("updates timestamp on subsequent reads", async () => {
|
|
await using tmp = await tmpdir()
|
|
const filepath = path.join(tmp.path, "file.txt")
|
|
await fs.writeFile(filepath, "content", "utf-8")
|
|
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
FileTime.read(sessionID, filepath)
|
|
const first = FileTime.get(sessionID, filepath)!
|
|
|
|
await new Promise((resolve) => setTimeout(resolve, 10))
|
|
|
|
FileTime.read(sessionID, filepath)
|
|
const second = FileTime.get(sessionID, filepath)!
|
|
|
|
expect(second.getTime()).toBeGreaterThanOrEqual(first.getTime())
|
|
},
|
|
})
|
|
})
|
|
})
|
|
|
|
describe("assert()", () => {
|
|
test("passes when file has not been modified", async () => {
|
|
await using tmp = await tmpdir()
|
|
const filepath = path.join(tmp.path, "file.txt")
|
|
await fs.writeFile(filepath, "content", "utf-8")
|
|
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
FileTime.read(sessionID, filepath)
|
|
|
|
// Should not throw
|
|
await FileTime.assert(sessionID, filepath)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("throws when file was not read first", async () => {
|
|
await using tmp = await tmpdir()
|
|
const filepath = path.join(tmp.path, "file.txt")
|
|
await fs.writeFile(filepath, "content", "utf-8")
|
|
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
await expect(FileTime.assert(sessionID, filepath)).rejects.toThrow("You must read file")
|
|
},
|
|
})
|
|
})
|
|
|
|
test("throws when file was modified after read", async () => {
|
|
await using tmp = await tmpdir()
|
|
const filepath = path.join(tmp.path, "file.txt")
|
|
await fs.writeFile(filepath, "content", "utf-8")
|
|
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
FileTime.read(sessionID, filepath)
|
|
|
|
// Wait to ensure different timestamps
|
|
await new Promise((resolve) => setTimeout(resolve, 100))
|
|
|
|
// Modify file after reading
|
|
await fs.writeFile(filepath, "modified content", "utf-8")
|
|
|
|
await expect(FileTime.assert(sessionID, filepath)).rejects.toThrow("modified since it was last read")
|
|
},
|
|
})
|
|
})
|
|
|
|
test("includes timestamps in error message", async () => {
|
|
await using tmp = await tmpdir()
|
|
const filepath = path.join(tmp.path, "file.txt")
|
|
await fs.writeFile(filepath, "content", "utf-8")
|
|
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
FileTime.read(sessionID, filepath)
|
|
await new Promise((resolve) => setTimeout(resolve, 100))
|
|
await fs.writeFile(filepath, "modified", "utf-8")
|
|
|
|
let error: Error | undefined
|
|
try {
|
|
await FileTime.assert(sessionID, filepath)
|
|
} catch (e) {
|
|
error = e as Error
|
|
}
|
|
expect(error).toBeDefined()
|
|
expect(error!.message).toContain("Last modification:")
|
|
expect(error!.message).toContain("Last read:")
|
|
},
|
|
})
|
|
})
|
|
|
|
test("skips check when OPENCODE_DISABLE_FILETIME_CHECK is true", async () => {
|
|
await using tmp = await tmpdir()
|
|
const filepath = path.join(tmp.path, "file.txt")
|
|
await fs.writeFile(filepath, "content", "utf-8")
|
|
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const { Flag } = await import("../../src/flag/flag")
|
|
const original = Flag.OPENCODE_DISABLE_FILETIME_CHECK
|
|
;(Flag as { OPENCODE_DISABLE_FILETIME_CHECK: boolean }).OPENCODE_DISABLE_FILETIME_CHECK = true
|
|
|
|
try {
|
|
// Should not throw even though file wasn't read
|
|
await FileTime.assert(sessionID, filepath)
|
|
} finally {
|
|
;(Flag as { OPENCODE_DISABLE_FILETIME_CHECK: boolean }).OPENCODE_DISABLE_FILETIME_CHECK = original
|
|
}
|
|
},
|
|
})
|
|
})
|
|
})
|
|
|
|
describe("withLock()", () => {
|
|
test("executes function within lock", async () => {
|
|
await using tmp = await tmpdir()
|
|
const filepath = path.join(tmp.path, "file.txt")
|
|
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
let executed = false
|
|
await FileTime.withLock(filepath, async () => {
|
|
executed = true
|
|
return "result"
|
|
})
|
|
expect(executed).toBe(true)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("returns function result", async () => {
|
|
await using tmp = await tmpdir()
|
|
const filepath = path.join(tmp.path, "file.txt")
|
|
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const result = await FileTime.withLock(filepath, async () => {
|
|
return "success"
|
|
})
|
|
expect(result).toBe("success")
|
|
},
|
|
})
|
|
})
|
|
|
|
test("serializes concurrent operations on same file", async () => {
|
|
await using tmp = await tmpdir()
|
|
const filepath = path.join(tmp.path, "file.txt")
|
|
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
const order: number[] = []
|
|
|
|
const op1 = FileTime.withLock(filepath, async () => {
|
|
order.push(1)
|
|
await new Promise((resolve) => setTimeout(resolve, 10))
|
|
order.push(2)
|
|
})
|
|
|
|
const op2 = FileTime.withLock(filepath, async () => {
|
|
order.push(3)
|
|
order.push(4)
|
|
})
|
|
|
|
await Promise.all([op1, op2])
|
|
|
|
// Operations should be serialized
|
|
expect(order).toContain(1)
|
|
expect(order).toContain(2)
|
|
expect(order).toContain(3)
|
|
expect(order).toContain(4)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("allows concurrent operations on different files", async () => {
|
|
await using tmp = await tmpdir()
|
|
const filepath1 = path.join(tmp.path, "file1.txt")
|
|
const filepath2 = path.join(tmp.path, "file2.txt")
|
|
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
let started1 = false
|
|
let started2 = false
|
|
|
|
const op1 = FileTime.withLock(filepath1, async () => {
|
|
started1 = true
|
|
await new Promise((resolve) => setTimeout(resolve, 50))
|
|
expect(started2).toBe(true) // op2 should have started while op1 is running
|
|
})
|
|
|
|
const op2 = FileTime.withLock(filepath2, async () => {
|
|
started2 = true
|
|
})
|
|
|
|
await Promise.all([op1, op2])
|
|
|
|
expect(started1).toBe(true)
|
|
expect(started2).toBe(true)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("releases lock even if function throws", async () => {
|
|
await using tmp = await tmpdir()
|
|
const filepath = path.join(tmp.path, "file.txt")
|
|
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
await expect(
|
|
FileTime.withLock(filepath, async () => {
|
|
throw new Error("Test error")
|
|
}),
|
|
).rejects.toThrow("Test error")
|
|
|
|
// Lock should be released, subsequent operations should work
|
|
let executed = false
|
|
await FileTime.withLock(filepath, async () => {
|
|
executed = true
|
|
})
|
|
expect(executed).toBe(true)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("deadlocks on nested locks (expected behavior)", async () => {
|
|
await using tmp = await tmpdir()
|
|
const filepath = path.join(tmp.path, "file.txt")
|
|
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
// Nested locks on same file cause deadlock - this is expected
|
|
// The outer lock waits for inner to complete, but inner waits for outer to release
|
|
const timeout = new Promise<never>((_, reject) =>
|
|
setTimeout(() => reject(new Error("Deadlock detected")), 100),
|
|
)
|
|
|
|
const nestedLock = FileTime.withLock(filepath, async () => {
|
|
return FileTime.withLock(filepath, async () => {
|
|
return "inner"
|
|
})
|
|
})
|
|
|
|
// Should timeout due to deadlock
|
|
await expect(Promise.race([nestedLock, timeout])).rejects.toThrow("Deadlock detected")
|
|
},
|
|
})
|
|
})
|
|
})
|
|
|
|
describe("stat() Bun.file pattern", () => {
|
|
test("reads file modification time via Bun.file().stat()", async () => {
|
|
await using tmp = await tmpdir()
|
|
const filepath = path.join(tmp.path, "file.txt")
|
|
await fs.writeFile(filepath, "content", "utf-8")
|
|
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
FileTime.read(sessionID, filepath)
|
|
|
|
const stats = await Bun.file(filepath).stat()
|
|
expect(stats.mtime).toBeInstanceOf(Date)
|
|
expect(stats.mtime.getTime()).toBeGreaterThan(0)
|
|
|
|
// FileTime.assert uses this stat internally
|
|
await FileTime.assert(sessionID, filepath)
|
|
},
|
|
})
|
|
})
|
|
|
|
test("detects modification via stat mtime", async () => {
|
|
await using tmp = await tmpdir()
|
|
const filepath = path.join(tmp.path, "file.txt")
|
|
await fs.writeFile(filepath, "original", "utf-8")
|
|
|
|
await Instance.provide({
|
|
directory: tmp.path,
|
|
fn: async () => {
|
|
FileTime.read(sessionID, filepath)
|
|
|
|
const originalStat = await Bun.file(filepath).stat()
|
|
|
|
// Wait and modify
|
|
await new Promise((resolve) => setTimeout(resolve, 100))
|
|
await fs.writeFile(filepath, "modified", "utf-8")
|
|
|
|
const newStat = await Bun.file(filepath).stat()
|
|
expect(newStat.mtime.getTime()).toBeGreaterThan(originalStat.mtime.getTime())
|
|
|
|
await expect(FileTime.assert(sessionID, filepath)).rejects.toThrow()
|
|
},
|
|
})
|
|
})
|
|
})
|
|
})
|