@adsim/wordpress-mcp-server 4.6.0 → 5.3.1

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

@@ -0,0 +1,548 @@
+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));
+}
+
+// ════════════════════════════════════════════════════════════
+// FSE: TEMPLATES
+// ════════════════════════════════════════════════════════════
+
+describe('wp_list_templates', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('returns formatted template list on success', async () => {
+    fetch.mockResolvedValue(mockSuccess([
+      { id: 'theme//index', slug: 'index', title: { rendered: 'Index' }, description: 'Main template', status: 'publish', type: 'wp_template', theme: 'twentytwentyfour', has_theme_file: true }
+    ]));
+    const result = await call('wp_list_templates');
+    const data = parseResult(result);
+    expect(data.total).toBe(1);
+    expect(data.templates[0].id).toBe('theme//index');
+    expect(data.templates[0].slug).toBe('index');
+    expect(data.templates[0].has_theme_file).toBe(true);
+  });
+
+  it('logs audit entry', async () => {
+    fetch.mockResolvedValue(mockSuccess([]));
+    await call('wp_list_templates');
+    const logs = getAuditLogs();
+    const entry = logs.find(l => l.tool === 'wp_list_templates');
+    expect(entry).toBeDefined();
+    expect(entry.status).toBe('success');
+  });
+});
+
+describe('wp_get_template', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('returns full template data', async () => {
+    fetch.mockResolvedValue(mockSuccess({
+      id: 'theme//single', slug: 'single', title: { rendered: 'Single' }, content: { raw: '<!-- wp:post-content /-->' },
+      description: 'Single post', status: 'publish', type: 'wp_template', theme: 'twentytwentyfour', has_theme_file: true, modified: '2024-01-01'
+    }));
+    const result = await call('wp_get_template', { id: 'theme//single' });
+    const data = parseResult(result);
+    expect(data.id).toBe('theme//single');
+    expect(data.content).toBe('<!-- wp:post-content /-->');
+    expect(data.title).toBe('Single');
+  });
+
+  it('returns error on 404', async () => {
+    fetch.mockResolvedValue(mockError(404));
+    const result = await call('wp_get_template', { id: 'nonexistent//template' });
+    expect(result.isError).toBe(true);
+  });
+});
+
+describe('wp_create_template', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('creates a template', async () => {
+    fetch.mockResolvedValue(mockSuccess({
+      id: 'theme//custom', slug: 'custom', title: { rendered: 'Custom' }, status: 'publish'
+    }));
+    const result = await call('wp_create_template', { slug: 'custom', title: 'Custom', content: '<!-- wp:paragraph --><p>Hello</p><!-- /wp:paragraph -->' });
+    const data = parseResult(result);
+    expect(data.success).toBe(true);
+    expect(data.template.slug).toBe('custom');
+  });
+
+  it('is blocked by WP_READ_ONLY', async () => {
+    process.env.WP_READ_ONLY = 'true';
+    try {
+      const result = await call('wp_create_template', { slug: 'test' });
+      expect(result.isError).toBe(true);
+      expect(result.content[0].text).toContain('READ-ONLY');
+    } finally {
+      delete process.env.WP_READ_ONLY;
+    }
+  });
+});
+
+describe('wp_update_template', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('updates a template', async () => {
+    fetch.mockResolvedValue(mockSuccess({
+      id: 'theme//index', slug: 'index', title: { rendered: 'Updated Index' }, status: 'publish'
+    }));
+    const result = await call('wp_update_template', { id: 'theme//index', title: 'Updated Index' });
+    const data = parseResult(result);
+    expect(data.success).toBe(true);
+    expect(data.template.title).toBe('Updated Index');
+  });
+});
+
+describe('wp_delete_template', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('deletes a template', async () => {
+    fetch.mockResolvedValue(mockSuccess({ deleted: true }));
+    const result = await call('wp_delete_template', { id: 'theme//custom' });
+    const data = parseResult(result);
+    expect(data.success).toBe(true);
+  });
+
+  it('is blocked by WP_DISABLE_DELETE', async () => {
+    process.env.WP_DISABLE_DELETE = 'true';
+    try {
+      const result = await call('wp_delete_template', { id: 'theme//custom' });
+      expect(result.isError).toBe(true);
+      expect(result.content[0].text).toContain('DISABLE_DELETE');
+    } finally {
+      delete process.env.WP_DISABLE_DELETE;
+    }
+  });
+});
+
+// ════════════════════════════════════════════════════════════
+// FSE: TEMPLATE PARTS
+// ════════════════════════════════════════════════════════════
+
+describe('wp_list_template_parts', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('returns template parts with area', async () => {
+    fetch.mockResolvedValue(mockSuccess([
+      { id: 'theme//header', slug: 'header', title: { rendered: 'Header' }, area: 'header', description: 'Site header', status: 'publish', theme: 'twentytwentyfour', has_theme_file: true }
+    ]));
+    const result = await call('wp_list_template_parts', { area: 'header' });
+    const data = parseResult(result);
+    expect(data.total).toBe(1);
+    expect(data.template_parts[0].area).toBe('header');
+  });
+});
+
+describe('wp_get_template_part', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('returns full template part data', async () => {
+    fetch.mockResolvedValue(mockSuccess({
+      id: 'theme//footer', slug: 'footer', title: { rendered: 'Footer' }, content: { raw: '<!-- wp:paragraph --><p>Footer</p><!-- /wp:paragraph -->' },
+      area: 'footer', description: 'Site footer', status: 'publish', theme: 'twentytwentyfour', has_theme_file: true, modified: '2024-01-01'
+    }));
+    const result = await call('wp_get_template_part', { id: 'theme//footer' });
+    const data = parseResult(result);
+    expect(data.id).toBe('theme//footer');
+    expect(data.area).toBe('footer');
+  });
+});
+
+describe('wp_create_template_part', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('creates a template part', async () => {
+    fetch.mockResolvedValue(mockSuccess({
+      id: 'theme//sidebar', slug: 'sidebar', title: { rendered: 'Sidebar' }, area: 'general', status: 'publish'
+    }));
+    const result = await call('wp_create_template_part', { slug: 'sidebar', title: 'Sidebar', area: 'general' });
+    const data = parseResult(result);
+    expect(data.success).toBe(true);
+    expect(data.template_part.area).toBe('general');
+  });
+});
+
+describe('wp_update_template_part', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('updates a template part', async () => {
+    fetch.mockResolvedValue(mockSuccess({
+      id: 'theme//header', slug: 'header', title: { rendered: 'Updated Header' }, area: 'header', status: 'publish'
+    }));
+    const result = await call('wp_update_template_part', { id: 'theme//header', title: 'Updated Header' });
+    const data = parseResult(result);
+    expect(data.success).toBe(true);
+  });
+});
+
+describe('wp_delete_template_part', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('deletes a template part', async () => {
+    fetch.mockResolvedValue(mockSuccess({ deleted: true }));
+    const result = await call('wp_delete_template_part', { id: 'theme//custom-header' });
+    const data = parseResult(result);
+    expect(data.success).toBe(true);
+  });
+});
+
+// ════════════════════════════════════════════════════════════
+// FSE: GLOBAL STYLES
+// ════════════════════════════════════════════════════════════
+
+describe('wp_get_global_styles', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('returns global styles data', async () => {
+    fetch.mockResolvedValue(mockSuccess({
+      id: 42, title: { rendered: 'Custom Styles' },
+      styles: { color: { background: '#ffffff' }, typography: { fontSize: '16px' } },
+      settings: { color: { palette: [{ name: 'White', slug: 'white', color: '#ffffff' }] } },
+      modified: '2024-01-01'
+    }));
+    const result = await call('wp_get_global_styles', { id: 42 });
+    const data = parseResult(result);
+    expect(data.id).toBe(42);
+    expect(data.styles.color.background).toBe('#ffffff');
+    expect(data.settings.color.palette).toHaveLength(1);
+  });
+});
+
+describe('wp_update_global_styles', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('updates global styles', async () => {
+    fetch.mockResolvedValue(mockSuccess({
+      id: 42, title: { rendered: 'Custom Styles' },
+      styles: { color: { background: '#000000' } },
+      settings: {}
+    }));
+    const result = await call('wp_update_global_styles', { id: 42, styles: { color: { background: '#000000' } } });
+    const data = parseResult(result);
+    expect(data.success).toBe(true);
+    expect(data.global_styles.styles.color.background).toBe('#000000');
+  });
+
+  it('is blocked by WP_READ_ONLY', async () => {
+    process.env.WP_READ_ONLY = 'true';
+    try {
+      const result = await call('wp_update_global_styles', { id: 42, styles: {} });
+      expect(result.isError).toBe(true);
+      expect(result.content[0].text).toContain('READ-ONLY');
+    } finally {
+      delete process.env.WP_READ_ONLY;
+    }
+  });
+});
+
+describe('wp_get_global_styles_variations', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('returns style variations for a theme', async () => {
+    fetch.mockResolvedValue(mockSuccess([
+      { title: 'Dark', settings: { color: { palette: [] } }, styles: { color: { background: '#1a1a1a' } } },
+      { title: 'Light', settings: {}, styles: { color: { background: '#ffffff' } } }
+    ]));
+    const result = await call('wp_get_global_styles_variations', { stylesheet: 'twentytwentyfour' });
+    const data = parseResult(result);
+    expect(data.stylesheet).toBe('twentytwentyfour');
+    expect(data.total).toBe(2);
+    expect(data.variations).toHaveLength(2);
+  });
+});
+
+// ════════════════════════════════════════════════════════════
+// FSE: BLOCK PATTERNS
+// ════════════════════════════════════════════════════════════
+
+describe('wp_list_block_patterns', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('returns block patterns list', async () => {
+    fetch.mockResolvedValue(mockSuccess([
+      { name: 'core/query-standard-posts', title: 'Standard Posts', description: 'A list of posts', categories: ['query'], keywords: ['posts'], blockTypes: ['core/query'], content: '<!-- wp:query --><!-- /wp:query -->' }
+    ]));
+    const result = await call('wp_list_block_patterns');
+    const data = parseResult(result);
+    expect(data.total).toBe(1);
+    expect(data.patterns[0].name).toBe('core/query-standard-posts');
+  });
+});
+
+describe('wp_get_block_pattern', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('returns a single pattern by name', async () => {
+    fetch.mockResolvedValue(mockSuccess([
+      { name: 'core/query-standard-posts', title: 'Standard Posts', description: 'A list', content: '<!-- wp:query -->', categories: ['query'], keywords: ['posts'], blockTypes: ['core/query'] },
+      { name: 'core/social-links', title: 'Social Links', description: 'Social', content: '<!-- wp:social-links -->', categories: ['social'], keywords: [], blockTypes: [] }
+    ]));
+    const result = await call('wp_get_block_pattern', { name: 'core/social-links' });
+    const data = parseResult(result);
+    expect(data.name).toBe('core/social-links');
+    expect(data.title).toBe('Social Links');
+  });
+
+  it('returns error when pattern not found', async () => {
+    fetch.mockResolvedValue(mockSuccess([]));
+    const result = await call('wp_get_block_pattern', { name: 'nonexistent/pattern' });
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('not found');
+  });
+});
+
+describe('wp_create_block_pattern', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('creates a block pattern', async () => {
+    fetch.mockResolvedValue(mockSuccess({
+      id: 99, name: 'custom/hero', title: { rendered: 'Hero Section' }
+    }));
+    const result = await call('wp_create_block_pattern', { title: 'Hero Section', content: '<!-- wp:cover -->', name: 'custom/hero' });
+    const data = parseResult(result);
+    expect(data.success).toBe(true);
+    expect(data.pattern.name).toBe('custom/hero');
+  });
+});
+
+describe('wp_delete_block_pattern', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('deletes a block pattern', async () => {
+    fetch.mockResolvedValue(mockSuccess({ deleted: true }));
+    const result = await call('wp_delete_block_pattern', { id: 99 });
+    const data = parseResult(result);
+    expect(data.success).toBe(true);
+  });
+});
+
+// ════════════════════════════════════════════════════════════
+// FSE: NAVIGATION MENUS
+// ════════════════════════════════════════════════════════════
+
+describe('wp_list_navigation_menus', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('returns navigation menus', async () => {
+    fetch.mockResolvedValue(mockSuccess([
+      { id: 1, title: { rendered: 'Main Menu' }, status: 'publish', date: '2024-01-01', modified: '2024-01-01', slug: 'main-menu' },
+      { id: 2, title: { rendered: 'Footer Menu' }, status: 'publish', date: '2024-01-01', modified: '2024-01-01', slug: 'footer-menu' }
+    ]));
+    const result = await call('wp_list_navigation_menus');
+    const data = parseResult(result);
+    expect(data.total).toBe(2);
+    expect(data.navigation_menus[0].title).toBe('Main Menu');
+    expect(data.navigation_menus[1].title).toBe('Footer Menu');
+  });
+
+  it('supports search parameter', async () => {
+    fetch.mockResolvedValue(mockSuccess([
+      { id: 1, title: { rendered: 'Main Menu' }, status: 'publish', date: '2024-01-01', modified: '2024-01-01', slug: 'main-menu' }
+    ]));
+    await call('wp_list_navigation_menus', { search: 'Main' });
+    const [url] = fetch.mock.calls[0];
+    expect(url).toContain('search=Main');
+  });
+});
+
+describe('wp_get_navigation_menu', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('returns full navigation menu data', async () => {
+    fetch.mockResolvedValue(mockSuccess({
+      id: 1, title: { rendered: 'Main Menu' }, content: { rendered: '<!-- wp:navigation-link /-->' },
+      status: 'publish', date: '2024-01-01', modified: '2024-01-01', slug: 'main-menu'
+    }));
+    const result = await call('wp_get_navigation_menu', { id: 1 });
+    const data = parseResult(result);
+    expect(data.id).toBe(1);
+    expect(data.content).toBe('<!-- wp:navigation-link /-->');
+  });
+});
+
+describe('wp_create_navigation_menu', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('creates a navigation menu', async () => {
+    fetch.mockResolvedValue(mockSuccess({
+      id: 3, title: { rendered: 'New Menu' }, status: 'publish'
+    }));
+    const result = await call('wp_create_navigation_menu', { title: 'New Menu', content: '<!-- wp:navigation-link {"label":"Home","url":"/"} /-->' });
+    const data = parseResult(result);
+    expect(data.success).toBe(true);
+    expect(data.navigation.title).toBe('New Menu');
+  });
+});
+
+describe('wp_update_navigation_menu', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('updates a navigation menu', async () => {
+    fetch.mockResolvedValue(mockSuccess({
+      id: 1, title: { rendered: 'Updated Menu' }, status: 'publish'
+    }));
+    const result = await call('wp_update_navigation_menu', { id: 1, title: 'Updated Menu' });
+    const data = parseResult(result);
+    expect(data.success).toBe(true);
+  });
+});
+
+describe('wp_delete_navigation_menu', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('deletes a navigation menu', async () => {
+    fetch.mockResolvedValue(mockSuccess({ deleted: true }));
+    const result = await call('wp_delete_navigation_menu', { id: 1 });
+    const data = parseResult(result);
+    expect(data.success).toBe(true);
+  });
+});
+
+// ════════════════════════════════════════════════════════════
+// FSE: WIDGETS
+// ════════════════════════════════════════════════════════════
+
+describe('wp_list_widgets', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('returns widgets list', async () => {
+    fetch.mockResolvedValue(mockSuccess([
+      { id: 'text-2', id_base: 'text', sidebar: 'sidebar-1', rendered: '<div class="textwidget">Hello</div>' }
+    ]));
+    const result = await call('wp_list_widgets');
+    const data = parseResult(result);
+    expect(data.total).toBe(1);
+    expect(data.widgets[0].id).toBe('text-2');
+    expect(data.widgets[0].sidebar).toBe('sidebar-1');
+  });
+
+  it('filters by sidebar', async () => {
+    fetch.mockResolvedValue(mockSuccess([]));
+    await call('wp_list_widgets', { sidebar: 'sidebar-1' });
+    const [url] = fetch.mock.calls[0];
+    expect(url).toContain('sidebar=sidebar-1');
+  });
+});
+
+describe('wp_get_widget', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('returns full widget data', async () => {
+    fetch.mockResolvedValue(mockSuccess({
+      id: 'text-2', id_base: 'text', sidebar: 'sidebar-1',
+      instance: { raw: { title: 'Hello', text: 'World' } },
+      rendered: '<div class="textwidget"><p>World</p></div>'
+    }));
+    const result = await call('wp_get_widget', { id: 'text-2' });
+    const data = parseResult(result);
+    expect(data.id).toBe('text-2');
+    expect(data.instance.raw.title).toBe('Hello');
+    expect(data.rendered).toContain('textwidget');
+  });
+});
+
+describe('wp_update_widget', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('updates a widget', async () => {
+    fetch.mockResolvedValue(mockSuccess({
+      id: 'text-2', id_base: 'text', sidebar: 'sidebar-2'
+    }));
+    const result = await call('wp_update_widget', { id: 'text-2', sidebar: 'sidebar-2' });
+    const data = parseResult(result);
+    expect(data.success).toBe(true);
+    expect(data.widget.sidebar).toBe('sidebar-2');
+  });
+
+  it('is blocked by WP_READ_ONLY', async () => {
+    process.env.WP_READ_ONLY = 'true';
+    try {
+      const result = await call('wp_update_widget', { id: 'text-2' });
+      expect(result.isError).toBe(true);
+      expect(result.content[0].text).toContain('READ-ONLY');
+    } finally {
+      delete process.env.WP_READ_ONLY;
+    }
+  });
+});
+
+describe('wp_delete_widget', () => {
+  let consoleSpy;
+  beforeEach(() => { fetch.mockReset(); consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); });
+  afterEach(() => { consoleSpy.mockRestore(); });
+
+  it('deletes a widget', async () => {
+    fetch.mockResolvedValue(mockSuccess({ deleted: true }));
+    const result = await call('wp_delete_widget', { id: 'text-2' });
+    const data = parseResult(result);
+    expect(data.success).toBe(true);
+  });
+
+  it('is blocked by WP_DISABLE_DELETE', async () => {
+    process.env.WP_DISABLE_DELETE = 'true';
+    try {
+      const result = await call('wp_delete_widget', { id: 'text-2' });
+      expect(result.isError).toBe(true);
+      expect(result.content[0].text).toContain('DISABLE_DELETE');
+    } finally {
+      delete process.env.WP_DISABLE_DELETE;
+    }
+  });
+});