@futdevpro/nts-dynamo 1.15.68 → 1.15.70

package/src/_modules/rate-limit/rate-limit.middleware.spec.ts

@@ -1,264 +1,264 @@
-import { Request, Response } from 'express';
-
-import { DyFM_Error } from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_RateLimit_Middleware } from './rate-limit.middleware';
-
-
-/** Test-only — minimal Request mock-ot ad vissza. */
-const mockReq = (overrides: Partial<{ ip: string; path: string; headers: Record<string, string> }> = {}): Request => {
-  return {
-    ip:      overrides.ip ?? '127.0.0.1',
-    path:    overrides.path ?? '/api/test',
-    headers: overrides.headers ?? {},
-  } as unknown as Request;
-};
-
-/** Test-only — Response stub a setHeader-rel. */
-const mockRes = (): Response & { _headers: Record<string, string> } => {
-  const headers: Record<string, string> = {};
-  return {
-    _headers: headers,
-    setHeader: function(name: string, value: string): void {
-      headers[name] = value;
-    },
-  } as unknown as Response & { _headers: Record<string, string> };
-};
-
-
-describe('| DyNTS_RateLimit_Middleware', (): void => {
-  let svc: DyNTS_RateLimit_Middleware;
-
-  beforeEach((): void => {
-    svc = DyNTS_RateLimit_Middleware.getInstance();
-    svc._resetForTesting();
-  });
-
-  afterEach((): void => {
-    svc._resetForTesting();
-  });
-
-
-  describe('| singleton', (): void => {
-    it('| ugyanazt az instance-t adja vissza', (): void => {
-      const a: DyNTS_RateLimit_Middleware = DyNTS_RateLimit_Middleware.getInstance();
-      const b: DyNTS_RateLimit_Middleware = DyNTS_RateLimit_Middleware.getInstance();
-      expect(a).toBe(b);
-    });
-  });
-
-
-  describe('| check() — default limit', (): void => {
-    it('| atengedi az elso request-et', async (): Promise<void> => {
-      let thrown: any = null;
-      try { await svc.check(mockReq(), mockRes()); } catch (e) { thrown = e; }
-      expect(thrown).toBeNull();
-    });
-
-    it('| 429 amikor a limit-et eleri', async (): Promise<void> => {
-      svc.configure({ defaultLimit: 3, defaultWindowMs: 10000 });
-
-      // 3 sikeres request a limit-en belul
-      await svc.check(mockReq(), mockRes());
-      await svc.check(mockReq(), mockRes());
-      await svc.check(mockReq(), mockRes());
-
-      // 4. request: 429
-      let thrown: any = null;
-      try { await svc.check(mockReq(), mockRes()); } catch (e) { thrown = e; }
-      expect(thrown).not.toBeNull();
-      expect(DyFM_Error.getErrorStatus(thrown)).toBe(429);
-      expect(DyFM_Error.getErrorCode(thrown)).toContain('DyNTS-RL-LIMIT');
-    });
-
-    it('| kulonbozo IP-k kulon vodorbe kerulnek', async (): Promise<void> => {
-      svc.configure({ defaultLimit: 2, defaultWindowMs: 10000 });
-
-      await svc.check(mockReq({ ip: '1.1.1.1' }), mockRes());
-      await svc.check(mockReq({ ip: '1.1.1.1' }), mockRes());
-      // 1.1.1.1 most a limit-en van; 2.2.2.2 meg friss
-      let thrown: any = null;
-      try { await svc.check(mockReq({ ip: '2.2.2.2' }), mockRes()); } catch (e) { thrown = e; }
-      expect(thrown).toBeNull();
-    });
-
-    it('| kulonbozo endpoint-ok kulon vodorbe kerulnek', async (): Promise<void> => {
-      svc.configure({ defaultLimit: 2, defaultWindowMs: 10000 });
-
-      await svc.check(mockReq({ path: '/api/a' }), mockRes());
-      await svc.check(mockReq({ path: '/api/a' }), mockRes());
-      // /api/a most a limit-en van; /api/b meg friss
-      let thrown: any = null;
-      try { await svc.check(mockReq({ path: '/api/b' }), mockRes()); } catch (e) { thrown = e; }
-      expect(thrown).toBeNull();
-    });
-  });
-
-
-  describe('| response headers', (): void => {
-    it('| beallitja az X-RateLimit-* header-eket sikeres request-nel', async (): Promise<void> => {
-      svc.configure({ defaultLimit: 10, defaultWindowMs: 60000 });
-      const res = mockRes();
-      await svc.check(mockReq(), res);
-      expect(res._headers['X-RateLimit-Limit']).toBe('10');
-      expect(res._headers['X-RateLimit-Remaining']).toBe('9');
-      expect(res._headers['X-RateLimit-Reset']).toBeDefined();
-    });
-
-    it('| beallitja a Retry-After header-t 429-nel', async (): Promise<void> => {
-      svc.configure({ defaultLimit: 1, defaultWindowMs: 10000 });
-      await svc.check(mockReq(), mockRes());
-
-      const res = mockRes();
-      let thrown: any = null;
-      try { await svc.check(mockReq(), res); } catch (e) { thrown = e; }
-      expect(thrown).not.toBeNull();
-      expect(res._headers['Retry-After']).toBeDefined();
-      expect(res._headers['X-RateLimit-Remaining']).toBe('0');
-    });
-
-    it('| nem allit be header-t ha responseHeaders=false', async (): Promise<void> => {
-      svc.configure({ defaultLimit: 10, defaultWindowMs: 60000, responseHeaders: false });
-      const res = mockRes();
-      await svc.check(mockReq(), res);
-      expect(res._headers['X-RateLimit-Limit']).toBeUndefined();
-    });
-  });
-
-
-  describe('| setPolicyForKey() — subscription-tier-up', (): void => {
-    it('| egyedi limit a kulcsra felulhatja a default-ot', async (): Promise<void> => {
-      svc.configure({
-        defaultLimit:    2,
-        defaultWindowMs: 10000,
-        keyExtractor:    (req: Request): string => (req.headers['x-api-key'] as string) ?? req.ip ?? 'anon',
-      });
-      svc.setPolicyForKey('premium-key', { limit: 10, windowMs: 10000 });
-
-      // premium-key 10-et kap
-      for (let i: number = 0; i < 10; i++) {
-        await svc.check(mockReq({ headers: { 'x-api-key': 'premium-key' } }), mockRes());
-      }
-      let thrown: any = null;
-      try { await svc.check(mockReq({ headers: { 'x-api-key': 'premium-key' } }), mockRes()); } catch (e) { thrown = e; }
-      expect(thrown).not.toBeNull();
-      expect(DyFM_Error.getErrorStatus(thrown)).toBe(429);
-    });
-
-    it('| clearPolicyForKey visszaallit a default-ra', async (): Promise<void> => {
-      svc.configure({
-        defaultLimit:    1,
-        defaultWindowMs: 10000,
-        keyExtractor:    (req: Request): string => (req.headers['x-api-key'] as string) ?? 'anon',
-      });
-      svc.setPolicyForKey('k1', { limit: 5, windowMs: 10000 });
-      svc.clearPolicyForKey('k1');
-
-      // most a default 1-es limit ervenyes
-      await svc.check(mockReq({ headers: { 'x-api-key': 'k1' } }), mockRes());
-      let thrown: any = null;
-      try { await svc.check(mockReq({ headers: { 'x-api-key': 'k1' } }), mockRes()); } catch (e) { thrown = e; }
-      expect(thrown).not.toBeNull();
-    });
-  });
-
-
-  describe('| setPolicyForEndpoint() — per-endpoint limit', (): void => {
-    it('| egyedi limit az endpointra felulhatja a default-ot, mas endpoint nem erintett', async (): Promise<void> => {
-      svc.configure({ defaultLimit: 2, defaultWindowMs: 10000 });
-      svc.setPolicyForEndpoint('/webhook', { limit: 5, windowMs: 10000 });
-
-      // /webhook 5-ot kap a default 2 helyett
-      for (let i: number = 0; i < 5; i++) {
-        await svc.check(mockReq({ path: '/webhook' }), mockRes());
-      }
-      let webhookThrown: any = null;
-      try { await svc.check(mockReq({ path: '/webhook' }), mockRes()); } catch (e) { webhookThrown = e; }
-      expect(webhookThrown).not.toBeNull();
-      expect(DyFM_Error.getErrorStatus(webhookThrown)).toBe(429);
-
-      // egy masik endpoint tovabbra is a default 2-t kapja (a per-endpoint policy izolalt)
-      await svc.check(mockReq({ path: '/admin/refund' }), mockRes());
-      await svc.check(mockReq({ path: '/admin/refund' }), mockRes());
-      let refundThrown: any = null;
-      try { await svc.check(mockReq({ path: '/admin/refund' }), mockRes()); } catch (e) { refundThrown = e; }
-      expect(refundThrown).not.toBeNull();
-    });
-
-    it('| clearPolicyForEndpoint visszaallit a default-ra', async (): Promise<void> => {
-      svc.configure({ defaultLimit: 1, defaultWindowMs: 10000 });
-      svc.setPolicyForEndpoint('/webhook', { limit: 5, windowMs: 10000 });
-      svc.clearPolicyForEndpoint('/webhook');
-
-      await svc.check(mockReq({ path: '/webhook' }), mockRes());
-      let thrown: any = null;
-      try { await svc.check(mockReq({ path: '/webhook' }), mockRes()); } catch (e) { thrown = e; }
-      expect(thrown).not.toBeNull();
-    });
-
-    it('| precedencia: per-kulcs policy felulirja a per-endpoint policy-t', async (): Promise<void> => {
-      svc.configure({
-        defaultLimit:    2,
-        defaultWindowMs: 10000,
-        keyExtractor:    (req: Request): string => (req.headers['x-api-key'] as string) ?? req.ip ?? 'anon',
-      });
-      svc.setPolicyForEndpoint('/webhook', { limit: 5, windowMs: 10000 });
-      svc.setPolicyForKey('throttled-key', { limit: 1, windowMs: 10000 });
-
-      // a kulcs-policy (1) gyoz az endpoint-policy (5) felett
-      await svc.check(mockReq({ path: '/webhook', headers: { 'x-api-key': 'throttled-key' } }), mockRes());
-      let thrown: any = null;
-      try {
-        await svc.check(mockReq({ path: '/webhook', headers: { 'x-api-key': 'throttled-key' } }), mockRes());
-      } catch (e) { thrown = e; }
-      expect(thrown).not.toBeNull();
-    });
-  });
-
-
-  describe('| keyExtractor override', (): void => {
-    it('| custom keyExtractor felulhatja a default IP-alapu-t', async (): Promise<void> => {
-      svc.configure({
-        defaultLimit:    1,
-        defaultWindowMs: 10000,
-        keyExtractor:    (req: Request): string => (req.headers['x-api-key'] as string) ?? 'anon',
-      });
-      // ugyanaz a IP, kulonbozo api-key — kulon limit
-      await svc.check(mockReq({ ip: '1.1.1.1', headers: { 'x-api-key': 'k1' } }), mockRes());
-      await svc.check(mockReq({ ip: '1.1.1.1', headers: { 'x-api-key': 'k2' } }), mockRes());
-      // k1 most a limit-en, k2 meg friss; ujabb k1 → 429
-      let thrown: any = null;
-      try { await svc.check(mockReq({ ip: '1.1.1.1', headers: { 'x-api-key': 'k1' } }), mockRes()); } catch (e) { thrown = e; }
-      expect(thrown).not.toBeNull();
-    });
-  });
-
-
-  describe('| GC', (): void => {
-    it('| runGc eltavolitja az ures kulcsokat', async (): Promise<void> => {
-      svc.configure({ defaultLimit: 10, defaultWindowMs: 10 }); // 10ms-os window
-      await svc.check(mockReq(), mockRes());
-      expect(svc.getConfig().trackedStorageKeys).toBe(1);
-
-      // varjunk meg amig a window lejar
-      await new Promise<void>((resolve: () => void): void => { setTimeout(resolve, 50); });
-
-      svc.runGc();
-      expect(svc.getConfig().trackedStorageKeys).toBe(0);
-    });
-  });
-
-
-  describe('| getConfig() diagnosztika', (): void => {
-    it('| visszaadja az aktualis allapotot', (): void => {
-      svc.configure({ defaultLimit: 50, defaultWindowMs: 30000 });
-      svc.setPolicyForKey('a', { limit: 100, windowMs: 60000 });
-      svc.setPolicyForKey('b', { limit: 200, windowMs: 60000 });
-
-      const cfg = svc.getConfig();
-      expect(cfg.defaultLimit).toBe(50);
-      expect(cfg.defaultWindowMs).toBe(30000);
-      expect(cfg.activeKeyPolicies).toBe(2);
-    });
-  });
-});
+import { Request, Response } from 'express';
+
+import { DyFM_Error } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_RateLimit_Middleware } from './rate-limit.middleware';
+
+
+/** Test-only — minimal Request mock-ot ad vissza. */
+const mockReq = (overrides: Partial<{ ip: string; path: string; headers: Record<string, string> }> = {}): Request => {
+  return {
+    ip:      overrides.ip ?? '127.0.0.1',
+    path:    overrides.path ?? '/api/test',
+    headers: overrides.headers ?? {},
+  } as unknown as Request;
+};
+
+/** Test-only — Response stub a setHeader-rel. */
+const mockRes = (): Response & { _headers: Record<string, string> } => {
+  const headers: Record<string, string> = {};
+  return {
+    _headers: headers,
+    setHeader: function(name: string, value: string): void {
+      headers[name] = value;
+    },
+  } as unknown as Response & { _headers: Record<string, string> };
+};
+
+
+describe('| DyNTS_RateLimit_Middleware', (): void => {
+  let svc: DyNTS_RateLimit_Middleware;
+
+  beforeEach((): void => {
+    svc = DyNTS_RateLimit_Middleware.getInstance();
+    svc._resetForTesting();
+  });
+
+  afterEach((): void => {
+    svc._resetForTesting();
+  });
+
+
+  describe('| singleton', (): void => {
+    it('| ugyanazt az instance-t adja vissza', (): void => {
+      const a: DyNTS_RateLimit_Middleware = DyNTS_RateLimit_Middleware.getInstance();
+      const b: DyNTS_RateLimit_Middleware = DyNTS_RateLimit_Middleware.getInstance();
+      expect(a).toBe(b);
+    });
+  });
+
+
+  describe('| check() — default limit', (): void => {
+    it('| atengedi az elso request-et', async (): Promise<void> => {
+      let thrown: any = null;
+      try { await svc.check(mockReq(), mockRes()); } catch (e) { thrown = e; }
+      expect(thrown).toBeNull();
+    });
+
+    it('| 429 amikor a limit-et eleri', async (): Promise<void> => {
+      svc.configure({ defaultLimit: 3, defaultWindowMs: 10000 });
+
+      // 3 sikeres request a limit-en belul
+      await svc.check(mockReq(), mockRes());
+      await svc.check(mockReq(), mockRes());
+      await svc.check(mockReq(), mockRes());
+
+      // 4. request: 429
+      let thrown: any = null;
+      try { await svc.check(mockReq(), mockRes()); } catch (e) { thrown = e; }
+      expect(thrown).not.toBeNull();
+      expect(DyFM_Error.getErrorStatus(thrown)).toBe(429);
+      expect(DyFM_Error.getErrorCode(thrown)).toContain('DyNTS-RL-LIMIT');
+    });
+
+    it('| kulonbozo IP-k kulon vodorbe kerulnek', async (): Promise<void> => {
+      svc.configure({ defaultLimit: 2, defaultWindowMs: 10000 });
+
+      await svc.check(mockReq({ ip: '1.1.1.1' }), mockRes());
+      await svc.check(mockReq({ ip: '1.1.1.1' }), mockRes());
+      // 1.1.1.1 most a limit-en van; 2.2.2.2 meg friss
+      let thrown: any = null;
+      try { await svc.check(mockReq({ ip: '2.2.2.2' }), mockRes()); } catch (e) { thrown = e; }
+      expect(thrown).toBeNull();
+    });
+
+    it('| kulonbozo endpoint-ok kulon vodorbe kerulnek', async (): Promise<void> => {
+      svc.configure({ defaultLimit: 2, defaultWindowMs: 10000 });
+
+      await svc.check(mockReq({ path: '/api/a' }), mockRes());
+      await svc.check(mockReq({ path: '/api/a' }), mockRes());
+      // /api/a most a limit-en van; /api/b meg friss
+      let thrown: any = null;
+      try { await svc.check(mockReq({ path: '/api/b' }), mockRes()); } catch (e) { thrown = e; }
+      expect(thrown).toBeNull();
+    });
+  });
+
+
+  describe('| response headers', (): void => {
+    it('| beallitja az X-RateLimit-* header-eket sikeres request-nel', async (): Promise<void> => {
+      svc.configure({ defaultLimit: 10, defaultWindowMs: 60000 });
+      const res = mockRes();
+      await svc.check(mockReq(), res);
+      expect(res._headers['X-RateLimit-Limit']).toBe('10');
+      expect(res._headers['X-RateLimit-Remaining']).toBe('9');
+      expect(res._headers['X-RateLimit-Reset']).toBeDefined();
+    });
+
+    it('| beallitja a Retry-After header-t 429-nel', async (): Promise<void> => {
+      svc.configure({ defaultLimit: 1, defaultWindowMs: 10000 });
+      await svc.check(mockReq(), mockRes());
+
+      const res = mockRes();
+      let thrown: any = null;
+      try { await svc.check(mockReq(), res); } catch (e) { thrown = e; }
+      expect(thrown).not.toBeNull();
+      expect(res._headers['Retry-After']).toBeDefined();
+      expect(res._headers['X-RateLimit-Remaining']).toBe('0');
+    });
+
+    it('| nem allit be header-t ha responseHeaders=false', async (): Promise<void> => {
+      svc.configure({ defaultLimit: 10, defaultWindowMs: 60000, responseHeaders: false });
+      const res = mockRes();
+      await svc.check(mockReq(), res);
+      expect(res._headers['X-RateLimit-Limit']).toBeUndefined();
+    });
+  });
+
+
+  describe('| setPolicyForKey() — subscription-tier-up', (): void => {
+    it('| egyedi limit a kulcsra felulhatja a default-ot', async (): Promise<void> => {
+      svc.configure({
+        defaultLimit:    2,
+        defaultWindowMs: 10000,
+        keyExtractor:    (req: Request): string => (req.headers['x-api-key'] as string) ?? req.ip ?? 'anon',
+      });
+      svc.setPolicyForKey('premium-key', { limit: 10, windowMs: 10000 });
+
+      // premium-key 10-et kap
+      for (let i: number = 0; i < 10; i++) {
+        await svc.check(mockReq({ headers: { 'x-api-key': 'premium-key' } }), mockRes());
+      }
+      let thrown: any = null;
+      try { await svc.check(mockReq({ headers: { 'x-api-key': 'premium-key' } }), mockRes()); } catch (e) { thrown = e; }
+      expect(thrown).not.toBeNull();
+      expect(DyFM_Error.getErrorStatus(thrown)).toBe(429);
+    });
+
+    it('| clearPolicyForKey visszaallit a default-ra', async (): Promise<void> => {
+      svc.configure({
+        defaultLimit:    1,
+        defaultWindowMs: 10000,
+        keyExtractor:    (req: Request): string => (req.headers['x-api-key'] as string) ?? 'anon',
+      });
+      svc.setPolicyForKey('k1', { limit: 5, windowMs: 10000 });
+      svc.clearPolicyForKey('k1');
+
+      // most a default 1-es limit ervenyes
+      await svc.check(mockReq({ headers: { 'x-api-key': 'k1' } }), mockRes());
+      let thrown: any = null;
+      try { await svc.check(mockReq({ headers: { 'x-api-key': 'k1' } }), mockRes()); } catch (e) { thrown = e; }
+      expect(thrown).not.toBeNull();
+    });
+  });
+
+
+  describe('| setPolicyForEndpoint() — per-endpoint limit', (): void => {
+    it('| egyedi limit az endpointra felulhatja a default-ot, mas endpoint nem erintett', async (): Promise<void> => {
+      svc.configure({ defaultLimit: 2, defaultWindowMs: 10000 });
+      svc.setPolicyForEndpoint('/webhook', { limit: 5, windowMs: 10000 });
+
+      // /webhook 5-ot kap a default 2 helyett
+      for (let i: number = 0; i < 5; i++) {
+        await svc.check(mockReq({ path: '/webhook' }), mockRes());
+      }
+      let webhookThrown: any = null;
+      try { await svc.check(mockReq({ path: '/webhook' }), mockRes()); } catch (e) { webhookThrown = e; }
+      expect(webhookThrown).not.toBeNull();
+      expect(DyFM_Error.getErrorStatus(webhookThrown)).toBe(429);
+
+      // egy masik endpoint tovabbra is a default 2-t kapja (a per-endpoint policy izolalt)
+      await svc.check(mockReq({ path: '/admin/refund' }), mockRes());
+      await svc.check(mockReq({ path: '/admin/refund' }), mockRes());
+      let refundThrown: any = null;
+      try { await svc.check(mockReq({ path: '/admin/refund' }), mockRes()); } catch (e) { refundThrown = e; }
+      expect(refundThrown).not.toBeNull();
+    });
+
+    it('| clearPolicyForEndpoint visszaallit a default-ra', async (): Promise<void> => {
+      svc.configure({ defaultLimit: 1, defaultWindowMs: 10000 });
+      svc.setPolicyForEndpoint('/webhook', { limit: 5, windowMs: 10000 });
+      svc.clearPolicyForEndpoint('/webhook');
+
+      await svc.check(mockReq({ path: '/webhook' }), mockRes());
+      let thrown: any = null;
+      try { await svc.check(mockReq({ path: '/webhook' }), mockRes()); } catch (e) { thrown = e; }
+      expect(thrown).not.toBeNull();
+    });
+
+    it('| precedencia: per-kulcs policy felulirja a per-endpoint policy-t', async (): Promise<void> => {
+      svc.configure({
+        defaultLimit:    2,
+        defaultWindowMs: 10000,
+        keyExtractor:    (req: Request): string => (req.headers['x-api-key'] as string) ?? req.ip ?? 'anon',
+      });
+      svc.setPolicyForEndpoint('/webhook', { limit: 5, windowMs: 10000 });
+      svc.setPolicyForKey('throttled-key', { limit: 1, windowMs: 10000 });
+
+      // a kulcs-policy (1) gyoz az endpoint-policy (5) felett
+      await svc.check(mockReq({ path: '/webhook', headers: { 'x-api-key': 'throttled-key' } }), mockRes());
+      let thrown: any = null;
+      try {
+        await svc.check(mockReq({ path: '/webhook', headers: { 'x-api-key': 'throttled-key' } }), mockRes());
+      } catch (e) { thrown = e; }
+      expect(thrown).not.toBeNull();
+    });
+  });
+
+
+  describe('| keyExtractor override', (): void => {
+    it('| custom keyExtractor felulhatja a default IP-alapu-t', async (): Promise<void> => {
+      svc.configure({
+        defaultLimit:    1,
+        defaultWindowMs: 10000,
+        keyExtractor:    (req: Request): string => (req.headers['x-api-key'] as string) ?? 'anon',
+      });
+      // ugyanaz a IP, kulonbozo api-key — kulon limit
+      await svc.check(mockReq({ ip: '1.1.1.1', headers: { 'x-api-key': 'k1' } }), mockRes());
+      await svc.check(mockReq({ ip: '1.1.1.1', headers: { 'x-api-key': 'k2' } }), mockRes());
+      // k1 most a limit-en, k2 meg friss; ujabb k1 → 429
+      let thrown: any = null;
+      try { await svc.check(mockReq({ ip: '1.1.1.1', headers: { 'x-api-key': 'k1' } }), mockRes()); } catch (e) { thrown = e; }
+      expect(thrown).not.toBeNull();
+    });
+  });
+
+
+  describe('| GC', (): void => {
+    it('| runGc eltavolitja az ures kulcsokat', async (): Promise<void> => {
+      svc.configure({ defaultLimit: 10, defaultWindowMs: 10 }); // 10ms-os window
+      await svc.check(mockReq(), mockRes());
+      expect(svc.getConfig().trackedStorageKeys).toBe(1);
+
+      // varjunk meg amig a window lejar
+      await new Promise<void>((resolve: () => void): void => { setTimeout(resolve, 50); });
+
+      svc.runGc();
+      expect(svc.getConfig().trackedStorageKeys).toBe(0);
+    });
+  });
+
+
+  describe('| getConfig() diagnosztika', (): void => {
+    it('| visszaadja az aktualis allapotot', (): void => {
+      svc.configure({ defaultLimit: 50, defaultWindowMs: 30000 });
+      svc.setPolicyForKey('a', { limit: 100, windowMs: 60000 });
+      svc.setPolicyForKey('b', { limit: 200, windowMs: 60000 });
+
+      const cfg = svc.getConfig();
+      expect(cfg.defaultLimit).toBe(50);
+      expect(cfg.defaultWindowMs).toBe(30000);
+      expect(cfg.activeKeyPolicies).toBe(2);
+    });
+  });
+});