@jgardner04/ghost-mcp-server 1.1.5 → 1.1.6

package/package.json

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

package/src/__tests__/helpers/mockGhostApi.js

@@ -0,0 +1,92 @@
+import { vi } from 'vitest';
+
+/**
+ * Creates a mock Ghost Admin API instance with configurable behavior.
+ *
+ * @param {Object} options - Configuration options for the mock
+ * @param {Object} options.posts - Mock implementations for posts methods
+ * @param {Object} options.tags - Mock implementations for tags methods
+ * @param {Object} options.site - Mock implementations for site methods
+ * @param {Object} options.images - Mock implementations for images methods
+ * @returns {Object} Mock Ghost Admin API instance
+ *
+ * @example
+ * import { createMockGhostApi } from '../helpers/mockGhostApi.js';
+ *
+ * const api = createMockGhostApi({
+ *   posts: {
+ *     add: vi.fn().mockResolvedValue({ id: '1', title: 'Test Post' }),
+ *   },
+ *   tags: {
+ *     browse: vi.fn().mockResolvedValue([{ id: '1', name: 'Test Tag' }]),
+ *   },
+ * });
+ */
+export function createMockGhostApi(options = {}) {
+  return {
+    posts: {
+      add: vi.fn(),
+      browse: vi.fn(),
+      read: vi.fn(),
+      edit: vi.fn(),
+      delete: vi.fn(),
+      ...options.posts,
+    },
+    tags: {
+      add: vi.fn(),
+      browse: vi.fn(),
+      read: vi.fn(),
+      edit: vi.fn(),
+      delete: vi.fn(),
+      ...options.tags,
+    },
+    site: {
+      read: vi.fn(),
+      ...options.site,
+    },
+    images: {
+      upload: vi.fn(),
+      ...options.images,
+    },
+  };
+}
+
+/**
+ * Creates a mock Ghost Admin API constructor for use with vi.mock().
+ *
+ * @param {Object} defaultOptions - Default configuration for all instances
+ * @returns {Function} Mock constructor function
+ *
+ * @example
+ * import { createMockGhostApiConstructor } from '../helpers/mockGhostApi.js';
+ *
+ * vi.mock('@tryghost/admin-api', () => ({
+ *   default: createMockGhostApiConstructor({
+ *     posts: {
+ *       add: vi.fn().mockResolvedValue({ id: '1', title: 'Test Post' }),
+ *     },
+ *   }),
+ * }));
+ */
+export function createMockGhostApiConstructor(defaultOptions = {}) {
+  return vi.fn(function () {
+    return createMockGhostApi(defaultOptions);
+  });
+}
+
+/**
+ * Creates a default mock Ghost Admin API module for vi.mock().
+ *
+ * @param {Object} options - Configuration options for the mock API
+ * @returns {Object} Mock module with default export
+ *
+ * @example
+ * import { mockGhostApiModule } from '../helpers/mockGhostApi.js';
+ *
+ * vi.mock('@tryghost/admin-api', () => mockGhostApiModule());
+ */
+export function mockGhostApiModule(options = {}) {
+  return {
+    default: createMockGhostApiConstructor(options),
+  };
+}

package/src/__tests__/helpers/mockLogger.js

@@ -0,0 +1,41 @@
+import { vi } from 'vitest';
+
+/**
+ * Creates a mock logger instance with spy functions for testing.
+ *
+ * @returns {Object} Mock logger with common logging methods
+ *
+ * @example
+ * import { createMockLogger } from '../helpers/mockLogger.js';
+ *
+ * const logger = createMockLogger();
+ * logger.info('test message');
+ * expect(logger.info).toHaveBeenCalledWith('test message');
+ */
+export function createMockLogger() {
+  return {
+    apiRequest: vi.fn(),
+    apiResponse: vi.fn(),
+    apiError: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    info: vi.fn(),
+    debug: vi.fn(),
+  };
+}
+
+/**
+ * Creates a mock context logger factory that returns a mock logger.
+ *
+ * @returns {Function} Mock createContextLogger function
+ *
+ * @example
+ * import { createMockContextLogger } from '../helpers/mockLogger.js';
+ *
+ * vi.mock('../../utils/logger.js', () => ({
+ *   createContextLogger: createMockContextLogger(),
+ * }));
+ */
+export function createMockContextLogger() {
+  return vi.fn(() => createMockLogger());
+}

package/src/__tests__/helpers/testUtils.js

@@ -0,0 +1,105 @@
+import { vi } from 'vitest';
+
+/**
+ * Creates a mock environment variable configuration.
+ *
+ * @param {Object} env - Environment variables to set
+ * @returns {Object} Mock dotenv module
+ *
+ * @example
+ * import { mockEnv } from '../helpers/testUtils.js';
+ *
+ * vi.mock('dotenv', () => mockEnv({
+ *   GHOST_ADMIN_API_URL: 'https://test.ghost.io',
+ *   GHOST_ADMIN_API_KEY: 'test-key',
+ * }));
+ */
+export function mockEnv(env = {}) {
+  // Set environment variables
+  Object.entries(env).forEach(([key, value]) => {
+    process.env[key] = value;
+  });
+
+  return {
+    default: {
+      config: vi.fn(),
+    },
+  };
+}
+
+/**
+ * Cleans up environment variables after tests.
+ *
+ * @param {string[]} keys - Array of environment variable keys to remove
+ *
+ * @example
+ * import { cleanupEnv } from '../helpers/testUtils.js';
+ *
+ * afterEach(() => {
+ *   cleanupEnv(['GHOST_ADMIN_API_URL', 'GHOST_ADMIN_API_KEY']);
+ * });
+ */
+export function cleanupEnv(keys) {
+  keys.forEach((key) => {
+    delete process.env[key];
+  });
+}
+
+/**
+ * Creates a mock dotenv module for use with vi.mock().
+ *
+ * @returns {Object} Mock dotenv module
+ *
+ * @example
+ * import { mockDotenv } from '../helpers/testUtils.js';
+ *
+ * vi.mock('dotenv', () => mockDotenv());
+ */
+export function mockDotenv() {
+  return {
+    default: {
+      config: vi.fn(),
+    },
+  };
+}
+
+/**
+ * Waits for a condition to be true or times out.
+ *
+ * @param {Function} condition - Function that returns true when condition is met
+ * @param {number} timeout - Maximum time to wait in milliseconds
+ * @param {number} interval - Check interval in milliseconds
+ * @returns {Promise<boolean>} True if condition met, false if timeout
+ *
+ * @example
+ * import { waitFor } from '../helpers/testUtils.js';
+ *
+ * await waitFor(() => mockFn.mock.calls.length > 0, 1000, 100);
+ */
+export async function waitFor(condition, timeout = 5000, interval = 100) {
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < timeout) {
+    if (condition()) {
+      return true;
+    }
+    await new Promise((resolve) => setTimeout(resolve, interval));
+  }
+
+  return false;
+}
+
+/**
+ * Creates a promise that resolves after a specified delay.
+ *
+ * @param {number} ms - Milliseconds to delay
+ * @returns {Promise<void>}
+ *
+ * @example
+ * import { delay } from '../helpers/testUtils.js';
+ *
+ * await delay(1000); // Wait 1 second
+ */
+export function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

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

@@ -1,46 +1,17 @@
 import { describe, it, expect, vi } from 'vitest';
+import { mockGhostApiModule } from '../../__tests__/helpers/mockGhostApi.js';
+import { createMockContextLogger } from '../../__tests__/helpers/mockLogger.js';
+import { mockDotenv } from '../../__tests__/helpers/testUtils.js';
 
 // Mock the Ghost Admin API
-vi.mock('@tryghost/admin-api', () => {
-  const GhostAdminAPI = vi.fn(function () {
-    return {
-      posts: {
-        add: vi.fn(),
-      },
-      tags: {
-        add: vi.fn(),
-        browse: vi.fn(),
-      },
-      site: {
-        read: vi.fn(),
-      },
-      images: {
-        upload: vi.fn(),
-      },
-    };
-  });
-
-  return {
-    default: GhostAdminAPI,
-  };
-});
+vi.mock('@tryghost/admin-api', () => mockGhostApiModule());
 
 // Mock dotenv
-vi.mock('dotenv', () => ({
-  default: {
-    config: vi.fn(),
-  },
-}));
+vi.mock('dotenv', () => mockDotenv());
 
 // Mock logger
 vi.mock('../../utils/logger.js', () => ({
-  createContextLogger: vi.fn(() => ({
-    apiRequest: vi.fn(),
-    apiResponse: vi.fn(),
-    apiError: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-  })),
+  createContextLogger: createMockContextLogger(),
 }));
 
 // Import after setting up mocks and environment