Nodejs-JSON-API-Server / tests /middleware /rate-limiter.test.js
dangkhoa2016's picture
feat: add runtime configuration for rate limiting and Redis
e9d5bbe
Raw History Blame Contribute Delete
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);
});
});
});