@adsim/wordpress-mcp-server 3.1.0 → 4.5.0

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

@@ -0,0 +1,192 @@
+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 { mockSuccess, mockError, 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(); _testSetTarget(null); });
+
+// =========================================================================
+// Helpers
+// =========================================================================
+
+const recentDate = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString();
+const oldDate = new Date(Date.now() - 400 * 24 * 60 * 60 * 1000).toISOString();
+
+function makeAuthor(id, { bio = '', avatarUrls = {} } = {}) {
+  return { id, name: `Author ${id}`, slug: `author-${id}`, description: bio, avatar_urls: avatarUrls };
+}
+
+function makePostWithContent(id, content, { author = 1, modified = recentDate } = {}) {
+  return {
+    id, title: { rendered: `Post ${id}` }, link: `https://test.example.com/post-${id}/`,
+    content: { rendered: content }, author, date: modified, modified, meta: {}
+  };
+}
+
+// Perfect post: all E-E-A-T signals present (must exceed 800 words for content_word_count_expert)
+const fillerSentences = Array(160).fill('This detailed analysis covers important aspects of the topic thoroughly.').join(' ');
+const perfectContent = `
+<p>I've been working on this project for years and my experience with client projects has taught me a lot.</p>
+<p>According to a recent study, 75% of websites need improvement. Source: research shows this clearly.</p>
+<p>Visit <a href="https://other-site.com/page1">External 1</a> and <a href="https://other-site.com/page2">External 2</a>
+and <a href="https://wikipedia.org/wiki/SEO">Wikipedia on SEO</a>.</p>
+<p>John Smith from Google confirmed these findings in his rapport.</p>
+<p>${fillerSentences}</p>
+<script type="application/ld+json">{"@type":"Article"}</script>
+`;
+
+const emptyContent = '<p>Short.</p>';
+
+// =========================================================================
+// wp_analyze_eeat_signals
+// =========================================================================
+
+describe('wp_analyze_eeat_signals', () => {
+  it('SUCCESS — perfect score (all signals present)', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    // 1. Fetch posts
+    mockSuccess([makePostWithContent(1, perfectContent)]);
+    // 2. Fetch author
+    mockSuccess(makeAuthor(1, { bio: 'Expert in SEO with 10 years of experience', avatarUrls: { '96': 'https://test.example.com/avatar.jpg' } }));
+
+    const res = await call('wp_analyze_eeat_signals');
+    const data = parseResult(res);
+
+    expect(data.analyses[0].scores.total).toBe(100);
+    expect(data.analyses[0].scores.experience).toBe(25);
+    expect(data.analyses[0].scores.expertise).toBe(25);
+    expect(data.analyses[0].scores.authoritativeness).toBe(25);
+    expect(data.analyses[0].scores.trustworthiness).toBe(25);
+  });
+
+  it('SUCCESS — zero score (no signals)', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makePostWithContent(1, emptyContent, { modified: oldDate })]);
+    mockSuccess(makeAuthor(1));
+
+    const res = await call('wp_analyze_eeat_signals');
+    const data = parseResult(res);
+
+    expect(data.analyses[0].scores.total).toBe(0);
+    expect(data.analyses[0].signals_present).toHaveLength(0);
+    expect(data.analyses[0].signals_missing.length).toBeGreaterThan(0);
+  });
+
+  it('SIGNAL — author_has_bio detected', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makePostWithContent(1, emptyContent)]);
+    mockSuccess(makeAuthor(1, { bio: 'I am an expert in WordPress development.' }));
+
+    const res = await call('wp_analyze_eeat_signals');
+    const data = parseResult(res);
+
+    expect(data.analyses[0].signals_present).toContain('author_has_bio');
+    expect(data.analyses[0].scores.experience).toBeGreaterThanOrEqual(10);
+  });
+
+  it('SIGNAL — has_authoritative_sources detected', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    const content = '<p>See <a href="https://external.com/a">link1</a> and <a href="https://external.com/b">link2</a> and <a href="https://wikipedia.org/wiki/Test">Wikipedia</a>.</p>';
+    mockSuccess([makePostWithContent(1, content)]);
+    mockSuccess(makeAuthor(1));
+
+    const res = await call('wp_analyze_eeat_signals');
+    const data = parseResult(res);
+
+    expect(data.analyses[0].signals_present).toContain('has_authoritative_sources');
+    expect(data.analyses[0].signals_present).toContain('has_outbound_links');
+  });
+
+  it('SIGNAL — content_has_data detected', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    const content = '<p>Our conversion rate improved by 45% after the optimization.</p>';
+    mockSuccess([makePostWithContent(1, content)]);
+    mockSuccess(makeAuthor(1));
+
+    const res = await call('wp_analyze_eeat_signals');
+    const data = parseResult(res);
+
+    expect(data.analyses[0].signals_present).toContain('content_has_data');
+    expect(data.analyses[0].scores.expertise).toBeGreaterThanOrEqual(8);
+  });
+
+  it('SIGNAL — has_structured_data detected', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    const content = '<p>Text.</p><script type="application/ld+json">{"@type":"Article"}</script>';
+    mockSuccess([makePostWithContent(1, content)]);
+    mockSuccess(makeAuthor(1));
+
+    const res = await call('wp_analyze_eeat_signals');
+    const data = parseResult(res);
+
+    expect(data.analyses[0].signals_present).toContain('has_structured_data');
+    expect(data.analyses[0].scores.trustworthiness).toBeGreaterThanOrEqual(7);
+  });
+
+  it('SUCCESS — priority_fixes returns max 3 items', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makePostWithContent(1, emptyContent, { modified: oldDate })]);
+    mockSuccess(makeAuthor(1));
+
+    const res = await call('wp_analyze_eeat_signals');
+    const data = parseResult(res);
+
+    expect(data.analyses[0].priority_fixes.length).toBeLessThanOrEqual(3);
+    expect(data.analyses[0].priority_fixes.length).toBeGreaterThan(0);
+    // Should be sorted by impact descending
+    if (data.analyses[0].priority_fixes.length >= 2) {
+      expect(data.analyses[0].priority_fixes[0].potential_points).toBeGreaterThanOrEqual(data.analyses[0].priority_fixes[1].potential_points);
+    }
+  });
+
+  it('SUCCESS — post_ids parameter respected', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makePostWithContent(42, emptyContent)]);
+    mockSuccess(makeAuthor(1));
+
+    const res = await call('wp_analyze_eeat_signals', { post_ids: [42] });
+    const data = parseResult(res);
+
+    expect(data.analyses[0].id).toBe(42);
+    expect(data.total_analyzed).toBe(1);
+    // Verify fetch was called with include parameter
+    const fetchUrl = fetch.mock.calls[0][0];
+    expect(fetchUrl).toContain('include=42');
+  });
+
+  it('AUDIT — logs success entry', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makePostWithContent(1, emptyContent)]);
+    mockSuccess(makeAuthor(1));
+
+    await call('wp_analyze_eeat_signals');
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_analyze_eeat_signals');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('audit_seo');
+  });
+
+  it('ERROR — logs error on API failure', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockError(403, '{"code":"rest_forbidden","message":"Forbidden"}');
+
+    const res = await call('wp_analyze_eeat_signals');
+    expect(res.isError).toBe(true);
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_analyze_eeat_signals');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('error');
+  });
+});

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

@@ -0,0 +1,251 @@
+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));
+}
+
+// ────────────────────────────────────────────────────────────
+// wp_submit_for_review
+// ────────────────────────────────────────────────────────────
+
+describe('wp_submit_for_review', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('transitions draft → pending on success', async () => {
+    mockSuccess({ id: 10, title: { rendered: 'Draft Post' }, status: 'draft', meta: {} });
+    mockSuccess({ id: 10, title: { rendered: 'Draft Post' }, status: 'pending', link: 'https://test.example.com/?p=10' });
+
+    const result = await call('wp_submit_for_review', { id: 10, note: 'Please review' });
+    const data = parseResult(result);
+
+    expect(data.success).toBe(true);
+    expect(data.post.id).toBe(10);
+    expect(data.post.status).toBe('pending');
+
+    const logs = getAuditLogs(consoleSpy);
+    const entry = logs.find(l => l.tool === 'wp_submit_for_review');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('submit_for_review');
+    expect(entry.target).toBe(10);
+  });
+
+  it('returns error if post is not in draft status', async () => {
+    mockSuccess({ id: 10, title: { rendered: 'Published Post' }, status: 'publish', meta: {} });
+
+    const result = await call('wp_submit_for_review', { id: 10 });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('draft');
+
+    const logs = getAuditLogs(consoleSpy);
+    const entry = logs.find(l => l.tool === 'wp_submit_for_review');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('error');
+  });
+
+  it('is blocked by WP_READ_ONLY', async () => {
+    process.env.WP_READ_ONLY = 'true';
+    try {
+      const result = await call('wp_submit_for_review', { id: 10 });
+
+      expect(result.isError).toBe(true);
+      expect(result.content[0].text).toContain('READ-ONLY');
+
+      const logs = getAuditLogs(consoleSpy);
+      const entry = logs.find(l => l.tool === 'wp_submit_for_review');
+      expect(entry).toBeDefined();
+      expect(entry.status).toBe('blocked');
+    } finally {
+      delete process.env.WP_READ_ONLY;
+    }
+  });
+});
+
+// ────────────────────────────────────────────────────────────
+// wp_approve_post
+// ────────────────────────────────────────────────────────────
+
+describe('wp_approve_post', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('transitions pending → publish on success', async () => {
+    mockSuccess({ id: 10, title: { rendered: 'Pending Post' }, status: 'pending', meta: {} });
+    mockSuccess({ id: 10, title: { rendered: 'Pending Post' }, status: 'publish', link: 'https://test.example.com/pending-post' });
+
+    const result = await call('wp_approve_post', { id: 10 });
+    const data = parseResult(result);
+
+    expect(data.success).toBe(true);
+    expect(data.post.id).toBe(10);
+    expect(data.post.status).toBe('publish');
+
+    const logs = getAuditLogs(consoleSpy);
+    const entry = logs.find(l => l.tool === 'wp_approve_post');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('approve');
+    expect(entry.target).toBe(10);
+  });
+
+  it('returns error if post is not in pending status', async () => {
+    mockSuccess({ id: 10, title: { rendered: 'Draft Post' }, status: 'draft', meta: {} });
+
+    const result = await call('wp_approve_post', { id: 10 });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('pending');
+
+    const logs = getAuditLogs(consoleSpy);
+    const entry = logs.find(l => l.tool === 'wp_approve_post');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('error');
+  });
+
+  it('is blocked by WP_READ_ONLY', async () => {
+    process.env.WP_READ_ONLY = 'true';
+    try {
+      const result = await call('wp_approve_post', { id: 10 });
+
+      expect(result.isError).toBe(true);
+      expect(result.content[0].text).toContain('READ-ONLY');
+
+      const logs = getAuditLogs(consoleSpy);
+      const entry = logs.find(l => l.tool === 'wp_approve_post');
+      expect(entry).toBeDefined();
+      expect(entry.status).toBe('blocked');
+    } finally {
+      delete process.env.WP_READ_ONLY;
+    }
+  });
+
+  it('is blocked by WP_DRAFT_ONLY', async () => {
+    process.env.WP_DRAFT_ONLY = 'true';
+    try {
+      const result = await call('wp_approve_post', { id: 10 });
+
+      expect(result.isError).toBe(true);
+      expect(result.content[0].text).toContain('DRAFT-ONLY');
+
+      const logs = getAuditLogs(consoleSpy);
+      const entry = logs.find(l => l.tool === 'wp_approve_post');
+      expect(entry).toBeDefined();
+      expect(entry.status).toBe('blocked');
+    } finally {
+      delete process.env.WP_DRAFT_ONLY;
+    }
+  });
+});
+
+// ────────────────────────────────────────────────────────────
+// wp_reject_post
+// ────────────────────────────────────────────────────────────
+
+describe('wp_reject_post', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('transitions pending → draft with reason and incremented rejection count', async () => {
+    mockSuccess({ id: 10, title: { rendered: 'Pending Post' }, status: 'pending', meta: { _mcp_rejection_count: 1 } });
+    mockSuccess({ id: 10, title: { rendered: 'Pending Post' }, status: 'draft' });
+
+    const result = await call('wp_reject_post', { id: 10, reason: 'Needs more detail' });
+    const data = parseResult(result);
+
+    expect(data.success).toBe(true);
+    expect(data.post.id).toBe(10);
+    expect(data.post.status).toBe('draft');
+    expect(data.rejection.reason).toBe('Needs more detail');
+    expect(data.rejection.count).toBe(2);
+
+    const logs = getAuditLogs(consoleSpy);
+    const entry = logs.find(l => l.tool === 'wp_reject_post');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('reject');
+    expect(entry.target).toBe(10);
+  });
+
+  it('returns error if post is not in pending status', async () => {
+    mockSuccess({ id: 10, title: { rendered: 'Draft Post' }, status: 'draft', meta: {} });
+
+    const result = await call('wp_reject_post', { id: 10, reason: 'Bad' });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('pending');
+
+    const logs = getAuditLogs(consoleSpy);
+    const entry = logs.find(l => l.tool === 'wp_reject_post');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('error');
+  });
+
+  it('is blocked by WP_READ_ONLY', async () => {
+    process.env.WP_READ_ONLY = 'true';
+    try {
+      const result = await call('wp_reject_post', { id: 10, reason: 'Bad' });
+
+      expect(result.isError).toBe(true);
+      expect(result.content[0].text).toContain('READ-ONLY');
+
+      const logs = getAuditLogs(consoleSpy);
+      const entry = logs.find(l => l.tool === 'wp_reject_post');
+      expect(entry).toBeDefined();
+      expect(entry.status).toBe('blocked');
+    } finally {
+      delete process.env.WP_READ_ONLY;
+    }
+  });
+});
+
+// ────────────────────────────────────────────────────────────
+// WP_REQUIRE_APPROVAL governance
+// ────────────────────────────────────────────────────────────
+
+describe('WP_REQUIRE_APPROVAL=true', () => {
+  let consoleSpy;
+  beforeEach(() => {
+    fetch.mockReset();
+    consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    process.env.WP_REQUIRE_APPROVAL = 'true';
+  });
+  afterEach(() => {
+    consoleSpy.mockRestore();
+    delete process.env.WP_REQUIRE_APPROVAL;
+  });
+
+  it('blocks wp_update_post when status is publish', async () => {
+    const result = await call('wp_update_post', { id: 1, status: 'publish' });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('APPROVAL REQUIRED');
+
+    const logs = getAuditLogs(consoleSpy);
+    const entry = logs.find(l => l.tool === 'wp_update_post');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('blocked');
+  });
+
+  it('blocks wp_create_post when status is publish', async () => {
+    const result = await call('wp_create_post', { title: 'T', content: 'C', status: 'publish' });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('APPROVAL REQUIRED');
+
+    const logs = getAuditLogs(consoleSpy);
+    const entry = logs.find(l => l.tool === 'wp_create_post');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('blocked');
+  });
+});

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

@@ -0,0 +1,149 @@
+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 { mockSuccess, mockError, 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(); _testSetTarget(null); });
+
+// =========================================================================
+// Helper
+// =========================================================================
+
+function makePost(id, canonical, link) {
+  return {
+    id, title: { rendered: `Post ${id}` },
+    link: link || `https://mysite.example.com/post-${id}/`,
+    meta: canonical !== undefined ? { rank_math_canonical_url: canonical } : {}
+  };
+}
+
+// =========================================================================
+// wp_audit_canonicals
+// =========================================================================
+
+describe('wp_audit_canonicals', () => {
+  it('SUCCESS — all canonicals valid', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    mockSuccess([
+      makePost(1, 'https://mysite.example.com/post-1/'),
+      makePost(2, 'https://mysite.example.com/post-2/')
+    ]);
+
+    const res = await call('wp_audit_canonicals');
+    const data = parseResult(res);
+
+    expect(data.total_issues).toBe(0);
+    expect(data.total_audited).toBe(2);
+  });
+
+  it('ISSUE — missing_canonical detected', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    mockSuccess([makePost(1, '')]);
+
+    const res = await call('wp_audit_canonicals');
+    const data = parseResult(res);
+
+    expect(data.issues_by_type.missing_canonical).toBe(1);
+    expect(data.audits[0].issues).toContain('missing_canonical');
+  });
+
+  it('ISSUE — http_on_https_site detected', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    mockSuccess([makePost(1, 'http://test.example.com/post-1/')]);
+
+    const res = await call('wp_audit_canonicals');
+    const data = parseResult(res);
+
+    expect(data.issues_by_type.http_on_https_site).toBe(1);
+    expect(data.audits[0].issues).toContain('http_on_https_site');
+  });
+
+  it('ISSUE — staging_url detected', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    mockSuccess([makePost(1, 'https://staging.example.com/post-1/')]);
+
+    const res = await call('wp_audit_canonicals');
+    const data = parseResult(res);
+
+    expect(data.issues_by_type.staging_url).toBe(1);
+    expect(data.audits[0].issues).toContain('staging_url');
+  });
+
+  it('ISSUE — wrong_domain detected', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    mockSuccess([makePost(1, 'https://other-domain.com/post-1/')]);
+
+    const res = await call('wp_audit_canonicals');
+    const data = parseResult(res);
+
+    expect(data.issues_by_type.wrong_domain).toBe(1);
+    expect(data.audits[0].issues).toContain('wrong_domain');
+  });
+
+  it('ISSUE — trailing_slash_mismatch detected', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    // Post link has trailing slash, canonical does not
+    mockSuccess([makePost(1, 'https://mysite.example.com/post-1', 'https://mysite.example.com/post-1/')]);
+
+    const res = await call('wp_audit_canonicals');
+    const data = parseResult(res);
+
+    expect(data.issues_by_type.trailing_slash_mismatch).toBe(1);
+    expect(data.audits[0].issues).toContain('trailing_slash_mismatch');
+  });
+
+  it('SUCCESS — SEO plugin auto-detected (RankMath vs Yoast)', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+
+    // RankMath detection
+    mockSuccess([makePost(1, 'https://mysite.example.com/post-1/')]);
+    let res = await call('wp_audit_canonicals');
+    let data = parseResult(res);
+    expect(data.seo_plugin_detected).toBe('RankMath');
+
+    // Yoast detection
+    fetch.mockReset();
+    mockSuccess([{
+      id: 2, title: { rendered: 'Post 2' }, link: 'https://mysite.example.com/post-2/',
+      meta: { _yoast_wpseo_canonical: 'https://mysite.example.com/post-2/' }
+    }]);
+    res = await call('wp_audit_canonicals');
+    data = parseResult(res);
+    expect(data.seo_plugin_detected).toBe('Yoast');
+  });
+
+  it('AUDIT — logs success entry', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    mockSuccess([makePost(1, 'https://mysite.example.com/post-1/')]);
+
+    await call('wp_audit_canonicals');
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_audit_canonicals');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('audit_seo');
+  });
+
+  it('ERROR — logs error on API failure', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    mockError(403, '{"code":"rest_forbidden","message":"Forbidden"}');
+
+    const res = await call('wp_audit_canonicals');
+    expect(res.isError).toBe(true);
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_audit_canonicals');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('error');
+  });
+});