test(vscode): headless activation smoke — run real activate() against a mock vscode

nugehs · nugehs · commit 4740804e3d44 · 2026-06-14T10:38:24.000+01:00
Inject a fake `vscode`, run the compiled activate(), and exercise the cockpit
render, chat participant, LM tool and MCP provider end-to-end. Catches runtime
wiring bugs the type-checker can't, without a live editor. +9 tests (36 total).
diff --git a/clients/vscode/test/activation.test.js b/clients/vscode/test/activation.test.js
@@ -0,0 +1,119 @@
+// Headless activation smoke test: inject a fake `vscode`, run the real compiled
+// activate(), and exercise the AI surfaces + cockpit end-to-end. This catches
+// runtime wiring bugs (bad command ids, missing registrations, render throws)
+// that the type-checker can't, without needing a live editor.
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const Module = require('node:module');
+
+const vscodeMock = require('./vscode-mock.js');
+const rec = vscodeMock.__;
+
+// Intercept `require('vscode')` for the extension and its modules.
+const origLoad = Module._load;
+Module._load = function (request, parent, isMain) {
+  if (request === 'vscode') return vscodeMock;
+  return origLoad.call(this, request, parent, isMain);
+};
+
+const extension = require('../out/extension.js');
+
+const ctxState = new Map();
+const context = {
+  subscriptions: [],
+  extensionPath: '/fake/ext',
+  extensionUri: vscodeMock.Uri.file('/fake/ext'),
+  workspaceState: {
+    get: (k, d) => (ctxState.has(k) ? ctxState.get(k) : d),
+    update: (k, v) => {
+      ctxState.set(k, v);
+      return Promise.resolve();
+    },
+  },
+};
+
+// Activate once (no workspace folders → check() early-returns, nothing spawns).
+let activateError = null;
+try {
+  extension.activate(context);
+} catch (e) {
+  activateError = e;
+}
+
+test('activate() runs without throwing and registers disposables', () => {
+  assert.equal(activateError, null);
+  assert.ok(context.subscriptions.length > 5);
+});
+
+test('all commands are registered', () => {
+  for (const id of [
+    'gate.check',
+    'gate.refresh',
+    'gate.showOutput',
+    'gate.focusCockpit',
+    'gate.muteFinding',
+    'gate.clearMutes',
+    'gate.installEngine',
+  ]) {
+    assert.equal(typeof rec.commands[id], 'function', `missing command: ${id}`);
+  }
+});
+
+test('views, diagnostics and the three providers are wired', () => {
+  assert.ok(rec.trees.some((t) => t.id === 'gate.verdict'));
+  assert.ok(rec.webviews.some((w) => w.id === 'gate.cockpit'));
+  assert.equal(rec.codeActionProviders.length, 1);
+  assert.equal(rec.hoverProviders.length, 1);
+  assert.equal(rec.codeLensProviders.length, 1);
+  assert.ok(rec.saveHandlers.length >= 1);
+});
+
+test('AI surfaces are registered: tool, participant, mcp provider', () => {
+  assert.ok(rec.tools['gate_check'], 'gate_check tool not registered');
+  assert.ok(rec.participants['nugehs.gate'], 'chat participant not registered');
+  assert.ok(rec.mcpProviders['nugehs-gate'], 'mcp provider not registered');
+});
+
+test('cockpit renders HTML when resolved', () => {
+  const cockpit = rec.webviews.find((w) => w.id === 'gate.cockpit').provider;
+  const view = { webview: { options: {}, html: '', onDidReceiveMessage: () => ({ dispose() {} }) } };
+  cockpit.resolveWebviewView(view);
+  assert.match(view.webview.html, /<!DOCTYPE html>/);
+  assert.match(view.webview.html, /Re-check/);
+  assert.match(view.webview.html, /No workspace folder open/); // no folders in this harness
+});
+
+test('chat participant streams a verdict', async () => {
+  const handler = rec.participants['nugehs.gate'];
+  const streamed = [];
+  const stream = {
+    markdown: (s) => streamed.push(typeof s === 'string' ? s : s.value),
+    progress: () => {},
+    button: () => {},
+  };
+  const token = { isCancellationRequested: false, onCancellationRequested: () => ({ dispose() {} }) };
+  await handler({ command: undefined, prompt: '' }, {}, stream, token);
+  const text = streamed.join('');
+  assert.match(text, /gate:/i);
+  assert.match(text, /NONE/); // no folders → nothing to check
+});
+
+test('LM tool returns an actionable text verdict', async () => {
+  const tool = rec.tools['gate_check'];
+  const token = { isCancellationRequested: false, onCancellationRequested: () => ({ dispose() {} }) };
+  const result = await tool.invoke({ input: {} }, token);
+  assert.ok(result && Array.isArray(result.parts));
+  assert.match(result.parts[0].value, /gate verdict:/);
+});
+
+test('MCP provider yields a stdio definition that runs `gate mcp`', () => {
+  const provider = rec.mcpProviders['nugehs-gate'];
+  const defs = provider.provideMcpServerDefinitions();
+  assert.equal(defs.length, 1);
+  assert.ok(defs[0].args.includes('mcp'));
+});
+
+test('deactivate() is clean', () => {
+  assert.doesNotThrow(() => extension.deactivate());
+  Module._load = origLoad; // restore
+});
diff --git a/clients/vscode/test/vscode-mock.js b/clients/vscode/test/vscode-mock.js
@@ -0,0 +1,216 @@
+// A minimal fake of the `vscode` module — just enough surface to run the real
+// activate() and exercise the cockpit, chat participant, LM tool and MCP provider
+// in plain node:test, with no editor. Every registration is recorded in `__` so
+// the activation test can assert on it and invoke captured handlers.
+
+const rec = {
+  commands: {},
+  executed: [],
+  trees: [],
+  webviews: [],
+  terminals: [],
+  codeActionProviders: [],
+  hoverProviders: [],
+  codeLensProviders: [],
+  saveHandlers: [],
+  folderHandlers: [],
+  tools: {},
+  mcpProviders: {},
+  participants: {},
+};
+
+class EventEmitter {
+  constructor() {
+    this.listeners = [];
+  }
+  get event() {
+    return (fn) => {
+      this.listeners.push(fn);
+      return { dispose() {} };
+    };
+  }
+  fire(e) {
+    for (const l of this.listeners) l(e);
+  }
+  dispose() {}
+}
+
+class Range {
+  constructor(...a) {
+    this.args = a;
+  }
+}
+class Diagnostic {
+  constructor(range, message, severity) {
+    Object.assign(this, { range, message, severity });
+  }
+}
+class ThemeIcon {
+  constructor(id, color) {
+    this.id = id;
+    this.color = color;
+  }
+}
+class ThemeColor {
+  constructor(id) {
+    this.id = id;
+  }
+}
+class TreeItem {
+  constructor(label, collapsibleState) {
+    this.label = label;
+    this.collapsibleState = collapsibleState;
+  }
+}
+class CodeAction {
+  constructor(title, kind) {
+    this.title = title;
+    this.kind = kind;
+  }
+}
+class MarkdownString {
+  constructor(value, supportThemeIcons) {
+    this.value = value || '';
+    this.supportThemeIcons = supportThemeIcons;
+    this.isTrusted = false;
+  }
+  appendMarkdown(s) {
+    this.value += s;
+    return this;
+  }
+}
+class Hover {
+  constructor(contents) {
+    this.contents = contents;
+  }
+}
+class CodeLens {
+  constructor(range, command) {
+    this.range = range;
+    this.command = command;
+  }
+}
+class LanguageModelToolResult {
+  constructor(parts) {
+    this.parts = parts;
+  }
+}
+class LanguageModelTextPart {
+  constructor(value) {
+    this.value = value;
+  }
+}
+class McpStdioServerDefinition {
+  constructor(label, command, args, env, version) {
+    Object.assign(this, { label, command, args, env, version });
+  }
+}
+
+const Uri = {
+  file: (p) => ({ scheme: 'file', fsPath: p, path: p, toString: () => 'file://' + p }),
+  parse: (s) => ({ scheme: 'parsed', fsPath: s, toString: () => s }),
+  joinPath: (base, ...segs) => ({ fsPath: [base.fsPath, ...segs].join('/'), toString: () => [base.fsPath, ...segs].join('/') }),
+};
+
+const window = {
+  createOutputChannel: (name) => ({ name, appendLine() {}, show() {}, dispose() {} }),
+  createStatusBarItem: () => ({ text: '', tooltip: '', command: '', show() {}, hide() {}, dispose() {} }),
+  registerTreeDataProvider: (id, provider) => {
+    rec.trees.push({ id, provider });
+    return { dispose() {} };
+  },
+  registerWebviewViewProvider: (id, provider) => {
+    rec.webviews.push({ id, provider });
+    return { dispose() {} };
+  },
+  createTerminal: (name) => {
+    rec.terminals.push(name);
+    return { show() {}, sendText() {} };
+  },
+};
+
+const languages = {
+  createDiagnosticCollection: (name) => ({ name, clear() {}, set() {}, delete() {}, dispose() {} }),
+  registerCodeActionsProvider: (_sel, provider) => {
+    rec.codeActionProviders.push(provider);
+    return { dispose() {} };
+  },
+  registerHoverProvider: (_sel, provider) => {
+    rec.hoverProviders.push(provider);
+    return { dispose() {} };
+  },
+  registerCodeLensProvider: (_sel, provider) => {
+    rec.codeLensProviders.push(provider);
+    return { dispose() {} };
+  },
+};
+
+const commands = {
+  registerCommand: (id, fn) => {
+    rec.commands[id] = fn;
+    return { dispose() {} };
+  },
+  executeCommand: (id, ...args) => {
+    rec.executed.push({ id, args });
+    return Promise.resolve();
+  },
+};
+
+const workspace = {
+  workspaceFolders: undefined,
+  getConfiguration: () => ({ get: (_key, def) => def }),
+  onDidSaveTextDocument: (fn) => {
+    rec.saveHandlers.push(fn);
+    return { dispose() {} };
+  },
+  onDidChangeWorkspaceFolders: (fn) => {
+    rec.folderHandlers.push(fn);
+    return { dispose() {} };
+  },
+};
+
+const lm = {
+  registerTool: (name, tool) => {
+    rec.tools[name] = tool;
+    return { dispose() {} };
+  },
+  registerMcpServerDefinitionProvider: (id, provider) => {
+    rec.mcpProviders[id] = provider;
+    return { dispose() {} };
+  },
+};
+
+const chat = {
+  createChatParticipant: (id, handler) => {
+    rec.participants[id] = handler;
+    return { id, iconPath: undefined, dispose() {} };
+  },
+};
+
+module.exports = {
+  __: rec,
+  EventEmitter,
+  Range,
+  Diagnostic,
+  ThemeIcon,
+  ThemeColor,
+  TreeItem,
+  CodeAction,
+  MarkdownString,
+  Hover,
+  CodeLens,
+  LanguageModelToolResult,
+  LanguageModelTextPart,
+  McpStdioServerDefinition,
+  Uri,
+  window,
+  languages,
+  commands,
+  workspace,
+  lm,
+  chat,
+  StatusBarAlignment: { Left: 1, Right: 2 },
+  DiagnosticSeverity: { Error: 0, Warning: 1, Information: 2, Hint: 3 },
+  TreeItemCollapsibleState: { None: 0, Collapsed: 1, Expanded: 2 },
+  CodeActionKind: { QuickFix: { value: 'quickfix' } },
+};
