@1agh/maude 0.60.2 → 0.60.4

package/apps/studio/test/sync-asset-push.test.ts

@@ -6,17 +6,22 @@
 // credential is read at call time; a failure is reported, never thrown.
 
 import { describe, expect, test } from 'bun:test';
-import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
+import { mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
-import { listPushableAssets, pushAssets, putTimeoutMs } from '../sync/asset-push.ts';
+import {
+  isPushableAssetRel,
+  listPushableAssets,
+  pushAssets,
+  putTimeoutMs,
+} from '../sync/asset-push.ts';
 
 function scratchDesignRoot(): string {
   return mkdtempSync(join(tmpdir(), 'asset-push-'));
 }
 
-describe('listPushableAssets — every assets/ dir, asset extensions only', () => {
+describe('listPushableAssets — classifier membership over the whole design root', () => {
   test('finds top-level content-addressed AND nested DS/brand assets', () => {
     const designRoot = scratchDesignRoot();
     // Class 1 — top-level content-addressed uploads (+ a .photo.json sidecar).
@@ -62,6 +67,51 @@ describe('listPushableAssets — every assets/ dir, asset extensions only', () =
     writeFileSync(join(designRoot, 'assets/a/b/c/d/e/f/g/x.png'), 'x');
     expect(listPushableAssets(designRoot)).toEqual([]);
   });
+
+  test('the file-plane widening: the RCA miss-list goes up, canvas lanes stay home', () => {
+    // feature-sync-file-plane — the sweep now carries what the fresh-link RCA
+    // named laneless: token stylesheets, docs, shared modules, underscore
+    // FILES. A canvas body and its named sidecars stay the CRDT lanes'.
+    const designRoot = scratchDesignRoot();
+    mkdirSync(join(designRoot, 'system/ds/preview'), { recursive: true });
+    writeFileSync(join(designRoot, 'config.json'), '{}');
+    writeFileSync(join(designRoot, 'system/ds/brand.css'), 'x');
+    writeFileSync(join(designRoot, 'system/ds/README.md'), 'x');
+    writeFileSync(join(designRoot, 'system/ds/preview/_brand-css.ts'), 'x');
+    writeFileSync(join(designRoot, 'system/ds/preview/_layout.css'), 'x');
+    writeFileSync(join(designRoot, 'system/ds/preview/specimen.tsx'), 'x');
+    writeFileSync(join(designRoot, 'system/ds/preview/specimen.css'), 'x'); // sibling css lane
+    writeFileSync(join(designRoot, 'system/ds/preview/specimen.meta.json'), '{}');
+    expect(listPushableAssets(designRoot, { syncFiles: true })).toEqual([
+      'system/ds/README.md',
+      'system/ds/brand.css',
+      'system/ds/preview/_brand-css.ts',
+      'system/ds/preview/_layout.css',
+    ]);
+    // Flag OFF ⇒ today's reach, byte-for-byte: none of these are binary
+    // media under an assets/ dir, so none of them move.
+    expect(listPushableAssets(designRoot)).toEqual([]);
+  });
+
+  test('declared canvasGroups decide what a canvas body IS', () => {
+    const designRoot = scratchDesignRoot();
+    mkdirSync(join(designRoot, 'mocks'), { recursive: true });
+    mkdirSync(join(designRoot, 'lib'), { recursive: true });
+    writeFileSync(join(designRoot, 'mocks/screen.tsx'), 'x');
+    writeFileSync(join(designRoot, 'lib/helpers.tsx'), 'x');
+    const groups = [{ path: 'mocks' }];
+    // `mocks/screen.tsx` is a canvas here; `lib/helpers.tsx` a shared module.
+    expect(listPushableAssets(designRoot, { canvasGroups: groups, syncFiles: true })).toEqual([
+      'lib/helpers.tsx',
+    ]);
+    // …and both the groups and the flag reach the walk through config.json —
+    // the out-of-process worker's path.
+    writeFileSync(
+      join(designRoot, 'config.json'),
+      JSON.stringify({ canvasGroups: groups, linkedHub: { url: 'http://h', syncFiles: true } })
+    );
+    expect(listPushableAssets(designRoot)).toEqual(['lib/helpers.tsx']);
+  });
 });
 
 describe('pushAssets — routes each class to the right hub endpoint', () => {
@@ -714,3 +764,94 @@ describe('pushAssets — incremental progress (feature-sync-progress-modal)', ()
     expect(r.pushed).toEqual(['assets/ok.png']);
   });
 });
+
+// An asset that appears AFTER boot has to go up now, not next launch.
+//
+// The sweep fired from exactly one place — `start()` — so a picture pasted into
+// an annotation reached the cloud only on the next boot or Resync, while the
+// annotation itself synced through the doc in milliseconds. The other side
+// rendered an `<image>` pointing at bytes nobody had sent: a permanent empty
+// frame that reads as a broken path. `isPushableAssetRel` is what decides an
+// `fs:any` event is worth a sweep, so it has to agree with the walk that
+// actually collects them.
+describe('isPushableAssetRel — the on-change trigger', () => {
+  test('it agrees with listPushableAssets on a real tree', () => {
+    const root = mkdtempSync(join(tmpdir(), 'pushable-'));
+    mkdirSync(join(root, 'assets'), { recursive: true });
+    mkdirSync(join(root, 'system/ds/assets/logos'), { recursive: true });
+    mkdirSync(join(root, '_history/ui-home/assets'), { recursive: true });
+    mkdirSync(join(root, 'ui'), { recursive: true });
+    writeFileSync(join(root, 'assets/5f809613.png'), 'x'); // the reported case
+    writeFileSync(join(root, 'system/ds/assets/logos/mark.svg'), 'x');
+    writeFileSync(join(root, '_history/ui-home/assets/shot.png'), 'x');
+    writeFileSync(join(root, 'ui/Home.tsx'), 'x');
+    writeFileSync(join(root, 'assets/notes.txt'), 'x');
+
+    const walked = new Set(listPushableAssets(root));
+    for (const rel of [
+      'assets/5f809613.png',
+      'system/ds/assets/logos/mark.svg',
+      '_history/ui-home/assets/shot.png',
+      'ui/Home.tsx',
+      'assets/notes.txt',
+    ]) {
+      expect(isPushableAssetRel(rel)).toBe(walked.has(rel));
+    }
+  });
+
+  test('the pasted-annotation image is what fires it', () => {
+    expect(isPushableAssetRel('assets/5f809613.png')).toBe(true);
+    expect(isPushableAssetRel('assets/9fb5bab5.jpg')).toBe(true);
+  });
+
+  test('runtime state and non-assets never fire a sweep', () => {
+    for (const rel of [
+      '_history/ui-home/assets/shot.png',
+      '_comments/assets/pasted.png',
+      'ui/Home.tsx',
+      'config.json',
+      'system/ds/preview/logo.tsx',
+      'assets/notes.txt',
+      'assets',
+      '',
+    ]) {
+      expect(isPushableAssetRel(rel)).toBe(false);
+    }
+  });
+
+  test('a windows-shaped path is normalized, not refused', () => {
+    expect(isPushableAssetRel('system\\ds\\assets\\logos\\mark.svg')).toBe(true);
+  });
+});
+
+// The WIRING, pinned at source (the sync-panel-surface precedent).
+//
+// `isPushableAssetRel` above is exercised directly; what a unit test cannot
+// reach here is that the runtime actually CALLS it from the fs watcher, which
+// is the half that was missing. A behavioural test needs a live runtime plus a
+// 1.5 s debounce and destabilises `sync-runtime.test.ts`'s shared fixtures, so
+// the invariant is pinned where it is cheap and unambiguous instead.
+describe('the runtime sweeps on change, not only at boot', () => {
+  const SYNC = readFileSync(join(import.meta.dir, '..', 'sync', 'index.ts'), 'utf8');
+
+  test('the fs watcher decides with isPushableAssetRel and schedules a sweep', () => {
+    // The predicate gets the project's OWN canvas groups — with the default
+    // set a custom-group project's shared module would answer canvas-owned
+    // and silently never schedule the sweep that uploads it.
+    expect(SYNC).toContain(
+      'if (isPushableAssetRel(rel, ctx.cfg.canvasGroups)) scheduleAssetSweep('
+    );
+  });
+
+  test('bursts coalesce, and a change DURING a sweep is not lost', () => {
+    // Dragging six images on is six events; each sweep costs a probe over the
+    // wire. And a file written while a sweep runs was not in that sweep's list.
+    expect(SYNC).toMatch(/ASSET_SWEEP_DEBOUNCE_MS = [\d_]+/);
+    expect(SYNC).toContain('assetSweepAgain');
+  });
+
+  test('only one sweep runs at a time, and stop() clears the pending one', () => {
+    expect(SYNC).toMatch(/if \(stopped \|\| assetSweep\) return;/);
+    expect(SYNC).toContain('if (assetSweepTimer !== null) clearTimeout(assetSweepTimer);');
+  });
+});