@adsim/wordpress-mcp-server 4.5.0 → 4.6.0

package/tests/unit/plugins/elementor/elementorAdapter.test.js

@@ -0,0 +1,206 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { elementorAdapter } from '../../../../src/plugins/adapters/elementor/elementorAdapter.js';
+import { validateAdapter } from '../../../../src/plugins/IPluginAdapter.js';
+import { PluginRegistry } from '../../../../src/plugins/registry.js';
+
+let consoleSpy;
+
+beforeEach(() => {
+  consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+});
+afterEach(() => {
+  consoleSpy.mockRestore();
+});
+
+// ── Helpers ──
+
+function parseResult(result) {
+  return JSON.parse(result?.content?.[0]?.text);
+}
+
+function getAuditLogs() {
+  return consoleSpy.mock.calls
+    .map(c => c[0])
+    .filter(m => typeof m === 'string' && m.startsWith('[AUDIT]'))
+    .map(m => JSON.parse(m.replace('[AUDIT] ', '')));
+}
+
+function mockApi(data, shouldThrow = false) {
+  if (shouldThrow) {
+    return async () => { throw new Error('WP API 404: Not Found'); };
+  }
+  return async () => data;
+}
+
+// ── Mock data ──
+
+const mockTemplates = [
+  { id: 1, title: { rendered: 'Hero Template' }, type: 'page', author: 1, date: '2024-06-01', source: 'local' },
+  { id: 2, title: { rendered: 'CTA Section' }, type: 'section', author: 1, date: '2024-06-02', source: 'local' },
+  { id: 3, title: { rendered: 'Header Block' }, type: 'block', author: 2, date: '2024-06-03', source: 'remote' },
+  { id: 4, title: { rendered: 'Promo Popup' }, type: 'popup', author: 1, date: '2024-06-04', source: 'local' },
+];
+
+const mockTemplateDetail = {
+  id: 1,
+  title: { rendered: 'Hero Template' },
+  type: 'page',
+  content: {
+    elements: [
+      { elType: 'section', elements: [{ elType: 'widget', widgetType: 'heading' }] },
+      { elType: 'section', elements: [{ elType: 'widget', widgetType: 'image' }] },
+    ],
+  },
+};
+
+const mockPageData = {
+  elements: [
+    { elType: 'section', widgetType: null, elements: [
+      { elType: 'column', elements: [
+        { elType: 'widget', widgetType: 'heading', elements: [] },
+        { elType: 'widget', widgetType: 'text-editor', elements: [] },
+      ]},
+    ]},
+    { elType: 'section', widgetType: null, elements: [
+      { elType: 'column', elements: [
+        { elType: 'widget', widgetType: 'image', elements: [] },
+        { elType: 'widget', widgetType: 'heading', elements: [] },
+      ]},
+    ]},
+  ],
+};
+
+// =========================================================================
+// Tests
+// =========================================================================
+
+describe('Elementor Adapter', () => {
+
+  // 1. elementor_list_templates → retourne liste avec id/title/type
+  it('elementor_list_templates returns list with id/title/type', async () => {
+    const tool = elementorAdapter.getTools().find(t => t.name === 'elementor_list_templates');
+    const result = await tool.handler({}, mockApi(mockTemplates));
+    const data = parseResult(result);
+    expect(data.total).toBe(4);
+    expect(data.templates[0].id).toBe(1);
+    expect(data.templates[0].title).toBe('Hero Template');
+    expect(data.templates[0].type).toBe('page');
+    expect(data.templates[2].source).toBe('remote');
+  });
+
+  // 2. elementor_list_templates avec type filter → filtre appliqué
+  it('elementor_list_templates filters by type', async () => {
+    const tool = elementorAdapter.getTools().find(t => t.name === 'elementor_list_templates');
+    const result = await tool.handler({ type: 'section' }, mockApi(mockTemplates));
+    const data = parseResult(result);
+    expect(data.total).toBe(1);
+    expect(data.templates[0].id).toBe(2);
+    expect(data.templates[0].type).toBe('section');
+  });
+
+  // 3. elementor_get_template → retourne contenu complet
+  it('elementor_get_template returns full template content', async () => {
+    const tool = elementorAdapter.getTools().find(t => t.name === 'elementor_get_template');
+    const result = await tool.handler({ id: 1 }, mockApi(mockTemplateDetail));
+    const data = parseResult(result);
+    expect(data.id).toBe(1);
+    expect(data.title).toBe('Hero Template');
+    expect(data.type).toBe('page');
+    expect(data.content).toBeDefined();
+  });
+
+  // 4. elementor_get_template → contextGuard truncate si > 50k
+  it('elementor_get_template applies contextGuard on large responses', async () => {
+    // Generate a template with > 50000 chars of content
+    const bigContent = { elements: [] };
+    for (let i = 0; i < 800; i++) {
+      bigContent.elements.push({ elType: 'widget', widgetType: 'text-editor', settings: { content: 'x'.repeat(100) } });
+    }
+    const bigTemplate = { id: 99, title: { rendered: 'Big Template' }, type: 'page', content: bigContent };
+    const tool = elementorAdapter.getTools().find(t => t.name === 'elementor_get_template');
+    const result = await tool.handler({ id: 99 }, mockApi(bigTemplate));
+    const data = parseResult(result);
+    expect(data._truncated).toBe(true);
+    expect(data._original_size).toBeGreaterThan(50000);
+    expect(data._warning).toContain('truncated');
+  });
+
+  // 5. elementor_get_page_data → retourne widgets_used et elements_count
+  it('elementor_get_page_data returns widgets_used and elements_count', async () => {
+    const tool = elementorAdapter.getTools().find(t => t.name === 'elementor_get_page_data');
+    const result = await tool.handler({ post_id: 42 }, mockApi(mockPageData));
+    const data = parseResult(result);
+    expect(data.post_id).toBe(42);
+    expect(data.elementor_status).toBe('active');
+    expect(data.widgets_used).toContain('heading');
+    expect(data.widgets_used).toContain('text-editor');
+    expect(data.widgets_used).toContain('image');
+    expect(data.elements_count).toBeGreaterThan(0);
+  });
+
+  // 6. elementor_get_template id invalide → erreur validation
+  it('elementor_get_template rejects invalid id', async () => {
+    const tool = elementorAdapter.getTools().find(t => t.name === 'elementor_get_template');
+    await expect(
+      tool.handler({ id: 'abc' }, mockApi({}))
+    ).rejects.toThrow('Validation error');
+  });
+
+  // 7. 404 template not found → erreur propre
+  it('elementor_get_template propagates 404 error', async () => {
+    const tool = elementorAdapter.getTools().find(t => t.name === 'elementor_get_template');
+    await expect(
+      tool.handler({ id: 99999 }, mockApi(null, true))
+    ).rejects.toThrow('404');
+  });
+
+  // 8. Adapter détecté uniquement si namespace /elementor/v1 présent
+  it('registry detects elementor only when namespace is present', async () => {
+    const registry = new PluginRegistry();
+
+    // Without elementor namespace
+    await registry.initialize(mockApi({ namespaces: ['wp/v2'] }));
+    expect(registry.isActive('elementor')).toBe(false);
+
+    // With elementor namespace
+    registry.active.clear();
+    await registry.initialize(mockApi({ namespaces: ['wp/v2', 'elementor/v1'] }));
+    expect(registry.isActive('elementor')).toBe(true);
+  });
+
+  // 9. Audit log format correct pour chaque outil
+  it('logs correct audit format for all 3 tools', async () => {
+    const listTool = elementorAdapter.getTools().find(t => t.name === 'elementor_list_templates');
+    const getTool = elementorAdapter.getTools().find(t => t.name === 'elementor_get_template');
+    const pageTool = elementorAdapter.getTools().find(t => t.name === 'elementor_get_page_data');
+
+    await listTool.handler({}, mockApi(mockTemplates));
+    await getTool.handler({ id: 1 }, mockApi(mockTemplateDetail));
+    await pageTool.handler({ post_id: 42 }, mockApi(mockPageData));
+
+    const logs = getAuditLogs();
+
+    const listEntry = logs.find(l => l.tool === 'elementor_list_templates');
+    expect(listEntry).toBeDefined();
+    expect(listEntry.action).toBe('list_templates');
+    expect(listEntry.status).toBe('success');
+    expect(typeof listEntry.latency_ms).toBe('number');
+
+    const getEntry = logs.find(l => l.tool === 'elementor_get_template');
+    expect(getEntry).toBeDefined();
+    expect(getEntry.action).toBe('read_template');
+    expect(getEntry.target).toBe(1);
+
+    const pageEntry = logs.find(l => l.tool === 'elementor_get_page_data');
+    expect(pageEntry).toBeDefined();
+    expect(pageEntry.action).toBe('read_page_data');
+    expect(pageEntry.target).toBe(42);
+  });
+
+  // 10. Passes validateAdapter
+  it('passes validateAdapter without errors', () => {
+    const { valid, errors } = validateAdapter(elementorAdapter);
+    expect(valid).toBe(true);
+    expect(errors).toEqual([]);
+  });
+});

package/tests/unit/plugins/iPluginAdapter.test.js

@@ -0,0 +1,34 @@
+import { describe, it, expect } from 'vitest';
+import { validateAdapter } from '../../../src/plugins/IPluginAdapter.js';
+
+const validAdapter = {
+  id: 'acf',
+  namespace: 'acf/v3',
+  riskLevel: 'medium',
+  contextConfig: {
+    maxChars: 30000,
+    defaultMode: 'compact',
+    supportedModes: ['raw', 'compact', 'summary', 'ids_only'],
+  },
+  getTools: () => [],
+};
+
+describe('validateAdapter', () => {
+  it('validates a complete adapter', () => {
+    const { valid, errors } = validateAdapter(validAdapter);
+    expect(valid).toBe(true);
+    expect(errors).toEqual([]);
+  });
+
+  it('rejects an adapter without id', () => {
+    const { valid, errors } = validateAdapter({ ...validAdapter, id: undefined });
+    expect(valid).toBe(false);
+    expect(errors.some(e => e.includes('"id"'))).toBe(true);
+  });
+
+  it('rejects an adapter without getTools', () => {
+    const { valid, errors } = validateAdapter({ ...validAdapter, getTools: undefined });
+    expect(valid).toBe(false);
+    expect(errors.some(e => e.includes('"getTools"'))).toBe(true);
+  });
+});

package/tests/unit/plugins/registry.test.js

@@ -0,0 +1,84 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { PluginRegistry } from '../../../src/plugins/registry.js';
+
+let consoleSpy;
+const envBackup = {};
+
+function saveEnv(...keys) {
+  keys.forEach(k => { envBackup[k] = process.env[k]; });
+}
+function restoreEnv() {
+  Object.entries(envBackup).forEach(([k, v]) => {
+    if (v === undefined) delete process.env[k];
+    else process.env[k] = v;
+  });
+}
+
+beforeEach(() => {
+  consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  saveEnv('WP_DISABLE_PLUGIN_LAYERS');
+  delete process.env.WP_DISABLE_PLUGIN_LAYERS;
+});
+afterEach(() => {
+  consoleSpy.mockRestore();
+  restoreEnv();
+});
+
+function mockApiRequest(namespaces = []) {
+  return async () => ({ namespaces });
+}
+
+describe('PluginRegistry', () => {
+  it('initialize() detects ACF when "acf/v3" in namespaces', async () => {
+    const reg = new PluginRegistry();
+    await reg.initialize(mockApiRequest(['wp/v2', 'acf/v3']));
+    expect(reg.isActive('acf')).toBe(true);
+    expect(reg.isActive('elementor')).toBe(false);
+  });
+
+  it('initialize() detects Elementor when "elementor/v1" in namespaces', async () => {
+    const reg = new PluginRegistry();
+    await reg.initialize(mockApiRequest(['wp/v2', 'elementor/v1', 'elementor/v2']));
+    expect(reg.isActive('elementor')).toBe(true);
+    expect(reg.isActive('acf')).toBe(false);
+  });
+
+  it('initialize() detects nothing when namespaces is empty', async () => {
+    const reg = new PluginRegistry();
+    await reg.initialize(mockApiRequest([]));
+    expect(reg.isActive('acf')).toBe(false);
+    expect(reg.isActive('elementor')).toBe(false);
+    expect(reg.isActive('astra')).toBe(false);
+    expect(reg.getSummary().active).toEqual([]);
+  });
+
+  it('getAvailableTools() returns [] when WP_DISABLE_PLUGIN_LAYERS=true', async () => {
+    const reg = new PluginRegistry();
+    await reg.initialize(mockApiRequest(['acf/v3']));
+    reg.registerTools('acf', [{ name: 'acf_get_fields' }]);
+
+    process.env.WP_DISABLE_PLUGIN_LAYERS = 'true';
+    expect(reg.getAvailableTools()).toEqual([]);
+  });
+
+  it('isActive() returns true for detected plugins and false otherwise', async () => {
+    const reg = new PluginRegistry();
+    await reg.initialize(mockApiRequest(['acf/v3', 'astra/v1']));
+    expect(reg.isActive('acf')).toBe(true);
+    expect(reg.isActive('astra')).toBe(true);
+    expect(reg.isActive('elementor')).toBe(false);
+    expect(reg.isActive('nonexistent')).toBe(false);
+  });
+
+  it('getSummary() returns the correct structure', async () => {
+    const reg = new PluginRegistry();
+    await reg.initialize(mockApiRequest(['elementor/v1', 'acf/v3']));
+    const summary = reg.getSummary();
+    expect(summary.active).toContain('acf');
+    expect(summary.active).toContain('elementor');
+    expect(summary.disabled_by_env).toBe(false);
+
+    process.env.WP_DISABLE_PLUGIN_LAYERS = 'true';
+    expect(reg.getSummary().disabled_by_env).toBe(true);
+  });
+});

package/tests/unit/tools/dynamicFiltering.test.js

@@ -0,0 +1,136 @@
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+
+vi.mock('node-fetch', () => ({ default: vi.fn() }));
+
+import fetch from 'node-fetch';
+import { handleToolCall, getFilteredTools } from '../../../index.js';
+import { makeRequest, mockSuccess, mockError, parseResult } from '../../helpers/mockWpRequest.js';
+
+function call(name, args = {}) {
+  return handleToolCall(makeRequest(name, args));
+}
+
+let consoleSpy;
+const envBackup = {};
+
+function saveEnv(...keys) {
+  keys.forEach(k => { envBackup[k] = process.env[k]; });
+}
+function restoreEnv() {
+  Object.entries(envBackup).forEach(([k, v]) => {
+    if (v === undefined) delete process.env[k];
+    else process.env[k] = v;
+  });
+}
+
+beforeEach(() => {
+  fetch.mockReset();
+  consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  saveEnv('WC_CONSUMER_KEY', 'WP_REQUIRE_APPROVAL', 'WP_ENABLE_PLUGIN_INTELLIGENCE');
+  // Default: all optional features OFF
+  delete process.env.WC_CONSUMER_KEY;
+  delete process.env.WP_REQUIRE_APPROVAL;
+  delete process.env.WP_ENABLE_PLUGIN_INTELLIGENCE;
+});
+afterEach(() => {
+  consoleSpy.mockRestore();
+  restoreEnv();
+});
+
+// =========================================================================
+// WooCommerce filtering
+// =========================================================================
+
+describe('WooCommerce filtering', () => {
+  it('hides WooCommerce tools when WC_CONSUMER_KEY absent', () => {
+    const tools = getFilteredTools();
+    const wcTools = tools.filter(t => t.name.startsWith('wc_'));
+    expect(wcTools).toHaveLength(0);
+  });
+
+  it('shows WooCommerce tools when WC_CONSUMER_KEY set', () => {
+    process.env.WC_CONSUMER_KEY = 'ck_test';
+    const tools = getFilteredTools();
+    const wcTools = tools.filter(t => t.name.startsWith('wc_'));
+    expect(wcTools.length).toBe(13);
+  });
+});
+
+// =========================================================================
+// Editorial workflow filtering
+// =========================================================================
+
+describe('Editorial workflow filtering', () => {
+  it('hides editorial tools when WP_REQUIRE_APPROVAL not true', () => {
+    const tools = getFilteredTools();
+    const names = tools.map(t => t.name);
+    expect(names).not.toContain('wp_submit_for_review');
+    expect(names).not.toContain('wp_approve_post');
+    expect(names).not.toContain('wp_reject_post');
+  });
+
+  it('shows editorial tools when WP_REQUIRE_APPROVAL=true', () => {
+    process.env.WP_REQUIRE_APPROVAL = 'true';
+    const tools = getFilteredTools();
+    const names = tools.map(t => t.name);
+    expect(names).toContain('wp_submit_for_review');
+    expect(names).toContain('wp_approve_post');
+    expect(names).toContain('wp_reject_post');
+  });
+});
+
+// =========================================================================
+// Plugin Intelligence filtering
+// =========================================================================
+
+describe('Plugin Intelligence filtering', () => {
+  it('hides Plugin Intelligence when WP_ENABLE_PLUGIN_INTELLIGENCE not true', () => {
+    const tools = getFilteredTools();
+    const names = tools.map(t => t.name);
+    expect(names).not.toContain('wp_get_rendered_head');
+    expect(names).not.toContain('wp_audit_schema_plugins');
+    expect(names).not.toContain('wp_get_twitter_meta');
+  });
+
+  it('shows Plugin Intelligence when WP_ENABLE_PLUGIN_INTELLIGENCE=true', () => {
+    process.env.WP_ENABLE_PLUGIN_INTELLIGENCE = 'true';
+    const tools = getFilteredTools();
+    const piNames = ['wp_get_rendered_head', 'wp_audit_rendered_seo', 'wp_get_pillar_content', 'wp_audit_schema_plugins', 'wp_get_seo_score', 'wp_get_twitter_meta'];
+    const names = tools.map(t => t.name);
+    piNames.forEach(n => expect(names).toContain(n));
+  });
+});
+
+// =========================================================================
+// Combined counts
+// =========================================================================
+
+describe('Combined filtering counts', () => {
+  it('returns all 86 tools when all features enabled', () => {
+    process.env.WC_CONSUMER_KEY = 'ck_test';
+    process.env.WP_REQUIRE_APPROVAL = 'true';
+    process.env.WP_ENABLE_PLUGIN_INTELLIGENCE = 'true';
+    expect(getFilteredTools()).toHaveLength(86);
+  });
+
+  it('returns 64 tools with no optional features (86 - 13wc - 3editorial - 6pi)', () => {
+    expect(getFilteredTools()).toHaveLength(64);
+  });
+});
+
+// =========================================================================
+// handleToolCall still works for filtered-out tools
+// =========================================================================
+
+describe('Filtered tools remain callable', () => {
+  it('handleToolCall works for a filtered-out WooCommerce tool (wc_list_products)', async () => {
+    // WC_CONSUMER_KEY is absent, so wc_list_products is filtered from listTools
+    const names = getFilteredTools().map(t => t.name);
+    expect(names).not.toContain('wc_list_products');
+
+    // But calling it directly should NOT throw "Unknown tool"
+    // It will fail with a WooCommerce credentials error, which is fine
+    const res = await call('wc_list_products');
+    expect(res.content[0].text).not.toContain('Unknown tool');
+  });
+});