@adsim/wordpress-mcp-server 4.6.0 → 5.1.0

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

@@ -0,0 +1,188 @@
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+
+vi.mock('node-fetch', () => ({ default: vi.fn() }));
+
+import fetch from 'node-fetch';
+import { handleToolCall, _testSetTarget } from '../../../index.js';
+import { makeRequest, mockSuccess, 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(() => {});
+  _testSetTarget('site1', { url: 'https://example.com', auth: 'Basic dGVzdDp0ZXN0' });
+  delete process.env.WP_READ_ONLY;
+});
+afterEach(() => {
+  consoleSpy.mockRestore();
+  delete process.env.WP_READ_ONLY;
+});
+
+function mockPost(overrides = {}) {
+  const { title, content, excerpt, ...rest } = overrides;
+  return {
+    id: 1,
+    title: { rendered: title || 'Test Post' },
+    content: { rendered: content || '<p>Hello world. Replace me please.</p>' },
+    excerpt: { rendered: excerpt || '' },
+    status: 'publish',
+    slug: 'test-post',
+    link: 'https://example.com/test-post/',
+    date: '2025-06-15T10:00:00',
+    modified: '2025-06-15T10:00:00',
+    meta: { custom_key: 'old_value' },
+    ...rest
+  };
+}
+
+// =========================================================================
+// 1. dry_run: true → returns preview without modifying
+// =========================================================================
+describe('wp_bulk_update', () => {
+  it('dry_run=true returns preview without modifying posts', async () => {
+    // GET /posts?... → list of IDs
+    mockSuccess([{ id: 1 }, { id: 2 }]);
+    // GET /posts/1 → post detail for preview
+    mockSuccess(mockPost({ id: 1 }));
+    // GET /posts/2 → post detail for preview
+    mockSuccess(mockPost({ id: 2, title: 'Post 2' }));
+
+    const res = await call('wp_bulk_update', {
+      filters: { status: 'publish' },
+      operations: [{ type: 'replace_text', params: { search: 'Hello', replace: 'Hi' } }],
+      dry_run: true
+    });
+    const data = parseResult(res);
+    expect(data.mode).toBe('dry_run');
+    expect(data.posts_affected).toBe(2);
+    expect(data.operations_preview).toHaveLength(2);
+    expect(data.warning).toContain('dry_run=false');
+  });
+
+  // =========================================================================
+  // 2. dry_run: false + confirm: false → preview + warning
+  // =========================================================================
+  it('dry_run=false confirm=false returns preview with confirmation warning', async () => {
+    mockSuccess([{ id: 1 }]);
+    mockSuccess(mockPost({ id: 1 }));
+
+    const res = await call('wp_bulk_update', {
+      filters: { category_id: 5 },
+      operations: [{ type: 'update_status', params: { status: 'draft' } }],
+      dry_run: false,
+      confirm: false
+    });
+    const data = parseResult(res);
+    expect(data.mode).toBe('preview');
+    expect(data.warning).toContain('confirm=true');
+  });
+
+  // =========================================================================
+  // 3. dry_run: false + confirm: true → executes + audit log
+  // =========================================================================
+  it('dry_run=false confirm=true executes bulk update', async () => {
+    // GET /posts?... → IDs
+    mockSuccess([{ id: 1 }]);
+    // GET /posts/1 → post detail
+    mockSuccess(mockPost({ id: 1 }));
+    // POST /posts/1 → updated
+    mockSuccess(mockPost({ id: 1, title: 'Updated' }));
+
+    const res = await call('wp_bulk_update', {
+      filters: { status: 'publish' },
+      operations: [{ type: 'update_status', params: { status: 'draft' } }],
+      dry_run: false,
+      confirm: true
+    });
+    const data = parseResult(res);
+    expect(data.success).toBe(true);
+    expect(data.posts_updated).toBe(1);
+    expect(data.posts_failed).toHaveLength(0);
+    expect(data.duration_ms).toBeGreaterThanOrEqual(0);
+  });
+
+  // =========================================================================
+  // 4. replace_text → correct changes preview
+  // =========================================================================
+  it('replace_text operation shows correct occurrences in preview', async () => {
+    mockSuccess(mockPost({ id: 1, content: '<p>foo bar foo baz foo</p>' }));
+
+    const res = await call('wp_bulk_update', {
+      post_ids: [1],
+      operations: [{ type: 'replace_text', params: { search: 'foo', replace: 'qux' } }],
+      dry_run: true
+    });
+    const data = parseResult(res);
+    const changes = data.operations_preview[0].changes;
+    expect(changes[0].type).toBe('replace_text');
+    expect(changes[0].occurrences).toBe(3);
+  });
+
+  // =========================================================================
+  // 5. update_meta → meta correctly updated
+  // =========================================================================
+  it('update_meta operation updates meta in execute mode', async () => {
+    mockSuccess(mockPost({ id: 1, meta: { my_key: 'old' } }));
+    mockSuccess(mockPost({ id: 1, meta: { my_key: 'new_val' } }));
+
+    const res = await call('wp_bulk_update', {
+      post_ids: [1],
+      operations: [{ type: 'update_meta', params: { key: 'my_key', value: 'new_val' } }],
+      dry_run: false,
+      confirm: true
+    });
+    const data = parseResult(res);
+    expect(data.success).toBe(true);
+    expect(data.posts_updated).toBe(1);
+  });
+
+  // =========================================================================
+  // 6. limit respected (max 500)
+  // =========================================================================
+  it('respects limit of 500 maximum', async () => {
+    const manyIds = Array.from({ length: 600 }, (_, i) => i + 1);
+    // post_ids mode: no filter query, goes straight to preview GETs (max 10)
+    for (let i = 0; i < 10; i++) {
+      mockSuccess(mockPost({ id: i + 1 }));
+    }
+
+    const res = await call('wp_bulk_update', {
+      post_ids: manyIds,
+      operations: [{ type: 'update_status', params: { status: 'draft' } }],
+      dry_run: true,
+      limit: 600
+    });
+    const data = parseResult(res);
+    expect(data.posts_affected).toBe(500);
+  });
+
+  // =========================================================================
+  // 7. WP_READ_ONLY=true → blocked
+  // =========================================================================
+  it('is blocked when WP_READ_ONLY=true', async () => {
+    process.env.WP_READ_ONLY = 'true';
+
+    const res = await call('wp_bulk_update', {
+      post_ids: [1],
+      operations: [{ type: 'update_status', params: { status: 'draft' } }]
+    });
+    expect(res.isError).toBe(true);
+    expect(res.content[0].text).toContain('READ-ONLY');
+  });
+
+  // =========================================================================
+  // 8. post_ids empty + filters empty → explicit error
+  // =========================================================================
+  it('returns error when neither post_ids nor filters provided', async () => {
+    const res = await call('wp_bulk_update', {
+      operations: [{ type: 'update_status', params: { status: 'draft' } }]
+    });
+    expect(res.isError).toBe(true);
+    expect(res.content[0].text).toContain('post_ids or at least one filter');
+  });
+});

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

@@ -0,0 +1,397 @@
+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));
+}
+
+// ════════════════════════════════════════════════════════════
+// SITE HEALTH
+// ════════════════════════════════════════════════════════════
+
+describe('wp_get_site_health_status', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('returns health score with issue counts', async () => {
+    fetch.mockResolvedValue(mockSuccess([
+      { label: 'PHP update', status: 'critical', badge: { label: 'Security' }, description: 'Old PHP', test: 'php_version' },
+      { label: 'HTTPS', status: 'good', badge: { label: 'Security' }, description: 'HTTPS active', test: 'https_status' },
+      { label: 'Debug mode', status: 'recommended', badge: { label: 'Performance' }, description: 'Debug on', test: 'debug_enabled' }
+    ]));
+    const result = await call('wp_get_site_health_status');
+    const data = parseResult(result);
+    expect(data.score).toBe('critical');
+    expect(data.total_issues).toBe(3);
+    expect(data.counts.critical).toBe(1);
+    expect(data.counts.recommended).toBe(1);
+    expect(data.counts.good).toBe(1);
+  });
+
+  it('returns good when no issues', async () => {
+    fetch.mockResolvedValue(mockSuccess([]));
+    const result = await call('wp_get_site_health_status');
+    const data = parseResult(result);
+    expect(data.score).toBe('good');
+    expect(data.total_issues).toBe(0);
+  });
+
+  it('logs audit entry', async () => {
+    fetch.mockResolvedValue(mockSuccess([]));
+    await call('wp_get_site_health_status');
+    const logs = getAuditLogs();
+    expect(logs.find(l => l.tool === 'wp_get_site_health_status')).toBeDefined();
+  });
+});
+
+describe('wp_list_site_health_issues', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('returns all issues', async () => {
+    fetch.mockResolvedValue(mockSuccess([
+      { label: 'Issue 1', status: 'critical', badge: { label: 'Security' }, description: '<p>Desc 1</p>', actions: '', test: 'test_1' },
+      { label: 'Issue 2', status: 'recommended', badge: { label: 'Perf' }, description: '<p>Desc 2</p>', actions: '', test: 'test_2' }
+    ]));
+    const result = await call('wp_list_site_health_issues');
+    const data = parseResult(result);
+    expect(data.total).toBe(2);
+    expect(data.filter).toBe('all');
+    expect(data.issues[0].label).toBe('Issue 1');
+  });
+
+  it('filters by severity', async () => {
+    fetch.mockResolvedValue(mockSuccess([
+      { label: 'Critical', status: 'critical', badge: {}, description: '', actions: '', test: 't1' },
+      { label: 'Good', status: 'good', badge: {}, description: '', actions: '', test: 't2' }
+    ]));
+    const result = await call('wp_list_site_health_issues', { severity: 'critical' });
+    const data = parseResult(result);
+    expect(data.total).toBe(1);
+    expect(data.issues[0].label).toBe('Critical');
+  });
+});
+
+describe('wp_get_site_health_info', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('returns full system info summary', async () => {
+    fetch.mockResolvedValue(mockSuccess({
+      'wp-server': { label: 'Server', fields: { php_version: { label: 'PHP', value: '8.2.0' }, server_architecture: { label: 'Arch', value: 'Linux x86_64' } } },
+      'wp-database': { label: 'Database', fields: { server_version: { label: 'MySQL', value: '8.0.33' } } }
+    }));
+    const result = await call('wp_get_site_health_info');
+    const data = parseResult(result);
+    expect(data['wp-server'].label).toBe('Server');
+    expect(data['wp-server'].fields.php_version).toBe('8.2.0');
+    expect(data['wp-database'].fields.server_version).toBe('8.0.33');
+  });
+
+  it('returns single section when requested', async () => {
+    fetch.mockResolvedValue(mockSuccess({
+      'wp-server': { label: 'Server', fields: { php_version: { label: 'PHP', value: '8.2.0' } } },
+      'wp-database': { label: 'Database', fields: { server_version: { label: 'MySQL', value: '8.0.33' } } }
+    }));
+    const result = await call('wp_get_site_health_info', { section: 'wp-server' });
+    const data = parseResult(result);
+    expect(data.section).toBe('wp-server');
+    expect(data.label).toBe('Server');
+  });
+
+  it('errors on invalid section', async () => {
+    fetch.mockResolvedValue(mockSuccess({
+      'wp-server': { label: 'Server', fields: {} }
+    }));
+    const result = await call('wp_get_site_health_info', { section: 'nonexistent' });
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('not found');
+  });
+});
+
+// ════════════════════════════════════════════════════════════
+// DEBUG & CRON
+// ════════════════════════════════════════════════════════════
+
+describe('wp_get_debug_log', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('returns debug log lines', async () => {
+    fetch.mockResolvedValue(mockSuccess({
+      lines: ['[01-Jan-2024] PHP Warning: test', '[01-Jan-2024] PHP Fatal error: crash'],
+      total_lines: 2,
+      file_size: 1024,
+      last_modified: '2024-01-01T00:00:00Z'
+    }));
+    const result = await call('wp_get_debug_log', { lines: 50, level: 'all' });
+    const data = parseResult(result);
+    expect(data.lines_returned).toBe(2);
+    expect(data.file_size).toBe(1024);
+    expect(data.lines).toHaveLength(2);
+  });
+
+  it('passes correct basePath for mcp-diagnostics', async () => {
+    fetch.mockResolvedValue(mockSuccess({ lines: [], total_lines: 0 }));
+    await call('wp_get_debug_log');
+    const [url] = fetch.mock.calls[0];
+    expect(url).toContain('/wp-json/mcp-diagnostics/v1/debug-log');
+  });
+
+  it('returns error on 404 (plugin not installed)', async () => {
+    fetch.mockResolvedValue(mockError(404, 'No route'));
+    const result = await call('wp_get_debug_log');
+    expect(result.isError).toBe(true);
+  });
+});
+
+describe('wp_get_cron_events', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('returns cron events with overdue detection', async () => {
+    const pastTimestamp = Math.floor(Date.now() / 1000) - 3600;
+    const futureTimestamp = Math.floor(Date.now() / 1000) + 3600;
+    fetch.mockResolvedValue(mockSuccess({
+      events: [
+        { hook: 'wp_cron_test', args: [], schedule: 'hourly', interval: 3600, next_run: pastTimestamp },
+        { hook: 'wp_update_check', args: [], schedule: 'twicedaily', interval: 43200, next_run: futureTimestamp }
+      ]
+    }));
+    const result = await call('wp_get_cron_events');
+    const data = parseResult(result);
+    expect(data.total).toBe(2);
+    expect(data.events[0].overdue).toBe(true);
+    expect(data.events[1].overdue).toBe(false);
+    expect(data.events[0].next_run_date).toBeTruthy();
+  });
+
+  it('filters by hook name', async () => {
+    fetch.mockResolvedValue(mockSuccess({
+      events: [
+        { hook: 'wp_cron_test', args: [], schedule: 'hourly', interval: 3600, next_run: 1704067200 },
+        { hook: 'other_hook', args: [], schedule: 'daily', interval: 86400, next_run: 1704067200 }
+      ]
+    }));
+    const result = await call('wp_get_cron_events', { hook: 'wp_cron_test' });
+    const data = parseResult(result);
+    expect(data.total).toBe(1);
+    expect(data.events[0].hook).toBe('wp_cron_test');
+  });
+});
+
+describe('wp_get_transients', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('returns transients with expiration info', async () => {
+    const futureExp = Math.floor(Date.now() / 1000) + 3600;
+    const pastExp = Math.floor(Date.now() / 1000) - 3600;
+    fetch.mockResolvedValue(mockSuccess({
+      transients: [
+        { key: 'cache_data', expiration: futureExp, size_bytes: 512 },
+        { key: 'old_cache', expiration: pastExp, size_bytes: 128 }
+      ]
+    }));
+    const result = await call('wp_get_transients');
+    const data = parseResult(result);
+    expect(data.total).toBe(2);
+    expect(data.transients[0].expired).toBe(false);
+    expect(data.transients[1].expired).toBe(true);
+    expect(data.transients[0].expiration_date).toBeTruthy();
+  });
+
+  it('handles transients with no expiry', async () => {
+    fetch.mockResolvedValue(mockSuccess({
+      transients: [
+        { key: 'permanent', expiration: 0, size_bytes: 256 }
+      ]
+    }));
+    const result = await call('wp_get_transients');
+    const data = parseResult(result);
+    expect(data.transients[0].expiration_date).toBe('no expiry');
+    expect(data.transients[0].expired).toBe(false);
+  });
+
+  it('passes correct basePath', async () => {
+    fetch.mockResolvedValue(mockSuccess({ transients: [] }));
+    await call('wp_get_transients', { filter: 'expired', search: 'cache' });
+    const [url] = fetch.mock.calls[0];
+    expect(url).toContain('/wp-json/mcp-diagnostics/v1/transients');
+    expect(url).toContain('filter=expired');
+    expect(url).toContain('search=cache');
+  });
+});
+
+// ════════════════════════════════════════════════════════════
+// PLUGIN COMPATIBILITY
+// ════════════════════════════════════════════════════════════
+
+describe('wp_check_php_compatibility', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('reports compatible and incompatible plugins', async () => {
+    // First call: /plugins, Second call: /info (site health)
+    fetch
+      .mockImplementationOnce(() => Promise.resolve({
+        ok: true, status: 200,
+        headers: { get: (h) => h === 'content-type' ? 'application/json' : null },
+        json: () => Promise.resolve([
+          { plugin: 'akismet/akismet.php', name: 'Akismet', version: '5.0', status: 'active', requires_php: '7.4' },
+          { plugin: 'legacy/legacy.php', name: 'Legacy Plugin', version: '1.0', status: 'active', requires_php: '8.3' },
+          { plugin: 'noinfo/noinfo.php', name: 'No Info', version: '2.0', status: 'active', requires_php: null },
+          { plugin: 'inactive/inactive.php', name: 'Inactive', version: '1.0', status: 'inactive', requires_php: '7.0' }
+        ]),
+        text: () => Promise.resolve('[]')
+      }))
+      .mockImplementationOnce(() => Promise.resolve({
+        ok: true, status: 200,
+        headers: { get: (h) => h === 'content-type' ? 'application/json' : null },
+        json: () => Promise.resolve({
+          'wp-server': { label: 'Server', fields: { php_version: { label: 'PHP', value: '8.2.0' } } }
+        }),
+        text: () => Promise.resolve('{}')
+      }));
+
+    const result = await call('wp_check_php_compatibility');
+    const data = parseResult(result);
+    expect(data.php_version).toBe('8.2.0');
+    expect(data.total_active).toBe(3); // Only active plugins
+    expect(data.incompatible_count).toBe(1); // legacy requires 8.3, current is 8.2
+    const akismet = data.plugins.find(p => p.name === 'Akismet');
+    expect(akismet.status).toBe('compatible');
+    const legacy = data.plugins.find(p => p.name === 'Legacy Plugin');
+    expect(legacy.status).toBe('incompatible');
+    const noinfo = data.plugins.find(p => p.name === 'No Info');
+    expect(noinfo.status).toBe('unknown');
+  });
+
+  it('logs audit entry', async () => {
+    fetch
+      .mockImplementationOnce(() => Promise.resolve({
+        ok: true, status: 200,
+        headers: { get: (h) => h === 'content-type' ? 'application/json' : null },
+        json: () => Promise.resolve([]),
+        text: () => Promise.resolve('[]')
+      }))
+      .mockImplementationOnce(() => Promise.resolve({
+        ok: true, status: 200,
+        headers: { get: (h) => h === 'content-type' ? 'application/json' : null },
+        json: () => Promise.resolve({ 'wp-server': { label: 'Server', fields: { php_version: { value: '8.2.0' } } } }),
+        text: () => Promise.resolve('{}')
+      }));
+
+    await call('wp_check_php_compatibility');
+    const logs = getAuditLogs();
+    expect(logs.find(l => l.tool === 'wp_check_php_compatibility')).toBeDefined();
+  });
+});
+
+describe('wp_get_active_hooks', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('returns hooks with callbacks', async () => {
+    fetch.mockResolvedValue(mockSuccess({
+      hooks: [
+        { name: 'init', type: 'action', callbacks: [{ function: 'wp_init', priority: 10, accepted_args: 0 }] },
+        { name: 'the_content', type: 'filter', callbacks: [{ function: 'wpautop', priority: 10, accepted_args: 1 }, { function: 'do_shortcode', priority: 11, accepted_args: 1 }] }
+      ]
+    }));
+    const result = await call('wp_get_active_hooks', { type: 'all' });
+    const data = parseResult(result);
+    expect(data.total).toBe(2);
+    expect(data.hooks[0].name).toBe('init');
+    expect(data.hooks[0].type).toBe('action');
+    expect(data.hooks[1].callbacks).toHaveLength(2);
+  });
+
+  it('passes search and type params', async () => {
+    fetch.mockResolvedValue(mockSuccess({ hooks: [] }));
+    await call('wp_get_active_hooks', { type: 'filters', search: 'content', per_page: 25 });
+    const [url] = fetch.mock.calls[0];
+    expect(url).toContain('/wp-json/mcp-diagnostics/v1/hooks');
+    expect(url).toContain('type=filters');
+    expect(url).toContain('search=content');
+    expect(url).toContain('per_page=25');
+  });
+
+  it('returns error on 404 (plugin not installed)', async () => {
+    fetch.mockResolvedValue(mockError(404, 'No route'));
+    const result = await call('wp_get_active_hooks');
+    expect(result.isError).toBe(true);
+  });
+});
+
+// ════════════════════════════════════════════════════════════
+// READ-ONLY CHECK — All diagnostic tools are read-only
+// ════════════════════════════════════════════════════════════
+
+describe('Diagnostic tools are not blocked by WP_READ_ONLY', () => {
+  let consoleSpy;
+  beforeEach(() => {
+    fetch.mockReset();
+    consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    process.env.WP_READ_ONLY = 'true';
+  });
+  afterEach(() => {
+    consoleSpy.mockRestore();
+    delete process.env.WP_READ_ONLY;
+  });
+
+  const readOnlyTools = [
+    'wp_get_site_health_status',
+    'wp_list_site_health_issues',
+    'wp_get_site_health_info',
+    'wp_get_debug_log',
+    'wp_get_cron_events',
+    'wp_get_transients',
+    'wp_check_php_compatibility',
+    'wp_get_active_hooks'
+  ];
+
+  readOnlyTools.forEach(toolName => {
+    it(`${toolName} is not blocked by WP_READ_ONLY`, async () => {
+      // Mock a generic successful response
+      fetch.mockResolvedValue(mockSuccess(
+        toolName.includes('list') || toolName.includes('events') || toolName.includes('hooks')
+          ? []
+          : {}
+      ));
+      // For wp_check_php_compatibility which makes 2 calls
+      if (toolName === 'wp_check_php_compatibility') {
+        fetch
+          .mockImplementationOnce(() => Promise.resolve({
+            ok: true, status: 200,
+            headers: { get: (h) => h === 'content-type' ? 'application/json' : null },
+            json: () => Promise.resolve([]),
+            text: () => Promise.resolve('[]')
+          }))
+          .mockImplementationOnce(() => Promise.resolve({
+            ok: true, status: 200,
+            headers: { get: (h) => h === 'content-type' ? 'application/json' : null },
+            json: () => Promise.resolve({ 'wp-server': { label: 'S', fields: { php_version: { value: '8.2' } } } }),
+            text: () => Promise.resolve('{}')
+          }));
+      }
+
+      const result = await call(toolName);
+      // Should NOT be blocked
+      expect(result.isError).toBeFalsy();
+    });
+  });
+});