mcp-wordpress 1.2.2 → 1.3.0

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

@@ -2,11 +2,14 @@
  * Tests for CacheInvalidation
  */
 
-import { CacheManager } from '../CacheManager.js';
-import { HttpCacheWrapper } from '../HttpCacheWrapper.js';
-import { CacheInvalidation, WordPressCachePatterns } from '../CacheInvalidation.js';
-
-describe('CacheInvalidation', () => {
+import { CacheManager } from "../CacheManager.js";
+import { HttpCacheWrapper } from "../HttpCacheWrapper.js";
+import {
+  CacheInvalidation,
+  WordPressCachePatterns,
+} from "../CacheInvalidation.js";
+
+describe("CacheInvalidation", () => {
   let cacheManager: CacheManager;
   let httpCache: HttpCacheWrapper;
   let cacheInvalidation: CacheInvalidation;
@@ -16,10 +19,10 @@ describe('CacheInvalidation', () => {
       maxSize: 100,
       defaultTTL: 10000,
       enableLRU: true,
-      enableStats: true
+      enableStats: true,
     });
-    
-    httpCache = new HttpCacheWrapper(cacheManager, 'test-site');
+
+    httpCache = new HttpCacheWrapper(cacheManager, "test-site");
     cacheInvalidation = new CacheInvalidation(httpCache);
   });
 
@@ -27,73 +30,73 @@ describe('CacheInvalidation', () => {
     cacheManager.clear();
   });
 
-  describe('Default Invalidation Rules', () => {
-    test('should have default rules for posts', () => {
+  describe("Default Invalidation Rules", () => {
+    test("should have default rules for posts", () => {
       const rules = cacheInvalidation.getRules();
-      
+
       expect(rules.posts).toBeDefined();
       expect(rules.posts.length).toBeGreaterThan(0);
-      
-      const createRule = rules.posts.find(r => r.trigger === 'create');
+
+      const createRule = rules.posts.find((r) => r.trigger === "create");
       expect(createRule).toBeDefined();
-      expect(createRule?.patterns).toContain('posts');
+      expect(createRule?.patterns).toContain("posts");
       expect(createRule?.immediate).toBe(true);
       expect(createRule?.cascade).toBe(true);
     });
 
-    test('should have default rules for categories', () => {
+    test("should have default rules for categories", () => {
       const rules = cacheInvalidation.getRules();
-      
+
       expect(rules.categories).toBeDefined();
-      
-      const updateRule = rules.categories.find(r => r.trigger === 'update');
+
+      const updateRule = rules.categories.find((r) => r.trigger === "update");
       expect(updateRule).toBeDefined();
-      expect(updateRule?.patterns).toContain('categories/\\d+');
+      expect(updateRule?.patterns).toContain("categories/\\d+");
       expect(updateRule?.cascade).toBe(true);
     });
 
-    test('should have default rules for users', () => {
+    test("should have default rules for users", () => {
       const rules = cacheInvalidation.getRules();
-      
+
       expect(rules.users).toBeDefined();
-      
-      const deleteRule = rules.users.find(r => r.trigger === 'delete');
+
+      const deleteRule = rules.users.find((r) => r.trigger === "delete");
       expect(deleteRule).toBeDefined();
-      expect(deleteRule?.patterns).toContain('users');
+      expect(deleteRule?.patterns).toContain("users");
     });
   });
 
-  describe('Custom Invalidation Rules', () => {
-    test('should register custom invalidation rules', () => {
+  describe("Custom Invalidation Rules", () => {
+    test("should register custom invalidation rules", () => {
       const customRule = {
-        trigger: 'update' as const,
-        patterns: ['custom-endpoint.*'],
-        immediate: true
+        trigger: "update" as const,
+        patterns: ["custom-endpoint.*"],
+        immediate: true,
       };
 
-      cacheInvalidation.registerRule('custom', customRule);
-      
+      cacheInvalidation.registerRule("custom", customRule);
+
       const rules = cacheInvalidation.getRules();
       expect(rules.custom).toBeDefined();
       expect(rules.custom).toContain(customRule);
     });
 
-    test('should support multiple rules per resource', () => {
+    test("should support multiple rules per resource", () => {
       const rule1 = {
-        trigger: 'create' as const,
-        patterns: ['test.*'],
-        immediate: true
+        trigger: "create" as const,
+        patterns: ["test.*"],
+        immediate: true,
       };
-      
+
       const rule2 = {
-        trigger: 'update' as const,
-        patterns: ['test/\\d+'],
-        immediate: false
+        trigger: "update" as const,
+        patterns: ["test/\\d+"],
+        immediate: false,
       };
 
-      cacheInvalidation.registerRule('test', rule1);
-      cacheInvalidation.registerRule('test', rule2);
-      
+      cacheInvalidation.registerRule("test", rule1);
+      cacheInvalidation.registerRule("test", rule2);
+
       const rules = cacheInvalidation.getRules();
       expect(rules.test).toHaveLength(2);
       expect(rules.test).toContain(rule1);
@@ -101,22 +104,22 @@ describe('CacheInvalidation', () => {
     });
   });
 
-  describe('Event Processing', () => {
-    test('should process invalidation events', async () => {
+  describe("Event Processing", () => {
+    test("should process invalidation events", async () => {
       // Pre-populate cache with some test data
-      httpCache.warm('posts', [{ id: 1 }, { id: 2 }]);
-      httpCache.warm('posts/1', { id: 1, title: 'Test Post' });
-      httpCache.warm('categories', [{ id: 1 }]);
+      httpCache.warm("posts", [{ id: 1 }, { id: 2 }]);
+      httpCache.warm("posts/1", { id: 1, title: "Test Post" });
+      httpCache.warm("categories", [{ id: 1 }]);
 
       expect(cacheManager.getStats().totalSize).toBe(3);
 
       // Trigger post creation event
       await cacheInvalidation.trigger({
-        type: 'create',
-        resource: 'posts',
+        type: "create",
+        resource: "posts",
         id: 3,
-        siteId: 'test-site',
-        timestamp: Date.now()
+        siteId: "test-site",
+        timestamp: Date.now(),
       });
 
       // Should invalidate posts listings but not specific post
@@ -124,42 +127,44 @@ describe('CacheInvalidation', () => {
       expect(stats.totalSize).toBeLessThan(3);
     });
 
-    test('should process events in queue order', async () => {
+    test("should process events in queue order", async () => {
       const processedEvents: string[] = [];
-      
+
       // Mock the invalidation process to track order
       const originalInvalidatePattern = httpCache.invalidatePattern;
-      httpCache.invalidatePattern = jest.fn().mockImplementation((pattern: string) => {
-        processedEvents.push(pattern);
-        return originalInvalidatePattern.call(httpCache, pattern);
-      });
+      httpCache.invalidatePattern = jest
+        .fn()
+        .mockImplementation((pattern: string) => {
+          processedEvents.push(pattern);
+          return originalInvalidatePattern.call(httpCache, pattern);
+        });
 
       // Queue multiple events
       await Promise.all([
         cacheInvalidation.trigger({
-          type: 'create',
-          resource: 'posts',
-          siteId: 'test-site',
-          timestamp: Date.now()
+          type: "create",
+          resource: "posts",
+          siteId: "test-site",
+          timestamp: Date.now(),
         }),
         cacheInvalidation.trigger({
-          type: 'update',
-          resource: 'categories',
-          siteId: 'test-site',
-          timestamp: Date.now()
-        })
+          type: "update",
+          resource: "categories",
+          siteId: "test-site",
+          timestamp: Date.now(),
+        }),
       ]);
 
       expect(processedEvents.length).toBeGreaterThan(0);
     });
 
-    test('should handle resource invalidation by type', async () => {
-      httpCache.warm('posts', [{ id: 1 }]);
-      httpCache.warm('posts/1', { id: 1 });
-      
+    test("should handle resource invalidation by type", async () => {
+      httpCache.warm("posts", [{ id: 1 }]);
+      httpCache.warm("posts/1", { id: 1 });
+
       expect(cacheManager.getStats().totalSize).toBe(2);
 
-      await cacheInvalidation.invalidateResource('posts', 1, 'update');
+      await cacheInvalidation.invalidateResource("posts", 1, "update");
 
       // Should clear specific post and related caches
       const stats = cacheManager.getStats();
@@ -167,22 +172,22 @@ describe('CacheInvalidation', () => {
     });
   });
 
-  describe('Pattern Matching', () => {
-    test('should replace placeholders in patterns', async () => {
+  describe("Pattern Matching", () => {
+    test("should replace placeholders in patterns", async () => {
       // Pre-populate cache
-      httpCache.warm('posts/123', { id: 123 });
-      httpCache.warm('posts/456', { id: 456 });
-      httpCache.warm('pages/123', { id: 123 });
+      httpCache.warm("posts/123", { id: 123 });
+      httpCache.warm("posts/456", { id: 456 });
+      httpCache.warm("pages/123", { id: 123 });
 
       expect(cacheManager.getStats().totalSize).toBe(3);
 
       // Trigger event with specific ID
       await cacheInvalidation.trigger({
-        type: 'update',
-        resource: 'posts',
+        type: "update",
+        resource: "posts",
         id: 123,
-        siteId: 'test-site',
-        timestamp: Date.now()
+        siteId: "test-site",
+        timestamp: Date.now(),
       });
 
       // Should only invalidate posts/123, not posts/456 or pages/123
@@ -191,37 +196,37 @@ describe('CacheInvalidation', () => {
         remainingKeys.push(key);
       }
 
-      expect(remainingKeys).not.toContain(expect.stringContaining('posts'));
+      expect(remainingKeys).not.toContain(expect.stringContaining("posts"));
     });
   });
 
-  describe('Statistics', () => {
-    test('should track invalidation statistics', () => {
+  describe("Statistics", () => {
+    test("should track invalidation statistics", () => {
       const stats = cacheInvalidation.getStats();
-      
-      expect(stats).toHaveProperty('queueSize');
-      expect(stats).toHaveProperty('rulesCount');
-      expect(stats).toHaveProperty('processing');
-      
-      expect(typeof stats.queueSize).toBe('number');
-      expect(typeof stats.rulesCount).toBe('number');
-      expect(typeof stats.processing).toBe('boolean');
+
+      expect(stats).toHaveProperty("queueSize");
+      expect(stats).toHaveProperty("rulesCount");
+      expect(stats).toHaveProperty("processing");
+
+      expect(typeof stats.queueSize).toBe("number");
+      expect(typeof stats.rulesCount).toBe("number");
+      expect(typeof stats.processing).toBe("boolean");
       expect(stats.rulesCount).toBeGreaterThan(0);
     });
 
-    test('should clear rules', () => {
+    test("should clear rules", () => {
       const initialStats = cacheInvalidation.getStats();
       expect(initialStats.rulesCount).toBeGreaterThan(0);
 
       cacheInvalidation.clearRules();
-      
+
       const clearedStats = cacheInvalidation.getStats();
       expect(clearedStats.rulesCount).toBe(0);
     });
   });
 });
 
-describe('WordPressCachePatterns', () => {
+describe("WordPressCachePatterns", () => {
   let cacheManager: CacheManager;
   let httpCache: HttpCacheWrapper;
 
@@ -230,69 +235,69 @@ describe('WordPressCachePatterns', () => {
       maxSize: 100,
       defaultTTL: 10000,
       enableLRU: true,
-      enableStats: true
+      enableStats: true,
     });
-    
-    httpCache = new HttpCacheWrapper(cacheManager, 'test-site');
+
+    httpCache = new HttpCacheWrapper(cacheManager, "test-site");
   });
 
   afterEach(() => {
     cacheManager.clear();
   });
 
-  test('should invalidate content-related caches', () => {
+  test("should invalidate content-related caches", () => {
     // Pre-populate cache
-    httpCache.warm('posts', []);
-    httpCache.warm('pages', []);
-    httpCache.warm('comments', []);
-    httpCache.warm('categories', []);
+    httpCache.warm("posts", []);
+    httpCache.warm("pages", []);
+    httpCache.warm("comments", []);
+    httpCache.warm("categories", []);
 
     expect(cacheManager.getStats().totalSize).toBe(4);
 
     const invalidated = WordPressCachePatterns.invalidateContent(httpCache);
-    
+
     expect(invalidated).toBeGreaterThan(0);
     // Should invalidate posts, pages, comments but not categories
     expect(cacheManager.getStats().totalSize).toBeLessThan(4);
   });
 
-  test('should invalidate taxonomy-related caches', () => {
-    httpCache.warm('categories', []);
-    httpCache.warm('tags', []);
-    httpCache.warm('posts', []);
+  test("should invalidate taxonomy-related caches", () => {
+    httpCache.warm("categories", []);
+    httpCache.warm("tags", []);
+    httpCache.warm("posts", []);
 
     expect(cacheManager.getStats().totalSize).toBe(3);
 
     const invalidated = WordPressCachePatterns.invalidateTaxonomies(httpCache);
-    
+
     expect(invalidated).toBeGreaterThan(0);
     // Should invalidate categories and tags but not posts
     expect(cacheManager.getStats().totalSize).toBeLessThan(3);
   });
 
-  test('should invalidate user-related caches', () => {
-    httpCache.warm('users', []);
-    httpCache.warm('users/me', {});
-    httpCache.warm('posts', []);
+  test("should invalidate user-related caches", () => {
+    httpCache.warm("users", []);
+    httpCache.warm("users/me", {});
+    httpCache.warm("posts", []);
 
     expect(cacheManager.getStats().totalSize).toBe(3);
 
     const invalidated = WordPressCachePatterns.invalidateUsers(httpCache);
-    
+
     expect(invalidated).toBeGreaterThan(0);
     // Should invalidate user caches but not posts
     expect(cacheManager.getStats().totalSize).toBeLessThan(3);
   });
 
-  test('should invalidate all caches', () => {
-    httpCache.warm('posts', []);
-    httpCache.warm('categories', []);
-    httpCache.warm('users', []);
+  test("should invalidate all caches", () => {
+    httpCache.warm("posts", []);
+    httpCache.warm("categories", []);
+    httpCache.warm("users", []);
 
     expect(cacheManager.getStats().totalSize).toBe(3);
 
     const invalidated = WordPressCachePatterns.invalidateAll(httpCache);
-    
+
     expect(invalidated).toBe(3);
     expect(cacheManager.getStats().totalSize).toBe(0);
   });