[Init] Initial commit - NetMesh terminal manager

application/state/windowOpacitySync.test.ts

@@ -0,0 +1,199 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  parseWindowOpacityRecord,
+  serializeWindowOpacityRecord,
+  shouldApplyWindowOpacityRecord,
+  shouldBroadcastWindowOpacityChange,
+  type WindowOpacityMutationSource,
+  type WindowOpacityRecord,
+} from './windowOpacitySync.ts';
+
+/**
+ * Minimal model of the settings ↔ main opacity sync loop that caused #2018.
+ * Models both IPC rebroadcast and stale localStorage overwrites.
+ */
+function simulateOpacityDrag(options: {
+  shouldBroadcast: (
+    source: WindowOpacityMutationSource,
+    persistMounted: boolean,
+  ) => { shouldBroadcast: boolean; nextSource: WindowOpacityMutationSource };
+  shouldApply: (current: WindowOpacityRecord, incoming: WindowOpacityRecord) => boolean;
+  versioned: boolean;
+}): { settingsValues: number[]; mainValues: number[]; storageWrites: string[] } {
+  let settings: WindowOpacityRecord = { opacity: 1, version: 0 };
+  let main: WindowOpacityRecord = { opacity: 1, version: 0 };
+  let settingsSource: WindowOpacityMutationSource = 'local';
+  let mainSource: WindowOpacityMutationSource = 'local';
+  let storage = serializeWindowOpacityRecord(settings);
+  const settingsValues: number[] = [];
+  const mainValues: number[] = [];
+  const storageWrites: string[] = [];
+
+  const pendingIpc: Array<{ to: 'settings' | 'main'; record: WindowOpacityRecord }> = [];
+
+  const writeStorage = (record: WindowOpacityRecord) => {
+    const next = options.versioned
+      ? serializeWindowOpacityRecord(record)
+      : String(record.opacity);
+    if (next === storage) return;
+    storage = next;
+    storageWrites.push(next);
+    // Cross-window StorageEvent: deliver to the other window.
+  };
+
+  const applyLocal = (window: 'settings' | 'main', opacity: number) => {
+    const bump = (prev: WindowOpacityRecord): WindowOpacityRecord => (
+      options.versioned
+        ? { opacity, version: prev.version + 1 }
+        : { opacity, version: 0 }
+    );
+
+    if (window === 'settings') {
+      settingsSource = 'local';
+      settings = bump(settings);
+      settingsValues.push(settings.opacity);
+      writeStorage(settings);
+      const decision = options.shouldBroadcast(settingsSource, true);
+      settingsSource = decision.nextSource;
+      if (decision.shouldBroadcast) pendingIpc.push({ to: 'main', record: { ...settings } });
+      return;
+    }
+
+    mainSource = 'local';
+    main = bump(main);
+    mainValues.push(main.opacity);
+    writeStorage(main);
+    const decision = options.shouldBroadcast(mainSource, true);
+    mainSource = decision.nextSource;
+    if (decision.shouldBroadcast) pendingIpc.push({ to: 'settings', record: { ...main } });
+  };
+
+  const applyIncoming = (window: 'settings' | 'main', record: WindowOpacityRecord) => {
+    if (window === 'settings') {
+      if (!options.shouldApply(settings, record)) return;
+      settingsSource = 'incoming';
+      settings = { ...record };
+      settingsValues.push(settings.opacity);
+      writeStorage(settings);
+      const decision = options.shouldBroadcast(settingsSource, true);
+      settingsSource = decision.nextSource;
+      if (decision.shouldBroadcast) pendingIpc.push({ to: 'main', record: { ...settings } });
+      return;
+    }
+
+    if (!options.shouldApply(main, record)) return;
+    mainSource = 'incoming';
+    main = { ...record };
+    mainValues.push(main.opacity);
+    writeStorage(main);
+    const decision = options.shouldBroadcast(mainSource, true);
+    mainSource = decision.nextSource;
+    if (decision.shouldBroadcast) pendingIpc.push({ to: 'settings', record: { ...main } });
+  };
+
+  const flushIpc = () => {
+    while (pendingIpc.length > 0) {
+      const next = pendingIpc.shift()!;
+      applyIncoming(next.to, next.record);
+      if (settingsValues.length > 40) break;
+    }
+  };
+
+  // Replay storage writes onto the peer after each local burst, matching
+  // Electron's cross-window StorageEvent delivery.
+  const deliverStorageTo = (window: 'settings' | 'main') => {
+    const record = options.versioned
+      ? parseWindowOpacityRecord(JSON.parse(storage))
+      : parseWindowOpacityRecord(storage);
+    applyIncoming(window, record);
+  };
+
+  applyLocal('settings', 0.5);
+  deliverStorageTo('main');
+  applyLocal('settings', 0.65);
+  // Delayed IPC for the older 0.5 update arrives after 0.65 was already local.
+  const delayed = pendingIpc.shift();
+  flushIpc();
+  if (delayed) applyIncoming(delayed.to, delayed.record);
+  deliverStorageTo('settings');
+  flushIpc();
+
+  return { settingsValues, mainValues, storageWrites };
+}
+
+test('parseWindowOpacityRecord accepts legacy plain numbers and versioned JSON', () => {
+  assert.deepEqual(parseWindowOpacityRecord('0.85'), { opacity: 0.85, version: 0 });
+  assert.deepEqual(parseWindowOpacityRecord(0.7), { opacity: 0.7, version: 0 });
+  assert.deepEqual(
+    parseWindowOpacityRecord({ opacity: 0.5, version: 3 }),
+    { opacity: 0.5, version: 3 },
+  );
+  assert.deepEqual(
+    parseWindowOpacityRecord('{"opacity":0.55,"version":9}'),
+    { opacity: 0.55, version: 9 },
+  );
+  assert.equal(parseWindowOpacityRecord('bad').opacity, 1);
+});
+
+test('shouldApplyWindowOpacityRecord ignores stale revisions', () => {
+  const current = { opacity: 0.65, version: 2 };
+  assert.equal(shouldApplyWindowOpacityRecord(current, { opacity: 0.5, version: 1 }), false);
+  assert.equal(shouldApplyWindowOpacityRecord(current, { opacity: 0.7, version: 3 }), true);
+  assert.equal(shouldApplyWindowOpacityRecord(current, { opacity: 0.65, version: 2 }), false);
+});
+
+test('shouldBroadcastWindowOpacityChange suppresses incoming rebroadcasts', () => {
+  assert.deepEqual(
+    shouldBroadcastWindowOpacityChange('incoming', true),
+    { shouldBroadcast: false, nextSource: 'local' },
+  );
+  assert.deepEqual(
+    shouldBroadcastWindowOpacityChange('local', true),
+    { shouldBroadcast: true, nextSource: 'local' },
+  );
+  assert.deepEqual(
+    shouldBroadcastWindowOpacityChange('local', false),
+    { shouldBroadcast: false, nextSource: 'local' },
+  );
+});
+
+test('legacy unversioned always-broadcast opacity sync oscillates during a fast drag', () => {
+  const alwaysBroadcast = (
+    _source: WindowOpacityMutationSource,
+    persistMounted: boolean,
+  ) => ({
+    shouldBroadcast: persistMounted,
+    nextSource: 'local' as const,
+  });
+  const alwaysApply = () => true;
+
+  const { settingsValues } = simulateOpacityDrag({
+    shouldBroadcast: alwaysBroadcast,
+    shouldApply: alwaysApply,
+    versioned: false,
+  });
+  const unique = new Set(settingsValues);
+  assert.ok(
+    unique.has(0.5) && unique.has(0.65) && settingsValues.length > 2,
+    `expected oscillation between 0.5 and 0.65, got ${settingsValues.join(',')}`,
+  );
+});
+
+test('versioned opacity sync ignores stale peer echoes during a fast drag', () => {
+  const { settingsValues, mainValues } = simulateOpacityDrag({
+    shouldBroadcast: shouldBroadcastWindowOpacityChange,
+    shouldApply: shouldApplyWindowOpacityRecord,
+    versioned: true,
+  });
+
+  assert.deepEqual(settingsValues, [0.5, 0.65]);
+  assert.ok(mainValues.includes(0.65));
+  assert.equal(mainValues.includes(0.5) && mainValues[mainValues.length - 1] === 0.5, false);
+});
+
+test('serializeWindowOpacityRecord round-trips through parse', () => {
+  const raw = serializeWindowOpacityRecord({ opacity: 0.55, version: 9 });
+  assert.deepEqual(parseWindowOpacityRecord(JSON.parse(raw)), { opacity: 0.55, version: 9 });
+});