Skip to content

A spy satellite simulator in your browser, except the data is real. Live open source spatial intelligence on a photorealistic 3D globe.

14.4 KB
Raw Blame
import test from 'node:test';
import assert from 'node:assert/strict';
import { getEventListeners } from 'node:events';
import { createPanelActionObserver } from './actionObserver.js';
import { createVoiceSession } from '../session.js';

function deferred() {
  let resolve, reject;
  const promise = new Promise((yes, no) => {
    resolve = yes;
    reject = no;
  });
  return { promise, resolve, reject };
}

test('sync value/throw, receiver, arguments and opaque unsupported result stay exact', () => {
  const receiver = {},
    args = {},
    options = { extra: 7 };
  const error = Error('original');
  let calls = 0;
  const events = [];
  const observer = createPanelActionObserver({
    onObservation: (event) => events.push(event),
    runAction(name, received, opts, tail) {
      assert.equal(this, receiver);
      assert.equal(received, args);
      assert.equal(opts.extra, 7);
      assert.equal(tail, 'tail');
      calls++;
      if (name === 'throw') throw error;
      return 42;
    },
  });
  assert.equal(
    observer.runAction.call(receiver, 'value', args, options, 'tail'),
    42,
  );
  assert.throws(
    () => observer.runAction.call(receiver, 'throw', args, options, 'tail'),
    (e) => e === error,
  );
  assert.equal(calls, 2);
  assert.equal(observer.pendingCount, 0);
  assert.deepEqual(
    events.filter((e) => e.type === 'attempt-settled').map((e) => e.outcome),
    ['synchronous-return', 'synchronous-throw'],
  );
  const opaque = Object.defineProperty({}, 'then', {
    get() {
      throw Error('must not read then');
    },
  });
  const another = createPanelActionObserver({ runAction: () => opaque });
  assert.equal(another.runAction('opaque'), opaque);
  assert.equal(another.pendingCount, 0);
});

test('native Promise identity, fulfillment object and rejection object are preserved', async () => {
  for (const reject of [false, true]) {
    const d = deferred(),
      value = { exact: true },
      events = [];
    const observer = createPanelActionObserver({
      runAction: () => d.promise,
      onObservation: (e) => events.push(e),
    });
    const returned = observer.runAction('promise');
    assert.equal(returned, d.promise);
    assert.equal(observer.pendingCount, 1);
    if (reject) {
      d.reject(value);
      await assert.rejects(returned, (e) => e === value);
    } else {
      d.resolve(value);
      assert.equal(await returned, value);
    }
    assert.equal(observer.pendingCount, 0);
    assert.equal(events.at(-1).outcome, reject ? 'rejected' : 'fulfilled');
    assert.equal('result' in events.at(-1), false);
    assert.equal('error' in events.at(-1), false);
  }
});

test('null/reused callIds have independent keys and settlement cannot retire a sibling', async () => {
  const a = deferred(),
    b = deferred(),
    events = [];
  const observer = createPanelActionObserver({
    runAction: (name) => (name === 'a' ? a.promise : b.promise),
    onObservation: (e) => events.push(e),
  });
  const pa = observer.runAction('a', {}, { callId: null });
  const pb = observer.runAction('b', {}, { callId: null });
  const starts = events.filter((e) => e.type === 'attempt-started');
  assert.notEqual(starts[0].key, starts[1].key);
  assert.equal(observer.pendingCount, 2);
  b.resolve('b');
  await pb;
  assert.equal(observer.pendingCount, 1);
  assert.equal(events.at(-1).key, starts[1].key);
  a.resolve('a');
  await pa;
  assert.equal(observer.pendingCount, 0);
});

test('progress preserves public-before-original-before-private order, receiver and option references', async () => {
  const order = [],
    signal = new AbortController().signal,
    symbol = Symbol('unknown');
  let currentCalls = 0;
  const isCurrent = () => {
    currentCalls++;
    return true;
  };
  const options = {
    signal,
    isCurrent,
    progress(update) {
      assert.equal(this, options);
      order.push('original');
      return update;
    },
  };
  Object.defineProperty(options, 'hidden', { value: 8 });
  options[symbol] = 9;
  const custom = {};
  const observer = createPanelActionObserver({
    onObservation(e) {
      if (e.type === 'progress') order.push('private');
    },
    runAction(name, args, received) {
      assert.equal(received.signal, signal);
      assert.equal(received.isCurrent, isCurrent);
      assert.equal(received.hidden, 8);
      assert.equal(received[symbol], 9);
      assert.equal(
        Object.getOwnPropertyDescriptor(received, 'hidden').enumerable,
        false,
      );
      order.push('public');
      assert.equal(received.progress({ step: 'running' }).step, 'running');
      return Promise.resolve();
    },
  });
  await observer.runAction('action', {}, options);
  assert.deepEqual(order, ['public', 'original', 'private']);
  assert.equal(currentCalls, 0);
  const explicit = createPanelActionObserver({
    runAction(name, args, received) {
      received.progress.call(custom, { step: 'running' });
      return 0;
    },
  });
  let originalReceiver;
  explicit.runAction(
    'explicit',
    {},
    {
      progress() {
        originalReceiver = this;
      },
    },
  );
  assert.equal(originalReceiver, custom);
});

test('observer faults and private metadata faults cannot replace original callback errors', async () => {
  const originalError = Error('callback');
  const observer = createPanelActionObserver({
    onObservation() {
      throw Error('observer');
    },
    runAction(name, args, options) {
      options.progress({ step: 'work' });
      return Promise.resolve('ok');
    },
  });
  await assert.rejects(
    Promise.resolve().then(() =>
      observer.runAction(
        'error',
        {},
        {
          progress() {
            throw originalError;
          },
        },
      ),
    ),
    (e) => e === originalError,
  );
  const hostile = new Proxy(
    {},
    {
      getOwnPropertyDescriptor() {
        throw Error('private read');
      },
    },
  );
  const safe = createPanelActionObserver({
    runAction(name, args, options) {
      options.progress(hostile);
      return Promise.resolve('unchanged');
    },
    onObservation() {
      throw Error('observer');
    },
  });
  assert.equal(await safe.runAction('safe', {}, {}), 'unchanged');
});

test('accessor/custom options are forwarded untouched without extra getter/currentness probes', async () => {
  let reads = 0,
    predicates = 0;
  const options = Object.defineProperty(
    {
      isCurrent() {
        predicates++;
        return true;
      },
    },
    'progress',
    {
      get() {
        reads++;
        return () => {};
      },
    },
  );
  const observer = createPanelActionObserver({
    runAction(name, args, received) {
      assert.equal(received, options);
      received.progress({});
      received.isCurrent();
      return Promise.resolve();
    },
  });
  await observer.runAction('accessor', {}, options);
  assert.equal(reads, 1);
  assert.equal(predicates, 1);
  assert.equal(observer.pendingCount, 0);
});

test('real caller abort retires ownership only; late A cannot release or report over B', async () => {
  const a = deferred(),
    b = deferred(),
    caller = new AbortController(),
    events = [],
    callbacks = [];
  let oldOptions;
  const observer = createPanelActionObserver({
    onObservation: (e) => events.push(e),
    runAction(name, args, options) {
      if (name === 'a') oldOptions = options;
      return name === 'a' ? a.promise : b.promise;
    },
  });
  const pa = observer.runAction(
    'a',
    {},
    { signal: caller.signal, progress: () => callbacks.push('original') },
  );
  caller.abort();
  assert.equal(observer.pendingCount, 0);
  assert.equal(events.at(-1).type, 'ownership-retired');
  assert.equal(
    events.some((e) => e.type === 'attempt-settled'),
    false,
  );
  const pb = observer.runAction('b');
  const count = events.length;
  oldOptions.progress({ step: 'late' });
  a.resolve('a');
  await pa;
  assert.deepEqual(callbacks, ['original']);
  assert.equal(events.length, count);
  assert.equal(observer.pendingCount, 1);
  b.resolve('b');
  await pb;
  assert.equal(observer.pendingCount, 0);
  assert.equal(getEventListeners(caller.signal, 'abort').length, 0);
});

test('already-aborted caller and disposed mount still invoke original exactly once', async () => {
  const caller = new AbortController(),
    mount = new AbortController();
  caller.abort();
  let calls = 0;
  const events = [];
  const observer = createPanelActionObserver({
    signal: mount.signal,
    onObservation: (e) => events.push(e),
    runAction: () => {
      calls++;
      return Promise.resolve('original');
    },
  });
  assert.equal(
    await observer.runAction('aborted', {}, { signal: caller.signal }),
    'original',
  );
  assert.equal(observer.pendingCount, 0);
  mount.abort();
  assert.equal(await observer.runAction('disposed'), 'original');
  assert.equal(calls, 2);
  assert.equal(events.length, 0);
  assert.equal(getEventListeners(mount.signal, 'abort').length, 0);
});

test('reentrant start retirement retains only fresh ownership and never skips execution', async () => {
  const a = deferred(),
    b = deferred(),
    called = [];
  let observer, pb;
  observer = createPanelActionObserver({
    runAction(name) {
      called.push(name);
      return name === 'a' ? a.promise : b.promise;
    },
    onObservation(e) {
      if (e.type === 'attempt-started' && e.name === 'a') {
        observer.retire('actual-interruption');
        pb = observer.runAction('b');
      }
    },
  });
  const pa = observer.runAction('a');
  assert.deepEqual(called, ['b', 'a']);
  assert.equal(observer.pendingCount, 1);
  a.resolve();
  await pa;
  assert.equal(observer.pendingCount, 1);
  b.resolve();
  await pb;
  assert.equal(observer.pendingCount, 0);
});

test('actual pinned-main common session: private invocation stream is separate from public events', async (t) => {
  const publicEvents = [],
    privateEvents = [],
    order = [];
  let hooks, observer;
  const result = { ok: true, unchanged: true };
  const session = createVoiceSession({
    runner: async (name, args, options) => {
      assert.equal(options.isCurrent(), true);
      options.progress({ step: 'actual', label: 'Actual' });
      return result;
    },
    createAdapter(h) {
      hooks = h;
      observer = createPanelActionObserver({
        runAction: h.runAction,
        signal: h.signal,
        onObservation(e) {
          privateEvents.push(e);
          if (e.type === 'progress') order.push('private');
        },
      });
      return {
        start() {
          h.emit({ type: 'state', state: 'listening' });
        },
        stop() {},
        sendText() {},
        sendMapEvent() {},
      };
    },
  });
  t.after(() => session.destroy());
  session.subscribe((e) => {
    publicEvents.push(e);
    if (e.type === 'progress') order.push('public');
  });
  await session.start();
  assert.equal(
    await observer.runAction(
      'actual',
      {},
      {
        progress() {
          order.push('caller');
        },
      },
    ),
    result,
  );
  assert.deepEqual(order, ['public', 'caller', 'private']);
  const call = publicEvents.find((e) => e.type === 'action-call');
  assert.deepEqual(call, {
    type: 'action-call',
    name: 'actual',
    callId: null,
    arguments: {},
  });
  assert.equal(
    publicEvents.some((e) => e.type === 'action-settled'),
    false,
  );
  assert.equal(privateEvents.at(-1).type, 'attempt-settled');
  assert.equal(observer.pendingCount, 0);
  assert.equal(hooks.signal.aborted, false);
});

test('actual common interruption aborts resources; injected real-lifecycle observation retires uncooperative A', async (t) => {
  const a = deferred(),
    b = deferred(),
    events = [];
  let hooks, observer, aSignal;
  const session = createVoiceSession({
    runner: (name, args, options) => {
      if (name === 'a') aSignal = options.signal;
      return name === 'a' ? a.promise : b.promise;
    },
    createAdapter(h) {
      hooks = h;
      observer = createPanelActionObserver({
        runAction: h.runAction,
        signal: h.signal,
        onObservation: (e) => events.push(e),
      });
      return {
        start() {
          h.emit({ type: 'state', state: 'listening' });
        },
        stop() {},
        sendText() {},
        sendMapEvent() {},
      };
    },
  });
  t.after(() => session.destroy());
  await session.start();
  const pa = observer.runAction('a');
  const rejection = assert.rejects(pa, { name: 'AbortError' });
  hooks.emit({ type: 'interruption', reason: 'actual-common-event' });
  assert.equal(aSignal.aborted, true);
  // This bridge is explicitly supplied by the test, not automatically inferred.
  observer.retire('observed-common-interruption');
  assert.equal(observer.pendingCount, 0);
  const pb = observer.runAction('b');
  const count = events.length;
  a.resolve({ ok: true });
  await rejection;
  assert.equal(events.length, count);
  assert.equal(observer.pendingCount, 1);
  b.resolve({ ok: true });
  await pb;
  assert.equal(observer.pendingCount, 0);
});

test('null-prototype option descriptors survive instrumentation; mount abort does not fabricate settlement', async () => {
  const mount = new AbortController(),
    d = deferred(),
    events = [],
    originalProgress = [];
  const options = Object.assign(Object.create(null), {
    progress: () => originalProgress.push('original'),
  });
  let received;
  const observer = createPanelActionObserver({
    signal: mount.signal,
    onObservation: (e) => events.push(e),
    runAction(name, args, opts) {
      received = opts;
      return d.promise;
    },
  });
  const promise = observer.runAction('pending', {}, options);
  assert.equal(Object.getPrototypeOf(received), null);
  mount.abort();
  assert.equal(observer.pendingCount, 0);
  assert.equal(events.at(-1).type, 'ownership-retired');
  const count = events.length;
  received.progress({ step: 'late' });
  d.resolve('done');
  assert.equal(await promise, 'done');
  assert.deepEqual(originalProgress, ['original']);
  assert.equal(events.length, count);
  assert.equal(getEventListeners(mount.signal, 'abort').length, 0);
});

test('omitted and explicit undefined options keep original arity and values', () => {
  const calls = [];
  const observer = createPanelActionObserver({
    runAction: function (...args) {
      calls.push(args);
      return 1;
    },
  });
  assert.equal(observer.runAction('omitted', {}), 1);
  assert.equal(observer.runAction('explicit', {}, undefined), 1);
  assert.equal(calls[0].length, 2);
  assert.equal(calls[1].length, 3);
  assert.equal(calls[0][2], undefined);
  assert.equal(calls[1][2], undefined);
});