mcp-wordpress 1.2.2 → 1.3.0

package/src/cache/__tests__/CachedWordPressClient.test.ts

@@ -2,15 +2,15 @@
  * Tests for CachedWordPressClient
  */
 
-import { CachedWordPressClient } from '../index.js';
-import type { WordPressClientConfig } from '../../types/client.js';
+import { CachedWordPressClient } from "../index.js";
+import type { WordPressClientConfig } from "../../types/client.js";
 
 // Mock the base WordPress client
-jest.mock('../../client/api.js', () => {
+jest.mock("../../client/api.js", () => {
   return {
     WordPressClient: jest.fn().mockImplementation(() => ({
-      baseUrl: 'https://example.com',
-      auth: { method: 'app-password', username: 'test', appPassword: 'test' },
+      baseUrl: "https://example.com",
+      auth: { method: "app-password", username: "test", appPassword: "test" },
       jwtToken: null,
       request: jest.fn(),
       getPosts: jest.fn(),
@@ -21,26 +21,26 @@ jest.mock('../../client/api.js', () => {
       getCurrentUser: jest.fn(),
       getCategories: jest.fn(),
       getTags: jest.fn(),
-      getSiteSettings: jest.fn()
-    }))
+      getSiteSettings: jest.fn(),
+    })),
   };
 });
 
-describe('CachedWordPressClient', () => {
+describe("CachedWordPressClient", () => {
   let client: CachedWordPressClient;
   let config: WordPressClientConfig;
 
   beforeEach(() => {
     config = {
-      baseUrl: 'https://example.com',
+      baseUrl: "https://example.com",
       auth: {
-        method: 'app-password',
-        username: 'test',
-        appPassword: 'test-password'
-      }
+        method: "app-password",
+        username: "test",
+        appPassword: "test-password",
+      },
     };
 
-    client = new CachedWordPressClient(config, 'test-site');
+    client = new CachedWordPressClient(config, "test-site");
   });
 
   afterEach(() => {
@@ -48,29 +48,30 @@ describe('CachedWordPressClient', () => {
     jest.clearAllMocks();
   });
 
-  describe('Initialization', () => {
-    test('should initialize with caching system', () => {
+  describe("Initialization", () => {
+    test("should initialize with caching system", () => {
       expect(client).toBeDefined();
-      expect(client['cacheManager']).toBeDefined();
-      expect(client['httpCache']).toBeDefined();
-      expect(client['cacheInvalidation']).toBeDefined();
+      expect(client["cacheManager"]).toBeDefined();
+      expect(client["httpCache"]).toBeDefined();
+      expect(client["cacheInvalidation"]).toBeDefined();
     });
 
-    test('should use provided site ID', () => {
-      const customClient = new CachedWordPressClient(config, 'custom-site');
-      expect(customClient['siteId']).toBe('custom-site');
+    test("should use provided site ID", () => {
+      const customClient = new CachedWordPressClient(config, "custom-site");
+      expect(customClient["siteId"]).toBe("custom-site");
     });
 
-    test('should default to "default" site ID', () => {
+    test("should default to \"default\" site ID", () => {
       const defaultClient = new CachedWordPressClient(config);
-      expect(defaultClient['siteId']).toBe('default');
+      expect(defaultClient["siteId"]).toBe("default");
     });
   });
 
-  describe('GET Request Caching', () => {
-    test('should cache GET requests', async () => {
-      const mockResponse = [{ id: 1, title: 'Test Post' }];
-      (client as any).request = jest.fn()
+  describe("GET Request Caching", () => {
+    test("should cache GET requests", async () => {
+      const mockResponse = [{ id: 1, title: "Test Post" }];
+      (client as any).request = jest
+        .fn()
         .mockImplementationOnce(async () => mockResponse)
         .mockImplementationOnce(async () => mockResponse);
 
@@ -86,8 +87,8 @@ describe('CachedWordPressClient', () => {
       expect((client as any).request).toHaveBeenCalledTimes(1);
     });
 
-    test('should cache individual post requests', async () => {
-      const mockPost = { id: 1, title: 'Test Post' };
+    test("should cache individual post requests", async () => {
+      const mockPost = { id: 1, title: "Test Post" };
       (client as any).request = jest.fn().mockResolvedValue(mockPost);
 
       const result1 = await client.getPost(1);
@@ -99,117 +100,123 @@ describe('CachedWordPressClient', () => {
     });
   });
 
-  describe('Write Operations and Cache Invalidation', () => {
-    test('should invalidate cache on post creation', async () => {
-      const mockPost = { id: 1, title: 'New Post' };
-      const mockCreateData = { title: 'New Post', content: 'Content' };
-      
+  describe("Write Operations and Cache Invalidation", () => {
+    test("should invalidate cache on post creation", async () => {
+      const mockPost = { id: 1, title: "New Post" };
+      const mockCreateData = { title: "New Post", content: "Content" };
+
       // Mock the parent class methods
       const _originalCreatePost = client.createPost;
       client.createPost = jest.fn().mockResolvedValue(mockPost);
-      
-      const invalidateSpy = jest.spyOn(client['cacheInvalidation'], 'invalidateResource');
+
+      const invalidateSpy = jest.spyOn(
+        client["cacheInvalidation"],
+        "invalidateResource",
+      );
 
       await client.createPost(mockCreateData);
 
-      expect(invalidateSpy).toHaveBeenCalledWith('posts', 1, 'create');
+      expect(invalidateSpy).toHaveBeenCalledWith("posts", 1, "create");
     });
 
-    test('should invalidate cache on post update', async () => {
-      const mockPost = { id: 1, title: 'Updated Post' };
-      const mockUpdateData = { id: 1, title: 'Updated Post' };
-      
+    test("should invalidate cache on post update", async () => {
+      const mockPost = { id: 1, title: "Updated Post" };
+      const mockUpdateData = { id: 1, title: "Updated Post" };
+
       client.updatePost = jest.fn().mockResolvedValue(mockPost);
-      const invalidateSpy = jest.spyOn(client['cacheInvalidation'], 'invalidateResource');
+      const invalidateSpy = jest.spyOn(
+        client["cacheInvalidation"],
+        "invalidateResource",
+      );
 
       await client.updatePost(mockUpdateData);
 
-      expect(invalidateSpy).toHaveBeenCalledWith('posts', 1, 'update');
+      expect(invalidateSpy).toHaveBeenCalledWith("posts", 1, "update");
     });
 
-    test('should invalidate cache on post deletion', async () => {
+    test("should invalidate cache on post deletion", async () => {
       client.deletePost = jest.fn().mockResolvedValue(undefined);
-      const invalidateSpy = jest.spyOn(client['cacheInvalidation'], 'invalidateResource');
+      const invalidateSpy = jest.spyOn(
+        client["cacheInvalidation"],
+        "invalidateResource",
+      );
 
       await client.deletePost(1);
 
-      expect(invalidateSpy).toHaveBeenCalledWith('posts', 1, 'delete');
+      expect(invalidateSpy).toHaveBeenCalledWith("posts", 1, "delete");
     });
   });
 
-  describe('Cache Configuration by Endpoint Type', () => {
-    test('should use static caching for site settings', async () => {
-      const mockSettings = { title: 'Test Site' };
+  describe("Cache Configuration by Endpoint Type", () => {
+    test("should use static caching for site settings", async () => {
+      const mockSettings = { title: "Test Site" };
       (client as any).request = jest.fn().mockResolvedValue(mockSettings);
 
       await client.getSiteSettings();
 
       // Verify request was made with static cache configuration
-      expect((client as any).request).toHaveBeenCalledWith(
-        'GET',
-        'settings'
-      );
+      expect((client as any).request).toHaveBeenCalledWith("GET", "settings");
     });
 
-    test('should use semi-static caching for categories', async () => {
-      const mockCategories = [{ id: 1, name: 'Test Category' }];
+    test("should use semi-static caching for categories", async () => {
+      const mockCategories = [{ id: 1, name: "Test Category" }];
       (client as any).request = jest.fn().mockResolvedValue(mockCategories);
 
       await client.getCategories();
 
       expect((client as any).request).toHaveBeenCalledWith(
-        'GET',
-        'categories',
+        "GET",
+        "categories",
         null,
-        { params: {} }
+        { params: {} },
       );
     });
 
-    test('should use session caching for current user', async () => {
-      const mockUser = { id: 1, username: 'testuser' };
+    test("should use session caching for current user", async () => {
+      const mockUser = { id: 1, username: "testuser" };
       (client as any).request = jest.fn().mockResolvedValue(mockUser);
 
       await client.getCurrentUser();
 
-      expect((client as any).request).toHaveBeenCalledWith(
-        'GET',
-        'users/me'
-      );
+      expect((client as any).request).toHaveBeenCalledWith("GET", "users/me");
     });
   });
 
-  describe('Cache Management', () => {
-    test('should clear all cache', () => {
-      const clearSpy = jest.spyOn(client['httpCache'], 'invalidateAll');
-      
+  describe("Cache Management", () => {
+    test("should clear all cache", () => {
+      const clearSpy = jest.spyOn(client["httpCache"], "invalidateAll");
+
       const result = client.clearCache();
-      
+
       expect(clearSpy).toHaveBeenCalled();
-      expect(typeof result).toBe('number');
+      expect(typeof result).toBe("number");
     });
 
-    test('should clear cache by pattern', () => {
-      const pattern = 'posts.*';
-      const clearPatternSpy = jest.spyOn(client['httpCache'], 'invalidatePattern');
-      
+    test("should clear cache by pattern", () => {
+      const pattern = "posts.*";
+      const clearPatternSpy = jest.spyOn(
+        client["httpCache"],
+        "invalidatePattern",
+      );
+
       const result = client.clearCachePattern(pattern);
-      
+
       expect(clearPatternSpy).toHaveBeenCalledWith(pattern);
-      expect(typeof result).toBe('number');
+      expect(typeof result).toBe("number");
     });
 
-    test('should provide cache statistics', () => {
+    test("should provide cache statistics", () => {
       const stats = client.getCacheStats();
-      
-      expect(stats).toHaveProperty('cache');
-      expect(stats).toHaveProperty('invalidation');
-      expect(stats.cache).toHaveProperty('hits');
-      expect(stats.cache).toHaveProperty('misses');
-      expect(stats.cache).toHaveProperty('totalSize');
-      expect(stats.invalidation).toHaveProperty('queueSize');
+
+      expect(stats).toHaveProperty("cache");
+      expect(stats).toHaveProperty("invalidation");
+      expect(stats.cache).toHaveProperty("hits");
+      expect(stats.cache).toHaveProperty("misses");
+      expect(stats.cache).toHaveProperty("totalSize");
+      expect(stats.invalidation).toHaveProperty("queueSize");
     });
 
-    test('should warm cache with essential data', async () => {
+    test("should warm cache with essential data", async () => {
       // Mock all the methods that warmCache calls
       client.getCurrentUser = jest.fn().mockResolvedValue({ id: 1 });
       client.getCategories = jest.fn().mockResolvedValue([]);
@@ -224,23 +231,25 @@ describe('CachedWordPressClient', () => {
       expect(client.getSiteSettings).toHaveBeenCalled();
     });
 
-    test('should handle cache warming errors gracefully', async () => {
-      client.getCurrentUser = jest.fn().mockRejectedValue(new Error('Auth failed'));
+    test("should handle cache warming errors gracefully", async () => {
+      client.getCurrentUser = jest
+        .fn()
+        .mockRejectedValue(new Error("Auth failed"));
       client.getCategories = jest.fn().mockResolvedValue([]);
       client.getTags = jest.fn().mockResolvedValue([]);
       client.getSiteSettings = jest.fn().mockResolvedValue({});
 
       // Should not throw despite getCurrentUser failing
       await expect(client.warmCache()).resolves.toBeUndefined();
-      
+
       expect(client.getCategories).toHaveBeenCalled();
       expect(client.getTags).toHaveBeenCalled();
       expect(client.getSiteSettings).toHaveBeenCalled();
     });
   });
 
-  describe('Cache Key Generation', () => {
-    test('should generate different cache keys for different parameters', async () => {
+  describe("Cache Key Generation", () => {
+    test("should generate different cache keys for different parameters", async () => {
       const mockPosts = [{ id: 1 }];
       (client as any).request = jest.fn().mockResolvedValue(mockPosts);
 
@@ -252,12 +261,12 @@ describe('CachedWordPressClient', () => {
       expect((client as any).request).toHaveBeenCalledTimes(2);
     });
 
-    test('should use same cache key for identical parameters', async () => {
+    test("should use same cache key for identical parameters", async () => {
       const mockPosts = [{ id: 1 }];
       (client as any).request = jest.fn().mockResolvedValue(mockPosts);
 
-      const params = { per_page: 10, status: ['publish'] as ['publish'] };
-      
+      const params = { per_page: 10, status: ["publish"] as ["publish"] };
+
       await client.getPosts(params);
       await client.getPosts(params);
 
@@ -266,39 +275,45 @@ describe('CachedWordPressClient', () => {
     });
   });
 
-  describe('Helper Methods', () => {
-    test('should extract resource from endpoint', () => {
-      const resource1 = (client as any).extractResourceFromEndpoint('posts');
-      const resource2 = (client as any).extractResourceFromEndpoint('posts/123');
-      const resource3 = (client as any).extractResourceFromEndpoint('categories');
+  describe("Helper Methods", () => {
+    test("should extract resource from endpoint", () => {
+      const resource1 = (client as any).extractResourceFromEndpoint("posts");
+      const resource2 = (client as any).extractResourceFromEndpoint(
+        "posts/123",
+      );
+      const resource3 = (client as any).extractResourceFromEndpoint(
+        "categories",
+      );
 
-      expect(resource1).toBe('posts');
-      expect(resource2).toBe('posts');
-      expect(resource3).toBe('categories');
+      expect(resource1).toBe("posts");
+      expect(resource2).toBe("posts");
+      expect(resource3).toBe("categories");
     });
 
-    test('should extract ID from endpoint', () => {
-      const id1 = (client as any).extractIdFromEndpoint('posts/123');
-      const id2 = (client as any).extractIdFromEndpoint('posts/123/revisions');
-      const id3 = (client as any).extractIdFromEndpoint('posts');
+    test("should extract ID from endpoint", () => {
+      const id1 = (client as any).extractIdFromEndpoint("posts/123");
+      const id2 = (client as any).extractIdFromEndpoint("posts/123/revisions");
+      const id3 = (client as any).extractIdFromEndpoint("posts");
 
       expect(id1).toBe(123);
       expect(id2).toBe(123);
       expect(id3).toBeUndefined();
     });
 
-    test('should identify endpoint types correctly', () => {
-      expect((client as any).isStaticEndpoint('settings')).toBe(true);
-      expect((client as any).isStaticEndpoint('types')).toBe(true);
-      expect((client as any).isStaticEndpoint('posts')).toBe(false);
+    test("should identify endpoint types correctly", () => {
+      expect((client as any).isStaticEndpoint("settings")).toBe(true);
+      expect((client as any).isStaticEndpoint("types")).toBe(true);
+      expect((client as any).isStaticEndpoint("posts")).toBe(false);
 
-      expect((client as any).isSemiStaticEndpoint('categories')).toBe(true);
-      expect((client as any).isSemiStaticEndpoint('tags')).toBe(true);
-      expect((client as any).isSemiStaticEndpoint('posts')).toBe(false);
+      expect((client as any).isSemiStaticEndpoint("categories")).toBe(true);
+      expect((client as any).isSemiStaticEndpoint("tags")).toBe(true);
+      expect((client as any).isSemiStaticEndpoint("posts")).toBe(false);
 
-      expect((client as any).isSessionEndpoint('users/me')).toBe(true);
-      expect((client as any).isSessionEndpoint('application-passwords')).toBe(true);
-      expect((client as any).isSessionEndpoint('posts')).toBe(false);
+      expect((client as any).isSessionEndpoint("users/me")).toBe(true);
+      expect((client as any).isSessionEndpoint("application-passwords")).toBe(
+        true,
+      );
+      expect((client as any).isSessionEndpoint("posts")).toBe(false);
     });
   });
 });