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 make fixture cleanup descriptor-bound

Josuéeac3d58723a6
diff --git a/tests/e2e/gfsUploadV2Fixtures.test.ts b/tests/e2e/gfsUploadV2Fixtures.test.ts
index d52866858..db26d18b6 100644
--- a/tests/e2e/gfsUploadV2Fixtures.test.ts
+++ b/tests/e2e/gfsUploadV2Fixtures.test.ts
@@ -1,66 +1,64 @@
import { afterEach, describe, expect, it } from 'vitest'
import { existsSync } from 'node:fs'
-import {
- lstat,
- mkdir,
- mkdtemp,
- readdir,
- rename,
- rmdir,
- stat,
- symlink,
- unlink,
- writeFile,
-} from 'node:fs/promises'
+import { mkdir, 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,
+ setAfterFixtureHandleForTest,
+ sha256File,
} from './gfsUploadV2Fixtures.js'
const fixturePrefix = 'evenfire-gfs-upload-v2-'
async function fixtureDirectories(): Promise<string[]> {
- return (await readdir(os.tmpdir())).filter(entry => entry.startsWith(fixturePrefix)).sort()
+ return (await readdir(os.tmpdir()))
+ .filter(entry => entry.startsWith(fixturePrefix))
+ .map(entry => path.join(os.tmpdir(), entry))
+ .sort()
}
-async function removeKnownFixtureDirectory(directory: string, fileName: string): Promise<void> {
- const filePath = path.join(directory, fileName)
- if (existsSync(filePath)) await unlink(filePath)
+async function removeKnownFixtureDirectory(directory: string, fileNames: string[]): Promise<void> {
+ for (const fileName of fileNames) {
+ 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)
+ setAfterFixtureHandleForTest?.(undefined)
for (const fixture of fixtures.splice(0)) {
- if (existsSync(fixture.directory)) await removeDiskUploadFixture(fixture)
- }
- for (const directory of ownedDirectories.splice(0)) {
- if (existsSync(directory)) await rmdir(directory)
+ await removeDiskUploadFixture(fixture).catch(() => undefined)
+ await removeKnownFixtureDirectory(fixture.directory, [fixture.fileName]).catch(
+ () => undefined
+ )
}
})
- it('removes an owned fixture after a successful setup', async () => {
+ it('neutralizes an owned fixture through its retained handle without deleting its pathname', async () => {
const fixture = await createDiskUploadFixture(1, '.bin', 'cleanup-success')
fixtures.push(fixture)
expect((await stat(fixture.filePath)).size).toBe(1)
+ expect(await sha256File(fixture.filePath)).toBe(fixture.sha256)
+
await removeDiskUploadFixture(fixture)
- expect(existsSync(fixture.directory)).toBe(false)
- expect(existsSync(fixture.filePath)).toBe(false)
+
+ expect((await stat(fixture.filePath)).size).toBe(0)
+ expect(existsSync(fixture.directory)).toBe(true)
+ await expect(removeDiskUploadFixture(fixture)).resolves.toBeUndefined()
})
- it('removes a tracked owned fixture after an assertion-failure lifecycle', async () => {
+ it('neutralizes a tracked 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 {
@@ -70,159 +68,126 @@ describe('GFS Upload v2 disk fixtures', () => {
}
})()
).rejects.toBe(assertionFailure)
- expect(existsSync(fixture.directory)).toBe(false)
+ expect((await stat(fixture.filePath)).size).toBe(0)
+ await removeKnownFixtureDirectory(fixture.directory, [fixture.fileName])
})
- it('cleans an owned directory when fixture setup fails part-way through', async () => {
+ it('closes and neutralizes a partial fixture once its handle has been acquired', async () => {
const before = await fixtureDirectories()
- await expect(createDiskUploadFixture(1, '.bin', 'nested/partial')).rejects.toThrow()
- expect(await fixtureDirectories()).toEqual(before)
- })
+ expect(setAfterFixtureHandleForTest).toBeTypeOf('function')
+ setAfterFixtureHandleForTest?.(() => {
+ throw new Error('synthetic setup failure after handle acquisition')
+ })
- it('refuses to delete a directory the fixture did not create', async () => {
- const directory = await mkdtemp(path.join(os.tmpdir(), 'unowned-gfs-upload-v2-'))
- ownedDirectories.push(directory)
- await expect(
- removeDiskUploadFixture({
- directory,
- filePath: path.join(directory, 'payload.bin'),
- fileName: 'payload.bin',
- byteLength: 0,
- sha256: '',
- })
- ).rejects.toThrow('refusing to remove an unowned GFS v2 fixture directory')
- expect(existsSync(directory)).toBe(true)
+ await expect(createDiskUploadFixture(1, '.bin', 'partial-handle')).rejects.toThrow(
+ 'synthetic setup failure after handle acquisition'
+ )
+
+ const created = (await fixtureDirectories()).filter(directory => !before.includes(directory))
+ expect(created).toHaveLength(1)
+ const partialFile = path.join(created[0]!, 'partial-handle-1.bin')
+ expect((await stat(partialFile)).size).toBe(0)
+ await removeKnownFixtureDirectory(created[0]!, ['partial-handle-1.bin'])
})
- 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')
+ it('rejects a fabricated fixture object with copied pathname data', async () => {
+ const fixture = await createDiskUploadFixture(32, '.bin', 'cleanup-fabricated')
+ const fabricated = { ...fixture }
try {
- await expect(removeDiskUploadFixture(fixture)).rejects.toThrow(
- 'refusing to quarantine a replaced GFS v2 fixture directory'
+ await expect(removeDiskUploadFixture(fabricated)).rejects.toThrow(
+ 'refusing to neutralize an unowned GFS v2 fixture'
)
- await expect(stat(sentinel)).resolves.toBeDefined()
+ expect((await stat(fixture.filePath)).size).toBe(32)
} finally {
- await unlink(sentinel)
- await rmdir(fixture.directory)
- await removeKnownFixtureDirectory(movedDirectory, fixture.fileName)
+ await removeDiskUploadFixture(fixture)
+ await removeKnownFixtureDirectory(fixture.directory, [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)
+ it('neutralizes the created file after its visible child pathname is replaced', async () => {
+ const fixture = await createDiskUploadFixture(32, '.bin', 'cleanup-child-replacement')
+ const retainedOriginal = `${fixture.filePath}-retained`
+ await rename(fixture.filePath, retainedOriginal)
+ await writeFile(fixture.filePath, 'replacement sentinel')
try {
- await expect(removeDiskUploadFixture(fixture)).rejects.toThrow(
- 'cannot quarantine active GFS v2 fixture directory'
- )
- expect(existsSync(movedDirectory)).toBe(true)
+ await removeDiskUploadFixture(fixture)
+ expect((await stat(retainedOriginal)).size).toBe(0)
+ expect((await stat(fixture.filePath)).size).toBe('replacement sentinel'.length)
} finally {
- await removeKnownFixtureDirectory(movedDirectory, fixture.fileName)
+ await removeKnownFixtureDirectory(fixture.directory, [
+ fixture.fileName,
+ `${fixture.fileName}-retained`,
+ ])
}
})
- 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')
- })
+ it('does not redirect cleanup when the fixture directory pathname is replaced', async () => {
+ const fixture = await createDiskUploadFixture(32, '.bin', 'cleanup-directory-replacement')
+ const retainedDirectory = `${fixture.directory}-retained`
+ const replacementSentinel = path.join(fixture.directory, 'sentinel.txt')
+ await rename(fixture.directory, retainedDirectory)
+ await mkdir(fixture.directory)
+ await writeFile(replacementSentinel, 'replacement directory sentinel')
try {
await removeDiskUploadFixture(fixture)
- await expect(stat(sentinel)).resolves.toBeDefined()
+ expect((await stat(path.join(retainedDirectory, fixture.fileName))).size).toBe(0)
+ expect((await stat(replacementSentinel)).size).toBe('replacement directory sentinel'.length)
} finally {
- setAfterFixtureQuarantineForTest(undefined)
- await unlink(sentinel)
- await rmdir(fixture.directory)
+ await removeKnownFixtureDirectory(fixture.directory, ['sentinel.txt'])
+ await removeKnownFixtureDirectory(retainedDirectory, [fixture.fileName])
}
})
- 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')
+ it('cannot redirect cleanup by replacing the pathname immediately before disposal', async () => {
+ const fixture = await createDiskUploadFixture(32, '.bin', 'cleanup-last-moment-replacement')
+ const retainedOriginal = `${fixture.filePath}-retained`
+ await rename(fixture.filePath, retainedOriginal)
+ await writeFile(fixture.filePath, 'last moment sentinel')
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)
+ await removeDiskUploadFixture(fixture)
+ expect((await stat(retainedOriginal)).size).toBe(0)
+ expect((await stat(fixture.filePath)).size).toBe('last moment sentinel'.length)
} finally {
- setAfterFixtureQuarantineForTest(undefined)
+ await removeKnownFixtureDirectory(fixture.directory, [
+ fixture.fileName,
+ `${fixture.fileName}-retained`,
+ ])
}
})
- 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)
+ it('does not mutate a symlink replacement target', async () => {
+ const fixture = await createDiskUploadFixture(32, '.bin', 'cleanup-symlink-replacement')
+ const retainedOriginal = `${fixture.filePath}-retained`
+ const targetPath = `${fixture.filePath}-target`
+ await rename(fixture.filePath, retainedOriginal)
+ await writeFile(targetPath, 'symlink target sentinel')
+ await symlink(targetPath, fixture.filePath)
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)
+ await removeDiskUploadFixture(fixture)
+ expect((await stat(retainedOriginal)).size).toBe(0)
+ expect((await stat(targetPath)).size).toBe('symlink target sentinel'.length)
} finally {
- await unlink(fixture.directory)
- await unlink(targetSentinel)
- await rmdir(targetDirectory)
- await removeKnownFixtureDirectory(movedDirectory, fixture.fileName)
+ if (existsSync(fixture.filePath)) await unlink(fixture.filePath)
+ await removeKnownFixtureDirectory(fixture.directory, [
+ `${fixture.fileName}-retained`,
+ `${fixture.fileName}-target`,
+ ])
}
})
- it('makes repeated cleanup of a successfully disposed fixture a no-op', async () => {
- const fixture = await createDiskUploadFixture(1, '.bin', 'cleanup-repeated')
+ it('keeps a large sparse fixture from retaining its logical size after disposal', async () => {
+ const fixture = await createDiskUploadFixture(32 * 1024 * 1024, '.bin', 'cleanup-large-sparse')
fixtures.push(fixture)
- await removeDiskUploadFixture(fixture)
- await expect(removeDiskUploadFixture(fixture)).resolves.toBeUndefined()
- expect(existsSync(fixture.directory)).toBe(false)
- })
+ expect((await stat(fixture.filePath)).size).toBe(32 * 1024 * 1024)
- 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')
- })
+ await removeDiskUploadFixture(fixture)
- 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)
- }
+ expect((await stat(fixture.filePath)).size).toBe(0)
})
it('validates before creating a fixture directory', async () => {
diff --git a/tests/e2e/gfsUploadV2Fixtures.ts b/tests/e2e/gfsUploadV2Fixtures.ts
index 698eee533..6409d17fd 100644
--- a/tests/e2e/gfsUploadV2Fixtures.ts
+++ b/tests/e2e/gfsUploadV2Fixtures.ts
@@ -1,6 +1,6 @@
-import { createHash, randomUUID } from 'node:crypto'
+import { createHash } from 'node:crypto'
import { constants, createReadStream } from 'node:fs'
-import { lstat, mkdtemp, open, readdir, rename, rmdir, truncate, unlink } from 'node:fs/promises'
+import { type FileHandle, mkdtemp, open } from 'node:fs/promises'
import os from 'node:os'
import path from 'node:path'
@@ -22,30 +22,19 @@ export interface DiskUploadFixture {
sha256: string
}
-interface FilesystemIdentity {
- dev: number
- ino: number
-}
-
interface FixtureLease {
- directory: string
- directoryIdentity: FilesystemIdentity
- expectedFileName?: string
- expectedFileIdentity?: FilesystemIdentity
- quarantineDirectory?: string
- state: 'active' | 'quarantined' | 'disposed'
+ handle: FileHandle
+ state: 'active' | 'disposed'
}
-const fixtureLeases = new Map<string, FixtureLease>()
-let afterFixtureQuarantineForTest:
- | ((directory: string, quarantineDirectory: string) => Promise<void> | void)
- | undefined
+const fixtureLeases = new WeakMap<DiskUploadFixture, FixtureLease>()
+let afterFixtureHandleForTest: ((fixture: DiskUploadFixture) => 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
+/** Test-only seam for exercising cleanup after a failure that follows handle acquisition. */
+export function setAfterFixtureHandleForTest(
+ hook: ((fixture: DiskUploadFixture) => Promise<void> | void) | undefined
): void {
- afterFixtureQuarantineForTest = hook
+ afterFixtureHandleForTest = hook
}
/**
@@ -92,43 +81,37 @@ async function createFixture(
label: string
): Promise<DiskUploadFixture> {
const directory = await mkdtemp(path.join(os.tmpdir(), 'evenfire-gfs-upload-v2-'))
- 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
+ let fixture: DiskUploadFixture | undefined
try {
const handle = await open(
filePath,
- constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | constants.O_NOFOLLOW,
+ constants.O_CREAT | constants.O_EXCL | constants.O_RDWR | constants.O_NOFOLLOW,
0o600
)
- lease.expectedFileIdentity = await regularFileIdentity(filePath)
- await handle.close()
- await truncate(filePath, byteLength)
- return {
+ fixture = {
directory,
filePath,
fileName,
byteLength,
- sha256: await sha256File(filePath),
+ sha256: '',
}
+ fixtureLeases.set(fixture, { handle, state: 'active' })
+ await afterFixtureHandleForTest?.(fixture)
+ await handle.truncate(byteLength)
+ fixture.sha256 = await sha256File(filePath)
+ return fixture
} catch (error) {
- try {
- await disposeFixtureLease(lease)
- } catch (cleanupError) {
- throw new AggregateError([error, cleanupError], 'failed to clean partial GFS v2 fixture')
+ if (fixture) {
+ try {
+ await disposeFixtureLease(fixture)
+ } catch (cleanupError) {
+ throw new AggregateError(
+ [error, cleanupError],
+ 'failed to neutralize partial GFS v2 fixture'
+ )
+ }
}
throw error
}
@@ -141,100 +124,29 @@ export async function sha256File(filePath: string): Promise<string> {
}
export async function removeDiskUploadFixture(fixture: DiskUploadFixture): Promise<void> {
- const lease = fixtureLeases.get(fixture.directory)
+ const lease = fixtureLeases.get(fixture)
if (!lease) {
- throw new Error(`refusing to remove an unowned GFS v2 fixture directory: ${fixture.directory}`)
+ throw new Error(`refusing to neutralize an unowned GFS v2 fixture: ${fixture.filePath}`)
}
- await disposeFixtureLease(lease)
+ await disposeFixtureLease(fixture)
}
-async function disposeFixtureLease(lease: FixtureLease): Promise<void> {
+async function disposeFixtureLease(fixture: DiskUploadFixture): Promise<void> {
+ const lease = fixtureLeases.get(fixture)
+ if (!lease) {
+ throw new Error(`refusing to neutralize an unowned GFS v2 fixture: ${fixture.filePath}`)
+ }
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 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)
+ await lease.handle.truncate(0)
+ await lease.handle.close()
+ lease.state = 'disposed'
} 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}`)
+ try {
+ await lease.handle.close()
+ } catch {
+ // Preserve the original failure; this test-only helper has no pathname fallback.
}
- await unlink(filePath)
+ throw error
}
- await rmdir(quarantineDirectory)
- lease.state = 'disposed'
}
diff --git a/tests/e2e/package-lock.json b/tests/e2e/package-lock.json
index 7198158b0..6aa3b2259 100644
--- a/tests/e2e/package-lock.json
+++ b/tests/e2e/package-lock.json
@@ -1,12 +1,12 @@
{
"name": "clerum-e2e-tests",
- "version": "0.1.71",
+ "version": "0.1.72",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "clerum-e2e-tests",
- "version": "0.1.71",
+ "version": "0.1.72",
"devDependencies": {
"@types/jsonwebtoken": "^9.0.10",
"@types/node": "^22.0.0",
diff --git a/tests/e2e/package.json b/tests/e2e/package.json
index 7ede287f0..fa7c77be8 100644
--- a/tests/e2e/package.json
+++ b/tests/e2e/package.json
@@ -1,6 +1,6 @@
{
"name": "clerum-e2e-tests",
- "version": "0.1.71",
+ "version": "0.1.72",
"private": true,
"type": "module",
"scripts": {