@adsim/wordpress-mcp-server 4.5.1 → 4.6.0

package/tests/unit/plugins/acf/acfAdapter.write.test.js

@@ -0,0 +1,157 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { acfAdapter } from '../../../../src/plugins/adapters/acf/acfAdapter.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_READ_ONLY');
+  delete process.env.WP_READ_ONLY;
+});
+afterEach(() => {
+  consoleSpy.mockRestore();
+  restoreEnv();
+});
+
+// ── 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;
+}
+
+function mockApi403() {
+  return async () => { throw new Error('WP API 403: Forbidden'); };
+}
+
+// ── Mock data ──
+
+const mockUpdatedResponse = {
+  acf: {
+    hero_title: 'New Title',
+    price: 49.99,
+  },
+};
+
+// =========================================================================
+// Tests
+// =========================================================================
+
+describe('ACF Adapter — acf_update_fields (write)', () => {
+  const getTool = () => acfAdapter.getTools().find(t => t.name === 'acf_update_fields');
+
+  // 1. Update réussi → retourne les champs mis à jour
+  it('successful update returns updated fields', async () => {
+    const tool = getTool();
+    const result = await tool.handler(
+      { id: 42, post_type: 'posts', fields: { hero_title: 'New Title', price: 49.99 } },
+      mockApi(mockUpdatedResponse)
+    );
+    const data = parseResult(result);
+    expect(data.id).toBe(42);
+    expect(data.post_type).toBe('posts');
+    expect(data.updated_fields.hero_title).toBe('New Title');
+    expect(data.updated_fields.price).toBe(49.99);
+  });
+
+  // 2. WP_READ_ONLY=true → bloqué, status "blocked" dans le log
+  it('blocked when WP_READ_ONLY=true', async () => {
+    process.env.WP_READ_ONLY = 'true';
+    const tool = getTool();
+    const result = await tool.handler(
+      { id: 42, fields: { hero_title: 'New' } },
+      mockApi(mockUpdatedResponse)
+    );
+    const data = parseResult(result);
+    expect(data.error).toContain('READ-ONLY');
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'acf_update_fields');
+    expect(entry.status).toBe('blocked');
+  });
+
+  // 3. WP_READ_ONLY=false → exécution normale
+  it('executes normally when WP_READ_ONLY is not set', async () => {
+    delete process.env.WP_READ_ONLY;
+    const tool = getTool();
+    const result = await tool.handler(
+      { id: 10, fields: { price: 99 } },
+      mockApi({ acf: { price: 99 } })
+    );
+    const data = parseResult(result);
+    expect(data.updated_fields.price).toBe(99);
+    expect(data.id).toBe(10);
+  });
+
+  // 4. id invalide (string) → erreur validation
+  it('rejects non-integer id', async () => {
+    const tool = getTool();
+    await expect(
+      tool.handler({ id: 'abc', fields: { x: 1 } }, mockApi({}))
+    ).rejects.toThrow('Validation error');
+  });
+
+  // 5. fields vide {} → erreur
+  it('rejects empty fields object', async () => {
+    const tool = getTool();
+    await expect(
+      tool.handler({ id: 42, fields: {} }, mockApi({}))
+    ).rejects.toThrow('Validation error');
+  });
+
+  // 6. 404 post not found → erreur propre
+  it('propagates 404 error', async () => {
+    const tool = getTool();
+    await expect(
+      tool.handler({ id: 99999, fields: { x: 1 } }, mockApi(null, true))
+    ).rejects.toThrow('404');
+  });
+
+  // 7. 403 permission denied → erreur propre
+  it('propagates 403 permission error', async () => {
+    const tool = getTool();
+    await expect(
+      tool.handler({ id: 42, fields: { x: 1 } }, mockApi403())
+    ).rejects.toThrow('403');
+  });
+
+  // 8. Audit log format correct
+  it('logs correct audit format with action update_acf_fields', async () => {
+    const tool = getTool();
+    await tool.handler(
+      { id: 42, post_type: 'posts', fields: { hero_title: 'Updated' } },
+      mockApi(mockUpdatedResponse)
+    );
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'acf_update_fields');
+    expect(entry).toBeDefined();
+    expect(entry.action).toBe('update_acf_fields');
+    expect(entry.target).toBe(42);
+    expect(entry.status).toBe('success');
+    expect(typeof entry.latency_ms).toBe('number');
+  });
+});

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

@@ -0,0 +1,51 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { applyContextGuard } from '../../../src/plugins/contextGuard.js';
+
+let consoleSpy;
+
+beforeEach(() => {
+  consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+});
+afterEach(() => {
+  consoleSpy.mockRestore();
+});
+
+describe('applyContextGuard', () => {
+  it('returns data intact when below threshold', () => {
+    const data = { title: 'Hello', items: [1, 2, 3] };
+    const result = applyContextGuard(data, { toolName: 'test_tool', maxChars: 50000 });
+    expect(result).toEqual(data);
+  });
+
+  it('truncates and adds _truncated when above threshold', () => {
+    const bigArray = Array.from({ length: 5000 }, (_, i) => ({ id: i, label: `item-${i}-padding-data` }));
+    const result = applyContextGuard(bigArray, { toolName: 'test_tool', maxChars: 500 });
+    expect(result._truncated).toBe(true);
+    expect(result._original_size).toBeGreaterThan(500);
+    expect(typeof result._warning).toBe('string');
+    expect(result.data).toBeDefined();
+  });
+
+  it('does NOT truncate when mode is "raw" even if above threshold', () => {
+    const bigArray = Array.from({ length: 5000 }, (_, i) => ({ id: i, label: `item-${i}-padding-data` }));
+    const result = applyContextGuard(bigArray, { toolName: 'test_tool', mode: 'raw', maxChars: 500 });
+    expect(result._truncated).toBeUndefined();
+    expect(Array.isArray(result)).toBe(true);
+    expect(result.length).toBe(5000);
+  });
+
+  it('logs correct format to stderr on truncation', () => {
+    const bigArray = Array.from({ length: 5000 }, (_, i) => ({ id: i, label: `item-${i}-padding-data` }));
+    applyContextGuard(bigArray, { toolName: 'elementor_get_page', maxChars: 500 });
+
+    const logCalls = consoleSpy.mock.calls.map(c => c[0]).filter(m => typeof m === 'string');
+    const overflow = logCalls.find(m => m.includes('context_overflow'));
+    expect(overflow).toBeDefined();
+    const parsed = JSON.parse(overflow);
+    expect(parsed.tool).toBe('elementor_get_page');
+    expect(parsed.event).toBe('context_overflow');
+    expect(parsed.truncated).toBe(true);
+    expect(typeof parsed.size_chars).toBe('number');
+    expect(parsed.max_chars).toBe(500);
+  });
+});

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

@@ -106,15 +106,15 @@ describe('Plugin Intelligence filtering', () => {
 // =========================================================================
 
 describe('Combined filtering counts', () => {
-  it('returns all 85 tools when all features enabled', () => {
+  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(85);
+    expect(getFilteredTools()).toHaveLength(86);
   });
 
-  it('returns 63 tools with no optional features (85 - 13wc - 3editorial - 6pi)', () => {
-    expect(getFilteredTools()).toHaveLength(63);
+  it('returns 64 tools with no optional features (86 - 13wc - 3editorial - 6pi)', () => {
+    expect(getFilteredTools()).toHaveLength(64);
   });
 });
 

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

@@ -80,7 +80,7 @@ describe('wp_site_info', () => {
 
     // Server info
     expect(data.server.mcp_version).toBeDefined();
-    expect(data.server.tools_total).toBe(85);
+    expect(data.server.tools_total).toBe(86);
     expect(typeof data.server.tools_exposed).toBe('number');
     expect(Array.isArray(data.server.filtered_out)).toBe(true);
   });

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

@@ -0,0 +1,101 @@
+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, makeRequest, parseResult, getAuditLogs } 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('WP_READ_ONLY');
+});
+afterEach(() => {
+  consoleSpy.mockRestore();
+  restoreEnv();
+});
+
+// ── Mock data ──
+
+const mockSettings = {
+  title: 'My Site',
+  description: 'Just another WordPress site',
+  url: 'https://test.example.com',
+  email: 'admin@test.example.com',
+  timezone_string: 'Europe/Brussels',
+  date_format: 'Y-m-d',
+  time_format: 'H:i',
+  language: 'en_US',
+  posts_per_page: 10,
+};
+
+// =========================================================================
+// wp_get_site_options
+// =========================================================================
+
+describe('wp_get_site_options', () => {
+  it('returns all options when no keys parameter', async () => {
+    fetch.mockResolvedValue(mockSuccess(mockSettings));
+    const data = parseResult(await call('wp_get_site_options'));
+    expect(data.title).toBe('My Site');
+    expect(data.description).toBe('Just another WordPress site');
+    expect(data.timezone_string).toBe('Europe/Brussels');
+    expect(Object.keys(data).length).toBe(Object.keys(mockSettings).length);
+  });
+
+  it('filters to requested keys only', async () => {
+    fetch.mockResolvedValue(mockSuccess(mockSettings));
+    const data = parseResult(await call('wp_get_site_options', { keys: ['title', 'language'] }));
+    expect(data.title).toBe('My Site');
+    expect(data.language).toBe('en_US');
+    expect(Object.keys(data)).toEqual(['title', 'language']);
+    expect(data.email).toBeUndefined();
+  });
+
+  it('handles 403 (insufficient permissions)', async () => {
+    mockError(403, '{"code":"rest_forbidden","message":"Sorry, you are not allowed to manage options."}');
+    const res = await call('wp_get_site_options');
+    expect(res.isError).toBe(true);
+    expect(res.content[0].text).toContain('403');
+  });
+
+  it('logs correct audit format to stderr', async () => {
+    fetch.mockResolvedValue(mockSuccess(mockSettings));
+    await call('wp_get_site_options', { keys: ['title'] });
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_get_site_options');
+    expect(entry).toBeDefined();
+    expect(entry.action).toBe('read_options');
+    expect(entry.status).toBe('success');
+    expect(typeof entry.latency_ms).toBe('number');
+    expect(entry.params.keys_requested).toBe(1);
+    expect(entry.params.keys_returned).toBe(1);
+  });
+
+  it('is NOT blocked by WP_READ_ONLY=true', async () => {
+    process.env.WP_READ_ONLY = 'true';
+    fetch.mockResolvedValue(mockSuccess(mockSettings));
+    const res = await call('wp_get_site_options');
+    expect(res.isError).toBeUndefined();
+    const data = parseResult(res);
+    expect(data.title).toBe('My Site');
+  });
+});