@adsim/wordpress-mcp-server 1.0.0 → 3.0.0

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

@@ -0,0 +1,248 @@
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+
+vi.mock('node-fetch', () => ({ default: vi.fn() }));
+
+import fetch from 'node-fetch';
+import { handleToolCall } from '../../../index.js';
+import { mockSuccess, mockError, getAuditLogs, makeRequest, parseResult } from '../../helpers/mockWpRequest.js';
+
+function call(name, args = {}) {
+  return handleToolCall(makeRequest(name, args));
+}
+
+let consoleSpy;
+beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+afterEach(() => { consoleSpy.mockRestore(); });
+
+// =========================================================================
+// Shared mock data
+// =========================================================================
+
+const yoastPost = {
+  id: 1,
+  title: { rendered: 'Test Post' },
+  slug: 'test-post',
+  link: 'https://test.example.com/test-post',
+  status: 'publish',
+  meta: {
+    _yoast_wpseo_title: 'SEO Title',
+    _yoast_wpseo_metadesc: 'Meta description',
+    _yoast_wpseo_focuskw: 'keyword',
+    _yoast_wpseo_canonical: 'https://test.example.com/test-post',
+    _yoast_wpseo_meta_robots_noindex: '0',
+    _yoast_wpseo_meta_robots_nofollow: '0',
+  },
+  yoast_head_json: {
+    title: 'SEO Title',
+    description: 'Meta description',
+    canonical: 'https://test.example.com/test-post',
+    robots: { index: 'index', follow: 'follow' },
+    og_title: 'OG Title',
+    og_description: 'OG Desc',
+    og_image: [{ url: 'https://test.example.com/img.jpg' }],
+    schema: {},
+  },
+};
+
+// =========================================================================
+// wp_get_seo_meta
+// =========================================================================
+
+describe('wp_get_seo_meta', () => {
+  it('SUCCESS — detects Yoast and returns seo fields', async () => {
+    mockSuccess(yoastPost);
+
+    const res = await call('wp_get_seo_meta', { id: 1 });
+    const data = parseResult(res);
+
+    expect(data.id).toBe(1);
+    expect(data.title).toBe('Test Post');
+    expect(data.seo.plugin).toBe('yoast');
+    expect(data.seo.title).toBe('SEO Title');
+    expect(data.seo.description).toBe('Meta description');
+    expect(data.seo.focus_keyword).toBe('keyword');
+    expect(data.seo.canonical).toBe('https://test.example.com/test-post');
+    expect(data.seo.robots.noindex).toBe(false);
+    expect(data.seo.robots.nofollow).toBe(false);
+    expect(data.seo.og_title).toBe('OG Title');
+    expect(data.seo.og_description).toBe('OG Desc');
+    expect(data.seo.og_image).toBe('https://test.example.com/img.jpg');
+    expect(data.seo.schema).toEqual({});
+  });
+
+  it('ERROR 403 — returns error message', async () => {
+    mockError(403, '{"code":"rest_forbidden"}');
+
+    const res = await call('wp_get_seo_meta', { id: 1 });
+    expect(res.isError).toBe(true);
+    expect(res.content[0].text).toContain('403');
+  });
+
+  it('ERROR 404 — returns error message', async () => {
+    mockError(404, '{"code":"rest_post_invalid_id"}');
+
+    const res = await call('wp_get_seo_meta', { id: 99999 });
+    expect(res.isError).toBe(true);
+    expect(res.content[0].text).toContain('404');
+  });
+
+  it('AUDIT — logs read_seo action on success', async () => {
+    mockSuccess(yoastPost);
+
+    await call('wp_get_seo_meta', { id: 1 });
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_get_seo_meta');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('read_seo');
+    expect(entry.target).toBe(1);
+  });
+});
+
+// =========================================================================
+// wp_update_seo_meta
+// =========================================================================
+
+describe('wp_update_seo_meta', () => {
+  it('SUCCESS — detects Yoast and updates title + description', async () => {
+    // First fetch: read current post to detect plugin
+    mockSuccess(yoastPost);
+    // Second fetch: write the meta update
+    mockSuccess({});
+
+    const res = await call('wp_update_seo_meta', { id: 1, title: 'New SEO Title', description: 'New desc' });
+    const data = parseResult(res);
+
+    expect(data.success).toBe(true);
+    expect(data.plugin).toBe('yoast');
+    expect(data.fields_updated).toContain('title');
+    expect(data.fields_updated).toContain('description');
+  });
+
+  it('GOVERNANCE — blocked by WP_READ_ONLY', async () => {
+    const original = process.env.WP_READ_ONLY;
+    process.env.WP_READ_ONLY = 'true';
+    try {
+      const res = await call('wp_update_seo_meta', { id: 1, title: 'Blocked' });
+      expect(res.isError).toBe(true);
+      expect(res.content[0].text).toContain('READ-ONLY');
+      expect(res.content[0].text).toContain('wp_update_seo_meta');
+    } finally {
+      if (original === undefined) delete process.env.WP_READ_ONLY;
+      else process.env.WP_READ_ONLY = original;
+    }
+  });
+
+  it('ERROR 403 — returns error message', async () => {
+    mockError(403, '{"code":"rest_forbidden"}');
+
+    const res = await call('wp_update_seo_meta', { id: 1, title: 'Forbidden' });
+    expect(res.isError).toBe(true);
+    expect(res.content[0].text).toContain('403');
+  });
+
+  it('ERROR 404 — returns error message', async () => {
+    mockError(404, '{"code":"rest_post_invalid_id"}');
+
+    const res = await call('wp_update_seo_meta', { id: 99999, title: 'Missing' });
+    expect(res.isError).toBe(true);
+    expect(res.content[0].text).toContain('404');
+  });
+
+  it('AUDIT — logs update_seo action on success', async () => {
+    mockSuccess(yoastPost);
+    mockSuccess({});
+
+    await call('wp_update_seo_meta', { id: 1, title: 'Audit Test' });
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_update_seo_meta');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('update_seo');
+    expect(entry.target).toBe(1);
+  });
+});
+
+// =========================================================================
+// wp_audit_seo
+// =========================================================================
+
+describe('wp_audit_seo', () => {
+  const auditPosts = [
+    {
+      id: 1,
+      title: { rendered: 'Good Post' },
+      slug: 'good',
+      link: 'https://test.example.com/good',
+      meta: {
+        _yoast_wpseo_title: 'Good SEO Title Here Enough Length',
+        _yoast_wpseo_metadesc: 'This is a properly written meta description that has enough length to be considered good by SEO standards for search results.',
+        _yoast_wpseo_focuskw: 'good',
+      },
+    },
+    {
+      id: 2,
+      title: { rendered: 'Bad Post' },
+      slug: 'bad',
+      link: 'https://test.example.com/bad',
+      meta: {},
+    },
+  ];
+
+  it('SUCCESS — audits posts and calculates scores correctly', async () => {
+    mockSuccess(auditPosts);
+
+    const res = await call('wp_audit_seo', { post_type: 'post' });
+    const data = parseResult(res);
+
+    // Summary checks
+    expect(data.summary.total_audited).toBe(2);
+    expect(data.summary.seo_plugin).toBe('yoast');
+
+    // Good post: score 100 (title 30+ chars, desc 120+ chars, keyword present, keyword in title)
+    const goodPost = data.posts.find(p => p.id === 1);
+    expect(goodPost.score).toBe(100);
+    expect(goodPost.issues).toHaveLength(0);
+
+    // Bad post: missing_seo_title (-30), missing_meta_description (-30), missing_focus_keyword (-20) = 20
+    const badPost = data.posts.find(p => p.id === 2);
+    expect(badPost.score).toBe(20);
+    expect(badPost.issues).toContain('missing_seo_title');
+    expect(badPost.issues).toContain('missing_meta_description');
+    expect(badPost.issues).toContain('missing_focus_keyword');
+
+    // Average score = Math.round((100 + 20) / 2) = 60
+    expect(data.summary.average_score).toBe(60);
+
+    // Issues breakdown
+    expect(data.summary.issues_breakdown.missing_seo_title).toBe(1);
+    expect(data.summary.issues_breakdown.missing_meta_description).toBe(1);
+    expect(data.summary.issues_breakdown.missing_focus_keyword).toBe(1);
+    expect(data.summary.issues_breakdown.title_length_issues).toBe(0);
+    expect(data.summary.issues_breakdown.description_length_issues).toBe(0);
+    expect(data.summary.issues_breakdown.keyword_not_in_title).toBe(0);
+  });
+
+  it('ERROR 403 — returns error message', async () => {
+    mockError(403, '{"code":"rest_forbidden"}');
+
+    const res = await call('wp_audit_seo', { post_type: 'post' });
+    expect(res.isError).toBe(true);
+    expect(res.content[0].text).toContain('403');
+  });
+
+  it('AUDIT — logs audit_seo action on success', async () => {
+    mockSuccess(auditPosts);
+
+    await call('wp_audit_seo', { post_type: 'post' });
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_audit_seo');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.action).toBe('audit_seo');
+    expect(entry.params.avg_score).toBe(60);
+  });
+});

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

@@ -0,0 +1,133 @@
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+
+vi.mock('node-fetch', () => ({ default: vi.fn() }));
+
+import fetch from 'node-fetch';
+import { handleToolCall } from '../../../index.js';
+import { mockSuccess, mockError, getAuditLogs, makeRequest, parseResult } from '../../helpers/mockWpRequest.js';
+
+function call(name, args = {}) {
+  return handleToolCall(makeRequest(name, args));
+}
+
+let consoleSpy;
+beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+afterEach(() => { consoleSpy.mockRestore(); });
+
+// =========================================================================
+// Shared mock data
+// =========================================================================
+
+const siteInfoResponse = {
+  name: 'Test Site',
+  description: 'Just a test',
+  url: 'https://test.example.com',
+  gmt_offset: 1,
+  timezone_string: 'Europe/Brussels',
+};
+
+const userMeResponse = {
+  id: 1,
+  name: 'Admin',
+  slug: 'admin',
+  roles: ['administrator'],
+};
+
+const postTypesResponse = {
+  post: { slug: 'post', name: 'Posts', rest_base: 'posts' },
+  page: { slug: 'page', name: 'Pages', rest_base: 'pages' },
+};
+
+// =========================================================================
+// wp_site_info
+// =========================================================================
+
+describe('wp_site_info', () => {
+  it('SUCCESS — returns site, current_user, post_types, enterprise_controls, and server info', async () => {
+    // wp_site_info makes 3 sequential fetch calls:
+    // 1. GET /wp-json (direct fetch)
+    // 2. GET /wp-json/wp/v2/users/me (direct fetch)
+    // 3. GET /wp-json/wp/v2/types (via wpApiCall)
+    mockSuccess(siteInfoResponse);
+    mockSuccess(userMeResponse);
+    mockSuccess(postTypesResponse);
+
+    const res = await call('wp_site_info');
+    const data = parseResult(res);
+
+    // Site info
+    expect(data.site.name).toBe('Test Site');
+    expect(data.site.description).toBe('Just a test');
+
+    // Current user
+    expect(data.current_user.name).toBe('Admin');
+    expect(data.current_user.roles).toEqual(['administrator']);
+
+    // Post types
+    expect(data.post_types).toHaveLength(2);
+
+    // Enterprise controls
+    expect(data.enterprise_controls).toBeDefined();
+    expect(typeof data.enterprise_controls.read_only).toBe('boolean');
+    expect(typeof data.enterprise_controls.draft_only).toBe('boolean');
+    expect(typeof data.enterprise_controls.delete_disabled).toBe('boolean');
+    expect(typeof data.enterprise_controls.plugin_management_disabled).toBe('boolean');
+
+    // Server info
+    expect(data.server.mcp_version).toBeDefined();
+    expect(data.server.tools_count).toBe(35);
+  });
+
+  it('SUCCESS — enterprise_controls reflect WP_READ_ONLY env var', async () => {
+    const original = process.env.WP_READ_ONLY;
+    process.env.WP_READ_ONLY = 'true';
+
+    try {
+      mockSuccess(siteInfoResponse);
+      mockSuccess(userMeResponse);
+      mockSuccess(postTypesResponse);
+
+      const res = await call('wp_site_info');
+      const data = parseResult(res);
+
+      expect(data.enterprise_controls.read_only).toBe(true);
+    } finally {
+      if (original === undefined) delete process.env.WP_READ_ONLY;
+      else process.env.WP_READ_ONLY = original;
+    }
+  });
+
+  it('AUDIT — logs info action on success', async () => {
+    mockSuccess(siteInfoResponse);
+    mockSuccess(userMeResponse);
+    mockSuccess(postTypesResponse);
+
+    await call('wp_site_info');
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_site_info');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+  });
+});
+
+// =========================================================================
+// wp_set_target
+// =========================================================================
+
+describe('wp_set_target', () => {
+  it('ERROR — site not found when no targets configured', async () => {
+    const res = await call('wp_set_target', { site: 'staging' });
+    expect(res.isError).toBe(true);
+    expect(res.content[0].text).toContain('not found');
+  });
+
+  it('AUDIT — logs error on site not found', async () => {
+    await call('wp_set_target', { site: 'staging' });
+
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_set_target');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('error');
+  });
+});

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

@@ -0,0 +1,220 @@
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+
+vi.mock('node-fetch', () => ({ default: vi.fn() }));
+
+import fetch from 'node-fetch';
+import { handleToolCall } from '../../../index.js';
+import { mockSuccess, mockError, getAuditLogs, makeRequest, parseResult } from '../../helpers/mockWpRequest.js';
+
+function call(name, args = {}) {
+  return handleToolCall(makeRequest(name, args));
+}
+
+// ────────────────────────────────────────────────────────────
+// wp_list_categories
+// ────────────────────────────────────────────────────────────
+
+describe('wp_list_categories', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('returns formatted category list on success', async () => {
+    fetch.mockResolvedValue(mockSuccess([
+      { id: 1, name: 'Uncategorized', slug: 'uncategorized', description: '', parent: 0, count: 5 }
+    ]));
+
+    const result = await call('wp_list_categories');
+    const data = parseResult(result);
+
+    expect(data.total).toBe(1);
+    expect(data.categories).toHaveLength(1);
+    expect(data.categories[0].id).toBe(1);
+    expect(data.categories[0].name).toBe('Uncategorized');
+    expect(data.categories[0].slug).toBe('uncategorized');
+    expect(data.categories[0].description).toBe('');
+    expect(data.categories[0].parent).toBe(0);
+    expect(data.categories[0].count).toBe(5);
+  });
+
+  it('returns error on 403', async () => {
+    fetch.mockResolvedValue(mockError(403));
+
+    const result = await call('wp_list_categories');
+
+    expect(result.isError).toBe(true);
+  });
+
+  it('returns error on 404', async () => {
+    fetch.mockResolvedValue(mockError(404));
+
+    const result = await call('wp_list_categories');
+
+    expect(result.isError).toBe(true);
+  });
+
+  it('logs audit entry with status success', async () => {
+    fetch.mockResolvedValue(mockSuccess([
+      { id: 1, name: 'Uncategorized', slug: 'uncategorized', description: '', parent: 0, count: 5 }
+    ]));
+
+    await call('wp_list_categories');
+    const logs = getAuditLogs(consoleSpy);
+    const entry = logs.find(l => l.tool === 'wp_list_categories');
+
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+  });
+});
+
+// ────────────────────────────────────────────────────────────
+// wp_list_tags
+// ────────────────────────────────────────────────────────────
+
+describe('wp_list_tags', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('returns formatted tag list on success', async () => {
+    fetch.mockResolvedValue(mockSuccess([
+      { id: 10, name: 'javascript', slug: 'javascript', count: 3 }
+    ]));
+
+    const result = await call('wp_list_tags');
+    const data = parseResult(result);
+
+    expect(data.total).toBe(1);
+    expect(data.tags).toHaveLength(1);
+    expect(data.tags[0].id).toBe(10);
+    expect(data.tags[0].name).toBe('javascript');
+    expect(data.tags[0].slug).toBe('javascript');
+    expect(data.tags[0].count).toBe(3);
+  });
+
+  it('returns error on 403', async () => {
+    fetch.mockResolvedValue(mockError(403));
+
+    const result = await call('wp_list_tags');
+
+    expect(result.isError).toBe(true);
+  });
+
+  it('returns error on 404', async () => {
+    fetch.mockResolvedValue(mockError(404));
+
+    const result = await call('wp_list_tags');
+
+    expect(result.isError).toBe(true);
+  });
+
+  it('logs audit entry with status success', async () => {
+    fetch.mockResolvedValue(mockSuccess([
+      { id: 10, name: 'javascript', slug: 'javascript', count: 3 }
+    ]));
+
+    await call('wp_list_tags');
+    const logs = getAuditLogs(consoleSpy);
+    const entry = logs.find(l => l.tool === 'wp_list_tags');
+
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+  });
+});
+
+// ────────────────────────────────────────────────────────────
+// wp_create_taxonomy_term
+// ────────────────────────────────────────────────────────────
+
+describe('wp_create_taxonomy_term', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('creates a category on success', async () => {
+    fetch.mockResolvedValue(mockSuccess({ id: 2, name: 'Tech', slug: 'tech' }));
+
+    const result = await call('wp_create_taxonomy_term', { taxonomy: 'category', name: 'Tech' });
+    const data = parseResult(result);
+
+    expect(data.success).toBe(true);
+    expect(data.message).toContain('category');
+    expect(data.message).toContain('Tech');
+    expect(data.term.id).toBe(2);
+    expect(data.term.name).toBe('Tech');
+    expect(data.term.slug).toBe('tech');
+  });
+
+  it('creates a tag on success', async () => {
+    fetch.mockResolvedValue(mockSuccess({ id: 11, name: 'react', slug: 'react' }));
+
+    const result = await call('wp_create_taxonomy_term', { taxonomy: 'tag', name: 'react' });
+    const data = parseResult(result);
+
+    expect(data.success).toBe(true);
+    expect(data.message).toContain('tag');
+    expect(data.message).toContain('react');
+    expect(data.term.id).toBe(11);
+    expect(data.term.name).toBe('react');
+    expect(data.term.slug).toBe('react');
+  });
+
+  it('is blocked in READ-ONLY mode (governance)', async () => {
+    process.env.WP_READ_ONLY = 'true';
+
+    const result = await call('wp_create_taxonomy_term', { taxonomy: 'category', name: 'Blocked' });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('READ-ONLY');
+
+    delete process.env.WP_READ_ONLY;
+  });
+
+  it('rejects invalid taxonomy value', async () => {
+    const result = await call('wp_create_taxonomy_term', { taxonomy: 'invalid', name: 'Test' });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('taxonomy');
+  });
+
+  it('returns error on 403', async () => {
+    fetch.mockResolvedValue(mockError(403));
+
+    const result = await call('wp_create_taxonomy_term', { taxonomy: 'category', name: 'Forbidden' });
+
+    expect(result.isError).toBe(true);
+  });
+
+  it('returns error on 404', async () => {
+    fetch.mockResolvedValue(mockError(404));
+
+    const result = await call('wp_create_taxonomy_term', { taxonomy: 'tag', name: 'Missing' });
+
+    expect(result.isError).toBe(true);
+  });
+
+  it('logs audit entry with status success on create', async () => {
+    fetch.mockResolvedValue(mockSuccess({ id: 2, name: 'Tech', slug: 'tech' }));
+
+    await call('wp_create_taxonomy_term', { taxonomy: 'category', name: 'Tech' });
+    const logs = getAuditLogs(consoleSpy);
+    const entry = logs.find(l => l.tool === 'wp_create_taxonomy_term');
+
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+    expect(entry.target).toBe(2);
+  });
+
+  it('logs audit entry with status blocked in READ-ONLY mode', async () => {
+    process.env.WP_READ_ONLY = 'true';
+
+    await call('wp_create_taxonomy_term', { taxonomy: 'category', name: 'Blocked' });
+    const logs = getAuditLogs(consoleSpy);
+    const entry = logs.find(l => l.tool === 'wp_create_taxonomy_term');
+
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('blocked');
+
+    delete process.env.WP_READ_ONLY;
+  });
+});