@jgardner04/ghost-mcp-server 1.1.12 → 1.2.0

package/src/routes/__tests__/imageRoutes.test.js

@@ -0,0 +1,117 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import request from 'supertest';
+import express from 'express';
+
+// Mock dependencies
+vi.mock('../../utils/logger.js', () => ({
+  createContextLogger: vi.fn().mockReturnValue({
+    info: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+    debug: vi.fn(),
+  }),
+}));
+
+// Mock crypto for multer's safe filename generation
+vi.mock('crypto', () => ({
+  default: {
+    randomBytes: vi.fn().mockReturnValue({
+      toString: vi.fn().mockReturnValue('abcdef1234567890'),
+    }),
+  },
+}));
+
+// Mock os for temp directory
+vi.mock('os', () => ({
+  default: {
+    tmpdir: vi.fn().mockReturnValue('/tmp'),
+  },
+}));
+
+// Mock fs for file operations
+vi.mock('fs', () => ({
+  default: {
+    unlink: vi.fn((path, cb) => cb(null)),
+    existsSync: vi.fn().mockReturnValue(true),
+  },
+}));
+
+// Mock the image processing service
+vi.mock('../../services/imageProcessingService.js', () => ({
+  processImage: vi.fn().mockResolvedValue('/tmp/processed-image.jpg'),
+}));
+
+// Mock the ghost service
+vi.mock('../../services/ghostService.js', () => ({
+  uploadImage: vi.fn().mockResolvedValue({ url: 'https://ghost.com/image.jpg' }),
+}));
+
+// Import after mocks
+import imageRoutes from '../imageRoutes.js';
+
+function createTestApp() {
+  const app = express();
+  app.use(express.json());
+  app.use('/api/images', imageRoutes);
+  // Add error handler
+  app.use((err, req, res, _next) => {
+    res.status(err.status || 500).json({ error: err.message });
+  });
+  return app;
+}
+
+describe('imageRoutes', () => {
+  let app;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    app = createTestApp();
+  });
+
+  describe('POST /api/images', () => {
+    describe('rate limiting', () => {
+      it('should have rate limiting configured', () => {
+        // The route should be configured with rate limiting
+        // We verify indirectly by checking the route exists
+        expect(imageRoutes).toBeDefined();
+      });
+
+      it('should return rate limit headers', async () => {
+        const response = await request(app).post('/api/images');
+
+        // Rate limit headers should be present
+        expect(response.headers['ratelimit-limit']).toBeDefined();
+        expect(response.headers['ratelimit-remaining']).toBeDefined();
+      });
+    });
+
+    describe('file upload', () => {
+      it('should return 400 when no file is provided', async () => {
+        const response = await request(app).post('/api/images').send({});
+
+        // Without a file, the controller should return 400
+        expect(response.status).toBe(400);
+      });
+    });
+  });
+
+  describe('route configuration', () => {
+    it('should export router', () => {
+      expect(imageRoutes).toBeDefined();
+    });
+
+    it('should handle POST requests', async () => {
+      const response = await request(app).post('/api/images');
+
+      // Route exists (not 404)
+      expect(response.status).not.toBe(404);
+    });
+
+    it('should not handle GET requests (no route defined)', async () => {
+      const response = await request(app).get('/api/images');
+
+      // Should return 404 since no GET route is defined
+      expect(response.status).toBe(404);
+    });
+  });
+});

package/src/routes/__tests__/postRoutes.test.js

@@ -0,0 +1,262 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import request from 'supertest';
+import express from 'express';
+
+// Mock dependencies
+vi.mock('../../utils/logger.js', () => ({
+  createContextLogger: vi.fn().mockReturnValue({
+    info: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+    debug: vi.fn(),
+  }),
+}));
+
+const mockCreatePost = vi.fn();
+vi.mock('../../controllers/postController.js', () => ({
+  createPost: (req, res, next) => mockCreatePost(req, res, next),
+}));
+
+// Import after mocks
+import postRoutes from '../postRoutes.js';
+
+function createTestApp() {
+  const app = express();
+  app.use(express.json());
+  app.use('/api/posts', postRoutes);
+  return app;
+}
+
+describe('postRoutes', () => {
+  let app;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    app = createTestApp();
+    // Default mock response
+    mockCreatePost.mockImplementation((req, res) => {
+      res.status(201).json({ id: '1', title: req.body.title });
+    });
+  });
+
+  describe('POST /api/posts', () => {
+    describe('validation - title', () => {
+      it('should return 400 when title is missing', async () => {
+        const response = await request(app).post('/api/posts').send({ html: '<p>Content</p>' });
+
+        expect(response.status).toBe(400);
+        expect(response.body.errors).toBeDefined();
+        expect(response.body.errors.some((e) => e.path === 'title')).toBe(true);
+      });
+
+      it('should return 400 when title is empty string', async () => {
+        const response = await request(app)
+          .post('/api/posts')
+          .send({ title: '', html: '<p>Content</p>' });
+
+        expect(response.status).toBe(400);
+        expect(response.body.errors.some((e) => e.path === 'title')).toBe(true);
+      });
+
+      it('should return 400 when title is not a string', async () => {
+        const response = await request(app)
+          .post('/api/posts')
+          .send({ title: 123, html: '<p>Content</p>' });
+
+        expect(response.status).toBe(400);
+      });
+    });
+
+    describe('validation - html', () => {
+      it('should return 400 when html is missing', async () => {
+        const response = await request(app).post('/api/posts').send({ title: 'Test Post' });
+
+        expect(response.status).toBe(400);
+        expect(response.body.errors.some((e) => e.path === 'html')).toBe(true);
+      });
+
+      it('should return 400 when html is empty string', async () => {
+        const response = await request(app)
+          .post('/api/posts')
+          .send({ title: 'Test Post', html: '' });
+
+        expect(response.status).toBe(400);
+        expect(response.body.errors.some((e) => e.path === 'html')).toBe(true);
+      });
+    });
+
+    describe('validation - status', () => {
+      it('should accept valid status "draft"', async () => {
+        const response = await request(app)
+          .post('/api/posts')
+          .send({ title: 'Test', html: '<p>Content</p>', status: 'draft' });
+
+        expect(response.status).toBe(201);
+      });
+
+      it('should accept valid status "published"', async () => {
+        const response = await request(app)
+          .post('/api/posts')
+          .send({ title: 'Test', html: '<p>Content</p>', status: 'published' });
+
+        expect(response.status).toBe(201);
+      });
+
+      it('should accept valid status "scheduled"', async () => {
+        const response = await request(app)
+          .post('/api/posts')
+          .send({ title: 'Test', html: '<p>Content</p>', status: 'scheduled' });
+
+        expect(response.status).toBe(201);
+      });
+
+      it('should return 400 for invalid status', async () => {
+        const response = await request(app)
+          .post('/api/posts')
+          .send({ title: 'Test', html: '<p>Content</p>', status: 'invalid' });
+
+        expect(response.status).toBe(400);
+        expect(response.body.errors.some((e) => e.path === 'status')).toBe(true);
+      });
+    });
+
+    describe('validation - published_at', () => {
+      it('should accept valid ISO8601 date', async () => {
+        const response = await request(app).post('/api/posts').send({
+          title: 'Test',
+          html: '<p>Content</p>',
+          published_at: '2024-01-15T10:00:00Z',
+        });
+
+        expect(response.status).toBe(201);
+      });
+
+      it('should return 400 for invalid date format', async () => {
+        const response = await request(app).post('/api/posts').send({
+          title: 'Test',
+          html: '<p>Content</p>',
+          published_at: 'not-a-date',
+        });
+
+        expect(response.status).toBe(400);
+        expect(response.body.errors.some((e) => e.path === 'published_at')).toBe(true);
+      });
+    });
+
+    describe('validation - tags', () => {
+      it('should accept valid tags array', async () => {
+        const response = await request(app)
+          .post('/api/posts')
+          .send({ title: 'Test', html: '<p>Content</p>', tags: ['tech', 'news'] });
+
+        expect(response.status).toBe(201);
+      });
+
+      it('should return 400 when tags is not an array', async () => {
+        const response = await request(app)
+          .post('/api/posts')
+          .send({ title: 'Test', html: '<p>Content</p>', tags: 'tech' });
+
+        expect(response.status).toBe(400);
+        expect(response.body.errors.some((e) => e.path === 'tags')).toBe(true);
+      });
+    });
+
+    describe('validation - feature_image', () => {
+      it('should accept valid URL for feature_image', async () => {
+        const response = await request(app).post('/api/posts').send({
+          title: 'Test',
+          html: '<p>Content</p>',
+          feature_image: 'https://example.com/image.jpg',
+        });
+
+        expect(response.status).toBe(201);
+      });
+
+      it('should return 400 for invalid URL', async () => {
+        const response = await request(app).post('/api/posts').send({
+          title: 'Test',
+          html: '<p>Content</p>',
+          feature_image: 'not-a-url',
+        });
+
+        expect(response.status).toBe(400);
+        expect(response.body.errors.some((e) => e.path === 'feature_image')).toBe(true);
+      });
+    });
+
+    describe('validation - meta_title', () => {
+      it('should accept valid meta_title', async () => {
+        const response = await request(app)
+          .post('/api/posts')
+          .send({ title: 'Test', html: '<p>Content</p>', meta_title: 'SEO Title' });
+
+        expect(response.status).toBe(201);
+      });
+
+      it('should return 400 when meta_title exceeds 300 characters', async () => {
+        const response = await request(app)
+          .post('/api/posts')
+          .send({
+            title: 'Test',
+            html: '<p>Content</p>',
+            meta_title: 'a'.repeat(301),
+          });
+
+        expect(response.status).toBe(400);
+        expect(response.body.errors.some((e) => e.path === 'meta_title')).toBe(true);
+      });
+    });
+
+    describe('validation - meta_description', () => {
+      it('should accept valid meta_description', async () => {
+        const response = await request(app).post('/api/posts').send({
+          title: 'Test',
+          html: '<p>Content</p>',
+          meta_description: 'A brief description',
+        });
+
+        expect(response.status).toBe(201);
+      });
+
+      it('should return 400 when meta_description exceeds 500 characters', async () => {
+        const response = await request(app)
+          .post('/api/posts')
+          .send({
+            title: 'Test',
+            html: '<p>Content</p>',
+            meta_description: 'a'.repeat(501),
+          });
+
+        expect(response.status).toBe(400);
+        expect(response.body.errors.some((e) => e.path === 'meta_description')).toBe(true);
+      });
+    });
+
+    describe('successful post creation', () => {
+      it('should call createPost controller when validation passes', async () => {
+        const response = await request(app).post('/api/posts').send({
+          title: 'Test Post',
+          html: '<p>Content</p>',
+        });
+
+        expect(response.status).toBe(201);
+        expect(mockCreatePost).toHaveBeenCalled();
+      });
+
+      it('should pass validated body to controller', async () => {
+        await request(app).post('/api/posts').send({
+          title: 'My Title',
+          html: '<p>My Content</p>',
+          status: 'draft',
+        });
+
+        expect(mockCreatePost).toHaveBeenCalled();
+        const reqArg = mockCreatePost.mock.calls[0][0];
+        expect(reqArg.body.title).toBe('My Title');
+        expect(reqArg.body.html).toBe('<p>My Content</p>');
+        expect(reqArg.body.status).toBe('draft');
+      });
+    });
+  });
+});

package/src/routes/__tests__/tagRoutes.test.js

@@ -0,0 +1,175 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import request from 'supertest';
+import express from 'express';
+
+// Mock dependencies
+vi.mock('../../utils/logger.js', () => ({
+  createContextLogger: vi.fn().mockReturnValue({
+    info: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+    debug: vi.fn(),
+  }),
+}));
+
+const mockGetTags = vi.fn();
+const mockCreateTag = vi.fn();
+vi.mock('../../controllers/tagController.js', () => ({
+  getTags: (req, res, next) => mockGetTags(req, res, next),
+  createTag: (req, res, next) => mockCreateTag(req, res, next),
+}));
+
+// Import after mocks
+import tagRoutes from '../tagRoutes.js';
+
+function createTestApp() {
+  const app = express();
+  app.use(express.json());
+  app.use('/api/tags', tagRoutes);
+  return app;
+}
+
+describe('tagRoutes', () => {
+  let app;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    app = createTestApp();
+    // Default mock responses
+    mockGetTags.mockImplementation((req, res) => {
+      res.status(200).json([{ id: '1', name: 'Test Tag' }]);
+    });
+    mockCreateTag.mockImplementation((req, res) => {
+      res.status(201).json({ id: '1', name: req.body.name });
+    });
+  });
+
+  describe('GET /api/tags', () => {
+    it('should call getTags controller', async () => {
+      const response = await request(app).get('/api/tags');
+
+      expect(response.status).toBe(200);
+      expect(mockGetTags).toHaveBeenCalled();
+    });
+
+    it('should pass query parameters to controller', async () => {
+      await request(app).get('/api/tags?name=Technology');
+
+      expect(mockGetTags).toHaveBeenCalled();
+      const reqArg = mockGetTags.mock.calls[0][0];
+      expect(reqArg.query.name).toBe('Technology');
+    });
+  });
+
+  describe('POST /api/tags', () => {
+    describe('validation - name', () => {
+      it('should return 400 when name is missing', async () => {
+        const response = await request(app).post('/api/tags').send({ description: 'A tag' });
+
+        expect(response.status).toBe(400);
+        expect(response.body.errors).toBeDefined();
+        expect(response.body.errors.some((e) => e.path === 'name')).toBe(true);
+      });
+
+      it('should return 400 when name is empty string', async () => {
+        const response = await request(app).post('/api/tags').send({ name: '' });
+
+        expect(response.status).toBe(400);
+        expect(response.body.errors.some((e) => e.path === 'name')).toBe(true);
+      });
+    });
+
+    describe('validation - description', () => {
+      it('should accept valid description', async () => {
+        const response = await request(app)
+          .post('/api/tags')
+          .send({ name: 'Tech', description: 'Technology articles' });
+
+        expect(response.status).toBe(201);
+      });
+
+      it('should return 400 when description exceeds 500 characters', async () => {
+        const response = await request(app)
+          .post('/api/tags')
+          .send({ name: 'Tech', description: 'a'.repeat(501) });
+
+        expect(response.status).toBe(400);
+        expect(response.body.errors.some((e) => e.path === 'description')).toBe(true);
+      });
+    });
+
+    describe('validation - slug', () => {
+      it('should accept valid slug with lowercase letters', async () => {
+        const response = await request(app)
+          .post('/api/tags')
+          .send({ name: 'Tech', slug: 'technology' });
+
+        expect(response.status).toBe(201);
+      });
+
+      it('should accept valid slug with numbers', async () => {
+        const response = await request(app)
+          .post('/api/tags')
+          .send({ name: 'Tech', slug: 'tech123' });
+
+        expect(response.status).toBe(201);
+      });
+
+      it('should accept valid slug with hyphens', async () => {
+        const response = await request(app)
+          .post('/api/tags')
+          .send({ name: 'Tech News', slug: 'tech-news' });
+
+        expect(response.status).toBe(201);
+      });
+
+      it('should return 400 for slug with uppercase letters', async () => {
+        const response = await request(app)
+          .post('/api/tags')
+          .send({ name: 'Tech', slug: 'Technology' });
+
+        expect(response.status).toBe(400);
+        expect(response.body.errors.some((e) => e.path === 'slug')).toBe(true);
+      });
+
+      it('should return 400 for slug with spaces', async () => {
+        const response = await request(app)
+          .post('/api/tags')
+          .send({ name: 'Tech', slug: 'tech news' });
+
+        expect(response.status).toBe(400);
+        expect(response.body.errors.some((e) => e.path === 'slug')).toBe(true);
+      });
+
+      it('should return 400 for slug with underscores', async () => {
+        const response = await request(app)
+          .post('/api/tags')
+          .send({ name: 'Tech', slug: 'tech_news' });
+
+        expect(response.status).toBe(400);
+        expect(response.body.errors.some((e) => e.path === 'slug')).toBe(true);
+      });
+    });
+
+    describe('successful tag creation', () => {
+      it('should call createTag controller when validation passes', async () => {
+        const response = await request(app).post('/api/tags').send({ name: 'Technology' });
+
+        expect(response.status).toBe(201);
+        expect(mockCreateTag).toHaveBeenCalled();
+      });
+
+      it('should pass validated body to controller', async () => {
+        await request(app)
+          .post('/api/tags')
+          .send({ name: 'Tech', slug: 'tech', description: 'Technical articles' });
+
+        expect(mockCreateTag).toHaveBeenCalled();
+        const reqArg = mockCreateTag.mock.calls[0][0];
+        expect(reqArg.body.name).toBe('Tech');
+        expect(reqArg.body.slug).toBe('tech');
+        expect(reqArg.body.description).toBe('Technical articles');
+      });
+    });
+  });
+});