Spaces:
Sleeping
Sleeping
Download tests/middleware/rate-limiter.test.js from dangkhoa2016/Nodejs-JSON-API-Server: direct link, hf CLI and curl.
- Browser
- Download file 20.6 kB
-
https://huggingface.co/spaces/dangkhoa2016/Nodejs-JSON-API-Server/resolve/main/tests/middleware/rate-limiter.test.js
- Command line
-
hf download hf://spaces/dangkhoa2016/Nodejs-JSON-API-Server/tests/middleware/rate-limiter.test.js
-
curl -L -o rate-limiter.test.js https://huggingface.co/spaces/dangkhoa2016/Nodejs-JSON-API-Server/resolve/main/tests/middleware/rate-limiter.test.js
20.6 kB
| import { describe, it, expect, vi } from 'vitest' | |
| describe('Rate Limiter Middleware', () => { | |
| let createRateLimiter; | |
| let memFallback; | |
| let checkRedis; | |
| let getClientIp; | |
| let isTrustedProxy; | |
| let getRequestCost; | |
| let getCircuitBreaker; | |
| let resetCircuitBreaker; | |
| let resetMemStore; | |
| beforeEach(() => { | |
| const rateLimiter = require('../../src/middleware/rate-limiter'); | |
| createRateLimiter = rateLimiter.createRateLimiter; | |
| memFallback = rateLimiter.memFallback; | |
| checkRedis = rateLimiter.checkRedis; | |
| getClientIp = rateLimiter.getClientIp; | |
| isTrustedProxy = rateLimiter.isTrustedProxy; | |
| getRequestCost = rateLimiter.getRequestCost; | |
| getCircuitBreaker = rateLimiter.getCircuitBreaker; | |
| resetCircuitBreaker = rateLimiter.resetCircuitBreaker; | |
| resetMemStore = rateLimiter.resetMemStore; | |
| resetCircuitBreaker(); | |
| resetMemStore(); | |
| }); | |
| afterEach(() => { | |
| vi.useRealTimers(); | |
| }); | |
| describe('createRateLimiter', () => { | |
| it('should return next() when rate limiting is disabled', async () => { | |
| const rateLimiter = createRateLimiter(null, { enabled: false }); | |
| const next = vi.fn(); | |
| await rateLimiter({}, {}, next); | |
| expect(next).toHaveBeenCalledTimes(1); | |
| }); | |
| it('should skip rate limiting for exempt routes', async () => { | |
| const rateLimiter = createRateLimiter(null, { exemptRoutes: ['/health'] }); | |
| const next = vi.fn(); | |
| await rateLimiter({ path: '/health' }, {}, next); | |
| expect(next).toHaveBeenCalledTimes(1); | |
| }); | |
| it('should use effectiveMax for POST requests', async () => { | |
| const rateLimiter = createRateLimiter(null, { max: 100 }); | |
| const res = { setHeader: vi.fn() }; | |
| const req = { path: '/test', method: 'POST', headers: {}, socket: { remoteAddress: '127.0.0.1' } }; | |
| await rateLimiter(req, res, () => {}); | |
| expect(res.setHeader).toHaveBeenCalledWith('X-RateLimit-Limit', '50'); | |
| }); | |
| it('should handle invalid IP', async () => { | |
| const loggerStub = { warn: vi.fn(), error: vi.fn() }; | |
| const rateLimiter = createRateLimiter(null, { logger: loggerStub }); | |
| const res = { setHeader: vi.fn() }; | |
| const req = { path: '/test', headers: {}, socket: { remoteAddress: null } }; | |
| await rateLimiter(req, res, () => {}); | |
| expect(loggerStub.warn).toHaveBeenCalledTimes(1); | |
| }); | |
| it('should fall back to memory store when Redis errors', async () => { | |
| const redisStub = { connected: true, eval: vi.fn().mockRejectedValue(new Error('Redis error')) }; | |
| const loggerStub = { warn: vi.fn(), error: vi.fn() }; | |
| const rateLimiter = createRateLimiter(redisStub, { logger: loggerStub, retryDelayMs: 1 }); | |
| const res = { setHeader: vi.fn() }; | |
| const req = { path: '/test', headers: {}, socket: { remoteAddress: '127.0.0.1' } }; | |
| await rateLimiter(req, res, () => {}); | |
| expect(loggerStub.error).toHaveBeenCalledTimes(1); | |
| }); | |
| it('should return 429 when rate limit exceeded in memory after Redis fails', async () => { | |
| const redisStub = { connected: true, eval: vi.fn().mockRejectedValue(new Error('Redis error')) }; | |
| const rateLimiter = createRateLimiter(redisStub, { max: 1, retryDelayMs: 1 }); | |
| const res = { setHeader: vi.fn(), writeHead: vi.fn().mockReturnThis(), end: vi.fn() }; | |
| const req1 = { path: '/test', headers: {}, socket: { remoteAddress: '127.0.0.1' } }; | |
| await rateLimiter(req1, res, () => {}); | |
| const res2 = { setHeader: vi.fn(), writeHead: vi.fn().mockReturnThis(), end: vi.fn() }; | |
| const req2 = { path: '/test', headers: {}, socket: { remoteAddress: '127.0.0.1' } }; | |
| await rateLimiter(req2, res2, () => {}); | |
| expect(res2.writeHead).toHaveBeenCalledWith(429, expect.any(Object)); | |
| expect(res2.end).toHaveBeenCalledTimes(1); | |
| }); | |
| it('should set correct headers when rate limited after Redis fails', async () => { | |
| const redisStub = { connected: true, eval: vi.fn().mockRejectedValue(new Error('Redis error')) }; | |
| const rateLimiter = createRateLimiter(redisStub, { max: 1, retryDelayMs: 1 }); | |
| const res = { setHeader: vi.fn(), writeHead: vi.fn().mockReturnThis(), end: vi.fn() }; | |
| const req1 = { path: '/test', headers: {}, socket: { remoteAddress: '127.0.0.1' } }; | |
| await rateLimiter(req1, res, () => {}); | |
| const res2 = { setHeader: vi.fn(), writeHead: vi.fn(), end: vi.fn() }; | |
| const req2 = { path: '/test', headers: {}, socket: { remoteAddress: '127.0.0.1' } }; | |
| await rateLimiter(req2, res2, () => {}); | |
| expect(res2.setHeader).toHaveBeenCalledWith('X-RateLimit-Limit', '1'); | |
| expect(res2.setHeader).toHaveBeenCalledWith('X-RateLimit-Remaining', '0'); | |
| }); | |
| it('should set X-RateLimit-Store header to redis when using Redis', async () => { | |
| const redisStub = { connected: true, eval: vi.fn().mockResolvedValue([1, 99, 60, 0, false]) }; | |
| const rateLimiter = createRateLimiter(redisStub); | |
| const res = { setHeader: vi.fn(), writeHead: vi.fn(), end: vi.fn() }; | |
| const req = { path: '/test', headers: {}, socket: { remoteAddress: '127.0.0.1' } }; | |
| await rateLimiter(req, res, () => {}); | |
| expect(res.setHeader).toHaveBeenCalledWith('X-RateLimit-Store', 'redis'); | |
| }); | |
| it('should call next() when not rate limited (Redis)', async () => { | |
| const redisStub = { connected: true, eval: vi.fn().mockResolvedValue([1, 99, 60, 0, false]) }; | |
| const rateLimiter = createRateLimiter(redisStub); | |
| const res = { setHeader: vi.fn(), writeHead: vi.fn(), end: vi.fn() }; | |
| const req = { path: '/test', headers: {}, socket: { remoteAddress: '127.0.0.1' } }; | |
| const next = vi.fn(); | |
| await rateLimiter(req, res, next); | |
| expect(next).toHaveBeenCalledTimes(1); | |
| }); | |
| it('should use DELETE request cost of 3x', async () => { | |
| const rateLimiter = createRateLimiter(null, { max: 30 }); | |
| const res = { setHeader: vi.fn() }; | |
| const req = { path: '/test', method: 'DELETE', headers: {}, socket: { remoteAddress: '127.0.0.1' } }; | |
| await rateLimiter(req, res, () => {}); | |
| expect(res.setHeader).toHaveBeenCalledWith('X-RateLimit-Limit', '10'); | |
| }); | |
| it('should use PATCH request cost of 2x', async () => { | |
| const rateLimiter = createRateLimiter(null, { max: 100 }); | |
| const res = { setHeader: vi.fn() }; | |
| const req = { path: '/test', method: 'PATCH', headers: {}, socket: { remoteAddress: '127.0.0.1' } }; | |
| await rateLimiter(req, res, () => {}); | |
| expect(res.setHeader).toHaveBeenCalledWith('X-RateLimit-Limit', '50'); | |
| }); | |
| it('should expose updateConfig method', () => { | |
| const rateLimiter = createRateLimiter(null, { max: 100 }); | |
| expect(typeof rateLimiter.updateConfig).toBe('function'); | |
| }); | |
| it('updateConfig should disable rate limiting at runtime', async () => { | |
| const rateLimiter = createRateLimiter(null, { max: 1 }); | |
| const res = { setHeader: vi.fn(), writeHead: vi.fn().mockReturnThis(), end: vi.fn() }; | |
| const req = { path: '/test', headers: {}, socket: { remoteAddress: '127.0.0.1' } }; | |
| await rateLimiter(req, res, () => {}); | |
| res.setHeader.mockClear(); | |
| const next = vi.fn(); | |
| const res2 = { setHeader: vi.fn(), writeHead: vi.fn(), end: vi.fn() }; | |
| const req2 = { path: '/test', headers: {}, socket: { remoteAddress: '127.0.0.1' } }; | |
| rateLimiter.updateConfig({ enabled: false }); | |
| await rateLimiter(req2, res2, next); | |
| expect(next).toHaveBeenCalledTimes(1); | |
| }); | |
| it('updateConfig should change rate limit max at runtime', async () => { | |
| const rateLimiter = createRateLimiter(null, { max: 100 }); | |
| const req = { path: '/test', headers: {}, socket: { remoteAddress: '127.0.0.1' } }; | |
| const res = { setHeader: vi.fn(), writeHead: vi.fn(), end: vi.fn() }; | |
| await rateLimiter(req, res, () => {}); | |
| expect(res.setHeader).toHaveBeenCalledWith('X-RateLimit-Limit', '100'); | |
| rateLimiter.updateConfig({ max: 1 }); | |
| res.setHeader.mockClear(); | |
| const res2 = { setHeader: vi.fn(), writeHead: vi.fn().mockReturnThis(), end: vi.fn() }; | |
| const req2 = { path: '/test', headers: {}, socket: { remoteAddress: '127.0.0.1' } }; | |
| await rateLimiter(req2, res2, () => {}); | |
| expect(res2.writeHead).toHaveBeenCalledWith(429, expect.any(Object)); | |
| }); | |
| }); | |
| describe('memFallback', () => { | |
| beforeEach(() => { | |
| vi.useFakeTimers(); | |
| }); | |
| it('should reset count on new window', () => { | |
| const info1 = memFallback('127.0.0.1', 10, 60000); | |
| expect(info1.count).toBe(1); | |
| vi.advanceTimersByTime(61000); | |
| const info2 = memFallback('127.0.0.1', 10, 60000); | |
| expect(info2.count).toBe(1); | |
| }); | |
| it('should increase count within window', () => { | |
| const info1 = memFallback('127.0.0.1', 10, 60000); | |
| expect(info1.count).toBe(1); | |
| const info2 = memFallback('127.0.0.1', 10, 60000); | |
| expect(info2.count).toBe(2); | |
| }); | |
| it('should set limited=true when rate limit exceeded', () => { | |
| const info1 = memFallback('127.0.0.1', 1, 60000); | |
| expect(info1.limited).toBe(false); | |
| const info2 = memFallback('127.0.0.1', 1, 60000); | |
| expect(info2.limited).toBe(true); | |
| }); | |
| it('should track remaining requests correctly', () => { | |
| const info1 = memFallback('127.0.0.1', 10, 60000); | |
| expect(info1.remaining).toBe(9); | |
| const info2 = memFallback('127.0.0.1', 10, 60000); | |
| expect(info2.remaining).toBe(8); | |
| }); | |
| it('should increment violationCount on each violation within block', () => { | |
| const info1 = memFallback('127.0.0.1', 1, 60000); | |
| expect(info1.violationCount).toBe(0); | |
| const info2 = memFallback('127.0.0.1', 1, 60000); | |
| expect(info2.violationCount).toBe(1); | |
| const info3 = memFallback('127.0.0.1', 1, 60000); | |
| expect(info3.violationCount).toBe(2); | |
| }); | |
| it('should carry over violationCount when window expires but block continues', () => { | |
| const info1 = memFallback('127.0.0.1', 1, 60000); | |
| const info2 = memFallback('127.0.0.1', 1, 60000); | |
| expect(info2.violationCount).toBe(1); | |
| vi.advanceTimersByTime(301000); | |
| const info3 = memFallback('127.0.0.1', 1, 60000); | |
| expect(info3.violationCount).toBe(1); | |
| }); | |
| it('should use correct retryAfter values for escalation within block', () => { | |
| const info1 = memFallback('127.0.0.1', 1, 60000); | |
| expect(info1.retryAfter).toBe(0); | |
| const info2 = memFallback('127.0.0.1', 1, 60000); | |
| expect(info2.retryAfter).toBe(300); | |
| const info3 = memFallback('127.0.0.1', 1, 60000); | |
| expect(info3.retryAfter).toBe(1200); | |
| }); | |
| }); | |
| describe('checkRedis', () => { | |
| it('should return correct info when not rate limited', async () => { | |
| const redisStub = { eval: vi.fn().mockResolvedValue([50, 50, 60, 0, false]) }; | |
| const info = await checkRedis(redisStub, '127.0.0.1', 100, 60); | |
| expect(info.count).toBe(50); | |
| expect(info.limited).toBe(false); | |
| }); | |
| it('should return correct info when rate limited', async () => { | |
| const redisStub = { eval: vi.fn().mockResolvedValue([101, 0, 300, 300, true]) }; | |
| const info = await checkRedis(redisStub, '127.0.0.1', 100, 60); | |
| expect(info.limited).toBe(true); | |
| expect(info.retryAfter).toBe(300); | |
| }); | |
| it('should throw when circuit breaker is open', async () => { | |
| const cb = getCircuitBreaker(); | |
| cb.isOpen = true; | |
| cb.lastFailure = Date.now(); | |
| const redisStub = { eval: vi.fn() }; | |
| await expect(checkRedis(redisStub, '127.0.0.1', 100, 60)).rejects.toThrow(/Circuit breaker open/); | |
| }); | |
| it('should reset circuit breaker after timeout', async () => { | |
| const cb = getCircuitBreaker(); | |
| cb.isOpen = true; | |
| cb.lastFailure = Date.now() - 60000; | |
| cb.failureCount = 5; | |
| const redisStub = { eval: vi.fn().mockResolvedValue([1, 99, 60, 0, false]) }; | |
| const info = await checkRedis(redisStub, '127.0.0.1', 100, 60); | |
| expect(cb.isOpen).toBe(false); | |
| expect(cb.failureCount).toBe(0); | |
| }); | |
| it('should reset failure count on success', async () => { | |
| const cb = getCircuitBreaker(); | |
| cb.failureCount = 2; | |
| const redisStub = { eval: vi.fn().mockResolvedValue([1, 99, 60, 0, false]) }; | |
| await checkRedis(redisStub, '127.0.0.1', 100, 60); | |
| expect(cb.failureCount).toBe(0); | |
| }); | |
| it('should throw after max retries', async () => { | |
| const redisStub = { eval: vi.fn().mockRejectedValue(new Error('Permanent error')) }; | |
| await expect( | |
| checkRedis(redisStub, '127.0.0.1', 100, 60, 1) | |
| ).rejects.toThrow(/Max retries exceeded/); | |
| }); | |
| it('should use exponential backoff when retryDelayMs is not provided', async () => { | |
| const redisStub = { eval: vi.fn().mockRejectedValue(new Error('err')) }; | |
| await expect( | |
| checkRedis(redisStub, '127.0.0.1', 100, 60, 2) | |
| ).rejects.toThrow(/Max retries exceeded/); | |
| }) | |
| it('should open circuit breaker after 3 failures', async () => { | |
| const redisStub = { | |
| eval: vi.fn() | |
| .mockRejectedValueOnce(new Error('err1')) | |
| .mockRejectedValueOnce(new Error('err2')) | |
| .mockRejectedValueOnce(new Error('err3')) | |
| .mockRejectedValue(new Error('default err')) | |
| }; | |
| try { | |
| await checkRedis(redisStub, '127.0.0.1', 100, 60, 1); | |
| } catch (e) { | |
| } | |
| const cb = getCircuitBreaker(); | |
| expect(cb.isOpen).toBe(true); | |
| }); | |
| }); | |
| describe('getClientIp', () => { | |
| it('should extract IP from X-Forwarded-For with trusted proxy', () => { | |
| const req = { | |
| headers: { 'x-forwarded-for': '10.0.1.5, 192.168.1.1' }, | |
| socket: { remoteAddress: '127.0.0.1' } | |
| }; | |
| const ip = getClientIp(req); | |
| expect(ip).toBe('10.0.1.5'); | |
| }); | |
| it('should use remoteAddress when not from trusted proxy', () => { | |
| const req = { | |
| headers: { 'x-forwarded-for': '192.168.1.1' }, | |
| socket: { remoteAddress: '203.0.113.1' } | |
| }; | |
| const ip = getClientIp(req); | |
| expect(ip).toBe('203.0.113.1'); | |
| }); | |
| it('should handle IPv6-mapped IPv4', () => { | |
| const req = { | |
| headers: {}, | |
| socket: { remoteAddress: '::ffff:192.168.1.1' } | |
| }; | |
| const ip = getClientIp(req); | |
| expect(ip).toBe('192.168.1.1'); | |
| }); | |
| it('should handle IPv6 addresses', () => { | |
| const req = { | |
| headers: {}, | |
| socket: { remoteAddress: '2001:db8::1' } | |
| }; | |
| const ip = getClientIp(req); | |
| expect(ip).toBe('2001:db8::1'); | |
| }); | |
| it('should handle invalid IPs', () => { | |
| const req = { | |
| headers: {}, | |
| socket: { remoteAddress: null } | |
| }; | |
| const ip = getClientIp(req); | |
| expect(ip).toBe('unknown'); | |
| }); | |
| it('should handle missing X-Forwarded-For header', () => { | |
| const req = { | |
| headers: {}, | |
| socket: { remoteAddress: '127.0.0.1' } | |
| }; | |
| const ip = getClientIp(req); | |
| expect(ip).toBe('127.0.0.1'); | |
| }); | |
| it('should lowercase IPv6 addresses', () => { | |
| const req = { | |
| headers: {}, | |
| socket: { remoteAddress: '2001:DB8::1' } | |
| }; | |
| const ip = getClientIp(req); | |
| expect(ip).toBe('2001:db8::1'); | |
| }); | |
| it('should return first IP from X-Forwarded-For when multiple IPs', () => { | |
| const req = { | |
| headers: { 'x-forwarded-for': '1.2.3.4, 5.6.7.8, 9.10.11.12' }, | |
| socket: { remoteAddress: '127.0.0.1' } | |
| }; | |
| const ip = getClientIp(req); | |
| expect(ip).toBe('1.2.3.4'); | |
| }); | |
| }); | |
| describe('isTrustedProxy', () => { | |
| it('should match localhost', () => { | |
| expect(isTrustedProxy('127.0.0.1')).toBe(true); | |
| }); | |
| it('should match IPv6 localhost', () => { | |
| expect(isTrustedProxy('::1')).toBe(true); | |
| }); | |
| it('should match 10.0.0.0/8 range', () => { | |
| expect(isTrustedProxy('10.0.0.5')).toBe(true); | |
| expect(isTrustedProxy('10.255.255.255')).toBe(true); | |
| }); | |
| it('should match 172.16.0.0/12 range', () => { | |
| expect(isTrustedProxy('172.16.0.1')).toBe(true); | |
| expect(isTrustedProxy('172.31.255.255')).toBe(true); | |
| }); | |
| it('should match 192.168.0.0/16 range', () => { | |
| expect(isTrustedProxy('192.168.1.1')).toBe(true); | |
| }); | |
| it('should not match IPs outside trusted ranges', () => { | |
| expect(isTrustedProxy('8.8.8.8')).toBe(false); | |
| expect(isTrustedProxy('172.15.0.1')).toBe(false); | |
| }); | |
| it('should handle invalid inputs', () => { | |
| expect(isTrustedProxy(null)).toBe(false); | |
| expect(isTrustedProxy('unknown')).toBe(false); | |
| expect(isTrustedProxy('')).toBe(false); | |
| }); | |
| }); | |
| describe('getRequestCost', () => { | |
| it('should return 1 for GET', () => { | |
| expect(getRequestCost({ method: 'GET' })).toBe(1); | |
| }); | |
| it('should return 1 for HEAD', () => { | |
| expect(getRequestCost({ method: 'HEAD' })).toBe(1); | |
| }); | |
| it('should return 2 for POST', () => { | |
| expect(getRequestCost({ method: 'POST' })).toBe(2); | |
| }); | |
| it('should return 2 for PUT', () => { | |
| expect(getRequestCost({ method: 'PUT' })).toBe(2); | |
| }); | |
| it('should return 2 for PATCH', () => { | |
| expect(getRequestCost({ method: 'PATCH' })).toBe(2); | |
| }); | |
| it('should return 3 for DELETE', () => { | |
| expect(getRequestCost({ method: 'DELETE' })).toBe(3); | |
| }); | |
| it('should return 1 for unknown methods', () => { | |
| expect(getRequestCost({ method: 'UNKNOWN' })).toBe(1); | |
| expect(getRequestCost({ method: 'OPTIONS' })).toBe(1); | |
| }); | |
| }); | |
| describe('memStore internal operations', () => { | |
| it('should export getMemStore', () => { | |
| const rateLimiter = require('../../src/middleware/rate-limiter'); | |
| const memStore = rateLimiter.getMemStore(); | |
| expect(typeof memStore.get).toBe('function'); | |
| expect(typeof memStore.set).toBe('function'); | |
| expect(typeof memStore.delete).toBe('function'); | |
| expect(typeof memStore.entries).toBe('function'); | |
| expect(typeof memStore.size).toBe('function'); | |
| }); | |
| it('should track size correctly via size() method', () => { | |
| const rateLimiter = require('../../src/middleware/rate-limiter'); | |
| rateLimiter.resetMemStore(); | |
| const memStore = rateLimiter.getMemStore(); | |
| expect(memStore.size()).toBe(0); | |
| memStore.set('192.168.1.1', { count: 1, resetAt: Date.now() + 60000 }); | |
| expect(memStore.size()).toBe(1); | |
| memStore.set('192.168.1.2', { count: 2, resetAt: Date.now() + 60000 }); | |
| expect(memStore.size()).toBe(2); | |
| memStore.delete('192.168.1.1'); | |
| expect(memStore.size()).toBe(1); | |
| }); | |
| it('should handle entries iteration', () => { | |
| const rateLimiter = require('../../src/middleware/rate-limiter'); | |
| rateLimiter.resetMemStore(); | |
| const memStore = rateLimiter.getMemStore(); | |
| memStore.set('192.168.1.1', { count: 1, resetAt: Date.now() + 60000 }); | |
| memStore.set('192.168.1.2', { count: 2, resetAt: Date.now() + 60000 }); | |
| let entriesCount = 0; | |
| for (const entry of memStore.entries()) { | |
| entriesCount++; | |
| } | |
| expect(entriesCount).toBe(2); | |
| }); | |
| it('should use LRU behavior on get', () => { | |
| const rateLimiter = require('../../src/middleware/rate-limiter'); | |
| rateLimiter.resetMemStore(); | |
| const memStore = rateLimiter.getMemStore(); | |
| memStore.set('key1', { count: 1, resetAt: Date.now() + 60000 }); | |
| memStore.set('key2', { count: 2, resetAt: Date.now() + 60000 }); | |
| memStore.get('key1'); | |
| memStore.set('key3', { count: 3, resetAt: Date.now() + 60000 }); | |
| memStore.get('key1'); | |
| }); | |
| it('should trigger LRU eviction when exceeding max entries', () => { | |
| const rateLimiter = require('../../src/middleware/rate-limiter'); | |
| rateLimiter.resetMemStore(); | |
| const memStore = rateLimiter.getMemStore(); | |
| for (let i = 0; i < 10001; i++) { | |
| memStore.set(`ip${i}`, { count: i, resetAt: Date.now() + 60000 }); | |
| } | |
| expect(memStore.size()).toBeLessThanOrEqual(10000); | |
| }); | |
| it('should cleanup expired entries via triggerCleanup', () => { | |
| const rateLimiter = require('../../src/middleware/rate-limiter'); | |
| rateLimiter.resetMemStore(); | |
| const memStore = rateLimiter.getMemStore(); | |
| memStore.set('192.168.1.1', { count: 1, resetAt: Date.now() - 1000 }); | |
| memStore.set('192.168.1.2', { count: 2, resetAt: Date.now() + 60000 }); | |
| expect(memStore.size()).toBe(2); | |
| rateLimiter.triggerCleanup(); | |
| expect(memStore.size()).toBe(1); | |
| }); | |
| }); | |
| }); | |