Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

4.7 KB
Raw Blame
import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest';
import { mkdtemp, mkdir, writeFile, readFile, rm } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import express from 'express';
import { request } from '../lib/testHelper.js';
import { errorMiddleware } from '../lib/errorHandler.js';
import { acquireBackupSnapshotCut } from '../lib/backupSnapshotBoundary.js';

const fixture = vi.hoisted(() => ({ root: null, beforeDelete: null }));
vi.mock('../lib/fileUtils.js', async importOriginal => {
  const actual = await importOriginal();
  fixture.root = await mkdtemp(join(tmpdir(), 'portos-asset-purge-'));
  return { ...actual, PATHS: { ...actual.PATHS, data: fixture.root,
    images: join(fixture.root, 'images'), uploads: join(fixture.root, 'uploads'),
    cosAttachments: join(fixture.root, 'attachments') },
  rmGuarded: async (...args) => { await fixture.beforeDelete?.(...args); return actual.rmGuarded(...args); },
  unlinkGuarded: async (...args) => { await fixture.beforeDelete?.(...args); return actual.unlinkGuarded(...args); } };
});
const { purgeCategory } = await import('./dataManager.js');
const { default: uploads } = await import('../routes/uploads.js');
const { default: attachments } = await import('../routes/attachments.js');
const app = express();
app.use('/uploads', uploads);
app.use('/attachments', attachments);
app.use(errorMiddleware);
const deferred = () => { let resolve; const promise = new Promise(r => { resolve = r; }); return { promise, resolve }; };

beforeEach(async () => {
  fixture.beforeDelete = null;
  for (const folder of ['images', 'screenshots', 'uploads', 'attachments']) {
    await mkdir(join(fixture.root, folder), { recursive: true });
    await writeFile(join(fixture.root, folder, 'one.txt'), 'first');
    await writeFile(join(fixture.root, folder, 'two.txt'), 'second');
  }
});
afterAll(() => rm(fixture.root, { recursive: true, force: true }));

describe('operator file purges drain before a backup copies files', () => {
  it('drains sibling removals before releasing a failed bulk purge', async () => {
    const entered = deferred();
    const proceed = deferred();
    fixture.beforeDelete = async path => {
      if (path.endsWith('one.txt')) throw new Error('synthetic deletion failure');
      entered.resolve(); await proceed.promise;
    };
    const operation = purgeCategory('screenshots');
    const failed = expect(operation).rejects.toThrow('synthetic deletion failure');
    await entered.promise;
    let acquired = false;
    const cut = acquireBackupSnapshotCut().then(release => { acquired = true; return release; });
    try {
      await new Promise(resolve => setImmediate(resolve));
      expect(acquired, 'failure must not release admission while another removal runs').toBe(false);
    } finally {
      proceed.resolve();
      await failed;
      const release = await cut;
      release();
    }
    expect(await readFile(join(fixture.root, 'screenshots', 'one.txt'), 'utf8')).toBe('first');
    await expect(readFile(join(fixture.root, 'screenshots', 'two.txt'))).rejects.toMatchObject({ code: 'ENOENT' });
  });

  it.each([
    ['category item', 'images', false, () => purgeCategory('images', { subPath: 'one.txt' })],
    ['category bulk', 'screenshots', true, () => purgeCategory('screenshots')],
    ['upload item', 'uploads', false, () => request(app).delete('/uploads/one.txt')],
    ['upload bulk', 'uploads', true, () => request(app).delete('/uploads?confirm=true')],
    ['attachment', 'attachments', false, () => request(app).delete('/attachments/one.txt')],
  ])('%s finishes all removals before the snapshot begins', async (_name, folder, bulk, invoke) => {
    const entered = deferred();
    const proceed = deferred();
    fixture.beforeDelete = async () => { entered.resolve(); await proceed.promise; };
    const operation = Promise.resolve(invoke());
    await entered.promise;
    let acquired = false;
    const cut = acquireBackupSnapshotCut().then(release => { acquired = true; return release; });
    try {
      await new Promise(resolve => setImmediate(resolve));
      expect(acquired, 'a snapshot must wait for the entire admitted deletion').toBe(false);
      expect(await readFile(join(fixture.root, folder, 'one.txt'), 'utf8')).toBe('first');
    } finally {
      proceed.resolve();
      await operation;
      const release = await cut;
      release();
    }
    await expect(readFile(join(fixture.root, folder, 'one.txt'))).rejects.toMatchObject({ code: 'ENOENT' });
    if (bulk) await expect(readFile(join(fixture.root, folder, 'two.txt'))).rejects.toMatchObject({ code: 'ENOENT' });
    else expect(await readFile(join(fixture.root, folder, 'two.txt'), 'utf8')).toBe('second');
  });
});