@adsim/wordpress-mcp-server 4.4.0 → 4.5.0

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

@@ -0,0 +1,864 @@
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+
+vi.mock('node-fetch', () => ({ default: vi.fn() }));
+vi.mock('../../../src/pluginDetector.js', () => ({
+  detectSeoPlugin: vi.fn(),
+  getRenderedHead: vi.fn(),
+  parseRenderedHead: vi.fn(),
+  _clearPluginCache: vi.fn()
+}));
+
+import fetch from 'node-fetch';
+import { handleToolCall, _testSetTarget } from '../../../index.js';
+import { mockSuccess, mockError, getAuditLogs, makeRequest, parseResult } from '../../helpers/mockWpRequest.js';
+import { detectSeoPlugin, getRenderedHead, parseRenderedHead } from '../../../src/pluginDetector.js';
+
+function call(name, args = {}) {
+  return handleToolCall(makeRequest(name, args));
+}
+
+let consoleSpy;
+beforeEach(() => {
+  fetch.mockReset();
+  detectSeoPlugin.mockReset();
+  getRenderedHead.mockReset();
+  parseRenderedHead.mockReset();
+  consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+});
+afterEach(() => {
+  consoleSpy.mockRestore();
+  _testSetTarget(null);
+});
+
+// =========================================================================
+// Mock data
+// =========================================================================
+
+const RENDERED_HEAD_HTML = [
+  '<title>Mon Article Test | MonSite</title>',
+  '<meta name="description" content="Description rendue par RankMath" />',
+  '<link rel="canonical" href="https://test.example.com/mon-article-test" />',
+  '<meta name="robots" content="index, follow" />',
+  '<meta property="og:title" content="Mon Article Test" />',
+  '<meta property="og:description" content="OG Description" />',
+  '<meta property="og:image" content="https://test.example.com/image.jpg" />',
+  '<meta name="twitter:card" content="summary_large_image" />',
+  '<script type="application/ld+json">{"@type":"Article","headline":"Mon Article Test"}</script>'
+].join('\n');
+
+const PARSED_HEAD = {
+  title: 'Mon Article Test | MonSite',
+  meta_description: 'Description rendue par RankMath',
+  canonical: 'https://test.example.com/mon-article-test',
+  robots: 'index, follow',
+  og_title: 'Mon Article Test',
+  og_description: 'OG Description',
+  og_image: 'https://test.example.com/image.jpg',
+  og_type: null,
+  twitter_card: 'summary_large_image',
+  twitter_title: null,
+  twitter_description: null,
+  twitter_image: null,
+  schema_json_ld: [{ '@type': 'Article', headline: 'Mon Article Test' }]
+};
+
+function makePost(id, extras = {}) {
+  return {
+    id,
+    title: { rendered: `Post ${id}` },
+    link: `https://test.example.com/post-${id}`,
+    slug: `post-${id}`,
+    meta: {
+      rank_math_title: `SEO Title ${id}`,
+      rank_math_description: `SEO Desc ${id}`,
+      rank_math_focus_keyword: 'wordpress seo',
+      rank_math_canonical_url: `https://test.example.com/post-${id}`,
+      rank_math_robots: [],
+      rank_math_pillar_content: ''
+    },
+    ...extras
+  };
+}
+
+// =========================================================================
+// wp_get_rendered_head
+// =========================================================================
+
+describe('wp_get_rendered_head', () => {
+  it('NOMINAL RankMath — returns rendered + stored meta', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess(makePost(1));
+    getRenderedHead.mockResolvedValue({ success: true, head: RENDERED_HEAD_HTML, plugin: 'rankmath' });
+    parseRenderedHead.mockReturnValue(PARSED_HEAD);
+
+    const res = await call('wp_get_rendered_head', { post_id: 1 });
+    const data = parseResult(res);
+
+    expect(data.post_id).toBe(1);
+    expect(data.seo_plugin).toBe('rankmath');
+    expect(data.rendered.title).toBe('Mon Article Test | MonSite');
+    expect(data.rendered.meta_description).toBe('Description rendue par RankMath');
+    expect(data.stored.title).toBe('SEO Title 1');
+    expect(data.stored.description).toBe('SEO Desc 1');
+    expect(data.stored.focus_keyword).toBe('wordpress seo');
+    expect(data.raw_head_length).toBeGreaterThan(0);
+    expect(data.schemas_count).toBe(1);
+  });
+
+  it('NOMINAL Yoast — returns rendered meta', async () => {
+    detectSeoPlugin.mockResolvedValue('yoast');
+    const yoastPost = makePost(2, {
+      meta: {
+        _yoast_wpseo_title: 'Yoast Title',
+        _yoast_wpseo_metadesc: 'Yoast Desc',
+        _yoast_wpseo_focuskw: 'yoast keyword',
+        _yoast_wpseo_canonical: '',
+        _yoast_wpseo_meta_robots_noindex: ''
+      }
+    });
+    mockSuccess(yoastPost);
+    getRenderedHead.mockResolvedValue({ success: true, head: '<title>Yoast</title>', plugin: 'yoast' });
+    parseRenderedHead.mockReturnValue({ ...PARSED_HEAD, title: 'Yoast' });
+
+    const res = await call('wp_get_rendered_head', { post_id: 2 });
+    const data = parseResult(res);
+
+    expect(data.seo_plugin).toBe('yoast');
+    expect(data.stored.title).toBe('Yoast Title');
+    expect(data.stored.description).toBe('Yoast Desc');
+    expect(data.stored.focus_keyword).toBe('yoast keyword');
+  });
+
+  it('ERROR — unsupported plugin (seopress)', async () => {
+    detectSeoPlugin.mockResolvedValue('seopress');
+
+    const res = await call('wp_get_rendered_head', { post_id: 1 });
+    expect(res.isError).toBe(true);
+    expect(res.content[0].text).toContain('requires RankMath or Yoast');
+  });
+
+  it('ERROR — no SEO plugin detected', async () => {
+    detectSeoPlugin.mockResolvedValue(null);
+
+    const res = await call('wp_get_rendered_head', { post_id: 1 });
+    expect(res.isError).toBe(true);
+    expect(res.content[0].text).toContain('No supported SEO plugin');
+  });
+
+  it('ERROR — rendered head failure', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess(makePost(1));
+    getRenderedHead.mockResolvedValue({ success: false, error: 'RankMath API: 500' });
+
+    const res = await call('wp_get_rendered_head', { post_id: 1 });
+    expect(res.isError).toBe(true);
+    expect(res.content[0].text).toContain('RankMath API: 500');
+  });
+
+  it('STORED — compares stored vs rendered in response', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess(makePost(1));
+    getRenderedHead.mockResolvedValue({ success: true, head: 'x', plugin: 'rankmath' });
+    parseRenderedHead.mockReturnValue(PARSED_HEAD);
+
+    const res = await call('wp_get_rendered_head', { post_id: 1 });
+    const data = parseResult(res);
+
+    expect(data).toHaveProperty('rendered');
+    expect(data).toHaveProperty('stored');
+    expect(data.stored.canonical).toBe('https://test.example.com/post-1');
+  });
+
+  it('AUDIT — logs get_rendered_head with plugin param', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess(makePost(1));
+    getRenderedHead.mockResolvedValue({ success: true, head: 'x', plugin: 'rankmath' });
+    parseRenderedHead.mockReturnValue(PARSED_HEAD);
+
+    await call('wp_get_rendered_head', { post_id: 1 });
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_get_rendered_head');
+    expect(entry).toBeDefined();
+    expect(entry.action).toBe('get_rendered_head');
+    expect(entry.params.plugin).toBe('rankmath');
+  });
+
+  it('ERROR — post not found (404)', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockError(404, 'Not Found');
+
+    const res = await call('wp_get_rendered_head', { post_id: 9999 });
+    expect(res.isError).toBe(true);
+  });
+});
+
+// =========================================================================
+// wp_audit_rendered_seo
+// =========================================================================
+
+describe('wp_audit_rendered_seo', () => {
+  function makeAuditPost(id, meta = {}) {
+    return {
+      id,
+      title: { rendered: `Post ${id}` },
+      link: `https://test.example.com/post-${id}`,
+      slug: `post-${id}`,
+      meta: {
+        rank_math_title: `SEO Title ${id}`,
+        rank_math_description: `SEO Desc ${id}`,
+        rank_math_canonical_url: `https://test.example.com/post-${id}`,
+        rank_math_robots: [],
+        ...meta
+      }
+    };
+  }
+
+  it('NOMINAL — audits posts and returns scores', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess([makeAuditPost(1), makeAuditPost(2), makeAuditPost(3)]);
+
+    // Post 1: perfect
+    getRenderedHead.mockResolvedValueOnce({ success: true, head: 'h1', plugin: 'rankmath' });
+    parseRenderedHead.mockReturnValueOnce({
+      title: 'SEO Title 1 | Site', meta_description: 'SEO Desc 1',
+      canonical: 'https://test.example.com/post-1', robots: 'index, follow',
+      schema_json_ld: [{ '@type': 'Article' }]
+    });
+    // Post 2: title mismatch
+    getRenderedHead.mockResolvedValueOnce({ success: true, head: 'h2', plugin: 'rankmath' });
+    parseRenderedHead.mockReturnValueOnce({
+      title: 'Completely Different Title', meta_description: 'SEO Desc 2',
+      canonical: 'https://test.example.com/post-2', robots: 'index, follow',
+      schema_json_ld: [{ '@type': 'Article' }]
+    });
+    // Post 3: missing description + schema
+    getRenderedHead.mockResolvedValueOnce({ success: true, head: 'h3', plugin: 'rankmath' });
+    parseRenderedHead.mockReturnValueOnce({
+      title: 'SEO Title 3 | Site', meta_description: null,
+      canonical: 'https://test.example.com/post-3', robots: 'index',
+      schema_json_ld: []
+    });
+
+    const res = await call('wp_audit_rendered_seo', { limit: 3 });
+    const data = parseResult(res);
+
+    expect(data.seo_plugin).toBe('rankmath');
+    expect(data.total_audited).toBe(3);
+    expect(data.avg_score).toBeGreaterThan(0);
+    expect(data.issues_summary).toHaveProperty('title_mismatch');
+    expect(data.posts).toHaveLength(3);
+  });
+
+  it('TITLE MISMATCH — detected when stored title not in rendered', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess([makeAuditPost(1)]);
+    getRenderedHead.mockResolvedValue({ success: true, head: 'h', plugin: 'rankmath' });
+    parseRenderedHead.mockReturnValue({
+      title: 'Something Else Entirely', meta_description: 'SEO Desc 1',
+      canonical: 'https://test.example.com/post-1', robots: 'index',
+      schema_json_ld: [{ '@type': 'Article' }]
+    });
+
+    const res = await call('wp_audit_rendered_seo', { limit: 1 });
+    const data = parseResult(res);
+
+    expect(data.issues_summary.title_mismatch).toBe(1);
+    expect(data.posts[0].issues).toContain('title_mismatch');
+  });
+
+  it('DESCRIPTION MISMATCH — detected when rendered !== stored', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess([makeAuditPost(1)]);
+    getRenderedHead.mockResolvedValue({ success: true, head: 'h', plugin: 'rankmath' });
+    parseRenderedHead.mockReturnValue({
+      title: 'SEO Title 1 | Site', meta_description: 'Different description',
+      canonical: 'https://test.example.com/post-1', robots: 'index',
+      schema_json_ld: [{ '@type': 'Article' }]
+    });
+
+    const res = await call('wp_audit_rendered_seo', { limit: 1 });
+    const data = parseResult(res);
+
+    expect(data.issues_summary.description_mismatch).toBe(1);
+  });
+
+  it('SCHEMA MISSING — detected when no JSON-LD', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess([makeAuditPost(1)]);
+    getRenderedHead.mockResolvedValue({ success: true, head: 'h', plugin: 'rankmath' });
+    parseRenderedHead.mockReturnValue({
+      title: 'SEO Title 1 | Site', meta_description: 'SEO Desc 1',
+      canonical: 'https://test.example.com/post-1', robots: 'index',
+      schema_json_ld: []
+    });
+
+    const res = await call('wp_audit_rendered_seo', { limit: 1 });
+    const data = parseResult(res);
+
+    expect(data.issues_summary.schema_missing).toBe(1);
+  });
+
+  it('PERFECT SCORE — 100 when no divergences', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess([makeAuditPost(1)]);
+    getRenderedHead.mockResolvedValue({ success: true, head: 'h', plugin: 'rankmath' });
+    parseRenderedHead.mockReturnValue({
+      title: 'SEO Title 1 | Site', meta_description: 'SEO Desc 1',
+      canonical: 'https://test.example.com/post-1', robots: 'index',
+      schema_json_ld: [{ '@type': 'Article' }]
+    });
+
+    const res = await call('wp_audit_rendered_seo', { limit: 1 });
+    const data = parseResult(res);
+
+    expect(data.posts[0].score).toBe(100);
+    expect(data.posts[0].issues).toHaveLength(0);
+  });
+
+  it('DEGRADED SCORE — multiple issues reduce score', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess([makeAuditPost(1)]);
+    getRenderedHead.mockResolvedValue({ success: true, head: 'h', plugin: 'rankmath' });
+    parseRenderedHead.mockReturnValue({
+      title: null, meta_description: null,
+      canonical: 'https://test.example.com/post-1', robots: 'noindex',
+      schema_json_ld: []
+    });
+
+    const res = await call('wp_audit_rendered_seo', { limit: 1 });
+    const data = parseResult(res);
+
+    // missing_rendered_title + missing_rendered_description + robots_mismatch + schema_missing = 4 issues
+    expect(data.posts[0].issues.length).toBeGreaterThanOrEqual(3);
+    expect(data.posts[0].score).toBeLessThan(70);
+  });
+
+  it('AUDIT — logs audit_rendered_seo action', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess([makeAuditPost(1)]);
+    getRenderedHead.mockResolvedValue({ success: true, head: 'h', plugin: 'rankmath' });
+    parseRenderedHead.mockReturnValue({
+      title: 'SEO Title 1', meta_description: 'SEO Desc 1',
+      canonical: 'https://test.example.com/post-1', robots: 'index',
+      schema_json_ld: [{}]
+    });
+
+    await call('wp_audit_rendered_seo', { limit: 1 });
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_audit_rendered_seo');
+    expect(entry).toBeDefined();
+    expect(entry.action).toBe('audit_rendered_seo');
+    expect(entry.params.plugin).toBe('rankmath');
+  });
+
+  it('ERROR — unsupported plugin', async () => {
+    detectSeoPlugin.mockResolvedValue('seopress');
+
+    const res = await call('wp_audit_rendered_seo', { limit: 5 });
+    expect(res.isError).toBe(true);
+    expect(res.content[0].text).toContain('requires RankMath or Yoast');
+  });
+});
+
+// =========================================================================
+// wp_get_pillar_content
+// =========================================================================
+
+describe('wp_get_pillar_content', () => {
+  function makePillarPost(id, isPillar) {
+    return {
+      id,
+      title: { rendered: `Post ${id}` },
+      link: `https://test.example.com/post-${id}`,
+      slug: `post-${id}`,
+      meta: {
+        rank_math_pillar_content: isPillar ? 'on' : ''
+      }
+    };
+  }
+
+  it('LIST — returns pillar posts', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess([makePillarPost(1, true), makePillarPost(2, false), makePillarPost(3, true)]);
+
+    const res = await call('wp_get_pillar_content', { list_pillars: true });
+    const data = parseResult(res);
+
+    expect(data.mode).toBe('list_pillars');
+    expect(data.seo_plugin).toBe('rankmath');
+    expect(data.pillar_count).toBe(2);
+    expect(data.pillars).toHaveLength(2);
+    expect(data.pillars[0].id).toBe(1);
+    expect(data.pillars[1].id).toBe(3);
+  });
+
+  it('LIST — no pillars returns empty', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess([makePillarPost(1, false), makePillarPost(2, false)]);
+
+    const res = await call('wp_get_pillar_content', { list_pillars: true });
+    const data = parseResult(res);
+
+    expect(data.pillar_count).toBe(0);
+    expect(data.pillars).toHaveLength(0);
+  });
+
+  it('READ — post with pillar flag', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess(makePillarPost(1, true));
+
+    const res = await call('wp_get_pillar_content', { post_id: 1 });
+    const data = parseResult(res);
+
+    expect(data.mode).toBe('read');
+    expect(data.post_id).toBe(1);
+    expect(data.is_pillar).toBe(true);
+    expect(data.seo_plugin).toBe('rankmath');
+  });
+
+  it('READ — post without pillar flag', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess(makePillarPost(5, false));
+
+    const res = await call('wp_get_pillar_content', { post_id: 5 });
+    const data = parseResult(res);
+
+    expect(data.is_pillar).toBe(false);
+  });
+
+  it('WRITE — set_pillar=true marks post as pillar', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess(makePillarPost(1, false)); // GET post
+    mockSuccess({ id: 1 }); // PUT update
+
+    const res = await call('wp_get_pillar_content', { post_id: 1, set_pillar: true });
+    const data = parseResult(res);
+
+    expect(data.mode).toBe('write');
+    expect(data.is_pillar).toBe(true);
+    expect(data.action).toBe('marked_as_pillar');
+  });
+
+  it('WRITE — WP_READ_ONLY=true blocks write', async () => {
+    const original = process.env.WP_READ_ONLY;
+    process.env.WP_READ_ONLY = 'true';
+
+    try {
+      detectSeoPlugin.mockResolvedValue('rankmath');
+
+      const res = await call('wp_get_pillar_content', { post_id: 1, set_pillar: true });
+      expect(res.isError).toBe(true);
+      expect(res.content[0].text).toContain('READ-ONLY');
+    } finally {
+      if (original === undefined) delete process.env.WP_READ_ONLY;
+      else process.env.WP_READ_ONLY = original;
+    }
+  });
+
+  it('ERROR — plugin not RankMath', async () => {
+    detectSeoPlugin.mockResolvedValue('yoast');
+
+    const res = await call('wp_get_pillar_content', { list_pillars: true });
+    expect(res.isError).toBe(true);
+    expect(res.content[0].text).toContain('requires RankMath');
+  });
+
+  it('AUDIT — logs correctly for read vs write', async () => {
+    // Read mode
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess(makePillarPost(1, true));
+
+    await call('wp_get_pillar_content', { post_id: 1 });
+    let logs = getAuditLogs();
+    let entry = logs.find(l => l.tool === 'wp_get_pillar_content');
+    expect(entry).toBeDefined();
+    expect(entry.action).toBe('read_pillar_content');
+
+    // Write mode
+    consoleSpy.mockClear();
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess(makePillarPost(2, false));
+    mockSuccess({ id: 2 });
+
+    await call('wp_get_pillar_content', { post_id: 2, set_pillar: true });
+    logs = getAuditLogs();
+    const writeEntry = logs.find(l => l.tool === 'wp_get_pillar_content' && l.action === 'update_pillar_content');
+    expect(writeEntry).toBeDefined();
+    expect(writeEntry.target).toBe(2);
+  });
+});
+
+// =========================================================================
+// wp_audit_schema_plugins
+// =========================================================================
+
+describe('wp_audit_schema_plugins', () => {
+  function makeSchemaPost(id, schema) {
+    return {
+      id,
+      title: { rendered: `Post ${id}` },
+      link: `https://test.example.com/post-${id}`,
+      slug: `post-${id}`,
+      meta: { rank_math_schema: schema }
+    };
+  }
+
+  it('NOMINAL RankMath — parses and validates schemas', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess([
+      makeSchemaPost(1, '{"@type":"Article","headline":"Title","datePublished":"2025-01-01","author":{"@type":"Person","name":"A"}}'),
+      makeSchemaPost(2, '{"@type":"FAQPage","mainEntity":[{"@type":"Question"}]}')
+    ]);
+
+    const res = await call('wp_audit_schema_plugins', { limit: 5 });
+    const data = parseResult(res);
+
+    expect(data.seo_plugin).toBe('rankmath');
+    expect(data.total_audited).toBe(2);
+    expect(data.schema_coverage.posts_with_schema).toBe(2);
+    expect(data.schema_types_found).toHaveProperty('Article');
+    expect(data.posts).toHaveLength(2);
+  });
+
+  it('NOMINAL Yoast — reads schemas via getRenderedHead', async () => {
+    detectSeoPlugin.mockResolvedValue('yoast');
+    mockSuccess([makePost(1), makePost(2)]);
+    getRenderedHead.mockResolvedValue({ success: true, head: '<script type="application/ld+json">{"@type":"Article"}</script>', plugin: 'yoast' });
+    parseRenderedHead.mockReturnValue({ ...PARSED_HEAD, schema_json_ld: [{ '@type': 'Article', headline: 'T', datePublished: '2025-01-01', author: { '@type': 'Person' } }] });
+
+    const res = await call('wp_audit_schema_plugins', { limit: 5 });
+    const data = parseResult(res);
+
+    expect(data.seo_plugin).toBe('yoast');
+    expect(data.schema_coverage.posts_with_schema).toBe(2);
+  });
+
+  it('NO SCHEMA — flags no_plugin_schema issue', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess([makeSchemaPost(1, '')]);
+
+    const res = await call('wp_audit_schema_plugins', { limit: 5 });
+    const data = parseResult(res);
+
+    expect(data.issues_summary.no_plugin_schema).toBe(1);
+    expect(data.posts[0].issues).toContain('no_plugin_schema');
+  });
+
+  it('INVALID JSON — flags invalid_schema_json', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess([makeSchemaPost(1, '{invalid json}')]);
+
+    const res = await call('wp_audit_schema_plugins', { limit: 5 });
+    const data = parseResult(res);
+
+    expect(data.issues_summary.invalid_schema_json).toBe(1);
+    expect(data.posts[0].issues).toContain('invalid_schema_json');
+  });
+
+  it('MISSING FIELDS — Article without headline', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess([makeSchemaPost(1, '{"@type":"Article","datePublished":"2025-01-01"}')]);
+
+    const res = await call('wp_audit_schema_plugins', { limit: 5 });
+    const data = parseResult(res);
+
+    expect(data.issues_summary.missing_required_fields).toBe(1);
+    expect(data.posts[0].schemas[0].valid).toBe(false);
+    expect(data.posts[0].schemas[0].missing_fields).toContain('headline');
+  });
+
+  it('COVERAGE — calculated correctly', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess([
+      makeSchemaPost(1, '{"@type":"Article","headline":"T","datePublished":"2025","author":"A"}'),
+      makeSchemaPost(2, ''),
+      makeSchemaPost(3, '{"@type":"WebSite","name":"S","url":"https://s.com"}')
+    ]);
+
+    const res = await call('wp_audit_schema_plugins', { limit: 5 });
+    const data = parseResult(res);
+
+    expect(data.schema_coverage.posts_with_schema).toBe(2);
+    expect(data.schema_coverage.posts_without_schema).toBe(1);
+    expect(data.schema_coverage.coverage_percent).toBe(67);
+  });
+
+  it('AUDIT — logs audit_schema_plugins action', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess([makeSchemaPost(1, '{"@type":"Article","headline":"T","datePublished":"2025","author":"A"}')]);
+
+    await call('wp_audit_schema_plugins', { limit: 5 });
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_audit_schema_plugins');
+    expect(entry).toBeDefined();
+    expect(entry.action).toBe('audit_schema_plugins');
+    expect(entry.params.plugin).toBe('rankmath');
+  });
+
+  it('ERROR — unsupported plugin', async () => {
+    detectSeoPlugin.mockResolvedValue('seopress');
+
+    const res = await call('wp_audit_schema_plugins', { limit: 5 });
+    expect(res.isError).toBe(true);
+    expect(res.content[0].text).toContain('requires RankMath or Yoast');
+  });
+});
+
+// =========================================================================
+// wp_get_seo_score
+// =========================================================================
+
+describe('wp_get_seo_score', () => {
+  function makeScorePost(id, score, keyword) {
+    return {
+      id,
+      title: { rendered: `Post ${id}` },
+      link: `https://test.example.com/post-${id}`,
+      slug: `post-${id}`,
+      meta: {
+        rank_math_seo_score: score,
+        rank_math_focus_keyword: keyword || null
+      }
+    };
+  }
+
+  it('SINGLE — score 85 returns excellent rating', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess(makeScorePost(1, '85', 'wordpress seo'));
+
+    const res = await call('wp_get_seo_score', { post_id: 1 });
+    const data = parseResult(res);
+
+    expect(data.mode).toBe('single');
+    expect(data.post_id).toBe(1);
+    expect(data.seo_score).toBe(85);
+    expect(data.rating).toBe('excellent');
+    expect(data.focus_keyword).toBe('wordpress seo');
+  });
+
+  it('SINGLE — no score returns null and no_score', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess(makeScorePost(1, undefined));
+
+    const res = await call('wp_get_seo_score', { post_id: 1 });
+    const data = parseResult(res);
+
+    expect(data.seo_score).toBeNull();
+    expect(data.rating).toBe('no_score');
+  });
+
+  it('BULK — sorted by score DESC', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess([
+      makeScorePost(1, '92'), makeScorePost(2, '75'), makeScorePost(3, '65'),
+      makeScorePost(4, '55'), makeScorePost(5, '30')
+    ]);
+
+    const res = await call('wp_get_seo_score', { limit: 5 });
+    const data = parseResult(res);
+
+    expect(data.mode).toBe('bulk');
+    expect(data.total_analyzed).toBe(5);
+    expect(data.posts[0].seo_score).toBe(92);
+    expect(data.posts[4].seo_score).toBe(30);
+  });
+
+  it('BULK — order=asc sorts ascending', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess([
+      makeScorePost(1, '92'), makeScorePost(2, '30'), makeScorePost(3, '65')
+    ]);
+
+    const res = await call('wp_get_seo_score', { limit: 5, order: 'asc' });
+    const data = parseResult(res);
+
+    expect(data.posts[0].seo_score).toBe(30);
+    expect(data.posts[2].seo_score).toBe(92);
+  });
+
+  it('DISTRIBUTION — correct counts', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess([
+      makeScorePost(1, '92'), makeScorePost(2, '75'), makeScorePost(3, '65'),
+      makeScorePost(4, '55'), makeScorePost(5, '30')
+    ]);
+
+    const res = await call('wp_get_seo_score', { limit: 5 });
+    const data = parseResult(res);
+
+    expect(data.distribution.excellent.count).toBe(1);
+    expect(data.distribution.good.count).toBe(2);
+    expect(data.distribution.average.count).toBe(1);
+    expect(data.distribution.poor.count).toBe(1);
+  });
+
+  it('STATS — avg and median calculated', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess([
+      makeScorePost(1, '92'), makeScorePost(2, '75'), makeScorePost(3, '65'),
+      makeScorePost(4, '55'), makeScorePost(5, '30')
+    ]);
+
+    const res = await call('wp_get_seo_score', { limit: 5 });
+    const data = parseResult(res);
+
+    expect(data.avg_score).toBe(63);
+    expect(data.median_score).toBe(65);
+  });
+
+  it('ERROR — plugin not RankMath', async () => {
+    detectSeoPlugin.mockResolvedValue('yoast');
+
+    const res = await call('wp_get_seo_score', { post_id: 1 });
+    expect(res.isError).toBe(true);
+    expect(res.content[0].text).toContain('requires RankMath');
+  });
+
+  it('AUDIT — logs get_seo_score action', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess(makeScorePost(1, '85'));
+
+    await call('wp_get_seo_score', { post_id: 1 });
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_get_seo_score');
+    expect(entry).toBeDefined();
+    expect(entry.action).toBe('get_seo_score');
+  });
+});
+
+// =========================================================================
+// wp_get_twitter_meta
+// =========================================================================
+
+describe('wp_get_twitter_meta', () => {
+  function makeTwitterPost(id, twitterMeta) {
+    return {
+      id,
+      title: { rendered: `Post ${id}` },
+      link: `https://test.example.com/post-${id}`,
+      slug: `post-${id}`,
+      meta: twitterMeta || {}
+    };
+  }
+
+  it('READ RankMath — returns twitter meta values', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess(makeTwitterPost(1, {
+      rank_math_twitter_title: 'TW Title',
+      rank_math_twitter_description: 'TW Desc',
+      rank_math_twitter_image: 'https://img.com/tw.jpg',
+      rank_math_twitter_card_type: 'summary_large_image'
+    }));
+
+    const res = await call('wp_get_twitter_meta', { post_id: 1 });
+    const data = parseResult(res);
+
+    expect(data.mode).toBe('read');
+    expect(data.seo_plugin).toBe('rankmath');
+    expect(data.twitter.title).toBe('TW Title');
+    expect(data.twitter.description).toBe('TW Desc');
+    expect(data.twitter.image).toBe('https://img.com/tw.jpg');
+    expect(data.twitter.card_type).toBe('summary_large_image');
+  });
+
+  it('READ Yoast — returns twitter meta values', async () => {
+    detectSeoPlugin.mockResolvedValue('yoast');
+    mockSuccess(makeTwitterPost(1, {
+      '_yoast_wpseo_twitter-title': 'Yoast TW',
+      '_yoast_wpseo_twitter-description': 'Yoast TW Desc',
+      '_yoast_wpseo_twitter-image': 'https://img.com/yoast.jpg'
+    }));
+
+    const res = await call('wp_get_twitter_meta', { post_id: 1 });
+    const data = parseResult(res);
+
+    expect(data.seo_plugin).toBe('yoast');
+    expect(data.twitter.title).toBe('Yoast TW');
+    expect(data.twitter.description).toBe('Yoast TW Desc');
+    expect(data.twitter.image).toBe('https://img.com/yoast.jpg');
+  });
+
+  it('READ — no twitter meta returns all null', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess(makeTwitterPost(1, {}));
+
+    const res = await call('wp_get_twitter_meta', { post_id: 1 });
+    const data = parseResult(res);
+
+    expect(data.twitter.title).toBeNull();
+    expect(data.twitter.description).toBeNull();
+    expect(data.twitter.image).toBeNull();
+  });
+
+  it('WRITE RankMath — updates twitter_title', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess(makeTwitterPost(1, {}));
+    mockSuccess({ id: 1 });
+
+    const res = await call('wp_get_twitter_meta', { post_id: 1, twitter_title: 'New TW Title' });
+    const data = parseResult(res);
+
+    expect(data.mode).toBe('write');
+    expect(data.updated_fields).toContain('twitter_title');
+    expect(data.twitter.title).toBe('New TW Title');
+  });
+
+  it('WRITE Yoast — updates twitter_description', async () => {
+    detectSeoPlugin.mockResolvedValue('yoast');
+    mockSuccess(makeTwitterPost(1, {}));
+    mockSuccess({ id: 1 });
+
+    const res = await call('wp_get_twitter_meta', { post_id: 1, twitter_description: 'New Desc' });
+    const data = parseResult(res);
+
+    expect(data.mode).toBe('write');
+    expect(data.seo_plugin).toBe('yoast');
+    expect(data.updated_fields).toContain('twitter_description');
+  });
+
+  it('WRITE — WP_READ_ONLY=true blocks update', async () => {
+    const original = process.env.WP_READ_ONLY;
+    process.env.WP_READ_ONLY = 'true';
+
+    try {
+      detectSeoPlugin.mockResolvedValue('rankmath');
+
+      const res = await call('wp_get_twitter_meta', { post_id: 1, twitter_title: 'X' });
+      expect(res.isError).toBe(true);
+      expect(res.content[0].text).toContain('READ-ONLY');
+    } finally {
+      if (original === undefined) delete process.env.WP_READ_ONLY;
+      else process.env.WP_READ_ONLY = original;
+    }
+  });
+
+  it('WRITE — unsupported plugin (seopress) errors', async () => {
+    detectSeoPlugin.mockResolvedValue('seopress');
+
+    const res = await call('wp_get_twitter_meta', { post_id: 1, twitter_title: 'X' });
+    expect(res.isError).toBe(true);
+    expect(res.content[0].text).toContain('requires RankMath or Yoast');
+  });
+
+  it('AUDIT — different action for read vs write', async () => {
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess(makeTwitterPost(1, {}));
+
+    await call('wp_get_twitter_meta', { post_id: 1 });
+    let logs = getAuditLogs();
+    let entry = logs.find(l => l.tool === 'wp_get_twitter_meta');
+    expect(entry).toBeDefined();
+    expect(entry.action).toBe('read_twitter_meta');
+
+    detectSeoPlugin.mockResolvedValue('rankmath');
+    mockSuccess(makeTwitterPost(2, {}));
+    mockSuccess({ id: 2 });
+
+    await call('wp_get_twitter_meta', { post_id: 2, twitter_title: 'X' });
+    logs = getAuditLogs();
+    const writeEntry = logs.find(l => l.tool === 'wp_get_twitter_meta' && l.action === 'update_twitter_meta');
+    expect(writeEntry).toBeDefined();
+    expect(writeEntry.target).toBe(2);
+  });
+});