Skip to content

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

TypeScript

test(mcp-host): pin the GFS store kill tests from the adversarial review

Alfredo Lopez0ce07ef23572
diff --git a/mcp-host/package-lock.json b/mcp-host/package-lock.json
index 602049fe8..82d43ce64 100644
--- a/mcp-host/package-lock.json
+++ b/mcp-host/package-lock.json
@@ -1,12 +1,12 @@
{
"name": "clerum-mcp-host",
- "version": "0.1.532",
+ "version": "0.1.533",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "clerum-mcp-host",
- "version": "0.1.532",
+ "version": "0.1.533",
"license": "SEE LICENSE IN LICENSE",
"dependencies": {
"@anthropic-ai/sdk": "^0.32.0",
diff --git a/mcp-host/package.json b/mcp-host/package.json
index c4893bae3..0926ea7cf 100644
--- a/mcp-host/package.json
+++ b/mcp-host/package.json
@@ -1,6 +1,6 @@
{
"name": "clerum-mcp-host",
- "version": "0.1.532",
+ "version": "0.1.533",
"description": "MCP Host - reads Host CRD and provides LLM access via OpenAI/Claude",
"main": "dist/main.js",
"engines": {
diff --git a/mcp-host/src/internalTools/gfsDownloadMetrics.test.ts b/mcp-host/src/internalTools/gfsDownloadMetrics.test.ts
index c6ccb539b..001661a73 100644
--- a/mcp-host/src/internalTools/gfsDownloadMetrics.test.ts
+++ b/mcp-host/src/internalTools/gfsDownloadMetrics.test.ts
@@ -10,21 +10,18 @@ import {
recordGfsShellOutputLimit,
} from './gfsDownloadMetrics'
-async function counterValue(name: string): Promise<number> {
+/** Sum of the samples of `name` whose labels include every `labels` pair. */
+async function counterValue(name: string, labels: Record<string, string> = {}): Promise<number> {
const metric = register.getSingleMetric(name)
if (metric === undefined) throw new Error(`metric ${name} is not registered`)
const { values } = await metric.get()
- return values.reduce((sum, sample) => sum + sample.value, 0)
+ return values
+ .filter(sample => Object.entries(labels).every(([key, value]) => sample.labels[key] === value))
+ .reduce((sum, sample) => sum + sample.value, 0)
}
async function expiryValue(outcome: string): Promise<number> {
- const metric = register.getSingleMetric('clerum_gfs_download_expiry_total')
- if (metric === undefined)
- throw new Error('metric clerum_gfs_download_expiry_total is not registered')
- const { values } = await metric.get()
- return values
- .filter(sample => sample.labels.outcome === outcome)
- .reduce((sum, sample) => sum + sample.value, 0)
+ return counterValue('clerum_gfs_download_expiry_total', { outcome })
}
describe('GFS download metrics', () => {
@@ -40,14 +37,30 @@ describe('GFS download metrics', () => {
})
it('records admission, transfer, active count, and shell-limit outcomes', async () => {
+ const series = [
+ ['clerum_gfs_download_admissions_total', { outcome: 'workspace_attempt' }],
+ ['clerum_gfs_download_transfers_total', { outcome: 'success' }],
+ ['clerum_gfs_shell_output_limits_total', { outcome: 'output_limit_exceeded' }],
+ ['clerum_gfs_download_quota_total', { scope: 'caller', reason: 'storage_bytes' }],
+ ['clerum_gfs_download_expiry_total', { outcome: 'remove_failed' }],
+ ] as const
+ const before = await Promise.all(series.map(([name, labels]) => counterValue(name, labels)))
+ const active = await counterValue('clerum_gfs_download_active')
+
recordGfsDownloadAdmission('workspace_attempt')
enterGfsDownloadTransfer()
+ expect(await counterValue('clerum_gfs_download_active')).toBe(active + 1)
recordGfsDownloadTransfer('success', 0.25)
exitGfsDownloadTransfer()
recordGfsShellOutputLimit('output_limit_exceeded')
recordGfsDownloadQuota('caller', 'storage_bytes')
recordGfsDownloadExpiry('remove_failed')
+ // Each call moved its own series by exactly one.
+ for (const [index, [name, labels]] of series.entries())
+ expect(await counterValue(name, labels)).toBe(before[index]! + 1)
+ expect(await counterValue('clerum_gfs_download_active')).toBe(active)
+
const scraped = await register.metrics()
expect(scraped).toContain('clerum_gfs_download_admissions_total{outcome="workspace_attempt"}')
expect(scraped).toContain('clerum_gfs_download_transfers_total{outcome="success"}')
diff --git a/mcp-host/src/internalTools/gfsDownloadStore.test.ts b/mcp-host/src/internalTools/gfsDownloadStore.test.ts
index 6603312af..6c1ea78b3 100644
--- a/mcp-host/src/internalTools/gfsDownloadStore.test.ts
+++ b/mcp-host/src/internalTools/gfsDownloadStore.test.ts
@@ -985,3 +985,149 @@ describe('GFS download store: pins, lifecycle and errors', () => {
await expect(openStore(real)).resolves.toBeInstanceOf(GfsDownloadStore)
})
})
+
+// Kill tests for mutations the adversarial review of PR #1028 found surviving
+// (S08, S10, S11, S12, S13, S22, S24), adapted from its verified repros.
+describe('GFS download store: adversarial review kill tests', () => {
+ it('ADV-S08: an infeasible eviction plan deletes nothing even when some copies are evictable', async () => {
+ const { limited } = await limitedStore(HOST_30_CALLER_15)
+ const loose = await completedCopy(limited, callerRoot, CALLER, 70, 5)
+ tick()
+ await completedCopy(limited, callerRoot, CALLER, 71, 8, { owner: 'task-1' })
+ const denied = await quotaCount('caller', 'storage_bytes')
+ await expect(startTransfer(limited, callerRoot, CALLER, 72, 10)).rejects.toMatchObject({
+ code: 'caller_quota_exceeded',
+ })
+ // Witness: the admission reached the quota decision.
+ expect(await quotaCount('caller', 'storage_bytes')).toBe(denied + 1)
+ // The unpinned copy could not make room on its own, so it must survive.
+ expect(await exists(downloadDirectory(callerRoot, loose.receipt.id))).toBe(true)
+ // Witness: once the pin is released the same admission evicts and succeeds.
+ await limited.releaseReceiptOwner('task-1', CALLER)
+ await expect(startTransfer(limited, callerRoot, CALLER, 72, 10)).resolves.toBeDefined()
+ })
+
+ it('ADV-S11: publish refuses a digest that does not match the partial bytes', async () => {
+ const { transfer } = await startTransfer(store, callerRoot, CALLER, 73, 8)
+ hashBoundary.mockClear()
+ await expect(
+ store.publish(transfer.id, CALLER, digest(Buffer.alloc(8, 0xee)))
+ ).rejects.toMatchObject({ code: 'storage_write_failed' })
+ // Witness: publication hashed the partial file.
+ expect(hashBoundary).toHaveBeenCalled()
+ const directory = downloadDirectory(callerRoot, transfer.id)
+ expect(await exists(path.join(directory, 'source'))).toBe(false)
+ expect(await exists(path.join(directory, 'meta.json'))).toBe(false)
+ await store.fail(transfer.id, CALLER)
+ expect(await exists(directory)).toBe(false)
+ })
+
+ it('ADV-S13: publish refuses a partial file larger than the admitted size', async () => {
+ const transfer = await store.createTransfer({
+ callerIdentity: CALLER,
+ callerWorkspacePath: callerRoot,
+ source: sourceFor(74),
+ sizeBytes: 5,
+ expiresAt: future(),
+ })
+ const bigger = Buffer.alloc(9, 4)
+ await nativeFs.writeFile(path.join(callerRoot, transfer.partialPath), bigger)
+ await expect(store.publish(transfer.id, CALLER, digest(bigger))).rejects.toMatchObject({
+ code: 'download_missing',
+ })
+ // Witness: the oversized partial is the one that was offered.
+ expect((await nativeFs.stat(path.join(callerRoot, transfer.partialPath))).size).toBe(9)
+ expect(await exists(path.join(downloadDirectory(callerRoot, transfer.id), 'source'))).toBe(
+ false
+ )
+ })
+
+ it('ADV-S24: publish refuses a transfer whose expiry passed during the download', async () => {
+ const bytes = Buffer.alloc(6, 7)
+ const transfer = await store.createTransfer({
+ callerIdentity: CALLER,
+ callerWorkspacePath: callerRoot,
+ source: sourceFor(75),
+ sizeBytes: 6,
+ expiresAt: future(1_000),
+ })
+ await nativeFs.writeFile(path.join(callerRoot, transfer.partialPath), bytes)
+ vi.setSystemTime(Date.now() + 1_000)
+ await expect(store.publish(transfer.id, CALLER, digest(bytes))).rejects.toMatchObject({
+ code: 'download_expired',
+ })
+ // Witness: the transfer is still active, so fail() is accepted and cleans it up.
+ await expect(store.fail(transfer.id, CALLER)).resolves.toBeUndefined()
+ expect(await exists(downloadDirectory(callerRoot, transfer.id))).toBe(false)
+ })
+
+ it('ADV-S22: a caller root that is an alias of another caller directory is refused', async () => {
+ const otherRoot = await callerDirectory(hostRoot, 'caller-b')
+ const alias = path.join(hostRoot, 'users', 'alias')
+ await nativeFs.symlink(otherRoot, alias)
+ await expect(
+ store.createTransfer({
+ callerIdentity: 'alias',
+ callerWorkspacePath: alias,
+ source: sourceFor(76),
+ sizeBytes: 3,
+ expiresAt: future(),
+ })
+ ).rejects.toMatchObject({ code: 'workspace_unavailable' })
+ expect(await exists(path.join(otherRoot, '.gfs-downloads'))).toBe(false)
+ // Witness: the real directory is accepted.
+ await expect(
+ store.createTransfer({
+ callerIdentity: 'caller-b',
+ callerWorkspacePath: otherRoot,
+ source: sourceFor(76),
+ sizeBytes: 3,
+ expiresAt: future(),
+ })
+ ).resolves.toMatchObject({ sizeBytes: 3 })
+ })
+
+ it('ADV-S10: a source.partial swapped after meta.json is renamed is not published', async () => {
+ const { transfer, bytes } = await startTransfer(store, callerRoot, CALLER, 77, 8)
+ const partial = path.join(callerRoot, transfer.partialPath)
+ let swapped = false
+ renameBoundary.mockImplementation(async (from: string, to: string) => {
+ await nativeFs.rename(from, to)
+ if (to.endsWith(path.sep + 'meta.json') && !swapped) {
+ swapped = true
+ await nativeFs.writeFile(partial + '.swap', Buffer.alloc(8, 0x55), { mode: 0o600 })
+ await nativeFs.rename(partial + '.swap', partial)
+ }
+ })
+ await expect(store.publish(transfer.id, CALLER, digest(bytes))).rejects.toMatchObject({
+ code: 'storage_write_failed',
+ })
+ // Witness: the swap happened inside the publication.
+ expect(swapped).toBe(true)
+ await expect(store.readManagedFile(transfer.path, CALLER)).rejects.toMatchObject({
+ code: 'download_missing',
+ })
+ })
+
+ it('ADV-S12: a source.partial swapped after hashing is refused before meta.json is written', async () => {
+ const { transfer, bytes } = await startTransfer(store, callerRoot, CALLER, 78, 8)
+ let swapped = false
+ lstatBoundary.mockImplementation(async (target: string, options?: unknown) => {
+ // The store addresses the partial through the real path of the Host root.
+ const partial = target
+ if (target.endsWith(path.sep + 'source.partial') && options === undefined && !swapped) {
+ swapped = true
+ await nativeFs.writeFile(partial + '.swap', Buffer.alloc(8, 0x66), { mode: 0o600 })
+ await nativeFs.rename(partial + '.swap', partial)
+ }
+ return nativeFs.lstat(target, options as never)
+ })
+ await expect(store.publish(transfer.id, CALLER, digest(bytes))).rejects.toMatchObject({
+ code: 'download_missing',
+ })
+ expect(swapped).toBe(true)
+ expect(await exists(path.join(downloadDirectory(callerRoot, transfer.id), 'meta.json'))).toBe(
+ false
+ )
+ })
+})
diff --git a/mcp-host/src/internalTools/gfsDownloadStoreBoundaries.test.ts b/mcp-host/src/internalTools/gfsDownloadStoreBoundaries.test.ts
index 6db11e0a8..5e3d5ec30 100644
--- a/mcp-host/src/internalTools/gfsDownloadStoreBoundaries.test.ts
+++ b/mcp-host/src/internalTools/gfsDownloadStoreBoundaries.test.ts
@@ -6,7 +6,6 @@
* value that is refused, on a real temporary directory.
*/
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import * as crypto from 'node:crypto'
import { randomUUID } from 'node:crypto'
import * as syncFs from 'node:fs'
import * as fs from 'node:fs/promises'
diff --git a/mcp-host/src/internalTools/gfsDownloadStoreRestart.test.ts b/mcp-host/src/internalTools/gfsDownloadStoreRestart.test.ts
index d226af9a5..cf1b9cbba 100644
--- a/mcp-host/src/internalTools/gfsDownloadStoreRestart.test.ts
+++ b/mcp-host/src/internalTools/gfsDownloadStoreRestart.test.ts
@@ -361,3 +361,55 @@ describe('GFS download store restart', () => {
expect(await second.debugInventory()).toMatchObject({ bytes: 128, files: 2 })
})
})
+
+describe('GFS download store restart: retirement edge cases', () => {
+ it('S14: only `.gfs-download-store.retired-<uuid>` names are removed', async () => {
+ const foreign = path.join(hostRoot, `${RETIRED_PREFIX}foo`)
+ const retired = path.join(hostRoot, `${RETIRED_PREFIX}00000000-0000-4000-8000-000000000001`)
+ for (const directory of [foreign, retired]) {
+ await fs.mkdir(directory, { mode: 0o700 })
+ await fs.writeFile(path.join(directory, 'copy'), 'bytes', { mode: 0o600 })
+ }
+
+ await open()
+
+ // Witness: a uuid-named retired tree is removed by the same sweep.
+ expect(exists(retired)).toBe(false)
+ expect(exists(path.join(foreign, 'copy'))).toBe(true)
+ })
+
+ it.each([
+ ['a file', 'file'],
+ ['a symlink', 'symlink'],
+ ] as const)(
+ 'S15: a `.gfs-download-store` that is %s is retired without following it',
+ async (_label, kind) => {
+ const legacy = path.join(hostRoot, '.gfs-download-store')
+ const outside = await fs.mkdtemp(path.join(tmpdir(), 'gfs-store-legacy-target-'))
+ const target = path.join(outside, 'target')
+ try {
+ await fs.writeFile(target, 'outside bytes', { mode: 0o600 })
+ if (kind === 'file') await fs.writeFile(legacy, 'legacy bytes', { mode: 0o600 })
+ else await fs.symlink(target, legacy)
+ const warn = vi.spyOn(logger, 'warn')
+ const retiredBefore = await expiryCount('retired_legacy_store')
+
+ const store = await open()
+
+ expect(store.isAvailable()).toBe(true)
+ expect(retirementWarnings(warn)).toEqual([
+ expect.objectContaining({ files: kind === 'file' ? 1 : 0 }),
+ ])
+ expect(await expiryCount('retired_legacy_store')).toBe(retiredBefore + 1)
+ expect(exists(legacy)).toBe(false)
+ expect((await hostRootEntries()).filter(name => name.startsWith(RETIRED_PREFIX))).toEqual(
+ []
+ )
+ // The symlink's target is never followed.
+ await expect(fs.readFile(target, 'utf8')).resolves.toBe('outside bytes')
+ } finally {
+ await fs.rm(outside, { recursive: true, force: true })
+ }
+ }
+ )
+})
diff --git a/mcp-host/src/internalTools/gfsStorePrivateFiles.test.ts b/mcp-host/src/internalTools/gfsStorePrivateFiles.test.ts
new file mode 100644
index 000000000..061f06eeb
--- /dev/null
+++ b/mcp-host/src/internalTools/gfsStorePrivateFiles.test.ts
@@ -0,0 +1,83 @@
+/**
+ * The private-object opener of the GFS download store: it never follows a
+ * symlink, and it refuses an opened inode whose name moved to another inode
+ * before the check finished.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import * as syncFs from 'node:fs'
+import type * as fs from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import * as path from 'node:path'
+import {
+ PrivateStoreNameMovedError,
+ PrivateStoreUntrustedError,
+ openPrivateStoreObject,
+} from './gfsStorePrivateFiles'
+
+const { beforeLstat } = vi.hoisted(() => ({
+ beforeLstat: { hook: undefined as ((target: string) => void) | undefined },
+}))
+// Pass-through lstat; a test can act on the name right before the opener's
+// name check, the window an atomic rename over the name would use.
+vi.mock('node:fs/promises', async original => {
+ const actual = await original<typeof fs>()
+ return {
+ ...actual,
+ lstat: ((target: syncFs.PathLike, ...rest: never[]) => {
+ beforeLstat.hook?.(String(target))
+ return (actual.lstat as (...args: unknown[]) => Promise<unknown>)(target, ...rest)
+ }) as typeof actual.lstat,
+ }
+})
+
+let root: string
+
+beforeEach(() => {
+ beforeLstat.hook = undefined
+ root = syncFs.mkdtempSync(path.join(tmpdir(), 'gfs-private-files-'))
+})
+
+afterEach(() => {
+ beforeLstat.hook = undefined
+ syncFs.rmSync(root, { recursive: true, force: true })
+})
+
+function privateFile(name: string, content: string): string {
+ const target = path.join(root, name)
+ syncFs.writeFileSync(target, content, { mode: 0o600 })
+ return target
+}
+
+describe('openPrivateStoreObject', () => {
+ it('S02: refuses a symlink at the open itself, with ELOOP', async () => {
+ const target = privateFile('target', 'private bytes')
+ const link = path.join(root, 'link')
+ syncFs.symlinkSync(target, link)
+ // Witness: the private file it points at is opened.
+ const handle = await openPrivateStoreObject(target, 'file')
+ await handle.close()
+
+ await expect(openPrivateStoreObject(link, 'file')).rejects.toMatchObject({ code: 'ELOOP' })
+ })
+
+ it('S03: refuses an opened inode whose name moved to another inode', async () => {
+ const target = privateFile('source', 'published bytes')
+ const replacement = privateFile('replacement', 'other bytes')
+ let swapped = false
+ beforeLstat.hook = name => {
+ if (name !== target || swapped) return
+ swapped = true
+ syncFs.renameSync(replacement, target)
+ }
+
+ const refusal = await openPrivateStoreObject(target, 'file').catch(error => error)
+
+ expect(swapped).toBe(true)
+ expect(refusal).toBeInstanceOf(PrivateStoreNameMovedError)
+ expect(refusal).toBeInstanceOf(PrivateStoreUntrustedError)
+ // Witness: without the swap the same name opens.
+ beforeLstat.hook = undefined
+ const handle = await openPrivateStoreObject(target, 'file')
+ await handle.close()
+ })
+})
diff --git a/scripts/ci/pinned-vitest-cases/mcp-host.json b/scripts/ci/pinned-vitest-cases/mcp-host.json
index cef64ec25..ef3dd2d64 100644
--- a/scripts/ci/pinned-vitest-cases/mcp-host.json
+++ b/scripts/ci/pinned-vitest-cases/mcp-host.json
@@ -606,5 +606,153 @@
{
"suite": "gfsDownloadStoreBoundaries.test.ts",
"fullName": "GFS download store boundaries: path swapped between check and use K2b: a caller directory swapped between the meta.json rename and the source rename publishes nothing"
+ },
+ {
+ "suite": "gfsDownloadStore.test.ts",
+ "fullName": "GFS download store: adversarial review kill tests ADV-S08: an infeasible eviction plan deletes nothing even when some copies are evictable"
+ },
+ {
+ "suite": "gfsDownloadStore.test.ts",
+ "fullName": "GFS download store: adversarial review kill tests ADV-S11: publish refuses a digest that does not match the partial bytes"
+ },
+ {
+ "suite": "gfsDownloadStore.test.ts",
+ "fullName": "GFS download store: adversarial review kill tests ADV-S13: publish refuses a partial file larger than the admitted size"
+ },
+ {
+ "suite": "gfsDownloadStore.test.ts",
+ "fullName": "GFS download store: adversarial review kill tests ADV-S24: publish refuses a transfer whose expiry passed during the download"
+ },
+ {
+ "suite": "gfsDownloadStore.test.ts",
+ "fullName": "GFS download store: adversarial review kill tests ADV-S22: a caller root that is an alias of another caller directory is refused"
+ },
+ {
+ "suite": "gfsDownloadStore.test.ts",
+ "fullName": "GFS download store: adversarial review kill tests ADV-S10: a source.partial swapped after meta.json is renamed is not published"
+ },
+ {
+ "suite": "gfsDownloadStore.test.ts",
+ "fullName": "GFS download store: adversarial review kill tests ADV-S12: a source.partial swapped after hashing is refused before meta.json is written"
+ },
+ {
+ "suite": "gfsDownloadStoreAdversarial.test.ts",
+ "fullName": "GFS download store adversarial round: caller identity (ADV-1) two channels with the same sender never see each other’s copy"
+ },
+ {
+ "suite": "gfsDownloadStoreAdversarial.test.ts",
+ "fullName": "GFS download store adversarial round: caller identity (ADV-1) refuses an identity that is not the caller root’s key"
+ },
+ {
+ "suite": "gfsDownloadStoreAdversarial.test.ts",
+ "fullName": "GFS download store adversarial round: caller root shape (F9) refuses the Host root as a caller root"
+ },
+ {
+ "suite": "gfsDownloadStoreAdversarial.test.ts",
+ "fullName": "GFS download store adversarial round: caller root shape (F9) refuses the users directory as a caller root"
+ },
+ {
+ "suite": "gfsDownloadStoreAdversarial.test.ts",
+ "fullName": "GFS download store adversarial round: caller root shape (F9) refuses a directory inside a caller root as a caller root"
+ },
+ {
+ "suite": "gfsDownloadStoreAdversarial.test.ts",
+ "fullName": "GFS download store adversarial round: caller root shape (F9) refuses a directory outside users as a caller root"
+ },
+ {
+ "suite": "gfsDownloadStoreAdversarial.test.ts",
+ "fullName": "GFS download store adversarial round: transient I/O is not corruption (F1/ADV-3) reuse that cannot open a pinned copy keeps it for the task that holds it"
+ },
+ {
+ "suite": "gfsDownloadStoreAdversarial.test.ts",
+ "fullName": "GFS download store adversarial round: transient I/O is not corruption (F1/ADV-3) reuse still removes a copy whose bytes no longer match its receipt"
+ },
+ {
+ "suite": "gfsDownloadStoreAdversarial.test.ts",
+ "fullName": "GFS download store adversarial round: transient I/O is not corruption (F1/ADV-3) a sweep that cannot lstat a published copy keeps it and counts sweep_failed"
+ },
+ {
+ "suite": "gfsDownloadStoreAdversarial.test.ts",
+ "fullName": "GFS download store adversarial round: transient I/O is not corruption (F1/ADV-3) a startup sweep that cannot open meta.json keeps the copy for the next start"
+ },
+ {
+ "suite": "gfsDownloadStoreAdversarial.test.ts",
+ "fullName": "GFS download store adversarial round: transient I/O is not corruption (F1/ADV-3) an admission that cannot verify .gfs-downloads fails and keeps every copy"
+ },
+ {
+ "suite": "gfsDownloadStoreAdversarial.test.ts",
+ "fullName": "GFS download store adversarial round: transient I/O is not corruption (F1/ADV-3) readManagedFile logs a non-ENOENT failure of the owner’s copy and still answers download_missing"
+ },
+ {
+ "suite": "gfsDownloadStoreAdversarial.test.ts",
+ "fullName": "GFS download store adversarial round: transient I/O is not corruption (F1/ADV-3) readManagedFilePrefix logs a non-ENOENT failure of the owner’s copy and still answers download_missing"
+ },
+ {
+ "suite": "gfsDownloadStoreAdversarial.test.ts",
+ "fullName": "GFS download store adversarial round: trash, eviction and undo (ADV-2/F2/F3/F8) a replaced .gfs-downloads stranded by a failed rm is protected and swept"
+ },
+ {
+ "suite": "gfsDownloadStoreAdversarial.test.ts",
+ "fullName": "GFS download store adversarial round: trash, eviction and undo (ADV-2/F2/F3/F8) an eviction whose removal fails keeps the copy published and charged"
+ },
+ {
+ "suite": "gfsDownloadStoreAdversarial.test.ts",
+ "fullName": "GFS download store adversarial round: trash, eviction and undo (ADV-2/F2/F3/F8) a refused removal whose undo also fails reports the refusal, not the undo"
+ },
+ {
+ "suite": "gfsDownloadStoreAdversarial.test.ts",
+ "fullName": "GFS download store adversarial round: trash, eviction and undo (ADV-2/F2/F3/F8) a removal of a directory that never existed is not counted as removed"
+ },
+ {
+ "suite": "gfsDownloadStoreAdversarial.test.ts",
+ "fullName": "GFS download store adversarial round: expiry, close, recency and removal proof S17: createTransfer refuses an expiry at or before its creation instant"
+ },
+ {
+ "suite": "gfsDownloadStoreAdversarial.test.ts",
+ "fullName": "GFS download store adversarial round: expiry, close, recency and removal proof S18: close() does not wait for pinned copies, only for active transfers"
+ },
+ {
+ "suite": "gfsDownloadStoreAdversarial.test.ts",
+ "fullName": "GFS download store adversarial round: expiry, close, recency and removal proof S28: a managed read refreshes recency, so the unread copy is evicted first"
+ },
+ {
+ "suite": "gfsDownloadStoreAdversarial.test.ts",
+ "fullName": "GFS download store adversarial round: expiry, close, recency and removal proof S31: a removal is proven by ENOENT, not by rm returning"
+ },
+ {
+ "suite": "gfsDownloadStoreAdversarial.test.ts",
+ "fullName": "GFS download store adversarial round: expiry, close, recency and removal proof S01: a descriptor with the published inode number on another device is not served"
+ },
+ {
+ "suite": "gfsDownloadStoreAdversarial.test.ts",
+ "fullName": "GFS download store adversarial round: expiry, close, recency and removal proof S09: publication syncs the download directory after the source rename"
+ },
+ {
+ "suite": "gfsDownloadStoreRestart.test.ts",
+ "fullName": "GFS download store restart: retirement edge cases S14: only `.gfs-download-store.retired-<uuid>` names are removed"
+ },
+ {
+ "suite": "gfsDownloadStoreRestart.test.ts",
+ "fullName": "GFS download store restart: retirement edge cases S15: a `.gfs-download-store` that is a file is retired without following it"
+ },
+ {
+ "suite": "gfsDownloadStoreRestart.test.ts",
+ "fullName": "GFS download store restart: retirement edge cases S15: a `.gfs-download-store` that is a symlink is retired without following it"
+ },
+ {
+ "suite": "gfsStorePrivateFiles.test.ts",
+ "fullName": "openPrivateStoreObject S02: refuses a symlink at the open itself, with ELOOP"
+ },
+ {
+ "suite": "gfsStorePrivateFiles.test.ts",
+ "fullName": "openPrivateStoreObject S03: refuses an opened inode whose name moved to another inode"
+ },
+ {
+ "suite": "gfsExecutionCapability.test.ts",
+ "fullName": "gfsStoreCallerIdentity keys the store by the channel-namespaced caller-root key, never the raw sender"
+ },
+ {
+ "suite": "gfsExecutionCapability.test.ts",
+ "fullName": "gfsStoreCallerIdentity gives a task without a source message the system key of its caller root"
}
]