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.tsindex 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.tsindex 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 = fileNametry {- 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.jsonindex 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.jsonindex 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": {