[Init] Initial commit - NetMesh terminal manager

application/state/pluginViewLifecycle.test.ts

@@ -0,0 +1,213 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  PluginViewLifecycleController,
+  consumeClosedPluginViewInstance,
+  reconcilePluginViewTabCatalog,
+  markPluginViewOpenTokensClosed,
+  reconcileClosedPluginView,
+  rememberClosedPluginViewInstance,
+  resolvePluginViewSnapshotSelection,
+  shouldReconcilePluginViewTabCatalog,
+  withdrawPluginViewTab,
+  type HostedPluginViewState,
+} from './pluginViewLifecycle.ts';
+import { PluginViewTabStore } from './pluginViewTabStore.ts';
+
+function view(id: string, tabId?: string): HostedPluginViewState {
+  return {
+    id,
+    viewId: `view.${id}`,
+    scopeId: 'window:main',
+    retainContextWhenHidden: false,
+    ...(tabId ? { tabId } : {}),
+  };
+}
+
+test('host close events clear the active renderer instance and identify its native tab', () => {
+  const current = view('active', 'plugin-view:publisher.plugin:view.active');
+  const result = reconcileClosedPluginView({
+    current,
+    retained: new Map([['retained', view('retained')]]),
+    instanceId: 'active',
+  });
+
+  assert.equal(result.current, null);
+  assert.equal(result.matchedCurrent, true);
+  assert.equal(result.closedTabId, current.tabId);
+  assert.equal(result.retained.size, 1);
+});
+
+test('host close events remove retained instances without dismissing another active view', () => {
+  const current = view('active');
+  const retainedTab = view('retained-closed', 'plugin-view:publisher.plugin:view.retained');
+  const result = reconcileClosedPluginView({
+    current,
+    retained: new Map([
+      ['closed', retainedTab],
+      ['kept', view('retained-kept')],
+    ]),
+    instanceId: 'retained-closed',
+  });
+
+  assert.equal(result.current, current);
+  assert.equal(result.matchedCurrent, false);
+  assert.equal(result.matchedRetained, true);
+  assert.deepEqual([...result.retained.keys()], ['kept']);
+  assert.equal(result.closedTabId, retainedTab.tabId);
+});
+
+test('explicit native-tab close destroys active and retained instances instead of retaining them', () => {
+  const tabId = 'plugin-view:publisher.plugin:view.shared';
+  const result = withdrawPluginViewTab({
+    current: view('active', tabId),
+    retained: new Map([
+      ['same-tab', view('retained-same', tabId)],
+      ['other-tab', view('retained-other', 'plugin-view:publisher.plugin:view.other')],
+    ]),
+    tabId,
+  });
+
+  assert.equal(result.current, null);
+  assert.equal(result.matchedCurrent, true);
+  assert.equal(result.matchedRetained, true);
+  assert.deepEqual(result.instanceIds, ['active', 'retained-same']);
+  assert.deepEqual([...result.retained.keys()], ['other-tab']);
+});
+
+test('an early host close tombstone is consumed when the open response arrives later', () => {
+  const tombstones = new Set<string>();
+  rememberClosedPluginViewInstance(tombstones, 'instance-early');
+  assert.equal(consumeClosedPluginViewInstance(tombstones, 'instance-early'), true);
+  assert.equal(consumeClosedPluginViewInstance(tombstones, 'instance-early'), false);
+
+  for (let index = 0; index < 300; index += 1) {
+    rememberClosedPluginViewInstance(tombstones, `instance-${index}`);
+  }
+  assert.equal(tombstones.size, 256);
+  assert.equal(tombstones.has('instance-0'), false);
+});
+
+test('explicit close marks only in-flight opens owned by the closed surface', () => {
+  const first = Symbol('first');
+  const second = Symbol('second');
+  const explicitlyClosed = new Set<symbol>();
+  const opening = new Map<string, Set<symbol>>([
+    ['window:main\0view.first', new Set([first])],
+    ['window:main\0view.second', new Set([second])],
+  ]);
+
+  assert.equal(markPluginViewOpenTokensClosed(
+    opening,
+    explicitlyClosed,
+    'window:main\0view.first',
+  ), 1);
+  assert.deepEqual([...explicitlyClosed], [first]);
+  assert.equal(markPluginViewOpenTokensClosed(opening, explicitlyClosed, null), 0);
+});
+
+test('locale-only snapshot refresh keeps the owned view alive without weakening context fail-closed behavior', () => {
+  const previous = {
+    requestViewId: 'publisher.plugin.view',
+    contextKey: '{"netcatty.surface":"view"}',
+    value: { id: 'resolved-view' },
+  };
+  assert.equal(resolvePluginViewSnapshotSelection({
+    resolved: null,
+    previous,
+    loading: true,
+    requestedViewId: previous.requestViewId,
+    contextKey: previous.contextKey,
+  }), previous.value);
+  assert.equal(resolvePluginViewSnapshotSelection({
+    resolved: null,
+    previous,
+    loading: true,
+    requestedViewId: previous.requestViewId,
+    contextKey: '{"netcatty.surface":"terminal/toolbar"}',
+  }), null);
+  assert.equal(resolvePluginViewSnapshotSelection({
+    resolved: null,
+    previous,
+    loading: false,
+    requestedViewId: previous.requestViewId,
+    contextKey: previous.contextKey,
+  }), null);
+});
+
+test('native tab catalog reconciliation pauses for every in-flight query', () => {
+  assert.equal(shouldReconcilePluginViewTabCatalog({
+    loading: true,
+  }), false);
+  assert.equal(shouldReconcilePluginViewTabCatalog({
+    loading: false,
+  }), true);
+});
+
+test('active-tab context refresh cannot withdraw the plugin tab that triggered it', () => {
+  let activeTabId = 'vault';
+  const store = new PluginViewTabStore({
+    getActiveTabId: () => activeTabId,
+    setActiveTabId: (next) => { activeTabId = next; },
+  });
+  const tab = store.open({
+    pluginId: 'publisher.plugin',
+    pluginName: 'Plugin',
+    viewId: 'publisher.plugin.view',
+    title: 'View',
+  });
+
+  assert.equal(reconcilePluginViewTabCatalog({
+    loading: true,
+    plugins: [],
+    store,
+  }), false);
+  assert.deepEqual(store.getTabs().map((candidate) => candidate.id), [tab.id]);
+  assert.equal(activeTabId, tab.id);
+
+  const plugins = [{
+    id: 'publisher.plugin',
+    displayName: 'Plugin',
+    views: [{
+      id: 'publisher.plugin.view',
+      title: 'Localized View',
+      location: 'tab',
+    }],
+  }] as unknown as NetcattyPluginContributionSnapshot['plugins'];
+  assert.equal(reconcilePluginViewTabCatalog({
+    loading: false,
+    plugins,
+    store,
+  }), true);
+  assert.deepEqual(store.getTabs().map((candidate) => candidate.id), [tab.id]);
+  assert.equal(store.getTabs()[0]?.title, 'Localized View');
+  assert.equal(activeTabId, tab.id);
+});
+
+test('lifecycle controller owns retained views, open tokens, tombstones, and teardown', () => {
+  const controller = new PluginViewLifecycleController<HostedPluginViewState>();
+  const tabId = 'plugin-view:publisher.plugin:view.shared';
+  const active = view('active', tabId);
+  const retained = view('retained');
+  controller.setCurrent(active);
+  controller.retain('window:main\0view.retained', retained);
+
+  const token = controller.beginOpen({
+    viewKey: 'window:main\0view.active',
+    tabId,
+  });
+  const closed = controller.handleTabClose(tabId);
+  assert.deepEqual(closed.instanceIds, [active.id]);
+  assert.equal(controller.shouldCloseOpen(token), true);
+  controller.finishOpen({ token, viewKey: 'window:main\0view.active', tabId });
+  assert.equal(controller.shouldCloseOpen(token), false);
+
+  const early = controller.handleHostClose('instance-before-open-response');
+  assert.equal(early.matchedCurrent, false);
+  assert.equal(early.matchedRetained, false);
+  assert.equal(controller.consumeHostClose('instance-before-open-response'), true);
+
+  assert.deepEqual(controller.drain().map((candidate) => candidate.id), [retained.id]);
+  assert.equal(controller.getCurrent(), null);
+});