test: add 32 tests covering resources, commands, MCP, discovery, and platform

Extension Resources (9): validates webview-dist, schema, snippets, and
language config are bundled. Plugin Discovery (6): go.mod regex parsing
and cache logic. MCP Config (6): JSON read/write/merge and error handling.
Commands (3): package.json command declarations and menu contributions.
Platform Detection (3): binary download platform mapping.
Visual Editor (5): content detection, partial match rejection.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: intel352

src/test/suite/commands.test.ts

@@ -0,0 +1,72 @@
+import * as assert from 'assert';
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * Validates that all commands declared in package.json exist in the
+ * extension source. This is a static check that doesn't require
+ * activation (which would prompt for binary downloads in CI).
+ */
+suite('Commands', () => {
+  const extensionRoot = path.resolve(__dirname, '..', '..', '..');
+
+  test('all declared commands have matching registrations in extension.ts', () => {
+    const packageJson = JSON.parse(
+      fs.readFileSync(path.join(extensionRoot, 'package.json'), 'utf-8'),
+    );
+    const declaredCommands: string[] = packageJson.contributes.commands.map(
+      (c: { command: string }) => c.command,
+    );
+
+    assert.ok(declaredCommands.length > 0, 'Must have declared commands');
+
+    // Read the compiled extension source to verify commands are registered
+    const extensionSrc = fs.readFileSync(
+      path.join(extensionRoot, 'out', 'extension.js'),
+      'utf-8',
+    );
+    const commandsSrc = fs.readFileSync(
+      path.join(extensionRoot, 'out', 'commands.js'),
+      'utf-8',
+    );
+    const allSrc = extensionSrc + commandsSrc;
+
+    for (const cmd of declaredCommands) {
+      assert.ok(
+        allSrc.includes(cmd),
+        `Command ${cmd} declared in package.json but not found in compiled source`,
+      );
+    }
+  });
+
+  test('package.json commands have title and command fields', () => {
+    const packageJson = JSON.parse(
+      fs.readFileSync(path.join(extensionRoot, 'package.json'), 'utf-8'),
+    );
+    for (const cmd of packageJson.contributes.commands) {
+      assert.ok(cmd.command, `Command missing "command" field`);
+      assert.ok(cmd.title, `Command ${cmd.command} missing "title" field`);
+      assert.ok(
+        cmd.title.startsWith('Workflow:'),
+        `Command ${cmd.command} title should start with "Workflow:", got "${cmd.title}"`,
+      );
+    }
+  });
+
+  test('visual editor menu contribution has correct when clause', () => {
+    const packageJson = JSON.parse(
+      fs.readFileSync(path.join(extensionRoot, 'package.json'), 'utf-8'),
+    );
+    const editorTitleMenus = packageJson.contributes.menus['editor/title'];
+    assert.ok(editorTitleMenus, 'Must have editor/title menu contributions');
+
+    const visualEditorMenu = editorTitleMenus.find(
+      (m: { command: string }) => m.command === 'workflow.openVisualEditor',
+    );
+    assert.ok(visualEditorMenu, 'Visual editor must be in editor/title menu');
+    assert.ok(
+      visualEditorMenu.when.includes('.yaml') || visualEditorMenu.when.includes('.yml'),
+      'Visual editor menu should only show for YAML files',
+    );
+  });
+});

src/test/suite/mcp-config.test.ts

@@ -0,0 +1,115 @@
+import * as assert from 'assert';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as os from 'os';
+
+/**
+ * Tests MCP config file read/write/merge logic.
+ * Validates the same patterns used in mcp-config.ts without needing
+ * the full VS Code API for the pure I/O functions.
+ */
+suite('MCP Config', () => {
+  let tmpDir: string;
+
+  setup(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'workflow-mcp-test-'));
+  });
+
+  teardown(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test('creates new mcp.json with workflow server', () => {
+    const mcpPath = path.join(tmpDir, '.vscode', 'mcp.json');
+    const dir = path.dirname(mcpPath);
+    fs.mkdirSync(dir, { recursive: true });
+
+    const config = {
+      servers: {
+        workflow: {
+          command: '/usr/local/bin/wfctl',
+          args: ['mcp'],
+        },
+      },
+    };
+    fs.writeFileSync(mcpPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+
+    const loaded = JSON.parse(fs.readFileSync(mcpPath, 'utf-8'));
+    assert.ok(loaded.servers.workflow, 'Must have workflow server');
+    assert.strictEqual(loaded.servers.workflow.command, '/usr/local/bin/wfctl');
+    assert.deepStrictEqual(loaded.servers.workflow.args, ['mcp']);
+  });
+
+  test('merges workflow server into existing mcp.json', () => {
+    const mcpPath = path.join(tmpDir, 'mcp.json');
+    const existing = {
+      servers: {
+        other: { command: '/usr/local/bin/other', args: ['serve'] },
+      },
+    };
+    fs.writeFileSync(mcpPath, JSON.stringify(existing));
+
+    // Simulate the merge logic from mcp-config.ts
+    const current = JSON.parse(fs.readFileSync(mcpPath, 'utf-8'));
+    const updated = {
+      ...current,
+      servers: {
+        ...(current.servers ?? {}),
+        workflow: { command: '/usr/local/bin/wfctl', args: ['mcp'] },
+      },
+    };
+    fs.writeFileSync(mcpPath, JSON.stringify(updated, null, 2) + '\n');
+
+    const result = JSON.parse(fs.readFileSync(mcpPath, 'utf-8'));
+    assert.ok(result.servers.other, 'Must preserve existing server');
+    assert.ok(result.servers.workflow, 'Must add workflow server');
+    assert.strictEqual(result.servers.other.command, '/usr/local/bin/other');
+    assert.strictEqual(result.servers.workflow.command, '/usr/local/bin/wfctl');
+  });
+
+  test('detects existing workflow server', () => {
+    const config = {
+      servers: {
+        workflow: { command: '/usr/local/bin/wfctl', args: ['mcp'] },
+      },
+    };
+    const hasWorkflow = !!(config.servers && config.servers['workflow']);
+    assert.ok(hasWorkflow);
+  });
+
+  test('detects missing workflow server', () => {
+    const config = {
+      servers: {
+        other: { command: '/usr/local/bin/other' },
+      },
+    };
+    const hasWorkflow = !!(config.servers && (config.servers as Record<string, unknown>)['workflow']);
+    assert.ok(!hasWorkflow);
+  });
+
+  test('handles empty/missing config gracefully', () => {
+    const mcpPath = path.join(tmpDir, 'nonexistent.json');
+    let config = {};
+    if (fs.existsSync(mcpPath)) {
+      try {
+        config = JSON.parse(fs.readFileSync(mcpPath, 'utf-8'));
+      } catch {
+        config = {};
+      }
+    }
+    assert.deepStrictEqual(config, {});
+  });
+
+  test('handles corrupt JSON gracefully', () => {
+    const mcpPath = path.join(tmpDir, 'corrupt.json');
+    fs.writeFileSync(mcpPath, '{not valid json!!!');
+
+    let config = {};
+    try {
+      config = JSON.parse(fs.readFileSync(mcpPath, 'utf-8'));
+    } catch {
+      config = {};
+    }
+    assert.deepStrictEqual(config, {});
+  });
+});

src/test/suite/platform.test.ts

@@ -0,0 +1,55 @@
+import * as assert from 'assert';
+import * as os from 'os';
+
+/**
+ * Tests the platform detection logic used by wfctl.ts and lsp-client.ts
+ * for binary downloads. Validates the current platform is supported and
+ * maps correctly.
+ */
+suite('Platform Detection', () => {
+  // Reimplements getPlatformSuffix() from wfctl.ts for testing
+  function getPlatformSuffix(): string {
+    const platform = os.platform();
+    const arch = os.arch();
+    if (platform === 'darwin') {
+      return arch === 'arm64' ? 'darwin-arm64' : 'darwin-amd64';
+    }
+    if (platform === 'linux') {
+      return arch === 'arm64' ? 'linux-arm64' : 'linux-amd64';
+    }
+    if (platform === 'win32') {
+      return 'windows-amd64';
+    }
+    throw new Error(`Unsupported platform: ${platform}/${arch}`);
+  }
+
+  test('current platform is supported', () => {
+    // Should not throw
+    const suffix = getPlatformSuffix();
+    assert.ok(suffix.length > 0, 'Platform suffix must not be empty');
+  });
+
+  test('platform suffix contains expected segments', () => {
+    const suffix = getPlatformSuffix();
+    const [osName, arch] = suffix.split('-');
+
+    assert.ok(
+      ['darwin', 'linux', 'windows'].includes(osName),
+      `OS must be darwin/linux/windows, got ${osName}`,
+    );
+    assert.ok(
+      ['amd64', 'arm64'].includes(arch),
+      `Arch must be amd64/arm64, got ${arch}`,
+    );
+  });
+
+  test('binary filename has .exe on windows', () => {
+    const platform = os.platform();
+    const binaryFileName = platform === 'win32' ? 'wfctl.exe' : 'wfctl';
+    if (platform === 'win32') {
+      assert.ok(binaryFileName.endsWith('.exe'));
+    } else {
+      assert.ok(!binaryFileName.endsWith('.exe'));
+    }
+  });
+});

src/test/suite/plugin-discovery.test.ts

@@ -0,0 +1,110 @@
+import * as assert from 'assert';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as os from 'os';
+
+/**
+ * Test the parseGoModPlugins function by importing the module's logic.
+ * Since parseGoModPlugins is not exported, we test the regex pattern directly.
+ */
+suite('Plugin Discovery', () => {
+  let tmpDir: string;
+
+  setup(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'workflow-pd-test-'));
+  });
+
+  teardown(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test('go.mod plugin regex matches workflow-plugin-* dependencies', () => {
+    const goMod = `module github.com/example/myapp
+
+go 1.22
+
+require (
+	github.com/GoCodeAlone/workflow v0.3.30
+	github.com/GoCodeAlone/workflow-plugin-agent v0.3.1
+	github.com/GoCodeAlone/workflow-plugin-authz v0.2.0
+	github.com/GoCodeAlone/workflow-plugin-payments v0.1.0
+	github.com/GoCodeAlone/modular v1.12.0
+	github.com/some-other/module v1.0.0
+)`;
+
+    const plugins: string[] = [];
+    for (const line of goMod.split('\n')) {
+      const match = line.match(/github\.com\/GoCodeAlone\/(workflow-plugin-\S+)/);
+      if (match) plugins.push(match[1]);
+    }
+
+    assert.deepStrictEqual(plugins, [
+      'workflow-plugin-agent',
+      'workflow-plugin-authz',
+      'workflow-plugin-payments',
+    ]);
+  });
+
+  test('go.mod regex does not match non-plugin workflow modules', () => {
+    const goMod = `require (
+	github.com/GoCodeAlone/workflow v0.3.30
+	github.com/GoCodeAlone/modular v1.12.0
+	github.com/GoCodeAlone/workflow-editor v0.1.0
+)`;
+
+    const plugins: string[] = [];
+    for (const line of goMod.split('\n')) {
+      const match = line.match(/github\.com\/GoCodeAlone\/(workflow-plugin-\S+)/);
+      if (match) plugins.push(match[1]);
+    }
+
+    assert.deepStrictEqual(plugins, []);
+  });
+
+  test('go.mod regex handles version suffixes correctly', () => {
+    const goMod = `require github.com/GoCodeAlone/workflow-plugin-agent v0.3.1 // indirect`;
+
+    const plugins: string[] = [];
+    for (const line of goMod.split('\n')) {
+      const match = line.match(/github\.com\/GoCodeAlone\/(workflow-plugin-\S+)/);
+      if (match) plugins.push(match[1]);
+    }
+
+    // The regex captures "workflow-plugin-agent" and stops at whitespace
+    assert.strictEqual(plugins.length, 1);
+    assert.strictEqual(plugins[0], 'workflow-plugin-agent');
+  });
+
+  test('go.mod regex returns empty for empty content', () => {
+    const plugins: string[] = [];
+    for (const line of ''.split('\n')) {
+      const match = line.match(/github\.com\/GoCodeAlone\/(workflow-plugin-\S+)/);
+      if (match) plugins.push(match[1]);
+    }
+    assert.deepStrictEqual(plugins, []);
+  });
+
+  test('cache directory creation works', () => {
+    const cacheDir = path.join(tmpDir, 'plugin-manifests');
+    assert.ok(!fs.existsSync(cacheDir));
+    fs.mkdirSync(cacheDir, { recursive: true });
+    assert.ok(fs.existsSync(cacheDir));
+  });
+
+  test('cached manifest read/write round-trips', () => {
+    const cacheDir = path.join(tmpDir, 'plugin-manifests');
+    fs.mkdirSync(cacheDir, { recursive: true });
+
+    const manifest = {
+      name: 'workflow-plugin-agent',
+      stepTypes: [{ name: 'step.agent_execute' }],
+      moduleTypes: [{ name: 'agent.provider' }],
+    };
+
+    const cacheFile = path.join(cacheDir, 'workflow-plugin-agent.json');
+    fs.writeFileSync(cacheFile, JSON.stringify(manifest));
+
+    const loaded = JSON.parse(fs.readFileSync(cacheFile, 'utf-8'));
+    assert.deepStrictEqual(loaded, manifest);
+  });
+});