@adsim/wordpress-mcp-server 3.0.0 → 4.4.0

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

@@ -0,0 +1,175 @@
+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
+// =========================================================================
+
+function makePost(id, content) {
+  return {
+    id, title: { rendered: `Post ${id}` },
+    link: `https://mysite.example.com/post-${id}/`,
+    content: { rendered: content }
+  };
+}
+
+// =========================================================================
+// wp_audit_outbound_links
+// =========================================================================
+
+describe('wp_audit_outbound_links', () => {
+  it('STATUS — no_outbound when article has no external links', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    const html = '<p>Just text, no links at all.</p>';
+    mockSuccess([makePost(1, html)]);
+
+    const res = await call('wp_audit_outbound_links');
+    const data = parseResult(res);
+
+    expect(data.articles[0].status).toBe('no_outbound');
+    expect(data.articles[0].outbound_count).toBe(0);
+    expect(data.by_status.no_outbound).toBe(1);
+  });
+
+  it('STATUS — good when article has appropriate external links', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    const html = '<p>See <a href="https://external.com/page">external</a> and <a href="https://other.com/page">other</a>.</p>';
+    mockSuccess([makePost(1, html)]);
+
+    const res = await call('wp_audit_outbound_links');
+    const data = parseResult(res);
+
+    expect(data.articles[0].status).toBe('good');
+    expect(data.articles[0].outbound_count).toBe(2);
+    expect(data.by_status.good).toBe(1);
+  });
+
+  it('STATUS — excessive when too many external links', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    // Generate 20 external links
+    const links = Array.from({ length: 20 }, (_, i) =>
+      `<a href="https://site${i}.com/page">link${i}</a>`
+    ).join(' ');
+    const html = `<p>${links}</p>`;
+    mockSuccess([makePost(1, html)]);
+
+    const res = await call('wp_audit_outbound_links', { max_outbound: 15 });
+    const data = parseResult(res);
+
+    expect(data.articles[0].status).toBe('excessive');
+    expect(data.articles[0].outbound_count).toBe(20);
+    expect(data.by_status.excessive).toBe(1);
+  });
+
+  it('FILTER — internal links NOT counted as external', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    const html = `<p>
+      <a href="https://mysite.example.com/other-post/">internal</a>
+      <a href="https://external.com/page">external</a>
+    </p>`;
+    mockSuccess([makePost(1, html)]);
+
+    const res = await call('wp_audit_outbound_links');
+    const data = parseResult(res);
+
+    // Only the external link should be counted
+    expect(data.articles[0].outbound_count).toBe(1);
+    expect(data.articles[0].external_domains).toContain('external.com');
+    expect(data.articles[0].external_domains).not.toContain('mysite.example.com');
+  });
+
+  it('AUTH — authoritative domains identified correctly', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    const html = `<p>
+      <a href="https://en.wikipedia.org/wiki/SEO">wiki</a>
+      <a href="https://www.cdc.gov/health">gov</a>
+      <a href="https://randomsite.com/page">random</a>
+    </p>`;
+    mockSuccess([makePost(1, html)]);
+
+    const res = await call('wp_audit_outbound_links');
+    const data = parseResult(res);
+
+    expect(data.articles[0].authoritative_count).toBe(2);
+    expect(data.posts_with_authoritative_sources).toBe(1);
+    // Top cited domains should include authoritative flag
+    const wikiDomain = data.top_cited_domains.find(d => d.domain === 'en.wikipedia.org');
+    expect(wikiDomain).toBeDefined();
+    expect(wikiDomain.is_authoritative).toBe(true);
+  });
+
+  it('RANKING — top_cited_domains sorted by count DESC', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    const html = `<p>
+      <a href="https://siteA.com/1">a1</a>
+      <a href="https://siteB.com/1">b1</a>
+      <a href="https://siteB.com/2">b2</a>
+      <a href="https://siteC.com/1">c1</a>
+      <a href="https://siteC.com/2">c2</a>
+      <a href="https://siteC.com/3">c3</a>
+    </p>`;
+    mockSuccess([makePost(1, html)]);
+
+    const res = await call('wp_audit_outbound_links');
+    const data = parseResult(res);
+
+    expect(data.top_cited_domains[0].domain).toBe('sitec.com');
+    expect(data.top_cited_domains[0].count).toBe(3);
+    expect(data.top_cited_domains[1].domain).toBe('siteb.com');
+    expect(data.top_cited_domains[1].count).toBe(2);
+  });
+
+  it('RATIO — outbound_ratio calculated correctly', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    // 100 words + 2 external links → ratio = 2 / (100/100) = 2.0
+    const words = Array(100).fill('word').join(' ');
+    const html = `<p>${words} <a href="https://ext1.com/p">ext1</a> <a href="https://ext2.com/p">ext2</a></p>`;
+    mockSuccess([makePost(1, html)]);
+
+    const res = await call('wp_audit_outbound_links');
+    const data = parseResult(res);
+
+    // Word count includes link text, so it's slightly more than 100
+    expect(data.articles[0].outbound_ratio).toBeGreaterThan(0);
+    expect(typeof data.articles[0].outbound_ratio).toBe('number');
+  });
+
+  it('AUDIT — logs success entry', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    mockSuccess([makePost(1, '<p>Text.</p>')]);
+
+    await call('wp_audit_outbound_links');
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_audit_outbound_links');
+    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_outbound_links');
+    expect(res.isError).toBe(true);
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_audit_outbound_links');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('error');
+  });
+});

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

@@ -0,0 +1,173 @@
+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
+// =========================================================================
+
+function makeTag(id, name, count = 5) {
+  return { id, name, slug: name.toLowerCase().replace(/\s+/g, '-'), count, description: '' };
+}
+
+function makeCategory(id, name, count = 5, description = 'A category about ' + name) {
+  return { id, name, slug: name.toLowerCase().replace(/\s+/g, '-'), count, description };
+}
+
+// =========================================================================
+// wp_audit_taxonomies
+// =========================================================================
+
+describe('wp_audit_taxonomies', () => {
+  it('SUCCESS — no issues detected', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeTag(1, 'WordPress', 10), makeTag(2, 'SEO', 8)]);
+    mockSuccess([makeCategory(1, 'Tutorials', 15, 'Step by step tutorials'), makeCategory(2, 'News', 12, 'Latest news')]);
+
+    const res = await call('wp_audit_taxonomies');
+    const data = parseResult(res);
+
+    expect(data.total_issues).toBe(0);
+    expect(data.crawl_waste_score).toBe(0);
+  });
+
+  it('ISSUE — empty tag detected', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeTag(1, 'WordPress', 0), makeTag(2, 'SEO', 8)]);
+    mockSuccess([makeCategory(1, 'Tutorials', 15, 'Tutorials desc')]);
+
+    const res = await call('wp_audit_taxonomies');
+    const data = parseResult(res);
+
+    expect(data.tags.issues.empty).toHaveLength(1);
+    expect(data.tags.issues.empty[0].name).toBe('WordPress');
+    expect(data.tags.issues.empty[0].issue_type).toBe('empty');
+  });
+
+  it('ISSUE — single_post tag detected', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeTag(1, 'Niche Topic', 1)]);
+    mockSuccess([makeCategory(1, 'General', 10, 'General desc')]);
+
+    const res = await call('wp_audit_taxonomies');
+    const data = parseResult(res);
+
+    expect(data.tags.issues.single_post).toHaveLength(1);
+    expect(data.tags.issues.single_post[0].issue_type).toBe('single_post');
+  });
+
+  it('ISSUE — category missing_description detected', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeTag(1, 'SEO', 10)]);
+    mockSuccess([makeCategory(1, 'Tutorials', 15, ''), makeCategory(2, 'News', 12, 'Has description')]);
+
+    const res = await call('wp_audit_taxonomies');
+    const data = parseResult(res);
+
+    expect(data.categories.issues.missing_description).toHaveLength(1);
+    expect(data.categories.issues.missing_description[0].name).toBe('Tutorials');
+  });
+
+  it('DEDUP — exact duplicates grouped', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeTag(1, 'seo', 5), makeTag(2, 'SEO', 3), makeTag(3, 'WordPress', 10)]);
+    mockSuccess([makeCategory(1, 'General', 10, 'Desc')]);
+
+    const res = await call('wp_audit_taxonomies');
+    const data = parseResult(res);
+
+    expect(data.tags.issues.duplicate_groups.length).toBeGreaterThanOrEqual(1);
+    const group = data.tags.issues.duplicate_groups[0];
+    expect(group.terms.length).toBeGreaterThanOrEqual(2);
+    expect(group.similarity).toBe('exact');
+  });
+
+  it('DEDUP — near duplicates via Levenshtein grouped', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    // 'wordpress' and 'wordpres' differ by 1 char, both >= 4 chars
+    mockSuccess([makeTag(1, 'WordPress', 5), makeTag(2, 'Wordpres', 3)]);
+    mockSuccess([makeCategory(1, 'General', 10, 'Desc')]);
+
+    const res = await call('wp_audit_taxonomies');
+    const data = parseResult(res);
+
+    expect(data.tags.issues.duplicate_groups.length).toBeGreaterThanOrEqual(1);
+    const group = data.tags.issues.duplicate_groups[0];
+    expect(group.similarity).toBe('near');
+  });
+
+  it('PARAM — check_tags: false skips tags', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeCategory(1, 'Tutorials', 15, 'Desc')]);
+
+    const res = await call('wp_audit_taxonomies', { check_tags: false });
+    const data = parseResult(res);
+
+    expect(data.tags).toBeUndefined();
+    expect(data.categories).toBeDefined();
+  });
+
+  it('PARAM — check_categories: false skips categories', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeTag(1, 'SEO', 10)]);
+
+    const res = await call('wp_audit_taxonomies', { check_categories: false });
+    const data = parseResult(res);
+
+    expect(data.categories).toBeUndefined();
+    expect(data.tags).toBeDefined();
+  });
+
+  it('SCORE — crawl_waste_score calculated correctly', async () => {
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    // 2 tags: 1 empty (issue) + 1 ok, 2 cats: 1 missing_desc (issue) + 1 ok → 2 issues / 4 terms = 50%
+    mockSuccess([makeTag(1, 'Empty', 0), makeTag(2, 'OK', 10)]);
+    mockSuccess([makeCategory(1, 'NoDesc', 5, ''), makeCategory(2, 'WithDesc', 5, 'Good')]);
+
+    const res = await call('wp_audit_taxonomies', { detect_duplicates: false });
+    const data = parseResult(res);
+
+    expect(data.crawl_waste_score).toBe(50);
+  });
+
+  it('AUDIT — logs success and error', async () => {
+    // Success
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeTag(1, 'SEO', 10)]);
+    mockSuccess([makeCategory(1, 'General', 5, 'Desc')]);
+
+    await call('wp_audit_taxonomies');
+
+    let logs = getAuditLogs();
+    let entry = logs.find(l => l.tool === 'wp_audit_taxonomies');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('audit_seo');
+
+    // Error
+    fetch.mockReset();
+    consoleSpy.mockClear();
+    _testSetTarget('test', { url: 'https://mysite.example.com', username: 'u', password: 'p' });
+    mockError(403, '{"code":"rest_forbidden","message":"Forbidden"}');
+
+    const res = await call('wp_audit_taxonomies');
+    expect(res.isError).toBe(true);
+
+    logs = getAuditLogs();
+    entry = logs.find(l => l.tool === 'wp_audit_taxonomies');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('error');
+  });
+});

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

@@ -0,0 +1,320 @@
+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';
+import { stripHtml, extractLinksOnly, truncateContent, summarizePost, applyContentFormat } from '../../../src/utils/contentCompressor.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
+// =========================================================================
+
+function makeWpPost(id, content = '<p>Content</p>', extras = {}) {
+  return {
+    id,
+    title: { rendered: `Post ${id}` },
+    content: { rendered: content },
+    excerpt: { rendered: `Excerpt ${id}` },
+    status: 'publish',
+    date: '2025-06-01',
+    modified: '2025-06-02',
+    link: `https://test.example.com/post-${id}`,
+    slug: `post-${id}`,
+    categories: [1],
+    tags: [2],
+    author: 1,
+    featured_media: 0,
+    comment_status: 'open',
+    meta: {},
+    ...extras
+  };
+}
+
+// =========================================================================
+// Unit tests — contentCompressor.js
+// =========================================================================
+
+describe('contentCompressor — stripHtml', () => {
+  it('strips tags and decodes entities', () => {
+    const html = '<p>Hello &amp; <strong>world</strong></p>';
+    expect(stripHtml(html)).toBe('Hello & world');
+  });
+
+  it('removes script and style blocks', () => {
+    const html = '<p>text</p><script>alert("x")</script><style>.a{}</style><p>more</p>';
+    expect(stripHtml(html)).not.toContain('alert');
+    expect(stripHtml(html)).not.toContain('.a{}');
+    expect(stripHtml(html)).toContain('text');
+    expect(stripHtml(html)).toContain('more');
+  });
+
+  it('returns empty string for falsy input', () => {
+    expect(stripHtml('')).toBe('');
+    expect(stripHtml(null)).toBe('');
+    expect(stripHtml(undefined)).toBe('');
+  });
+});
+
+describe('contentCompressor — extractLinksOnly', () => {
+  const siteUrl = 'https://mysite.example.com';
+
+  it('extracts internal links only', () => {
+    const html = `<p>
+      <a href="https://mysite.example.com/about/">About</a>
+      <a href="https://external.com/page">External</a>
+    </p>`;
+    const links = extractLinksOnly(html, siteUrl);
+    expect(links).toHaveLength(1);
+    expect(links[0].text).toBe('About');
+    expect(links[0].href).toBe('https://mysite.example.com/about/');
+  });
+
+  it('handles relative links', () => {
+    const html = '<a href="/contact/">Contact</a>';
+    const links = extractLinksOnly(html, siteUrl);
+    expect(links).toHaveLength(1);
+    expect(links[0].href).toBe('https://mysite.example.com/contact/');
+  });
+
+  it('uses [no anchor text] for empty anchors', () => {
+    const html = '<a href="https://mysite.example.com/page/"></a>';
+    const links = extractLinksOnly(html, siteUrl);
+    expect(links[0].text).toBe('[no anchor text]');
+  });
+
+  it('returns empty array for no html', () => {
+    expect(extractLinksOnly('', siteUrl)).toEqual([]);
+    expect(extractLinksOnly(null, siteUrl)).toEqual([]);
+  });
+});
+
+describe('contentCompressor — truncateContent', () => {
+  it('does not truncate short content', () => {
+    expect(truncateContent('short text', 100)).toBe('short text');
+  });
+
+  it('truncates at word boundary', () => {
+    const text = 'word1 word2 word3 word4 word5';
+    const result = truncateContent(text, 15);
+    expect(result).toContain('[truncated:');
+    expect(result).not.toContain('word4');
+  });
+
+  it('returns empty string for falsy input', () => {
+    expect(truncateContent('', 100)).toBe('');
+    expect(truncateContent(null, 100)).toBe('');
+  });
+
+  it('no limit when maxChars is 0', () => {
+    const longText = 'a'.repeat(50000);
+    expect(truncateContent(longText, 0)).toBe(longText);
+  });
+});
+
+describe('contentCompressor — summarizePost', () => {
+  it('filters to requested fields only', () => {
+    const post = { id: 1, title: 'T', content: 'C', slug: 's', status: 'publish', date: '2025-01-01' };
+    const result = summarizePost(post, ['id', 'title']);
+    expect(Object.keys(result)).toEqual(['id', 'title']);
+    expect(result.id).toBe(1);
+  });
+
+  it('returns full post when fields is empty or null', () => {
+    const post = { id: 1, title: 'T', content: 'C' };
+    expect(summarizePost(post, [])).toBe(post);
+    expect(summarizePost(post, null)).toBe(post);
+  });
+
+  it('ignores non-existent fields gracefully', () => {
+    const post = { id: 1, title: 'T' };
+    const result = summarizePost(post, ['id', 'nonexistent']);
+    expect(result).toEqual({ id: 1 });
+  });
+});
+
+describe('contentCompressor — applyContentFormat', () => {
+  const siteUrl = 'https://mysite.example.com';
+
+  it('html mode — truncates long content', () => {
+    const post = { id: 1, content: 'a'.repeat(20000) };
+    const result = applyContentFormat(post, 'html', siteUrl, 15000);
+    expect(result._content_format).toBe('html');
+    expect(result.content.length).toBeLessThan(20000);
+    expect(result.content).toContain('[truncated:');
+  });
+
+  it('text mode — strips HTML and truncates', () => {
+    const post = { id: 1, content: '<p>Hello <strong>world</strong></p>' };
+    const result = applyContentFormat(post, 'text', siteUrl, 15000);
+    expect(result._content_format).toBe('text');
+    expect(result.content).toContain('Hello world');
+    expect(result.content).not.toContain('<p>');
+  });
+
+  it('links_only mode — extracts internal links', () => {
+    const html = '<a href="https://mysite.example.com/page/">Page</a><a href="https://ext.com/x">Ext</a>';
+    const post = { id: 1, content: html };
+    const result = applyContentFormat(post, 'links_only', siteUrl);
+    expect(result._content_format).toBe('links_only');
+    expect(result.content).toBeNull();
+    expect(result.internal_links).toHaveLength(1);
+    expect(result.internal_links[0].text).toBe('Page');
+  });
+
+  it('returns post unchanged if no content', () => {
+    const post = { id: 1 };
+    expect(applyContentFormat(post, 'html', siteUrl)).toBe(post);
+  });
+});
+
+// =========================================================================
+// Integration tests — wp_get_post with content_format & fields
+// =========================================================================
+
+describe('wp_get_post — content_format', () => {
+  it('DEFAULT — returns truncated HTML (html mode)', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    const longContent = '<p>' + 'word '.repeat(5000) + '</p>';
+    mockSuccess(makeWpPost(1, longContent));
+
+    const res = await call('wp_get_post', { id: 1 });
+    const data = parseResult(res);
+
+    expect(data._content_format).toBe('html');
+    expect(data.id).toBe(1);
+    expect(data.title).toBe('Post 1');
+  });
+
+  it('TEXT — strips HTML tags', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess(makeWpPost(1, '<p>Hello <strong>world</strong></p>'));
+
+    const res = await call('wp_get_post', { id: 1, content_format: 'text' });
+    const data = parseResult(res);
+
+    expect(data._content_format).toBe('text');
+    expect(data.content).toContain('Hello world');
+    expect(data.content).not.toContain('<p>');
+  });
+
+  it('LINKS_ONLY — extracts internal links', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    const html = '<p>See <a href="https://test.example.com/other/">other</a> and <a href="https://ext.com/x">ext</a></p>';
+    mockSuccess(makeWpPost(1, html));
+
+    const res = await call('wp_get_post', { id: 1, content_format: 'links_only' });
+    const data = parseResult(res);
+
+    expect(data._content_format).toBe('links_only');
+    expect(data.content).toBeNull();
+    expect(data.internal_links).toHaveLength(1);
+    expect(data.internal_links[0].text).toBe('other');
+    expect(data.internal_links[0].href).toBe('https://test.example.com/other/');
+  });
+});
+
+describe('wp_get_post — fields filter', () => {
+  it('returns only requested fields', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess(makeWpPost(1));
+
+    const res = await call('wp_get_post', { id: 1, fields: ['id', 'title', 'slug'] });
+    const data = parseResult(res);
+
+    expect(Object.keys(data).sort()).toEqual(['id', 'slug', 'title']);
+    expect(data.id).toBe(1);
+    expect(data.title).toBe('Post 1');
+    expect(data.slug).toBe('post-1');
+  });
+
+  it('fields + content_format work together', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess(makeWpPost(1, '<p>Hello <b>world</b></p>'));
+
+    const res = await call('wp_get_post', { id: 1, fields: ['id', 'content'], content_format: 'text' });
+    const data = parseResult(res);
+
+    expect(Object.keys(data).sort()).toEqual(['content', 'id']);
+    expect(data.content).toContain('Hello world');
+    expect(data.content).not.toContain('<p>');
+  });
+});
+
+// =========================================================================
+// Integration tests — wp_list_posts with mode
+// =========================================================================
+
+describe('wp_list_posts — mode', () => {
+  function makeWpListPost(id) {
+    return {
+      id,
+      title: { rendered: `Post ${id}` },
+      status: 'publish',
+      date: '2025-06-01',
+      modified: '2025-06-02',
+      link: `https://test.example.com/post-${id}`,
+      slug: `post-${id}`,
+      author: 1,
+      categories: [1],
+      tags: [],
+      excerpt: { rendered: `Excerpt for post ${id}` }
+    };
+  }
+
+  it('FULL — returns all fields (default)', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeWpListPost(1), makeWpListPost(2)]);
+
+    const res = await call('wp_list_posts');
+    const data = parseResult(res);
+
+    expect(data.total).toBe(2);
+    expect(data.posts[0].excerpt).toBeDefined();
+    expect(data.posts[0].author).toBeDefined();
+  });
+
+  it('IDS_ONLY — returns flat array of IDs', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeWpListPost(1), makeWpListPost(2), makeWpListPost(3)]);
+
+    const res = await call('wp_list_posts', { mode: 'ids_only' });
+    const data = parseResult(res);
+
+    expect(data.mode).toBe('ids_only');
+    expect(data.ids).toEqual([1, 2, 3]);
+    expect(data.posts).toBeUndefined();
+  });
+
+  it('SUMMARY — returns id/title/slug/date/status/link only', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+    mockSuccess([makeWpListPost(1)]);
+
+    const res = await call('wp_list_posts', { mode: 'summary' });
+    const data = parseResult(res);
+
+    expect(data.mode).toBe('summary');
+    expect(data.posts).toHaveLength(1);
+    const p = data.posts[0];
+    expect(Object.keys(p).sort()).toEqual(['date', 'id', 'link', 'slug', 'status', 'title']);
+    expect(p.excerpt).toBeUndefined();
+    expect(p.author).toBeUndefined();
+    expect(p.categories).toBeUndefined();
+  });
+
+  it('VALIDATION — rejects invalid mode', async () => {
+    _testSetTarget('test', { url: 'https://test.example.com', username: 'u', password: 'p' });
+
+    const res = await call('wp_list_posts', { mode: 'invalid' });
+    expect(res.isError).toBe(true);
+  });
+});