Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript

fix(test): r1-m1 bind fixture cleanup to created identity

Josué699953b8aaf5
diff --git a/tests/e2e/gfsUploadV2Fixtures.test.ts b/tests/e2e/gfsUploadV2Fixtures.test.ts
index ac0589517..d52866858 100644
--- a/tests/e2e/gfsUploadV2Fixtures.test.ts
+++ b/tests/e2e/gfsUploadV2Fixtures.test.ts
@@ -1,12 +1,24 @@
import { afterEach, describe, expect, it } from 'vitest'
import { existsSync } from 'node:fs'
-import { mkdtemp, readdir, rm, stat } from 'node:fs/promises'
+import {
+ lstat,
+ mkdir,
+ mkdtemp,
+ readdir,
+ rename,
+ rmdir,
+ stat,
+ symlink,
+ unlink,
+ writeFile,
+} from 'node:fs/promises'
import os from 'node:os'
import path from 'node:path'
import {
createDiskUploadFixture,
createOversizedDiskUploadFixture,
removeDiskUploadFixture,
+ setAfterFixtureQuarantineForTest,
} from './gfsUploadV2Fixtures.js'
const fixturePrefix = 'evenfire-gfs-upload-v2-'
@@ -15,24 +27,50 @@ async function fixtureDirectories(): Promise<string[]> {
return (await readdir(os.tmpdir())).filter(entry => entry.startsWith(fixturePrefix)).sort()
}
+async function removeKnownFixtureDirectory(directory: string, fileName: string): Promise<void> {
+ const filePath = path.join(directory, fileName)
+ if (existsSync(filePath)) await unlink(filePath)
+ if (existsSync(directory)) await rmdir(directory)
+}
+
describe('GFS Upload v2 disk fixtures', () => {
const fixtures: Array<Awaited<ReturnType<typeof createDiskUploadFixture>>> = []
const ownedDirectories: string[] = []
afterEach(async () => {
+ setAfterFixtureQuarantineForTest(undefined)
for (const fixture of fixtures.splice(0)) {
if (existsSync(fixture.directory)) await removeDiskUploadFixture(fixture)
}
- await Promise.all(
- ownedDirectories.splice(0).map(directory => rm(directory, { recursive: true, force: true }))
- )
+ for (const directory of ownedDirectories.splice(0)) {
+ if (existsSync(directory)) await rmdir(directory)
+ }
})
it('removes an owned fixture after a successful setup', async () => {
const fixture = await createDiskUploadFixture(1, '.bin', 'cleanup-success')
+ fixtures.push(fixture)
expect((await stat(fixture.filePath)).size).toBe(1)
await removeDiskUploadFixture(fixture)
expect(existsSync(fixture.directory)).toBe(false)
+ expect(existsSync(fixture.filePath)).toBe(false)
+ })
+
+ it('removes a tracked owned fixture after an assertion-failure lifecycle', async () => {
+ const fixture = await createDiskUploadFixture(1, '.bin', 'cleanup-assertion-failure')
+ fixtures.push(fixture)
+
+ const assertionFailure = new Error('synthetic assertion failure')
+ await expect(
+ (async () => {
+ try {
+ throw assertionFailure
+ } finally {
+ for (const tracked of fixtures.splice(0)) await removeDiskUploadFixture(tracked)
+ }
+ })()
+ ).rejects.toBe(assertionFailure)
+ expect(existsSync(fixture.directory)).toBe(false)
})
it('cleans an owned directory when fixture setup fails part-way through', async () => {
@@ -56,6 +94,137 @@ describe('GFS Upload v2 disk fixtures', () => {
expect(existsSync(directory)).toBe(true)
})
+ it('rejects a replaced owned pathname and preserves its sentinel', async () => {
+ const fixture = await createDiskUploadFixture(1, '.bin', 'cleanup-replacement')
+ const movedDirectory = `${fixture.directory}-original`
+ const sentinel = path.join(fixture.directory, 'sentinel.txt')
+ await rename(fixture.directory, movedDirectory)
+ await mkdir(fixture.directory)
+ await writeFile(sentinel, 'replacement must survive')
+
+ try {
+ await expect(removeDiskUploadFixture(fixture)).rejects.toThrow(
+ 'refusing to quarantine a replaced GFS v2 fixture directory'
+ )
+ await expect(stat(sentinel)).resolves.toBeDefined()
+ } finally {
+ await unlink(sentinel)
+ await rmdir(fixture.directory)
+ await removeKnownFixtureDirectory(movedDirectory, fixture.fileName)
+ }
+ })
+
+ it('does not treat a missing active fixture directory as already disposed', async () => {
+ const fixture = await createDiskUploadFixture(1, '.bin', 'cleanup-missing')
+ const movedDirectory = `${fixture.directory}-original`
+ await rename(fixture.directory, movedDirectory)
+
+ try {
+ await expect(removeDiskUploadFixture(fixture)).rejects.toThrow(
+ 'cannot quarantine active GFS v2 fixture directory'
+ )
+ expect(existsSync(movedDirectory)).toBe(true)
+ } finally {
+ await removeKnownFixtureDirectory(movedDirectory, fixture.fileName)
+ }
+ })
+
+ it('leaves a recreated original pathname untouched after quarantining the real fixture', async () => {
+ const fixture = await createDiskUploadFixture(1, '.bin', 'cleanup-recreated-original')
+ const sentinel = path.join(fixture.directory, 'sentinel.txt')
+ setAfterFixtureQuarantineForTest(async directory => {
+ await mkdir(directory)
+ await writeFile(sentinel, 'replacement after quarantine')
+ })
+
+ try {
+ await removeDiskUploadFixture(fixture)
+ await expect(stat(sentinel)).resolves.toBeDefined()
+ } finally {
+ setAfterFixtureQuarantineForTest(undefined)
+ await unlink(sentinel)
+ await rmdir(fixture.directory)
+ }
+ })
+
+ it('rejects unexpected contents in a verified owned fixture directory', async () => {
+ const fixture = await createDiskUploadFixture(1, '.bin', 'cleanup-unexpected')
+ const unexpected = path.join(fixture.directory, 'unexpected.txt')
+ let quarantineDirectory: string | undefined
+ setAfterFixtureQuarantineForTest((_directory, quarantined) => {
+ quarantineDirectory = quarantined
+ })
+ await writeFile(unexpected, 'preserve unexpected content')
+
+ try {
+ await expect(removeDiskUploadFixture(fixture)).rejects.toThrow(
+ 'refusing to remove unexpected GFS v2 fixture contents'
+ )
+ expect(quarantineDirectory).toBeDefined()
+ await expect(stat(path.join(quarantineDirectory!, 'unexpected.txt'))).resolves.toBeDefined()
+ await unlink(path.join(quarantineDirectory!, 'unexpected.txt'))
+ await removeKnownFixtureDirectory(quarantineDirectory!, fixture.fileName)
+ } finally {
+ setAfterFixtureQuarantineForTest(undefined)
+ }
+ })
+
+ it('rejects a symlink replacement without deleting its target', async () => {
+ const fixture = await createDiskUploadFixture(1, '.bin', 'cleanup-symlink')
+ const movedDirectory = `${fixture.directory}-original`
+ const targetDirectory = await mkdtemp(path.join(os.tmpdir(), 'unowned-gfs-upload-v2-target-'))
+ const targetSentinel = path.join(targetDirectory, 'sentinel.txt')
+ await rename(fixture.directory, movedDirectory)
+ await writeFile(targetSentinel, 'symlink target must survive')
+ await symlink(targetDirectory, fixture.directory)
+
+ try {
+ await expect(removeDiskUploadFixture(fixture)).rejects.toThrow(
+ 'cannot quarantine active GFS v2 fixture directory'
+ )
+ await expect(stat(targetSentinel)).resolves.toBeDefined()
+ expect((await lstat(fixture.directory)).isSymbolicLink()).toBe(true)
+ } finally {
+ await unlink(fixture.directory)
+ await unlink(targetSentinel)
+ await rmdir(targetDirectory)
+ await removeKnownFixtureDirectory(movedDirectory, fixture.fileName)
+ }
+ })
+
+ it('makes repeated cleanup of a successfully disposed fixture a no-op', async () => {
+ const fixture = await createDiskUploadFixture(1, '.bin', 'cleanup-repeated')
+ fixtures.push(fixture)
+ await removeDiskUploadFixture(fixture)
+ await expect(removeDiskUploadFixture(fixture)).resolves.toBeUndefined()
+ expect(existsSync(fixture.directory)).toBe(false)
+ })
+
+ it('rejects a replacement that appears after the original directory is quarantined', async () => {
+ const fixture = await createDiskUploadFixture(1, '.bin', 'cleanup-quarantine-replacement')
+ let quarantinedOriginal: string | undefined
+ let quarantineReplacement: string | undefined
+ setAfterFixtureQuarantineForTest(async (_directory, quarantineDirectory) => {
+ quarantinedOriginal = `${quarantineDirectory}-original`
+ quarantineReplacement = quarantineDirectory
+ await rename(quarantineDirectory, quarantinedOriginal)
+ await mkdir(quarantineDirectory)
+ await writeFile(path.join(quarantineDirectory, 'sentinel.txt'), 'quarantine replacement')
+ })
+
+ try {
+ await expect(removeDiskUploadFixture(fixture)).rejects.toThrow(
+ 'refusing to remove a replaced GFS v2 fixture directory'
+ )
+ await expect(stat(path.join(quarantineReplacement!, 'sentinel.txt'))).resolves.toBeDefined()
+ } finally {
+ setAfterFixtureQuarantineForTest(undefined)
+ await unlink(path.join(quarantineReplacement!, 'sentinel.txt'))
+ await rmdir(quarantineReplacement!)
+ await removeKnownFixtureDirectory(quarantinedOriginal!, fixture.fileName)
+ }
+ })
+
it('validates before creating a fixture directory', async () => {
const before = await fixtureDirectories()
await expect(createOversizedDiskUploadFixture('.bin', 'invalid-product', 0)).rejects.toThrow(
diff --git a/tests/e2e/gfsUploadV2Fixtures.ts b/tests/e2e/gfsUploadV2Fixtures.ts
index 7a440f132..698eee533 100644
--- a/tests/e2e/gfsUploadV2Fixtures.ts
+++ b/tests/e2e/gfsUploadV2Fixtures.ts
@@ -1,6 +1,6 @@
-import { createHash } from 'node:crypto'
-import { createReadStream } from 'node:fs'
-import { mkdtemp, rm, truncate, writeFile } from 'node:fs/promises'
+import { createHash, randomUUID } from 'node:crypto'
+import { constants, createReadStream } from 'node:fs'
+import { lstat, mkdtemp, open, readdir, rename, rmdir, truncate, unlink } from 'node:fs/promises'
import os from 'node:os'
import path from 'node:path'
@@ -22,7 +22,31 @@ export interface DiskUploadFixture {
sha256: string
}
-const ownedFixtureDirectories = new Set<string>()
+interface FilesystemIdentity {
+ dev: number
+ ino: number
+}
+
+interface FixtureLease {
+ directory: string
+ directoryIdentity: FilesystemIdentity
+ expectedFileName?: string
+ expectedFileIdentity?: FilesystemIdentity
+ quarantineDirectory?: string
+ state: 'active' | 'quarantined' | 'disposed'
+}
+
+const fixtureLeases = new Map<string, FixtureLease>()
+let afterFixtureQuarantineForTest:
+ | ((directory: string, quarantineDirectory: string) => Promise<void> | void)
+ | undefined
+
+/** Test-only synchronization seam for proving that recreation after quarantine is harmless. */
+export function setAfterFixtureQuarantineForTest(
+ hook: ((directory: string, quarantineDirectory: string) => Promise<void> | void) | undefined
+): void {
+ afterFixtureQuarantineForTest = hook
+}
/**
* Creates a deterministic sparse, zero-filled fixture on disk. Playwright
@@ -68,11 +92,30 @@ async function createFixture(
label: string
): Promise<DiskUploadFixture> {
const directory = await mkdtemp(path.join(os.tmpdir(), 'evenfire-gfs-upload-v2-'))
- ownedFixtureDirectories.add(directory)
+ let lease: FixtureLease
+ try {
+ lease = {
+ directory,
+ directoryIdentity: await directoryIdentity(directory),
+ state: 'active',
+ }
+ fixtureLeases.set(directory, lease)
+ } catch (error) {
+ await rmdir(directory).catch(() => undefined)
+ throw error
+ }
+
const fileName = `${label}-${byteLength}${extension}`
const filePath = path.join(directory, fileName)
+ lease.expectedFileName = fileName
try {
- await writeFile(filePath, Buffer.alloc(0))
+ const handle = await open(
+ filePath,
+ constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | constants.O_NOFOLLOW,
+ 0o600
+ )
+ lease.expectedFileIdentity = await regularFileIdentity(filePath)
+ await handle.close()
await truncate(filePath, byteLength)
return {
directory,
@@ -83,7 +126,7 @@ async function createFixture(
}
} catch (error) {
try {
- await removeOwnedFixtureDirectory(directory)
+ await disposeFixtureLease(lease)
} catch (cleanupError) {
throw new AggregateError([error, cleanupError], 'failed to clean partial GFS v2 fixture')
}
@@ -98,13 +141,100 @@ export async function sha256File(filePath: string): Promise<string> {
}
export async function removeDiskUploadFixture(fixture: DiskUploadFixture): Promise<void> {
- await removeOwnedFixtureDirectory(fixture.directory)
+ const lease = fixtureLeases.get(fixture.directory)
+ if (!lease) {
+ throw new Error(`refusing to remove an unowned GFS v2 fixture directory: ${fixture.directory}`)
+ }
+ await disposeFixtureLease(lease)
+}
+
+async function disposeFixtureLease(lease: FixtureLease): Promise<void> {
+ if (lease.state === 'disposed') return
+ if (lease.state === 'active') await quarantineFixtureDirectory(lease)
+ await cleanQuarantinedFixtureDirectory(lease)
+}
+
+async function directoryIdentity(directory: string): Promise<FilesystemIdentity> {
+ const metadata = await lstat(directory)
+ if (!metadata.isDirectory()) throw new Error(`fixture directory is not a directory: ${directory}`)
+ return { dev: metadata.dev, ino: metadata.ino }
}
-async function removeOwnedFixtureDirectory(directory: string): Promise<void> {
- if (!ownedFixtureDirectories.has(directory)) {
- throw new Error(`refusing to remove an unowned GFS v2 fixture directory: ${directory}`)
+async function regularFileIdentity(filePath: string): Promise<FilesystemIdentity> {
+ const metadata = await lstat(filePath)
+ if (!metadata.isFile()) throw new Error(`fixture file is not a regular file: ${filePath}`)
+ return { dev: metadata.dev, ino: metadata.ino }
+}
+
+function identitiesMatch(left: FilesystemIdentity, right: FilesystemIdentity): boolean {
+ return left.dev === right.dev && left.ino === right.ino
+}
+
+async function quarantineFixtureDirectory(lease: FixtureLease): Promise<void> {
+ let currentIdentity: FilesystemIdentity
+ try {
+ currentIdentity = await directoryIdentity(lease.directory)
+ } catch (error) {
+ throw new Error(`cannot quarantine active GFS v2 fixture directory: ${lease.directory}`, {
+ cause: error,
+ })
+ }
+ if (!identitiesMatch(currentIdentity, lease.directoryIdentity)) {
+ throw new Error(
+ `refusing to quarantine a replaced GFS v2 fixture directory: ${lease.directory}`
+ )
+ }
+
+ const quarantineDirectory = path.join(
+ path.dirname(lease.directory),
+ `${path.basename(lease.directory)}-quarantine-${randomUUID()}`
+ )
+ await rename(lease.directory, quarantineDirectory)
+ lease.quarantineDirectory = quarantineDirectory
+ lease.state = 'quarantined'
+ await afterFixtureQuarantineForTest?.(lease.directory, quarantineDirectory)
+
+ const quarantinedIdentity = await directoryIdentity(quarantineDirectory)
+ if (identitiesMatch(quarantinedIdentity, lease.directoryIdentity)) return
+
+ throw new Error(
+ `refusing to remove a replaced GFS v2 fixture directory; retained at ${quarantineDirectory}`
+ )
+}
+
+async function cleanQuarantinedFixtureDirectory(lease: FixtureLease): Promise<void> {
+ const quarantineDirectory = lease.quarantineDirectory
+ if (!quarantineDirectory) {
+ throw new Error(`missing quarantine directory for GFS v2 fixture: ${lease.directory}`)
+ }
+
+ const quarantinedIdentity = await directoryIdentity(quarantineDirectory)
+ if (!identitiesMatch(quarantinedIdentity, lease.directoryIdentity)) {
+ throw new Error(
+ `refusing to remove a replaced GFS v2 fixture directory; retained at ${quarantineDirectory}`
+ )
+ }
+
+ const entries = await readdir(quarantineDirectory)
+ if (!lease.expectedFileIdentity) {
+ if (entries.length > 0) {
+ throw new Error(
+ `refusing to remove unexpected GFS v2 fixture contents: ${quarantineDirectory}`
+ )
+ }
+ } else {
+ if (entries.length !== 1 || entries[0] !== lease.expectedFileName) {
+ throw new Error(
+ `refusing to remove unexpected GFS v2 fixture contents: ${quarantineDirectory}`
+ )
+ }
+ const filePath = path.join(quarantineDirectory, lease.expectedFileName)
+ const fileIdentity = await regularFileIdentity(filePath)
+ if (!identitiesMatch(fileIdentity, lease.expectedFileIdentity)) {
+ throw new Error(`refusing to remove a replaced GFS v2 fixture file: ${filePath}`)
+ }
+ await unlink(filePath)
}
- await rm(directory, { recursive: true, force: true })
- ownedFixtureDirectories.delete(directory)
+ await rmdir(quarantineDirectory)
+ lease.state = 'disposed'
}
diff --git a/tests/e2e/package-lock.json b/tests/e2e/package-lock.json
index 5d46fa2b3..7198158b0 100644
--- a/tests/e2e/package-lock.json
+++ b/tests/e2e/package-lock.json
@@ -1,12 +1,12 @@
{
"name": "clerum-e2e-tests",
- "version": "0.1.70",
+ "version": "0.1.71",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "clerum-e2e-tests",
- "version": "0.1.70",
+ "version": "0.1.71",
"devDependencies": {
"@types/jsonwebtoken": "^9.0.10",
"@types/node": "^22.0.0",
diff --git a/tests/e2e/package.json b/tests/e2e/package.json
index ba921241d..7ede287f0 100644
--- a/tests/e2e/package.json
+++ b/tests/e2e/package.json
@@ -1,6 +1,6 @@
{
"name": "clerum-e2e-tests",
- "version": "0.1.70",
+ "version": "0.1.71",
"private": true,
"type": "module",
"scripts": {