mcp-wordpress 1.2.2 → 1.3.0

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

@@ -2,9 +2,9 @@
  * Tests for CacheManager
  */
 
-import { CacheManager, CachePresets } from '../CacheManager.js';
+import { CacheManager, CachePresets } from "../CacheManager.js";
 
-describe('CacheManager', () => {
+describe("CacheManager", () => {
   let cacheManager: CacheManager;
 
   beforeEach(() => {
@@ -12,7 +12,7 @@ describe('CacheManager', () => {
       maxSize: 100,
       defaultTTL: 1000,
       enableLRU: true,
-      enableStats: true
+      enableStats: true,
     });
   });
 
@@ -20,10 +20,10 @@ describe('CacheManager', () => {
     cacheManager.clear();
   });
 
-  describe('Basic Operations', () => {
-    test('should store and retrieve values', () => {
-      const key = 'test-key';
-      const value = { data: 'test value' };
+  describe("Basic Operations", () => {
+    test("should store and retrieve values", () => {
+      const key = "test-key";
+      const value = { data: "test value" };
 
       cacheManager.set(key, value);
       const retrieved = cacheManager.get(key);
@@ -31,227 +31,227 @@ describe('CacheManager', () => {
       expect(retrieved).toEqual(value);
     });
 
-    test('should return null for non-existent keys', () => {
-      const result = cacheManager.get('non-existent');
+    test("should return null for non-existent keys", () => {
+      const result = cacheManager.get("non-existent");
       expect(result).toBeNull();
     });
 
-    test('should check if key exists', () => {
-      const key = 'exists-test';
+    test("should check if key exists", () => {
+      const key = "exists-test";
       expect(cacheManager.has(key)).toBe(false);
 
-      cacheManager.set(key, 'value');
+      cacheManager.set(key, "value");
       expect(cacheManager.has(key)).toBe(true);
     });
 
-    test('should delete entries', () => {
-      const key = 'delete-test';
-      cacheManager.set(key, 'value');
-      
+    test("should delete entries", () => {
+      const key = "delete-test";
+      cacheManager.set(key, "value");
+
       expect(cacheManager.has(key)).toBe(true);
       const deleted = cacheManager.delete(key);
-      
+
       expect(deleted).toBe(true);
       expect(cacheManager.has(key)).toBe(false);
     });
 
-    test('should clear all entries', () => {
-      cacheManager.set('key1', 'value1');
-      cacheManager.set('key2', 'value2');
-      
+    test("should clear all entries", () => {
+      cacheManager.set("key1", "value1");
+      cacheManager.set("key2", "value2");
+
       expect(cacheManager.getStats().totalSize).toBe(2);
-      
+
       cacheManager.clear();
-      
+
       expect(cacheManager.getStats().totalSize).toBe(0);
-      expect(cacheManager.has('key1')).toBe(false);
-      expect(cacheManager.has('key2')).toBe(false);
+      expect(cacheManager.has("key1")).toBe(false);
+      expect(cacheManager.has("key2")).toBe(false);
     });
   });
 
-  describe('TTL and Expiration', () => {
-    test('should expire entries after TTL', async () => {
-      const key = 'ttl-test';
+  describe("TTL and Expiration", () => {
+    test("should expire entries after TTL", async () => {
+      const key = "ttl-test";
       const shortTTL = 50; // 50ms
-      
-      cacheManager.set(key, 'value', shortTTL);
-      expect(cacheManager.get(key)).toBe('value');
-      
+
+      cacheManager.set(key, "value", shortTTL);
+      expect(cacheManager.get(key)).toBe("value");
+
       // Wait for expiration
-      await new Promise(resolve => setTimeout(resolve, 100));
-      
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
       expect(cacheManager.get(key)).toBeNull();
     });
 
-    test('should not expire entries before TTL', () => {
-      const key = 'no-expire-test';
+    test("should not expire entries before TTL", () => {
+      const key = "no-expire-test";
       const longTTL = 10000; // 10 seconds
-      
-      cacheManager.set(key, 'value', longTTL);
-      expect(cacheManager.get(key)).toBe('value');
+
+      cacheManager.set(key, "value", longTTL);
+      expect(cacheManager.get(key)).toBe("value");
     });
 
-    test('should use default TTL when not specified', () => {
-      const key = 'default-ttl-test';
-      cacheManager.set(key, 'value');
-      
+    test("should use default TTL when not specified", () => {
+      const key = "default-ttl-test";
+      cacheManager.set(key, "value");
+
       const entry = cacheManager.getEntry(key);
       expect(entry?.ttl).toBe(1000);
     });
   });
 
-  describe('Key Generation', () => {
-    test('should generate consistent keys for same parameters', () => {
-      const siteId = 'site1';
-      const endpoint = 'posts';
-      const params = { per_page: 10, status: 'publish' };
-      
+  describe("Key Generation", () => {
+    test("should generate consistent keys for same parameters", () => {
+      const siteId = "site1";
+      const endpoint = "posts";
+      const params = { per_page: 10, status: "publish" };
+
       const key1 = cacheManager.generateKey(siteId, endpoint, params);
       const key2 = cacheManager.generateKey(siteId, endpoint, params);
-      
+
       expect(key1).toBe(key2);
     });
 
-    test('should generate different keys for different parameters', () => {
-      const siteId = 'site1';
-      const endpoint = 'posts';
+    test("should generate different keys for different parameters", () => {
+      const siteId = "site1";
+      const endpoint = "posts";
       const params1 = { per_page: 10 };
       const params2 = { per_page: 20 };
-      
+
       const key1 = cacheManager.generateKey(siteId, endpoint, params1);
       const key2 = cacheManager.generateKey(siteId, endpoint, params2);
-      
+
       expect(key1).not.toBe(key2);
     });
 
-    test('should include site ID in key', () => {
-      const endpoint = 'posts';
+    test("should include site ID in key", () => {
+      const endpoint = "posts";
       const params = { per_page: 10 };
-      
-      const key1 = cacheManager.generateKey('site1', endpoint, params);
-      const key2 = cacheManager.generateKey('site2', endpoint, params);
-      
-      expect(key1).toContain('site1:');
-      expect(key2).toContain('site2:');
+
+      const key1 = cacheManager.generateKey("site1", endpoint, params);
+      const key2 = cacheManager.generateKey("site2", endpoint, params);
+
+      expect(key1).toContain("site1:");
+      expect(key2).toContain("site2:");
       expect(key1).not.toBe(key2);
     });
 
-    test('should handle undefined parameters', () => {
-      const key1 = cacheManager.generateKey('site1', 'posts');
-      const key2 = cacheManager.generateKey('site1', 'posts', undefined);
-      const key3 = cacheManager.generateKey('site1', 'posts', {});
-      
+    test("should handle undefined parameters", () => {
+      const key1 = cacheManager.generateKey("site1", "posts");
+      const key2 = cacheManager.generateKey("site1", "posts", undefined);
+      const key3 = cacheManager.generateKey("site1", "posts", {});
+
       expect(key1).toBe(key2);
       expect(key1).toBe(key3);
     });
   });
 
-  describe('Site-Specific Operations', () => {
-    test('should clear cache for specific site', () => {
-      cacheManager.set('site1:posts:abc123', 'value1');
-      cacheManager.set('site1:pages:def456', 'value2');
-      cacheManager.set('site2:posts:ghi789', 'value3');
-      
-      const cleared = cacheManager.clearSite('site1');
-      
+  describe("Site-Specific Operations", () => {
+    test("should clear cache for specific site", () => {
+      cacheManager.set("site1:posts:abc123", "value1");
+      cacheManager.set("site1:pages:def456", "value2");
+      cacheManager.set("site2:posts:ghi789", "value3");
+
+      const cleared = cacheManager.clearSite("site1");
+
       expect(cleared).toBe(2);
-      expect(cacheManager.has('site1:posts:abc123')).toBe(false);
-      expect(cacheManager.has('site1:pages:def456')).toBe(false);
-      expect(cacheManager.has('site2:posts:ghi789')).toBe(true);
+      expect(cacheManager.has("site1:posts:abc123")).toBe(false);
+      expect(cacheManager.has("site1:pages:def456")).toBe(false);
+      expect(cacheManager.has("site2:posts:ghi789")).toBe(true);
     });
 
-    test('should clear cache matching pattern', () => {
-      cacheManager.set('site1:posts:list', 'value1');
-      cacheManager.set('site1:posts:123', 'value2');
-      cacheManager.set('site1:pages:456', 'value3');
-      
+    test("should clear cache matching pattern", () => {
+      cacheManager.set("site1:posts:list", "value1");
+      cacheManager.set("site1:posts:123", "value2");
+      cacheManager.set("site1:pages:456", "value3");
+
       const pattern = /site1:posts/;
       const cleared = cacheManager.clearPattern(pattern);
-      
+
       expect(cleared).toBe(2);
-      expect(cacheManager.has('site1:posts:list')).toBe(false);
-      expect(cacheManager.has('site1:posts:123')).toBe(false);
-      expect(cacheManager.has('site1:pages:456')).toBe(true);
+      expect(cacheManager.has("site1:posts:list")).toBe(false);
+      expect(cacheManager.has("site1:posts:123")).toBe(false);
+      expect(cacheManager.has("site1:pages:456")).toBe(true);
     });
   });
 
-  describe('LRU Eviction', () => {
-    test('should evict least recently used items when at capacity', () => {
+  describe("LRU Eviction", () => {
+    test("should evict least recently used items when at capacity", () => {
       const smallCache = new CacheManager({
         maxSize: 3,
         defaultTTL: 10000,
         enableLRU: true,
-        enableStats: true
+        enableStats: true,
       });
 
       // Fill cache to capacity
-      smallCache.set('key1', 'value1');
-      smallCache.set('key2', 'value2'); 
-      smallCache.set('key3', 'value3');
-      
+      smallCache.set("key1", "value1");
+      smallCache.set("key2", "value2");
+      smallCache.set("key3", "value3");
+
       expect(smallCache.getStats().totalSize).toBe(3);
-      
+
       // Access key1 to make it more recently used
-      smallCache.get('key1');
-      
+      smallCache.get("key1");
+
       // Add new item, should evict key2 (least recently used)
-      smallCache.set('key4', 'value4');
-      
-      expect(smallCache.has('key1')).toBe(true);  // Recently accessed
-      expect(smallCache.has('key2')).toBe(false); // Should be evicted
-      expect(smallCache.has('key3')).toBe(true);  // Recently added
-      expect(smallCache.has('key4')).toBe(true);  // Just added
+      smallCache.set("key4", "value4");
+
+      expect(smallCache.has("key1")).toBe(true); // Recently accessed
+      expect(smallCache.has("key2")).toBe(false); // Should be evicted
+      expect(smallCache.has("key3")).toBe(true); // Recently added
+      expect(smallCache.has("key4")).toBe(true); // Just added
       expect(smallCache.getStats().evictions).toBe(1);
     });
   });
 
-  describe('ETags and Conditional Requests', () => {
-    test('should store and retrieve ETags', () => {
-      const key = 'etag-test';
-      const value = { data: 'test' };
-      const etag = '"abc123"';
-      
+  describe("ETags and Conditional Requests", () => {
+    test("should store and retrieve ETags", () => {
+      const key = "etag-test";
+      const value = { data: "test" };
+      const etag = "\"abc123\"";
+
       cacheManager.set(key, value, 1000, etag);
-      
+
       const entry = cacheManager.getEntry(key);
       expect(entry?.etag).toBe(etag);
     });
 
-    test('should support conditional request headers', () => {
-      const key = 'conditional-test';
-      const etag = '"abc123"';
-      const lastModified = 'Wed, 21 Oct 2015 07:28:00 GMT';
-      
-      cacheManager.set(key, { data: 'test' }, 1000, etag, lastModified);
-      
+    test("should support conditional request headers", () => {
+      const key = "conditional-test";
+      const etag = "\"abc123\"";
+      const lastModified = "Wed, 21 Oct 2015 07:28:00 GMT";
+
+      cacheManager.set(key, { data: "test" }, 1000, etag, lastModified);
+
       expect(cacheManager.supportsConditionalRequest(key)).toBe(true);
-      
+
       const headers = cacheManager.getConditionalHeaders(key);
-      expect(headers['If-None-Match']).toBe(etag);
-      expect(headers['If-Modified-Since']).toBe(lastModified);
+      expect(headers["If-None-Match"]).toBe(etag);
+      expect(headers["If-Modified-Since"]).toBe(lastModified);
     });
 
-    test('should not support conditional requests without ETags', () => {
-      const key = 'no-etag-test';
-      cacheManager.set(key, { data: 'test' });
-      
+    test("should not support conditional requests without ETags", () => {
+      const key = "no-etag-test";
+      cacheManager.set(key, { data: "test" });
+
       expect(cacheManager.supportsConditionalRequest(key)).toBe(false);
       expect(cacheManager.getConditionalHeaders(key)).toEqual({});
     });
   });
 
-  describe('Statistics', () => {
-    test('should track cache hits and misses', () => {
-      const key = 'stats-test';
-      
+  describe("Statistics", () => {
+    test("should track cache hits and misses", () => {
+      const key = "stats-test";
+
       // Miss
       cacheManager.get(key);
       let stats = cacheManager.getStats();
       expect(stats.misses).toBe(1);
       expect(stats.hits).toBe(0);
-      
+
       // Hit
-      cacheManager.set(key, 'value');
+      cacheManager.set(key, "value");
       cacheManager.get(key);
       stats = cacheManager.getStats();
       expect(stats.hits).toBe(1);
@@ -259,27 +259,27 @@ describe('CacheManager', () => {
       expect(stats.hitRate).toBe(0.5);
     });
 
-    test('should track total size', () => {
+    test("should track total size", () => {
       const stats1 = cacheManager.getStats();
       expect(stats1.totalSize).toBe(0);
-      
-      cacheManager.set('key1', 'value1');
-      cacheManager.set('key2', 'value2');
-      
+
+      cacheManager.set("key1", "value1");
+      cacheManager.set("key2", "value2");
+
       const stats2 = cacheManager.getStats();
       expect(stats2.totalSize).toBe(2);
     });
 
-    test('should calculate hit rate correctly', () => {
-      cacheManager.set('key1', 'value1');
-      
+    test("should calculate hit rate correctly", () => {
+      cacheManager.set("key1", "value1");
+
       // 3 hits, 2 misses = 60% hit rate
-      cacheManager.get('key1'); // hit
-      cacheManager.get('key1'); // hit  
-      cacheManager.get('key1'); // hit
-      cacheManager.get('key2'); // miss
-      cacheManager.get('key3'); // miss
-      
+      cacheManager.get("key1"); // hit
+      cacheManager.get("key1"); // hit
+      cacheManager.get("key1"); // hit
+      cacheManager.get("key2"); // miss
+      cacheManager.get("key3"); // miss
+
       const stats = cacheManager.getStats();
       expect(stats.hits).toBe(3);
       expect(stats.misses).toBe(2);
@@ -287,14 +287,18 @@ describe('CacheManager', () => {
     });
   });
 
-  describe('Cache Presets', () => {
-    test('should have predefined cache presets', () => {
+  describe("Cache Presets", () => {
+    test("should have predefined cache presets", () => {
       expect(CachePresets.STATIC.ttl).toBeGreaterThan(CachePresets.DYNAMIC.ttl);
-      expect(CachePresets.SEMI_STATIC.ttl).toBeGreaterThan(CachePresets.DYNAMIC.ttl);
-      expect(CachePresets.SESSION.ttl).toBeGreaterThan(CachePresets.DYNAMIC.ttl);
-      
-      expect(CachePresets.STATIC.cacheControl).toContain('public');
-      expect(CachePresets.SESSION.cacheControl).toContain('private');
+      expect(CachePresets.SEMI_STATIC.ttl).toBeGreaterThan(
+        CachePresets.DYNAMIC.ttl,
+      );
+      expect(CachePresets.SESSION.ttl).toBeGreaterThan(
+        CachePresets.DYNAMIC.ttl,
+      );
+
+      expect(CachePresets.STATIC.cacheControl).toContain("public");
+      expect(CachePresets.SESSION.cacheControl).toContain("private");
     });
   });
 });