@adsim/wordpress-mcp-server 4.6.0 → 5.1.0

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

@@ -0,0 +1,351 @@
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+
+vi.mock('node-fetch', () => ({ default: vi.fn() }));
+
+import fetch from 'node-fetch';
+import { handleToolCall } from '../../../index.js';
+import { mockSuccess, mockError, getAuditLogs, makeRequest, parseResult } from '../../helpers/mockWpRequest.js';
+
+function call(name, args = {}) {
+  return handleToolCall(makeRequest(name, args));
+}
+
+function mockFetchJson(data, status = 200) {
+  return Promise.resolve({
+    ok: status >= 200 && status < 400,
+    status,
+    headers: { get: (h) => h === 'content-type' ? 'application/json' : null },
+    json: () => Promise.resolve(data),
+    text: () => Promise.resolve(typeof data === 'string' ? data : JSON.stringify(data))
+  });
+}
+
+function mockFetchText(text, status = 200) {
+  return Promise.resolve({
+    ok: status >= 200 && status < 400,
+    status,
+    headers: { get: (h) => h === 'content-type' ? 'text/html' : null },
+    json: () => Promise.reject(new Error('not json')),
+    text: () => Promise.resolve(text)
+  });
+}
+
+// ════════════════════════════════════════════════════════════
+// wp_audit_page_speed
+// ════════════════════════════════════════════════════════════
+
+describe('wp_audit_page_speed', () => {
+  let consoleSpy;
+  const envBackup = {};
+  beforeEach(() => {
+    fetch.mockReset();
+    consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    envBackup.PAGESPEED_API_KEY = process.env.PAGESPEED_API_KEY;
+    process.env.PAGESPEED_API_KEY = 'test-key-123';
+  });
+  afterEach(() => {
+    consoleSpy.mockRestore();
+    if (envBackup.PAGESPEED_API_KEY === undefined) delete process.env.PAGESPEED_API_KEY;
+    else process.env.PAGESPEED_API_KEY = envBackup.PAGESPEED_API_KEY;
+  });
+
+  it('returns Core Web Vitals and score', async () => {
+    fetch.mockImplementation(() => mockFetchJson({
+      lighthouseResult: {
+        categories: { performance: { score: 0.85 } },
+        audits: {
+          'largest-contentful-paint': { displayValue: '1.2 s', score: 0.9 },
+          'cumulative-layout-shift': { displayValue: '0.05', score: 0.95 },
+          'interaction-to-next-paint': { displayValue: '120 ms', score: 0.8 },
+          'first-contentful-paint': { displayValue: '0.8 s', score: 0.92 },
+          'server-response-time': { displayValue: '200 ms', score: 0.9 },
+          'speed-index': { displayValue: '1.5 s' },
+          'total-blocking-time': { displayValue: '50 ms' },
+          'render-blocking-resources': { title: 'Eliminate render-blocking resources', details: { type: 'opportunity', overallSavingsMs: 500, overallSavingsBytes: 50000 }, description: 'Remove render-blocking CSS' },
+          'unused-css-rules': { title: 'Reduce unused CSS', details: { type: 'opportunity', overallSavingsMs: 200 }, description: 'Remove unused CSS rules' }
+        }
+      }
+    }));
+
+    const result = await call('wp_audit_page_speed', { url: 'https://example.com', strategy: 'mobile' });
+    const data = parseResult(result);
+
+    expect(data.score).toBe(85);
+    expect(data.strategy).toBe('mobile');
+    expect(data.metrics.lcp).toBe('1.2 s');
+    expect(data.metrics.cls).toBe('0.05');
+    expect(data.metrics.inp).toBe('120 ms');
+    expect(data.metrics.fcp).toBe('0.8 s');
+    expect(data.metrics.ttfb).toBe('200 ms');
+    expect(data.opportunities_count).toBe(2);
+    expect(data.opportunities[0].savings_ms).toBe(500); // Sorted by impact
+  });
+
+  it('errors without PAGESPEED_API_KEY', async () => {
+    delete process.env.PAGESPEED_API_KEY;
+    const result = await call('wp_audit_page_speed', { url: 'https://example.com' });
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('PAGESPEED_API_KEY');
+  });
+
+  it('calls correct API URL', async () => {
+    fetch.mockImplementation(() => mockFetchJson({ lighthouseResult: { categories: {}, audits: {} } }));
+    await call('wp_audit_page_speed', { url: 'https://example.com', strategy: 'desktop' });
+    const [url] = fetch.mock.calls[0];
+    expect(url).toContain('googleapis.com/pagespeedonline/v5');
+    expect(url).toContain('strategy=desktop');
+    expect(url).toContain('key=test-key-123');
+  });
+
+  it('logs audit entry', async () => {
+    fetch.mockImplementation(() => mockFetchJson({ lighthouseResult: { categories: {}, audits: {} } }));
+    await call('wp_audit_page_speed', { url: 'https://example.com' });
+    const logs = getAuditLogs();
+    expect(logs.find(l => l.tool === 'wp_audit_page_speed')).toBeDefined();
+  });
+});
+
+// ════════════════════════════════════════════════════════════
+// wp_find_render_blocking_resources
+// ════════════════════════════════════════════════════════════
+
+describe('wp_find_render_blocking_resources', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('detects render-blocking CSS and JS in head', async () => {
+    const html = `<!DOCTYPE html><html><head>
+      <link rel="stylesheet" href="/style.css">
+      <link rel="stylesheet" href="/theme.css" media="print">
+      <script src="/main.js"></script>
+      <script src="/deferred.js" defer></script>
+      <script src="/async.js" async></script>
+      <script src="/module.js" type="module"></script>
+    </head><body></body></html>`;
+
+    fetch.mockImplementation(() => mockFetchText(html));
+    const result = await call('wp_find_render_blocking_resources', { url: 'https://example.com' });
+    const data = parseResult(result);
+
+    expect(data.total_blocking).toBe(2); // style.css + main.js (theme.css excluded by media=print, others by defer/async/module)
+    expect(data.blocking_css).toBe(1);
+    expect(data.blocking_js).toBe(1);
+    expect(data.resources[0].url).toBe('/style.css');
+    expect(data.resources[1].url).toBe('/main.js');
+  });
+
+  it('returns 0 when no blocking resources', async () => {
+    const html = `<html><head><script src="/app.js" defer></script></head><body></body></html>`;
+    fetch.mockImplementation(() => mockFetchText(html));
+    const result = await call('wp_find_render_blocking_resources', { url: 'https://example.com' });
+    const data = parseResult(result);
+    expect(data.total_blocking).toBe(0);
+  });
+
+  it('uses site URL as default when no url provided', async () => {
+    fetch.mockImplementation(() => mockFetchText('<html><head></head><body></body></html>'));
+    await call('wp_find_render_blocking_resources');
+    const [url] = fetch.mock.calls[0];
+    expect(url).toContain('test.example.com');
+  });
+});
+
+// ════════════════════════════════════════════════════════════
+// wp_audit_image_optimization
+// ════════════════════════════════════════════════════════════
+
+describe('wp_audit_image_optimization', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('detects non-WebP, large files, and missing alt text', async () => {
+    fetch.mockResolvedValue(mockSuccess([
+      { id: 1, source_url: 'https://example.com/big.jpg', mime_type: 'image/jpeg', alt_text: '', media_details: { filesize: 512000 } },
+      { id: 2, source_url: 'https://example.com/small.webp', mime_type: 'image/webp', alt_text: 'Good alt text', media_details: { filesize: 30000 } },
+      { id: 3, source_url: 'https://example.com/medium.png', mime_type: 'image/png', alt_text: 'Ok', media_details: { filesize: 200000 } }
+    ]));
+
+    const result = await call('wp_audit_image_optimization');
+    const data = parseResult(result);
+
+    expect(data.total_audited).toBe(3);
+    expect(data.issues_found).toBe(2); // big.jpg (3 problems) + medium.png (3: not_modern_format + large_file + short_alt_text "Ok"=2chars), small.webp is fine
+    expect(data.by_priority.high).toBe(2); // both have 3 problems
+
+    const bigJpg = data.images.find(i => i.id === 1);
+    expect(bigJpg.problems).toHaveLength(3); // not_modern_format + large_file + missing_alt_text
+    expect(bigJpg.priority).toBe('high');
+  });
+
+  it('respects min_size_kb parameter', async () => {
+    fetch.mockResolvedValue(mockSuccess([
+      { id: 1, source_url: 'https://example.com/img.jpg', mime_type: 'image/jpeg', alt_text: 'alt', media_details: { filesize: 60000 } }
+    ]));
+    // Default threshold 100KB - 60KB image should not be flagged for size
+    const result = await call('wp_audit_image_optimization');
+    const data = parseResult(result);
+    const img = data.images.find(i => i.id === 1);
+    // Still flagged for non-webp format
+    expect(img.problems.some(p => p.issue === 'large_file')).toBe(false);
+  });
+});
+
+// ════════════════════════════════════════════════════════════
+// wp_check_caching_status
+// ════════════════════════════════════════════════════════════
+
+describe('wp_check_caching_status', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('detects active caching plugin and cache headers', async () => {
+    // First call: /plugins
+    fetch.mockImplementationOnce(() => mockFetchJson([
+      { plugin: 'wp-rocket/wp-rocket.php', name: 'WP Rocket', version: '3.15', status: 'active' },
+      { plugin: 'akismet/akismet.php', name: 'Akismet', version: '5.0', status: 'active' }
+    ]));
+    // Second call: HEAD homepage
+    fetch.mockImplementationOnce(() => Promise.resolve({
+      ok: true, status: 200,
+      headers: { get: (h) => {
+        if (h === 'x-cache') return 'HIT';
+        if (h === 'cache-control') return 'max-age=3600';
+        return null;
+      }},
+      text: () => Promise.resolve('')
+    }));
+
+    const result = await call('wp_check_caching_status');
+    const data = parseResult(result);
+
+    expect(data.caching_detected).toBe(true);
+    expect(data.plugins).toHaveLength(1);
+    expect(data.plugins[0].name).toBe('WP Rocket');
+    expect(data.http_headers['x-cache']).toBe('HIT');
+    expect(data.recommendation).toBeNull();
+  });
+
+  it('recommends caching when none detected', async () => {
+    fetch.mockImplementationOnce(() => mockFetchJson([]));
+    fetch.mockImplementationOnce(() => Promise.resolve({
+      ok: true, status: 200,
+      headers: { get: () => null },
+      text: () => Promise.resolve('')
+    }));
+
+    const result = await call('wp_check_caching_status');
+    const data = parseResult(result);
+
+    expect(data.caching_detected).toBe(false);
+    expect(data.recommendation).toContain('No caching detected');
+  });
+});
+
+// ════════════════════════════════════════════════════════════
+// wp_audit_database_bloat
+// ════════════════════════════════════════════════════════════
+
+describe('wp_audit_database_bloat', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('returns database bloat report', async () => {
+    fetch.mockResolvedValue(mockSuccess({
+      revisions: 1500,
+      auto_drafts: 25,
+      trashed_posts: 80,
+      spam_comments: 200,
+      trashed_comments: 30,
+      transients_total: 150,
+      transients_expired: 75,
+      orphan_postmeta: 500,
+      database_size_mb: 128.5,
+      tables: [
+        { table: 'wp_posts', size_mb: 45.2, rows: 15000 },
+        { table: 'wp_postmeta', size_mb: 38.1, rows: 120000 }
+      ],
+      recommendations: ['Delete old revisions (1500 found).', 'Clean expired transients (75 found).']
+    }));
+
+    const result = await call('wp_audit_database_bloat');
+    const data = parseResult(result);
+
+    expect(data.revisions).toBe(1500);
+    expect(data.transients_expired).toBe(75);
+    expect(data.database_size_mb).toBe(128.5);
+    expect(data.tables).toHaveLength(2);
+    expect(data.recommendations).toHaveLength(2);
+  });
+
+  it('calls mcp-diagnostics endpoint', async () => {
+    fetch.mockResolvedValue(mockSuccess({ revisions: 0, auto_drafts: 0, trashed_posts: 0, spam_comments: 0, trashed_comments: 0, transients_total: 0, transients_expired: 0, orphan_postmeta: 0, database_size_mb: 10, tables: [], recommendations: [] }));
+    await call('wp_audit_database_bloat');
+    const [url] = fetch.mock.calls[0];
+    expect(url).toContain('/wp-json/mcp-diagnostics/v1/database-bloat');
+  });
+});
+
+// ════════════════════════════════════════════════════════════
+// wp_get_plugin_performance_impact
+// ════════════════════════════════════════════════════════════
+
+describe('wp_get_plugin_performance_impact', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('reports plugin performance impact from known database', async () => {
+    fetch.mockResolvedValue(mockSuccess([
+      { plugin: 'elementor/elementor.php', name: 'Elementor', version: '3.20', status: 'active' },
+      { plugin: 'wp-rocket/wp-rocket.php', name: 'WP Rocket', version: '3.15', status: 'active' },
+      { plugin: 'akismet/akismet.php', name: 'Akismet', version: '5.0', status: 'active' },
+      { plugin: 'custom-plugin/custom.php', name: 'Custom Plugin', version: '1.0', status: 'active' },
+      { plugin: 'jetpack/jetpack.php', name: 'Jetpack', version: '12.0', status: 'inactive' }
+    ]));
+
+    const result = await call('wp_get_plugin_performance_impact');
+    const data = parseResult(result);
+
+    expect(data.total_active).toBe(4); // 4 active, jetpack is inactive
+    expect(data.heavy_count).toBeGreaterThan(0); // Elementor impact=4
+    expect(data.positive_count).toBeGreaterThan(0); // WP Rocket impact=-3
+    expect(data.unknown_count).toBe(1); // custom-plugin
+
+    // Sorted by impact descending
+    expect(data.plugins[0].impact).toBeGreaterThanOrEqual(data.plugins[1].impact || -999);
+
+    const elementor = data.plugins.find(p => p.plugin === 'elementor/elementor.php');
+    expect(elementor.impact).toBe(4);
+    expect(elementor.impact_label).toBe('high');
+    expect(elementor.category).toBe('page-builder');
+
+    const wpRocket = data.plugins.find(p => p.plugin === 'wp-rocket/wp-rocket.php');
+    expect(wpRocket.impact).toBe(-3);
+    expect(wpRocket.impact_label).toBe('positive');
+
+    const custom = data.plugins.find(p => p.plugin === 'custom-plugin/custom.php');
+    expect(custom.impact).toBeNull();
+    expect(custom.impact_label).toBe('unknown');
+  });
+
+  it('returns clean summary when no heavy plugins', async () => {
+    fetch.mockResolvedValue(mockSuccess([
+      { plugin: 'akismet/akismet.php', name: 'Akismet', version: '5.0', status: 'active' }
+    ]));
+
+    const result = await call('wp_get_plugin_performance_impact');
+    const data = parseResult(result);
+    expect(data.summary).toBe('No high-impact plugins detected.');
+  });
+
+  it('logs audit entry', async () => {
+    fetch.mockResolvedValue(mockSuccess([]));
+    await call('wp_get_plugin_performance_impact');
+    const logs = getAuditLogs();
+    expect(logs.find(l => l.tool === 'wp_get_plugin_performance_impact')).toBeDefined();
+  });
+});

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

@@ -0,0 +1,150 @@
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+
+vi.mock('node-fetch', () => ({ default: vi.fn() }));
+
+import fetch from 'node-fetch';
+import { handleToolCall } from '../../../index.js';
+import { mockSuccess, getAuditLogs, makeRequest, parseResult } from '../../helpers/mockWpRequest.js';
+
+function call(name, args = {}) {
+  return handleToolCall(makeRequest(name, args));
+}
+
+let consoleSpy;
+beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+afterEach(() => { consoleSpy.mockRestore(); });
+
+// =========================================================================
+// wp_run_workflow
+// =========================================================================
+
+describe('wp_run_workflow', () => {
+  it('SUCCESS — named workflow site_health_report executes 3 steps', async () => {
+    // Each step calls a handler which calls wpApiCall → fetch
+    mockSuccess({ status: 'good', issues: [] });  // wp_get_site_health_status
+    mockSuccess({ issues: [] });                    // wp_list_site_health_issues
+    mockSuccess({ info: {} });                      // wp_get_site_health_info
+
+    const res = await call('wp_run_workflow', { workflow: 'site_health_report' });
+    const data = parseResult(res);
+
+    expect(data.workflow).toBe('site_health_report');
+    expect(data.steps_total).toBe(3);
+    expect(data.steps_completed).toBe(3);
+    expect(data.results).toHaveLength(3);
+    expect(data.summary).toBe('3/3 steps completed');
+  });
+
+  it('SUCCESS — custom workflow with 2 steps', async () => {
+    const post = (id, t) => ({ id, title: { rendered: t }, content: { rendered: '' }, excerpt: { rendered: '' }, status: 'draft', date: '2026-01-01', modified: '2026-01-01', link: `https://test.example.com/?p=${id}`, slug: `post-${id}`, categories: [], tags: [], author: 1, featured_media: 0, comment_status: 'open', meta: {} });
+    mockSuccess(post(1, 'Test'));
+    mockSuccess(post(2, 'Test 2'));
+
+    const res = await call('wp_run_workflow', {
+      workflow: 'custom',
+      steps: [
+        { tool: 'wp_get_post', args: { id: 1 } },
+        { tool: 'wp_get_post', args: { id: 2 } }
+      ]
+    });
+    const data = parseResult(res);
+
+    expect(data.steps_total).toBe(2);
+    expect(data.results).toHaveLength(2);
+    expect(data.results[0].status).toBe('success');
+    expect(data.results[1].status).toBe('success');
+  });
+
+  it('STOP_ON_ERROR — stops at first failure when stop_on_error=true', async () => {
+    // First step fails (404), second should not run
+    fetch.mockImplementationOnce(() => Promise.resolve({
+      ok: false, status: 404,
+      headers: { get: () => null },
+      text: () => Promise.resolve('Not found')
+    }));
+
+    const res = await call('wp_run_workflow', {
+      workflow: 'custom',
+      steps: [
+        { tool: 'wp_get_post', args: { id: 999 } },
+        { tool: 'wp_get_post', args: { id: 1 } }
+      ],
+      stop_on_error: true
+    });
+    const data = parseResult(res);
+
+    expect(data.steps_total).toBe(2);
+    expect(data.steps_completed).toBe(0);
+    expect(data.results).toHaveLength(1);
+    expect(data.results[0].status).toBe('error');
+  });
+
+  it('CONTINUE — continues despite error when stop_on_error=false', async () => {
+    // First step fails, second succeeds
+    fetch.mockImplementationOnce(() => Promise.resolve({
+      ok: false, status: 404,
+      headers: { get: () => null },
+      text: () => Promise.resolve('Not found')
+    }));
+    const post = (id) => ({ id, title: { rendered: 'Test' }, content: { rendered: '' }, excerpt: { rendered: '' }, status: 'draft', date: '2026-01-01', modified: '2026-01-01', link: `https://test.example.com/?p=${id}`, slug: `post-${id}`, categories: [], tags: [], author: 1, featured_media: 0, comment_status: 'open', meta: {} });
+    mockSuccess(post(1));
+
+    const res = await call('wp_run_workflow', {
+      workflow: 'custom',
+      steps: [
+        { tool: 'wp_get_post', args: { id: 999 } },
+        { tool: 'wp_get_post', args: { id: 1 } }
+      ],
+      stop_on_error: false
+    });
+    const data = parseResult(res);
+
+    expect(data.steps_total).toBe(2);
+    expect(data.results).toHaveLength(2);
+    expect(data.results[0].status).toBe('error');
+    expect(data.results[1].status).toBe('success');
+  });
+
+  it('TEMPLATE — resolves {{post_id}} from context', async () => {
+    const res = await call('wp_run_workflow', {
+      workflow: 'seo_audit_and_stage',
+      context: { post_id: 42 },
+      dry_run: true
+    });
+    const data = parseResult(res);
+
+    // Check that templates were resolved
+    expect(data.execution_plan[0].resolved_args.post_id).toBe('42');
+    expect(data.execution_plan[1].resolved_args.post_id).toBe('42');
+    expect(data.execution_plan[2].resolved_args.source_post_id).toBe('42');
+  });
+
+  it('DRY_RUN — returns plan without executing', async () => {
+    const res = await call('wp_run_workflow', {
+      workflow: 'site_health_report',
+      dry_run: true
+    });
+    const data = parseResult(res);
+
+    expect(data.mode).toBe('dry_run');
+    expect(data.steps_total).toBe(3);
+    expect(data.execution_plan).toHaveLength(3);
+    expect(data.hint).toContain('dry_run=false');
+    // fetch should NOT have been called
+    expect(fetch).not.toHaveBeenCalled();
+  });
+
+  it('ERROR — unknown workflow returns available list', async () => {
+    const res = await call('wp_run_workflow', { workflow: 'nonexistent' });
+    expect(res.isError).toBe(true);
+    expect(res.content[0].text).toContain('Unknown workflow');
+    expect(res.content[0].text).toContain('site_health_report');
+    expect(res.content[0].text).toContain('seo_audit_and_stage');
+  });
+
+  it('ERROR — custom without steps', async () => {
+    const res = await call('wp_run_workflow', { workflow: 'custom' });
+    expect(res.isError).toBe(true);
+    expect(res.content[0].text).toContain('requires a non-empty "steps" array');
+  });
+});