@jgardner04/ghost-mcp-server 1.1.8 → 1.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jgardner04/ghost-mcp-server",
-  "version": "1.1.8",
+  "version": "1.1.10",
   "description": "A Model Context Protocol (MCP) server for interacting with Ghost CMS via the Admin API",
   "author": "Jonathan Gardner",
   "type": "module",

package/src/services/__tests__/ghostService.test.js

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi } from 'vitest';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { mockGhostApiModule } from '../../__tests__/helpers/mockGhostApi.js';
 import { createMockContextLogger } from '../../__tests__/helpers/mockLogger.js';
 import { mockDotenv } from '../../__tests__/helpers/testUtils.js';
@@ -15,9 +15,218 @@ vi.mock('../../utils/logger.js', () => ({
 }));
 
 // Import after setting up mocks and environment
-import { createPost, createTag, getTags } from '../ghostService.js';
+import {
+  createPost,
+  createTag,
+  getTags,
+  getSiteInfo,
+  uploadImage,
+  handleApiRequest,
+  api,
+} from '../ghostService.js';
 
 describe('ghostService', () => {
+  beforeEach(() => {
+    // Reset all mocks before each test
+    vi.clearAllMocks();
+  });
+
+  describe('handleApiRequest', () => {
+    describe('success paths', () => {
+      it('should handle add action for posts successfully', async () => {
+        const expectedPost = { id: '1', title: 'Test Post', status: 'draft' };
+        api.posts.add.mockResolvedValue(expectedPost);
+
+        const result = await handleApiRequest('posts', 'add', { title: 'Test Post' });
+
+        expect(result).toEqual(expectedPost);
+        expect(api.posts.add).toHaveBeenCalledWith({ title: 'Test Post' });
+      });
+
+      it('should handle add action for tags successfully', async () => {
+        const expectedTag = { id: '1', name: 'Test Tag', slug: 'test-tag' };
+        api.tags.add.mockResolvedValue(expectedTag);
+
+        const result = await handleApiRequest('tags', 'add', { name: 'Test Tag' });
+
+        expect(result).toEqual(expectedTag);
+        expect(api.tags.add).toHaveBeenCalledWith({ name: 'Test Tag' });
+      });
+
+      it('should handle upload action for images successfully', async () => {
+        const expectedImage = { url: 'https://example.com/image.jpg' };
+        api.images.upload.mockResolvedValue(expectedImage);
+
+        const result = await handleApiRequest('images', 'upload', { file: '/path/to/image.jpg' });
+
+        expect(result).toEqual(expectedImage);
+        expect(api.images.upload).toHaveBeenCalledWith({ file: '/path/to/image.jpg' });
+      });
+
+      it('should handle browse action with options successfully', async () => {
+        const expectedTags = [
+          { id: '1', name: 'Tag1' },
+          { id: '2', name: 'Tag2' },
+        ];
+        api.tags.browse.mockResolvedValue(expectedTags);
+
+        const result = await handleApiRequest('tags', 'browse', {}, { limit: 'all' });
+
+        expect(result).toEqual(expectedTags);
+        expect(api.tags.browse).toHaveBeenCalledWith({ limit: 'all' }, {});
+      });
+
+      it('should handle add action with options successfully', async () => {
+        const postData = { title: 'Test Post', html: '<p>Content</p>' };
+        const options = { source: 'html' };
+        const expectedPost = { id: '1', ...postData };
+        api.posts.add.mockResolvedValue(expectedPost);
+
+        const result = await handleApiRequest('posts', 'add', postData, options);
+
+        expect(result).toEqual(expectedPost);
+        expect(api.posts.add).toHaveBeenCalledWith(postData, options);
+      });
+    });
+
+    describe('error handling', () => {
+      it('should throw error for invalid resource', async () => {
+        await expect(handleApiRequest('invalid', 'add', {})).rejects.toThrow(
+          'Invalid Ghost API resource or action: invalid.add'
+        );
+      });
+
+      it('should throw error for invalid action', async () => {
+        await expect(handleApiRequest('posts', 'invalid', {})).rejects.toThrow(
+          'Invalid Ghost API resource or action: posts.invalid'
+        );
+      });
+
+      it('should handle 404 error and throw', async () => {
+        const error404 = new Error('Not found');
+        error404.response = { status: 404 };
+        api.posts.read.mockRejectedValue(error404);
+
+        await expect(handleApiRequest('posts', 'read', { id: 'nonexistent' })).rejects.toThrow(
+          'Not found'
+        );
+      });
+    });
+
+    describe('retry logic', () => {
+      it('should retry on 429 rate limit error with delay', async () => {
+        const rateLimitError = new Error('Rate limit exceeded');
+        rateLimitError.response = { status: 429 };
+        const successResult = { id: '1', name: 'Success' };
+
+        api.tags.add.mockRejectedValueOnce(rateLimitError).mockResolvedValueOnce(successResult);
+
+        const startTime = Date.now();
+        const result = await handleApiRequest('tags', 'add', { name: 'Test' });
+        const elapsedTime = Date.now() - startTime;
+
+        expect(result).toEqual(successResult);
+        expect(api.tags.add).toHaveBeenCalledTimes(2);
+        // Should have delayed at least 5000ms for rate limit
+        expect(elapsedTime).toBeGreaterThanOrEqual(4900); // Allow small margin
+      }, 10000); // 10 second timeout
+
+      it('should retry on 500 server error with increasing delay', async () => {
+        const serverError = new Error('Internal server error');
+        serverError.response = { status: 500 };
+        const successResult = { id: '1', title: 'Success' };
+
+        api.posts.add.mockRejectedValueOnce(serverError).mockResolvedValueOnce(successResult);
+
+        const result = await handleApiRequest('posts', 'add', { title: 'Test' });
+
+        expect(result).toEqual(successResult);
+        expect(api.posts.add).toHaveBeenCalledTimes(2);
+      });
+
+      it('should retry on ECONNREFUSED network error', async () => {
+        const networkError = new Error('Connection refused');
+        networkError.code = 'ECONNREFUSED';
+        const successResult = { id: '1', title: 'Success' };
+
+        api.posts.add.mockRejectedValueOnce(networkError).mockResolvedValueOnce(successResult);
+
+        const result = await handleApiRequest('posts', 'add', { title: 'Test' });
+
+        expect(result).toEqual(successResult);
+        expect(api.posts.add).toHaveBeenCalledTimes(2);
+      });
+
+      it('should retry on ETIMEDOUT network error', async () => {
+        const timeoutError = new Error('Connection timeout');
+        timeoutError.code = 'ETIMEDOUT';
+        const successResult = { id: '1', title: 'Success' };
+
+        api.posts.add.mockRejectedValueOnce(timeoutError).mockResolvedValueOnce(successResult);
+
+        const result = await handleApiRequest('posts', 'add', { title: 'Test' });
+
+        expect(result).toEqual(successResult);
+        expect(api.posts.add).toHaveBeenCalledTimes(2);
+      });
+
+      it('should throw error after exhausting retries', async () => {
+        const serverError = new Error('Server error');
+        serverError.response = { status: 500 };
+
+        api.posts.add.mockRejectedValue(serverError);
+
+        // Should retry 3 times (4 attempts total)
+        await expect(handleApiRequest('posts', 'add', { title: 'Test' })).rejects.toThrow(
+          'Server error'
+        );
+        expect(api.posts.add).toHaveBeenCalledTimes(4); // Initial + 3 retries
+      }, 10000); // 10 second timeout
+
+      it('should not retry on non-retryable errors', async () => {
+        const badRequestError = new Error('Bad request');
+        badRequestError.response = { status: 400 };
+
+        api.posts.add.mockRejectedValue(badRequestError);
+
+        await expect(handleApiRequest('posts', 'add', { title: 'Test' })).rejects.toThrow(
+          'Bad request'
+        );
+        expect(api.posts.add).toHaveBeenCalledTimes(1); // No retries
+      });
+    });
+  });
+
+  describe('getSiteInfo', () => {
+    it('should successfully retrieve site information', async () => {
+      const expectedSite = { title: 'Test Site', url: 'https://example.com' };
+      api.site.read.mockResolvedValue(expectedSite);
+
+      const result = await getSiteInfo();
+
+      expect(result).toEqual(expectedSite);
+      expect(api.site.read).toHaveBeenCalled();
+    });
+  });
+
+  describe('uploadImage', () => {
+    it('should throw error when image path is missing', async () => {
+      await expect(uploadImage()).rejects.toThrow('Image path is required for upload');
+      await expect(uploadImage('')).rejects.toThrow('Image path is required for upload');
+    });
+
+    it('should successfully upload image with valid path', async () => {
+      const imagePath = '/path/to/image.jpg';
+      const expectedResult = { url: 'https://example.com/uploaded-image.jpg' };
+      api.images.upload.mockResolvedValue(expectedResult);
+
+      const result = await uploadImage(imagePath);
+
+      expect(result).toEqual(expectedResult);
+      expect(api.images.upload).toHaveBeenCalledWith({ file: imagePath });
+    });
+  });
+
   describe('createPost', () => {
     it('should throw error when title is missing', async () => {
       await expect(createPost({})).rejects.toThrow('Post title is required');
@@ -25,15 +234,27 @@ describe('ghostService', () => {
 
     it('should set default status to draft when not provided', async () => {
       const postData = { title: 'Test Post', html: '<p>Content</p>' };
+      const expectedPost = { id: '1', title: 'Test Post', html: '<p>Content</p>', status: 'draft' };
+      api.posts.add.mockResolvedValue(expectedPost);
 
-      // The function should call the API with default status
-      try {
-        await createPost(postData);
-      } catch (_error) {
-        // Expected to fail since we're using a mock, but we can verify the behavior
-      }
+      const result = await createPost(postData);
+
+      expect(result).toEqual(expectedPost);
+      expect(api.posts.add).toHaveBeenCalledWith(
+        { status: 'draft', title: 'Test Post', html: '<p>Content</p>' },
+        { source: 'html' }
+      );
+    });
 
-      expect(postData.title).toBe('Test Post');
+    it('should successfully create post with valid data', async () => {
+      const postData = { title: 'Test Post', html: '<p>Content</p>', status: 'published' };
+      const expectedPost = { id: '1', ...postData };
+      api.posts.add.mockResolvedValue(expectedPost);
+
+      const result = await createPost(postData);
+
+      expect(result).toEqual(expectedPost);
+      expect(api.posts.add).toHaveBeenCalled();
     });
   });
 
@@ -42,16 +263,15 @@ describe('ghostService', () => {
       await expect(createTag({})).rejects.toThrow('Tag name is required');
     });
 
-    it('should accept valid tag data', async () => {
+    it('should successfully create tag with valid data', async () => {
       const tagData = { name: 'Test Tag', slug: 'test-tag' };
+      const expectedTag = { id: '1', ...tagData };
+      api.tags.add.mockResolvedValue(expectedTag);
 
-      try {
-        await createTag(tagData);
-      } catch (_error) {
-        // Expected to fail with mock, but validates input handling
-      }
+      const result = await createTag(tagData);
 
-      expect(tagData.name).toBe('Test Tag');
+      expect(result).toEqual(expectedTag);
+      expect(api.tags.add).toHaveBeenCalledWith(tagData);
     });
   });
 
@@ -64,26 +284,36 @@ describe('ghostService', () => {
 
     it('should accept valid tag names', async () => {
       const validNames = ['Test Tag', 'test-tag', 'test_tag', 'Tag123'];
+      const expectedTags = [{ id: '1', name: 'Tag' }];
+      api.tags.browse.mockResolvedValue(expectedTags);
 
       for (const name of validNames) {
-        try {
-          await getTags(name);
-        } catch (_error) {
-          // Expected to fail with mock, but should not throw validation error
-          expect(_error.message).not.toContain('invalid characters');
-        }
+        const result = await getTags(name);
+        expect(result).toEqual(expectedTags);
       }
     });
 
-    it('should handle tag names without filter when name is not provided', async () => {
-      try {
-        await getTags();
-      } catch (_error) {
-        // Expected to fail with mock
-      }
+    it('should handle tags without filter when name is not provided', async () => {
+      const expectedTags = [
+        { id: '1', name: 'Tag1' },
+        { id: '2', name: 'Tag2' },
+      ];
+      api.tags.browse.mockResolvedValue(expectedTags);
+
+      const result = await getTags();
+
+      expect(result).toEqual(expectedTags);
+      expect(api.tags.browse).toHaveBeenCalledWith({ limit: 'all' }, {});
+    });
+
+    it('should properly escape tag names in filter', async () => {
+      const expectedTags = [{ id: '1', name: "Tag's Name" }];
+      api.tags.browse.mockResolvedValue(expectedTags);
+
+      // This should work because we properly escape single quotes
+      const result = await getTags('Valid Tag');
 
-      // Should not throw validation error
-      expect(true).toBe(true);
+      expect(result).toEqual(expectedTags);
     });
   });
 });

package/src/services/__tests__/postService.test.js

@@ -0,0 +1,504 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { mockDotenv } from '../../__tests__/helpers/testUtils.js';
+import { createMockContextLogger } from '../../__tests__/helpers/mockLogger.js';
+
+// Mock dotenv
+vi.mock('dotenv', () => mockDotenv());
+
+// Mock logger
+vi.mock('../../utils/logger.js', () => ({
+  createContextLogger: createMockContextLogger(),
+}));
+
+// Mock ghostService functions - must use factory pattern to avoid hoisting issues
+vi.mock('../ghostService.js', () => ({
+  createPost: vi.fn(),
+  getTags: vi.fn(),
+  createTag: vi.fn(),
+}));
+
+// Import after mocks are set up
+import { createPostService } from '../postService.js';
+import { createPost, getTags, createTag } from '../ghostService.js';
+
+describe('postService', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('createPostService - validation', () => {
+    it('should accept valid input and create a post', async () => {
+      const validInput = {
+        title: 'Test Post',
+        html: '<p>Test content</p>',
+      };
+      const expectedPost = { id: '1', title: 'Test Post', status: 'draft' };
+      createPost.mockResolvedValue(expectedPost);
+
+      const result = await createPostService(validInput);
+
+      expect(result).toEqual(expectedPost);
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          title: 'Test Post',
+          html: '<p>Test content</p>',
+          status: 'draft',
+        })
+      );
+    });
+
+    it('should reject input with missing title', async () => {
+      const invalidInput = {
+        html: '<p>Test content</p>',
+      };
+
+      await expect(createPostService(invalidInput)).rejects.toThrow(
+        'Invalid post input: "title" is required'
+      );
+      expect(createPost).not.toHaveBeenCalled();
+    });
+
+    it('should reject input with missing html', async () => {
+      const invalidInput = {
+        title: 'Test Post',
+      };
+
+      await expect(createPostService(invalidInput)).rejects.toThrow(
+        'Invalid post input: "html" is required'
+      );
+      expect(createPost).not.toHaveBeenCalled();
+    });
+
+    it('should reject input with invalid status', async () => {
+      const invalidInput = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+        status: 'invalid-status',
+      };
+
+      await expect(createPostService(invalidInput)).rejects.toThrow(
+        'Invalid post input: "status" must be one of [draft, published, scheduled]'
+      );
+      expect(createPost).not.toHaveBeenCalled();
+    });
+
+    it('should accept valid status values', async () => {
+      const statuses = ['draft', 'published', 'scheduled'];
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      for (const status of statuses) {
+        const input = {
+          title: 'Test Post',
+          html: '<p>Content</p>',
+          status,
+        };
+
+        await createPostService(input);
+
+        expect(createPost).toHaveBeenCalledWith(expect.objectContaining({ status }));
+        vi.clearAllMocks();
+      }
+    });
+
+    it('should validate tags array with maximum length', async () => {
+      const invalidInput = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+        tags: Array(11).fill('tag'), // 11 tags exceeds max of 10
+      };
+
+      await expect(createPostService(invalidInput)).rejects.toThrow('Invalid post input:');
+      expect(createPost).not.toHaveBeenCalled();
+    });
+
+    it('should validate tag string max length', async () => {
+      const invalidInput = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+        tags: ['a'.repeat(51)], // 51 chars exceeds max of 50
+      };
+
+      await expect(createPostService(invalidInput)).rejects.toThrow('Invalid post input:');
+      expect(createPost).not.toHaveBeenCalled();
+    });
+
+    it('should validate feature_image is a valid URI', async () => {
+      const invalidInput = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+        feature_image: 'not-a-valid-url',
+      };
+
+      await expect(createPostService(invalidInput)).rejects.toThrow('Invalid post input:');
+      expect(createPost).not.toHaveBeenCalled();
+    });
+
+    it('should accept valid feature_image URI', async () => {
+      const validInput = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+        feature_image: 'https://example.com/image.jpg',
+      };
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(validInput);
+
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          feature_image: 'https://example.com/image.jpg',
+        })
+      );
+    });
+  });
+
+  describe('createPostService - tag resolution', () => {
+    it('should find and reuse existing tag', async () => {
+      const input = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+        tags: ['existing-tag'],
+      };
+      const existingTag = { id: '1', name: 'existing-tag', slug: 'existing-tag' };
+      getTags.mockResolvedValue([existingTag]);
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      expect(getTags).toHaveBeenCalledWith('existing-tag');
+      expect(createTag).not.toHaveBeenCalled();
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          tags: [{ name: 'existing-tag' }],
+        })
+      );
+    });
+
+    it('should create new tag when not found', async () => {
+      const input = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+        tags: ['new-tag'],
+      };
+      getTags.mockResolvedValue([]); // Tag not found
+      const newTag = { id: '2', name: 'new-tag', slug: 'new-tag' };
+      createTag.mockResolvedValue(newTag);
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      expect(getTags).toHaveBeenCalledWith('new-tag');
+      expect(createTag).toHaveBeenCalledWith({ name: 'new-tag' });
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          tags: [{ name: 'new-tag' }],
+        })
+      );
+    });
+
+    it('should handle errors during tag lookup gracefully', async () => {
+      const input = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+        tags: ['error-tag', 'good-tag'],
+      };
+      // First tag causes error, second tag exists
+      getTags
+        .mockRejectedValueOnce(new Error('Tag lookup failed'))
+        .mockResolvedValueOnce([{ id: '1', name: 'good-tag' }]);
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      // Should skip error-tag and only include good-tag
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          tags: [{ name: 'good-tag' }],
+        })
+      );
+    });
+
+    it('should reject tags array with non-string values', async () => {
+      const input = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+        tags: [null, 'valid-tag'],
+      };
+
+      await expect(createPostService(input)).rejects.toThrow('Invalid post input:');
+      expect(createPost).not.toHaveBeenCalled();
+    });
+
+    it('should reject tags array with empty strings', async () => {
+      const input = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+        tags: ['', 'valid-tag'],
+      };
+
+      await expect(createPostService(input)).rejects.toThrow('Invalid post input:');
+      expect(createPost).not.toHaveBeenCalled();
+    });
+
+    it('should trim whitespace from tag names', async () => {
+      const input = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+        tags: ['  trimmed-tag  '],
+      };
+      getTags.mockResolvedValue([{ id: '1', name: 'trimmed-tag' }]);
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      expect(getTags).toHaveBeenCalledWith('trimmed-tag');
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          tags: [{ name: 'trimmed-tag' }],
+        })
+      );
+    });
+
+    it('should handle mixed existing and new tags', async () => {
+      const input = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+        tags: ['existing-tag', 'new-tag'],
+      };
+      getTags
+        .mockResolvedValueOnce([{ id: '1', name: 'existing-tag' }]) // First tag exists
+        .mockResolvedValueOnce([]); // Second tag doesn't exist
+      createTag.mockResolvedValue({ id: '2', name: 'new-tag' });
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      expect(getTags).toHaveBeenCalledTimes(2);
+      expect(createTag).toHaveBeenCalledTimes(1);
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          tags: [{ name: 'existing-tag' }, { name: 'new-tag' }],
+        })
+      );
+    });
+  });
+
+  describe('createPostService - metadata defaults', () => {
+    it('should default meta_title to title when not provided', async () => {
+      const input = {
+        title: 'Test Post Title',
+        html: '<p>Content</p>',
+      };
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          meta_title: 'Test Post Title',
+        })
+      );
+    });
+
+    it('should use provided meta_title instead of defaulting to title', async () => {
+      const input = {
+        title: 'Test Post Title',
+        html: '<p>Content</p>',
+        meta_title: 'Custom Meta Title',
+      };
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          meta_title: 'Custom Meta Title',
+        })
+      );
+    });
+
+    it('should default meta_description to custom_excerpt when provided', async () => {
+      const input = {
+        title: 'Test Post',
+        html: '<p>Long HTML content that would be stripped</p>',
+        custom_excerpt: 'This is the custom excerpt',
+      };
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          meta_description: 'This is the custom excerpt',
+        })
+      );
+    });
+
+    it('should generate meta_description from HTML when no excerpt provided', async () => {
+      const input = {
+        title: 'Test Post',
+        html: '<p>This is HTML content with tags stripped</p>',
+      };
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          meta_description: 'This is HTML content with tags stripped',
+        })
+      );
+    });
+
+    it('should use provided meta_description over custom_excerpt and HTML', async () => {
+      const input = {
+        title: 'Test Post',
+        html: '<p>HTML content</p>',
+        custom_excerpt: 'Custom excerpt',
+        meta_description: 'Explicit meta description',
+      };
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          meta_description: 'Explicit meta description',
+        })
+      );
+    });
+
+    it('should truncate meta_description to 500 characters with ellipsis when generated from long HTML', async () => {
+      const longHtml = '<p>' + 'a'.repeat(600) + '</p>';
+      const input = {
+        title: 'Test Post',
+        html: longHtml,
+      };
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      const calledDescription = createPost.mock.calls[0][0].meta_description;
+      expect(calledDescription).toHaveLength(500);
+      expect(calledDescription.endsWith('...')).toBe(true);
+      expect(calledDescription).toBe('a'.repeat(497) + '...');
+    });
+
+    it('should reject empty HTML content', async () => {
+      const input = {
+        title: 'Test Post',
+        html: '',
+      };
+
+      await expect(createPostService(input)).rejects.toThrow('Invalid post input:');
+      expect(createPost).not.toHaveBeenCalled();
+    });
+
+    it('should strip HTML tags and truncate when generating meta_description', async () => {
+      const longHtml = '<p>' + 'word '.repeat(200) + '</p>';
+      const input = {
+        title: 'Test Post',
+        html: longHtml,
+      };
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      const calledDescription = createPost.mock.calls[0][0].meta_description;
+      expect(calledDescription).not.toContain('<p>');
+      expect(calledDescription).not.toContain('</p>');
+      expect(calledDescription.length).toBeLessThanOrEqual(500);
+    });
+  });
+
+  describe('createPostService - complete post creation', () => {
+    it('should create post with all optional fields', async () => {
+      const input = {
+        title: 'Complete Post',
+        html: '<p>Full content</p>',
+        custom_excerpt: 'Excerpt',
+        status: 'published',
+        published_at: '2025-12-10T12:00:00.000Z',
+        tags: ['tag1', 'tag2'],
+        feature_image: 'https://example.com/image.jpg',
+        feature_image_alt: 'Image alt text',
+        feature_image_caption: 'Image caption',
+        meta_title: 'Custom Meta Title',
+        meta_description: 'Custom meta description',
+      };
+      getTags.mockResolvedValue([]);
+      createTag
+        .mockResolvedValueOnce({ id: '1', name: 'tag1' })
+        .mockResolvedValueOnce({ id: '2', name: 'tag2' });
+      createPost.mockResolvedValue({ id: '1', title: 'Complete Post' });
+
+      await createPostService(input);
+
+      expect(createPost).toHaveBeenCalledWith({
+        title: 'Complete Post',
+        html: '<p>Full content</p>',
+        custom_excerpt: 'Excerpt',
+        status: 'published',
+        published_at: '2025-12-10T12:00:00.000Z',
+        tags: [{ name: 'tag1' }, { name: 'tag2' }],
+        feature_image: 'https://example.com/image.jpg',
+        feature_image_alt: 'Image alt text',
+        feature_image_caption: 'Image caption',
+        meta_title: 'Custom Meta Title',
+        meta_description: 'Custom meta description',
+      });
+    });
+
+    it('should default status to draft when not provided', async () => {
+      const input = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+      };
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          status: 'draft',
+        })
+      );
+    });
+
+    it('should handle post creation with no tags', async () => {
+      const input = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+      };
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          tags: [],
+        })
+      );
+      expect(getTags).not.toHaveBeenCalled();
+      expect(createTag).not.toHaveBeenCalled();
+    });
+
+    it('should handle post creation with empty tags array', async () => {
+      const input = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+        tags: [],
+      };
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          tags: [],
+        })
+      );
+      expect(getTags).not.toHaveBeenCalled();
+      expect(createTag).not.toHaveBeenCalled();
+    });
+  });
+});