@amg555/frameforge-mcp 2.7.6 → 2.7.7

package/.agent/skills/gstack-browse/test/cookie-fixture-delete-lease.test.ts

@@ -1,256 +0,0 @@
-import { afterAll, expect, test } from 'bun:test';
-import { chmodSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, rmdirSync, symlinkSync, unlinkSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { spawn, type ChildProcess } from 'node:child_process';
-import { dlopen, FFIType, ptr } from 'bun:ffi';
-import { createFixtureDeleteLease, deleteWithFixtureLease, FixtureDeleteError, type FixtureDeleteBackend } from './fixtures/native-cookie-delete-lease';
-import { nativeCookieEnvironment } from '../src/cookie-import-native-worker';
-
-const root = mkdtempSync(path.join(tmpdir(), 'delete-lease-'));
-afterAll(() => rmSync(root, { recursive: true, force: true }));
-const identity = { dev: 7n, ino: 9007199254740993n, mode: 0o100666n };
-
-function model() {
-  let time = 0;
-  const calls: string[] = [];
-  const backend: FixtureDeleteBackend = {
-    open: () => { calls.push('open'); return 42; },
-    identity: () => { calls.push('identity'); return { ...identity, attributes: 0x80, filesystem: 'NTFS' }; },
-    dispose: () => { calls.push('dispose'); },
-    close: () => { calls.push('close'); },
-    absent: () => { calls.push('absent'); return true; },
-  };
-  const verify = () => { calls.push('verify'); };
-  const clock = { now: () => time, wait: (ms: number) => { calls.push(`wait:${ms}`); time += ms; } };
-  return { backend, calls, verify, clock, advance: (ms: number) => { time += ms; } };
-}
-
-test('an admitted identity is deleted once, closed, and checked for absence in that order', () => {
-  const f = model();
-  expect(deleteWithFixtureLease('owned', identity, 100, f.verify, f.backend, f.clock)).toEqual({ admissionProbes: 1, waitedMs: 0 });
-  expect(f.calls).toEqual(['verify', 'open', 'identity', 'verify', 'dispose', 'close', 'absent']);
-});
-
-test('sharing admission can settle inside the same deadline without retrying deletion', () => {
-  const f = model(); let attempts = 0;
-  f.backend.open = () => { f.calls.push('open'); if (++attempts < 3) throw new FixtureDeleteError('admission', 'owned', 32); return 42; };
-  expect(deleteWithFixtureLease('owned', identity, 100, f.verify, f.backend, f.clock)).toEqual({ admissionProbes: 3, waitedMs: 40 });
-  expect(f.calls.filter(call => call === 'dispose')).toHaveLength(1);
-  expect(f.calls.filter(call => call === 'close')).toHaveLength(1);
-});
-
-test('persistent sharing keeps its first error and performs zero deletes', () => {
-  const f = model(); const first = new FixtureDeleteError('admission', 'owned', 32); let attempts = 0;
-  f.backend.open = () => { attempts++; throw attempts === 1 ? first : new FixtureDeleteError('admission', 'owned', 32); };
-  let failure: unknown;
-  try { deleteWithFixtureLease('owned', identity, 40, f.verify, f.backend, f.clock); } catch (error) { failure = error; }
-  expect(failure).toBe(first);
-  expect(attempts).toBe(2);
-  expect(f.calls).not.toContain('dispose');
-  expect(f.calls).not.toContain('close');
-});
-
-test.each([2, 3, 5, 33, 50, 87])('admission error %s is never polled or deleted', code => {
-  const f = model(); const original = new FixtureDeleteError('admission', 'owned', code);
-  f.backend.open = () => { f.calls.push('open'); throw original; };
-  let failure: unknown;
-  try { deleteWithFixtureLease('owned', identity, 100, f.verify, f.backend, f.clock); } catch (error) { failure = error; }
-  expect(failure).toBe(original);
-  expect(f.calls).toEqual(['verify', 'open']);
-});
-
-test.each(['volume', 'inode', 'ReFS', 'readonly', 'directory', 'reparse', 'ancestor'])(
-  'a rejected %s identity closes its handle without deleting', defect => {
-    const f = model();
-    f.backend.identity = () => ({ ...identity, dev: defect === 'volume' ? 8n : identity.dev,
-      ino: defect === 'inode' ? 9007199254740992n : identity.ino, filesystem: defect === 'ReFS' ? 'ReFS' : 'NTFS',
-      attributes: { readonly: 1, directory: 16, reparse: 1024 }[defect] ?? 0x80 });
-    let checks = 0;
-    const verify = () => { if (++checks === 2 && defect === 'ancestor') throw new Error('Owned ancestor changed'); };
-    expect(() => deleteWithFixtureLease('owned', identity, 100, verify, f.backend, f.clock)).toThrow();
-    expect(f.calls.filter(call => call === 'close')).toHaveLength(1);
-    expect(f.calls).not.toContain('dispose');
-  });
-
-test.each(['before_open', 'after_verify', 'after_identity', 'after_revalidation'])(
-  'expiration %s never grants late deletion', stage => {
-    const f = model(); let checks = 0;
-    if (stage === 'before_open') f.advance(100);
-    const verify = () => { checks++; if (stage === 'after_verify' && checks === 1 || stage === 'after_revalidation' && checks === 2) f.advance(100); };
-    const identify = f.backend.identity;
-    f.backend.identity = (handle, file) => { const result = identify(handle, file); if (stage === 'after_identity') f.advance(100); return result; };
-    expect(() => deleteWithFixtureLease('owned', identity, 100, verify, f.backend, f.clock)).toThrow('deadline');
-    expect(f.calls).not.toContain('dispose');
-    expect(f.calls.filter(call => call === 'close')).toHaveLength(stage.startsWith('before') || stage === 'after_verify' ? 0 : 1);
-  });
-
-test('a disposition failure is not retried and survives close', () => {
-  const f = model(); const original = new FixtureDeleteError('disposition', 'owned', 32);
-  f.backend.dispose = () => { f.calls.push('dispose'); throw original; };
-  let failure: unknown;
-  try { deleteWithFixtureLease('owned', identity, 100, f.verify, f.backend, f.clock); } catch (error) { failure = error; }
-  expect(failure).toBe(original);
-  expect(f.calls.filter(call => call === 'dispose')).toHaveLength(1);
-  expect(f.calls.at(-1)).toBe('close');
-  expect(f.calls.some(call => call.startsWith('wait'))).toBe(false);
-});
-
-test.each(['close', 'absence'])('%s failure never reports completed removal', stage => {
-  const f = model();
-  if (stage === 'close') f.backend.close = () => { throw new FixtureDeleteError('close', 'owned', 6); };
-  else f.backend.absent = () => false;
-  expect(() => deleteWithFixtureLease('owned', identity, 100, f.verify, f.backend, f.clock)).toThrow(stage);
-});
-
-test('the actual Windows binding uses the checked handle, NTFS identity, and Ex flags without a fallback', () => {
-  const source = readFileSync(path.join(import.meta.dir, 'fixtures/native-cookie-delete-lease.ts'), 'utf8');
-  const start = source.indexOf('export function createFixtureDeleteLease(');
-  expect(start).toBeGreaterThan(0);
-  const body = new Bun.Transpiler({ loader: 'ts' }).transformSync(source.slice(start).replace('export function', 'function'));
-  const calls: string[] = [];
-  const api = {
-    CreateFileW(name: Buffer, access: number, share: number, security: unknown, creation: number, flags: number, template: number) {
-      calls.push('open');
-      expect(name.toString('utf16le')).toBe('namespaced-owned\0');
-      expect([access, share, security, creation, flags, template]).toEqual([0x10080, 3, null, 3, 0x00200000, 0]);
-      return 42;
-    },
-    GetLastError() { calls.push('last-error'); return 0; },
-    GetFileInformationByHandle(handle: number, info: Buffer) {
-      calls.push('identity'); expect(handle).toBe(42); expect(info.length).toBe(52);
-      info.writeUInt32LE(0x80, 0); info.writeUInt32LE(Number(identity.dev), 28);
-      info.writeUInt32LE(Number(identity.ino >> 32n), 44); info.writeUInt32LE(Number(identity.ino & 0xffffffffn), 48);
-      return 1;
-    },
-    GetVolumeInformationByHandleW(handle: number, name: unknown, length: number, serial: unknown, component: unknown, flags: unknown, filesystem: Buffer, size: number) {
-      calls.push('filesystem'); expect([handle, name, length, serial, component, flags, size]).toEqual([42, null, 0, null, null, null, 64]);
-      expect(filesystem.length).toBe(128); filesystem.write('NTFS\0', 'utf16le'); return 1;
-    },
-    SetFileInformationByHandle(handle: number, kind: number, flags: Buffer, size: number) {
-      calls.push('dispose'); expect([handle, kind, flags.length, flags.readUInt32LE(0), size]).toEqual([42, 21, 4, 3, 4]); return 1;
-    },
-    CloseHandle(handle: number) { calls.push('close'); expect(handle).toBe(42); return 1; },
-  };
-  const factory = new Function('process', 'dlopen', 'FFIType', 'ptr', 'unlinkSync', 'lstatSync', 'toNamespacedPath',
-    'FixtureDeleteError', 'deleteWithFixtureLease', 'leaseClock', `${body}\nreturn createFixtureDeleteLease;`)(
-    { platform: 'win32' }, (name: string) => { expect(name).toBe('kernel32.dll'); return { symbols: api, close() { calls.push('unload'); } }; },
-    { ptr: 'ptr', u32: 'u32', u64: 'u64', i32: 'i32' }, (value: Buffer) => value,
-    () => { throw new Error('Regular files must not use a path-based fallback'); },
-    () => { calls.push('absence'); throw Object.assign(new Error('Absent'), { code: 'ENOENT' }); },
-    (file: string) => { expect(file).toBe('owned'); return 'namespaced-owned'; },
-    FixtureDeleteError, deleteWithFixtureLease, { now: () => 0, wait: () => { throw new Error('Unexpected wait'); } });
-  const lease = factory(100);
-  lease.unlink('owned', identity, () => { calls.push('verify'); });
-  lease.close();
-  expect(calls).toEqual(['verify', 'open', 'last-error', 'identity', 'filesystem', 'verify', 'dispose', 'close', 'absence', 'unload']);
-});
-
-test.skipIf(process.platform !== 'win32')('the native lease refuses a persistent no-delete-sharing holder', () => {
-  const file = path.join(root, 'persistent'); writeFileSync(file, 'fixture-only');
-  const expected = lstatSync(file, { bigint: true });
-  const kernel = dlopen('kernel32.dll', {
-    CreateFileW: { args: [FFIType.ptr, FFIType.u32, FFIType.u32, FFIType.ptr, FFIType.u32, FFIType.u32, FFIType.u64], returns: FFIType.u64 },
-    CloseHandle: { args: [FFIType.u64], returns: FFIType.i32 },
-  });
-  const name = Buffer.from(file + '\0', 'utf16le');
-  const handle = kernel.symbols.CreateFileW(ptr(name), 0x80000000, 3, null, 3, 0x80, 0);
-  const lease = createFixtureDeleteLease(performance.now() + 1_000);
-  try {
-    expect(BigInt(handle)).not.toBe(0xffffffffffffffffn);
-    expect(BigInt(handle)).not.toBe(0n);
-    let failure: unknown;
-    try { lease.unlink(file, expected, () => {}); } catch (error) { failure = error; }
-    expect(failure).toBeInstanceOf(FixtureDeleteError);
-    expect(failure).toMatchObject({ stage: 'admission', win32Error: 32, code: 'EBUSY' });
-    expect(readFileSync(file, 'utf8')).toBe('fixture-only');
-    expect(lstatSync(file, { bigint: true }).ino).toBe(expected.ino);
-  } finally { lease.close(); if (BigInt(handle) !== 0xffffffffffffffffn && BigInt(handle) !== 0n) kernel.symbols.CloseHandle(handle); kernel.close(); }
-});
-
-test.skipIf(process.platform !== 'win32')('a compatible reader retains its data while the admitted delete removes the namespace', () => {
-  const directory = mkdtempSync(path.join(root, 'reader-'));
-  const file = path.join(directory, 'data'); writeFileSync(file, 'fixture-only');
-  const expected = lstatSync(file, { bigint: true });
-  const kernel = dlopen('kernel32.dll', {
-    CreateFileW: { args: [FFIType.ptr, FFIType.u32, FFIType.u32, FFIType.ptr, FFIType.u32, FFIType.u32, FFIType.u64], returns: FFIType.u64 },
-    ReadFile: { args: [FFIType.u64, FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
-    CloseHandle: { args: [FFIType.u64], returns: FFIType.i32 },
-  });
-  const name = Buffer.from(file + '\0', 'utf16le');
-  const handle = kernel.symbols.CreateFileW(ptr(name), 0x80000000, 7, null, 3, 0x80, 0);
-  const lease = createFixtureDeleteLease(performance.now() + 2_000);
-  try {
-    expect(BigInt(handle)).not.toBe(0xffffffffffffffffn);
-    expect(BigInt(handle)).not.toBe(0n);
-    let checks = 0;
-    lease.unlink(file, expected, () => { if (++checks === 2) expect(() => renameSync(file, path.join(directory, 'moved'))).toThrow(); });
-    expect(checks).toBe(2);
-    expect(existsSync(file)).toBe(false);
-    rmdirSync(directory);
-    const buffer = Buffer.alloc(32), bytes = Buffer.alloc(4);
-    expect(kernel.symbols.ReadFile(handle, ptr(buffer), buffer.length, ptr(bytes), null)).toBe(1);
-    expect(buffer.subarray(0, bytes.readUInt32LE()).toString()).toBe('fixture-only');
-  } finally { lease.close(); if (BigInt(handle) !== 0xffffffffffffffffn && BigInt(handle) !== 0n) kernel.symbols.CloseHandle(handle); kernel.close(); }
-});
-
-test.skipIf(process.platform !== 'win32')('an independently released holder admits one identity-bound deletion', async () => {
-  const directory = mkdtempSync(path.join(root, 'released-'));
-  const file = path.join(directory, 'held'), ready = path.join(directory, 'ready'), release = path.join(directory, 'release');
-  writeFileSync(file, 'fixture-only'); const expected = lstatSync(file, { bigint: true });
-  const script = `
-    const { dlopen, FFIType, ptr } = await import('bun:ffi');
-    const { existsSync, writeFileSync } = await import('node:fs');
-    const api = dlopen('kernel32.dll', {
-      CreateFileW: { args: [FFIType.ptr, FFIType.u32, FFIType.u32, FFIType.ptr, FFIType.u32, FFIType.u32, FFIType.u64], returns: FFIType.u64 },
-      CloseHandle: { args: [FFIType.u64], returns: FFIType.i32 },
-    });
-    const name = Buffer.from(${JSON.stringify(file)} + '\\0', 'utf16le');
-    const handle = api.symbols.CreateFileW(ptr(name), 0x80000000, 3, null, 3, 0x80, 0);
-    if (BigInt(handle) === 0xffffffffffffffffn || BigInt(handle) === 0n) throw new Error('Holder open failed');
-    try {
-      writeFileSync(${JSON.stringify(ready)}, 'ready');
-      while (!existsSync(${JSON.stringify(release)})) await Bun.sleep(10);
-    } finally { if (!api.symbols.CloseHandle(handle)) throw new Error('Holder close failed'); api.close(); }
-  `;
-  const child: ChildProcess = spawn(process.execPath, ['--no-env-file', '--no-install', '--config=NUL', '-e', script],
-    { env: nativeCookieEnvironment(process.env), stdio: 'ignore', windowsHide: true });
-  let spawnError: Error | undefined;
-  child.once('error', error => { spawnError = error; });
-  const closed = new Promise<void>(resolve => child.once('close', () => resolve()));
-  const timer = setTimeout(() => child.kill(), 5_000);
-  let lease: ReturnType<typeof createFixtureDeleteLease> | undefined;
-  try {
-    const deadline = performance.now() + 3_000;
-    while (!existsSync(ready) && child.exitCode === null && !spawnError && performance.now() < deadline) await Bun.sleep(10);
-    expect(spawnError).toBeUndefined();
-    expect(existsSync(ready)).toBe(true);
-    let blocked = 0;
-    lease = createFixtureDeleteLease(performance.now() + 2_000, () => { blocked++; writeFileSync(release, 'release'); });
-    lease.unlink(file, expected, () => {});
-    expect(blocked).toBe(1);
-    expect(existsSync(file)).toBe(false);
-    await closed;
-    expect(child.exitCode).toBe(0);
-  } finally { clearTimeout(timer); lease?.close(); child.kill(); await closed; }
-}, 10_000);
-
-test.skipIf(process.platform !== 'win32').each(['identity', 'readonly', 'reparse'])(
-  'the native lease refuses %s without removing the file or target', defect => {
-    const directory = mkdtempSync(path.join(root, 'refused-'));
-    const file = path.join(directory, 'data'); writeFileSync(file, 'fixture-only');
-    const expected = lstatSync(file, { bigint: true });
-    const destination = path.join(directory, 'destination');
-    if (defect === 'readonly') chmodSync(file, 0o444);
-    if (defect === 'reparse') {
-      unlinkSync(file); mkdirSync(destination); writeFileSync(path.join(destination, 'preserved'), 'fixture-only');
-      symlinkSync(destination, file, 'junction');
-    }
-    const lease = createFixtureDeleteLease(performance.now() + 2_000);
-    try {
-      expect(() => lease.unlink(file, defect === 'identity' ? { ...expected, ino: expected.ino + 1n } : expected, () => {})).toThrow();
-      expect(existsSync(file)).toBe(true);
-      if (defect === 'reparse') expect(readFileSync(path.join(destination, 'preserved'), 'utf8')).toBe('fixture-only');
-      else expect(readFileSync(file, 'utf8')).toBe('fixture-only');
-    } finally { lease.close(); if (defect === 'readonly') chmodSync(file, 0o666); }
-  });