lib/middleware/cache.test.ts
Rama master · réplica de lectura del repositorio original.
import { Context } from 'hono';
import Parser from 'rss-parser';
import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
import type CacheModule from '@/utils/cache';
import type { getRouteLimit as RouteLimit } from '@/utils/route-limit';
import wait from '@/utils/wait';
import type CacheMiddleware from './cache';
import type ParameterMiddleware from './parameter';
process.env.CACHE_EXPIRE = '1';
process.env.CACHE_CONTENT_EXPIRE = '2';
const parser = new Parser();
afterEach(() => {
vi.resetModules();
});
const noCacheTestFunc = async () => {
const app = (await import('@/app')).default;
const response1 = await app.request('/test/cache');
const response2 = await app.request('/test/cache');
const parsed1 = await parser.parseString(await response1.text());
const parsed2 = await parser.parseString(await response2.text());
expect(response2.status).toBe(200);
expect(response2.headers).not.toHaveProperty('rsshub-cache-status');
expect(parsed1.items[0].content).toBe('Cache1');
expect(parsed2.items[0].content).toBe('Cache2');
expect(parsed1.ttl).toEqual('1');
};
describe('cache', () => {
it('memory', async () => {
process.env.CACHE_TYPE = 'memory';
const app = (await import('@/app')).default;
const response1 = await app.request('/test/cache');
const response2 = await app.request('/test/cache');
const parsed1 = await parser.parseString(await response1.text());
const parsed2 = await parser.parseString(await response2.text());
delete parsed1.lastBuildDate;
delete parsed2.lastBuildDate;
delete parsed1.feedUrl;
delete parsed2.feedUrl;
delete parsed1.paginationLinks;
delete parsed2.paginationLinks;
expect(parsed2).toMatchObject(parsed1);
expect(response2.status).toBe(200);
expect(response2.headers.get('rsshub-cache-status')).toBe('HIT');
expect(parsed1.ttl).toEqual('1');
await wait(1 * 1000 + 100);
const response3 = await app.request('/test/cache');
expect(response3.headers).not.toHaveProperty('rsshub-cache-status');
const parsed3 = await parser.parseString(await response3.text());
await wait(2 * 1000 + 100);
const response4 = await app.request('/test/cache');
const parsed4 = await parser.parseString(await response4.text());
expect(parsed1.items[0].content).toBe('Cache1');
expect(parsed2.items[0].content).toBe('Cache1');
expect(parsed3.items[0].content).toBe('Cache1');
expect(parsed4.items[0].content).toBe('Cache2');
await app.request('/test/refreshCache');
await wait(1 * 1000 + 100);
const response5 = await app.request('/test/refreshCache');
const parsed5 = await parser.parseString(await response5.text());
await wait(1 * 1000 + 100);
const response6 = await app.request('/test/refreshCache');
const parsed6 = await parser.parseString(await response6.text());
expect(parsed5.items[0].content).toBe('1 1');
expect(parsed6.items[0].content).toBe('1 0');
}, 10000);
it('redis', async () => {
process.env.CACHE_TYPE = 'redis';
const app = (await import('@/app')).default;
await wait(500);
const response1 = await app.request('/test/cache');
const response2 = await app.request('/test/cache');
const parsed1 = await parser.parseString(await response1.text());
const parsed2 = await parser.parseString(await response2.text());
delete parsed1.lastBuildDate;
delete parsed2.lastBuildDate;
delete parsed1.feedUrl;
delete parsed2.feedUrl;
delete parsed1.paginationLinks;
delete parsed2.paginationLinks;
expect(parsed2).toMatchObject(parsed1);
expect(response2.status).toBe(200);
expect(response2.headers.get('rsshub-cache-status')).toBe('HIT');
expect(parsed1.ttl).toEqual('1');
await wait(1 * 1000 + 100);
const response3 = await app.request('/test/cache');
expect(response3.headers).not.toHaveProperty('rsshub-cache-status');
const parsed3 = await parser.parseString(await response3.text());
await wait(2 * 1000 + 100);
const response4 = await app.request('/test/cache');
const parsed4 = await parser.parseString(await response4.text());
expect(parsed1.items[0].content).toBe('Cache1');
expect(parsed2.items[0].content).toBe('Cache1');
expect(parsed3.items[0].content).toBe('Cache1');
expect(parsed4.items[0].content).toBe('Cache2');
await app.request('/test/refreshCache');
await wait(1 * 1000 + 100);
const response5 = await app.request('/test/refreshCache');
const parsed5 = await parser.parseString(await response5.text());
await wait(1 * 1000 + 100);
const response6 = await app.request('/test/refreshCache');
const parsed6 = await parser.parseString(await response6.text());
expect(parsed5.items[0].content).toBe('1 1');
expect(parsed6.items[0].content).toBe('1 0');
const cache = (await import('@/utils/cache')).default;
await cache.clients.redisClient!.quit();
}, 10000);
it('redis with quit', async () => {
process.env.CACHE_TYPE = 'redis';
const cache = (await import('@/utils/cache')).default;
await cache.clients.redisClient!.quit();
await noCacheTestFunc();
});
it('redis with error', async () => {
process.env.CACHE_TYPE = 'redis';
process.env.REDIS_URL = 'redis://wrongpath:6379';
await noCacheTestFunc();
const cache = (await import('@/utils/cache')).default;
cache.clients.redisClient?.disconnect();
}, 20000);
it('no cache', async () => {
process.env.CACHE_TYPE = 'NO';
await noCacheTestFunc();
});
it('no cache (empty string)', async () => {
process.env.CACHE_TYPE = '';
await noCacheTestFunc();
});
it('throws URL key', async () => {
process.env.CACHE_TYPE = 'memory';
const app = (await import('@/app')).default;
try {
const response = await app.request('/test/cacheUrlKey');
expect(response).toThrow(Error);
} catch (error: any) {
expect(error.message).toContain('Cache key must be a string');
}
});
it('RSS TTL (no cache)', async () => {
process.env.CACHE_TYPE = '';
process.env.CACHE_EXPIRE = '600';
const app = (await import('@/app')).default;
const response = await app.request('/test/cache');
const parsed = await parser.parseString(await response.text());
expect(parsed.ttl).toEqual('1');
});
it('RSS TTL (w/ cache)', async () => {
process.env.CACHE_TYPE = 'memory';
process.env.CACHE_EXPIRE = '600';
const app = (await import('@/app')).default;
const response = await app.request('/test/cache');
const parsed = await parser.parseString(await response.text());
expect(parsed.ttl).toEqual('10');
});
});
describe('cache middleware error handling', () => {
it('clears control key when downstream throws', async () => {
process.env.CACHE_TYPE = 'memory';
const cache = (await import('@/utils/cache')).default;
const setSpy = vi.spyOn(cache.globalCache, 'set');
const { default: cacheMiddleware } = await import('@/middleware/cache');
const ctx = new Context(new Request('http://localhost/test'), { env: {}, path: '/test' });
await expect(
cacheMiddleware(ctx, () => {
throw new Error('boom');
})
).rejects.toThrow('boom');
expect(setSpy.mock.calls.some(([key, value]) => key.startsWith('rsshub:path-requested:') && value === '0')).toBe(true);
setSpy.mockRestore();
});
});
describe('cache request variants', () => {
it('keeps source-order selections separate from date-order selections', async () => {
vi.stubEnv('CACHE_TYPE', 'memory');
vi.stubEnv('CACHE_EXPIRE', '300');
vi.resetModules();
const { default: middleware } = await import('./cache');
const { default: cacheModule } = await import('@/utils/cache/index');
cacheModule.clients.memoryCache?.clear();
const fetcher = vi.fn((ctx: Context) => {
if (!ctx.get('data')) {
const entry = ctx.req.query('sorted') === 'false' ? 'source-first' : 'date-first';
ctx.set('data', { title: 'Feed', item: [{ title: entry, link: `https://example.com/${entry}` }] });
}
return Promise.resolve();
});
const request = async (query = '') => {
const ctx = new Context(new Request(`https://rsshub.example/ordering?limit=1${query}`), { env: {}, path: '/ordering' });
await middleware(ctx, () => fetcher(ctx));
return ctx;
};
try {
const dateOrder = await request();
const sourceOrder = await request('&sorted=false');
const explicitDateOrder = await request('&sorted=true');
const defaultDateOrderHit = await request();
const dateOrderHit = await request('&sorted=true');
const sourceOrderHit = await request('&sorted=false');
expect(dateOrder.get('data').item[0].title).toBe('date-first');
expect(sourceOrder.get('data').item[0].title).toBe('source-first');
expect(explicitDateOrder.get('data').item[0].title).toBe('date-first');
expect(defaultDateOrderHit.res.headers.get('RSSHub-Cache-Status')).toBe('HIT');
expect(dateOrderHit.get('data').item[0].title).toBe('date-first');
expect(sourceOrderHit.get('data').item[0].title).toBe('source-first');
expect(dateOrderHit.res.headers.get('RSSHub-Cache-Status')).toBe('HIT');
expect(sourceOrderHit.res.headers.get('RSSHub-Cache-Status')).toBe('HIT');
expect(sourceOrder.res.headers.get('RSSHub-Cache-Status')).toBeNull();
expect(explicitDateOrder.res.headers.get('RSSHub-Cache-Status')).toBeNull();
} finally {
vi.unstubAllEnvs();
}
});
});
const coordinationContext = () => new Context(new Request('https://rsshub.example/test/cache'), { env: {}, path: '/test/cache' });
const isControlKey = (key: string) => key.startsWith('rsshub:path-requested:');
const loadCoordination = async () => {
// Pin the config values asserted below before the middleware loads the config.
vi.stubEnv('CACHE_TYPE', 'memory');
vi.stubEnv('FORMAT', 'rss');
vi.stubEnv('CACHE_REQUEST_TIMEOUT', '60');
vi.stubEnv('CACHE_EXPIRE', '300');
vi.resetModules();
const { default: middleware } = await import('./cache');
const { default: cacheModule } = await import('@/utils/cache/index');
const { globalCache } = cacheModule;
return {
middleware,
cacheModule,
globalCache,
cache: {
get: vi.spyOn(globalCache, 'get'),
set: vi.spyOn(globalCache, 'set'),
claim: vi.spyOn(globalCache, 'claim'),
},
};
};
type Loaded = Awaited<ReturnType<typeof loadCoordination>>;
describe('cache coordination capabilities', () => {
let middleware: Loaded['middleware'];
let cacheModule: Loaded['cacheModule'];
let globalCache: Loaded['globalCache'];
let cache: Loaded['cache'];
let originalSupportsAtomicClaims: boolean;
const feed = { title: 'Feed', link: 'https://example.com', item: [{ title: 'Entry', link: 'https://example.com/entry' }] };
beforeAll(async () => {
({ middleware, cacheModule, globalCache, cache } = await loadCoordination());
originalSupportsAtomicClaims = globalCache.supportsAtomicClaims;
});
beforeEach(() => {
vi.resetAllMocks();
cache.set.mockReturnValue(undefined);
vi.useFakeTimers();
globalCache.supportsAtomicClaims = false;
// Model a stale remote control key, including after the prior writer finished.
cache.get.mockImplementation((key: string) => (isControlKey(key) ? '1' : null));
cache.claim.mockResolvedValue(false);
});
afterEach(() => {
vi.useRealTimers();
});
afterAll(() => {
globalCache.supportsAtomicClaims = originalSupportsAtomicClaims;
vi.restoreAllMocks();
vi.unstubAllEnvs();
});
it('serves an HTTP/KV feed hit without touching a stale remote lock', async () => {
cache.get.mockImplementation((key: string) => (isControlKey(key) ? '1' : JSON.stringify(feed)));
const ctx = coordinationContext();
await middleware(ctx, vi.fn());
expect(ctx.get('data')).toEqual(feed);
expect(ctx.res.headers.get('RSSHub-Cache-Status')).toBe('HIT');
expect(cache.get).toHaveBeenCalledTimes(1);
expect(cache.claim).not.toHaveBeenCalled();
expect(cache.set).not.toHaveBeenCalled();
expect(vi.getTimerCount()).toBe(0);
});
it('fetches and caches HTTP/KV misses without waiting on or writing control keys', async () => {
const ctx = coordinationContext();
const next = vi.fn(() => {
ctx.set('data', structuredClone(feed));
return Promise.resolve();
});
await middleware(ctx, next);
expect(next).toHaveBeenCalledOnce();
expect(cache.get.mock.calls.every(([key]) => !isControlKey(key))).toBe(true);
expect(cache.claim).not.toHaveBeenCalled();
expect(cache.set).toHaveBeenCalledExactlyOnceWith(expect.stringMatching(/^rsshub:koa-redis-cache:/), expect.any(String), 300);
expect(JSON.parse(String(cache.set.mock.calls[0][1]))).toMatchObject(feed);
expect(ctx.get('cacheControlKey')).toBeUndefined();
expect(vi.getTimerCount()).toBe(0);
});
it('allows concurrent HTTP/KV cold misses even when remote reads remain stale', async () => {
const contexts = [coordinationContext(), coordinationContext()];
const fetcher = vi.fn((ctx: Context) => {
ctx.set('data', structuredClone(feed));
return Promise.resolve();
});
await Promise.all(contexts.map((ctx) => middleware(ctx, () => fetcher(ctx))));
expect(fetcher).toHaveBeenCalledTimes(2);
expect(cache.claim).not.toHaveBeenCalled();
expect(cache.get.mock.calls.every(([key]) => !isControlKey(key))).toBe(true);
expect(cache.set.mock.calls.every(([key]) => !isControlKey(key))).toBe(true);
expect(vi.getTimerCount()).toBe(0);
});
it('does not release a remote control key when an HTTP/KV route fails', async () => {
await expect(middleware(coordinationContext(), () => Promise.reject(new Error('route failed')))).rejects.toThrow('route failed');
expect(cache.set).not.toHaveBeenCalled();
expect(cache.claim).not.toHaveBeenCalled();
});
it('keeps atomic backends single-flight and serves the waiting request from the completed feed', async () => {
// Use the real memory backend, which claims atomically.
globalCache.supportsAtomicClaims = true;
cacheModule.clients.memoryCache?.clear();
cache.get.mockReset();
cache.set.mockReset();
cache.claim.mockReset();
const { promise: producerReady, resolve: markReady } = Promise.withResolvers<void>();
const { promise: releaseProducer, resolve: release } = Promise.withResolvers<void>();
const first = coordinationContext();
const second = coordinationContext();
const fetcher = vi.fn(async (ctx: Context) => {
if (ctx.get('data')) {
return;
}
markReady();
await releaseProducer;
ctx.set('data', structuredClone(feed));
});
const producer = middleware(first, () => fetcher(first));
await producerReady;
const waiter = middleware(second, () => fetcher(second));
await vi.advanceTimersByTimeAsync(0);
expect(cache.claim).toHaveBeenCalledTimes(2);
release();
await producer;
await vi.advanceTimersByTimeAsync(6000);
await waiter;
expect(second.res.headers.get('RSSHub-Cache-Status')).toBe('HIT');
expect(second.get('data')).toMatchObject(feed);
expect(cache.set.mock.calls.filter(([key]) => !isControlKey(key))).toHaveLength(1);
expect(cache.set.mock.calls.filter(([key, value]) => isControlKey(key) && value === '0')).toHaveLength(1);
});
it.each(['route', 'cache write'])('releases an owned atomic claim when the %s fails', async (failure) => {
globalCache.supportsAtomicClaims = true;
cache.claim.mockResolvedValue(true);
cache.set.mockImplementation((key: string) => {
if (!isControlKey(key)) {
throw new Error('cache write failed');
}
});
const ctx = coordinationContext();
const next = () => {
if (failure === 'route') {
return Promise.reject(new Error('route failed'));
}
ctx.set('data', structuredClone(feed));
return Promise.resolve();
};
await expect(middleware(ctx, next)).rejects.toThrow(`${failure} failed`);
expect(cache.set).toHaveBeenCalledWith(expect.stringMatching(/^rsshub:path-requested:/), '0', 60);
});
it('does not overwrite or release a competing atomic claim during takeover', async () => {
globalCache.supportsAtomicClaims = true;
cache.get.mockResolvedValue(null);
cache.claim.mockResolvedValue(false);
const next = vi.fn();
const result = expect(middleware(coordinationContext(), next)).rejects.toThrow('This path is currently fetching');
await vi.advanceTimersByTimeAsync(6000);
await result;
expect(cache.claim).toHaveBeenCalledTimes(2);
expect(cache.set).not.toHaveBeenCalled();
expect(next).not.toHaveBeenCalled();
});
});
const candidateEntries = [
{ title: 'skip', link: 'https://example.com/skip', pubDate: '2026-10-09T12:00:00Z' },
{ title: 'match older', link: 'https://example.com/older', pubDate: '2026-10-08T12:00:00Z' },
{ title: 'match newer', link: 'https://example.com/newer', pubDate: '2026-10-09T10:00:00Z' },
{ title: 'match fourth', link: 'https://example.com/fourth', pubDate: '2026-10-09T09:00:00Z' },
];
describe('filtered candidate cache variants', () => {
let parameter: typeof ParameterMiddleware;
let cache: typeof CacheMiddleware;
let cacheModule: typeof CacheModule;
let getRouteLimit: typeof RouteLimit;
beforeEach(async () => {
vi.stubEnv('CACHE_TYPE', 'memory');
vi.stubEnv('CACHE_EXPIRE', '300');
vi.resetModules();
({ default: parameter } = await import('./parameter'));
({ default: cache } = await import('./cache'));
({ default: cacheModule } = await import('@/utils/cache'));
({ getRouteLimit } = await import('@/utils/route-limit'));
cacheModule.clients.memoryCache?.clear();
});
afterEach(() => vi.unstubAllEnvs());
it.each([false, true])('isolates filtered and unfiltered source pools with filteredFirst=%s', async (filteredFirst) => {
let fetches = 0;
const request = async (query: string) => {
const ctx = new Context(new Request(`https://rsshub.example/candidates?${query}`), { env: {}, path: '/candidates' });
await parameter(ctx, async () => {
await cache(ctx, () => {
if (ctx.get('data')) {
return Promise.resolve();
}
fetches++;
const candidates = candidateEntries.slice(0, getRouteLimit(ctx, 3));
ctx.set('data', { title: 'Feed', item: structuredClone(candidates) });
return Promise.resolve();
});
});
return ctx;
};
const filteredQuery = 'limit=1&filter_title=match';
const limitedQuery = 'limit=1';
await request(filteredFirst ? filteredQuery : limitedQuery);
await request(filteredFirst ? limitedQuery : filteredQuery);
const limitedHit = await request(limitedQuery);
const filteredHit = await request(filteredQuery);
const differentFilterHit = await request('limit=1&filter_title=older');
const expanded = await request('limit=4&filter_title=match');
const sourceOrder = await request(`${filteredQuery}&sorted=false`);
const sourceOrderHit = await request(`${filteredQuery}&sorted=false`);
expect(limitedHit.get('data').item.map((item) => item.title)).toEqual(['skip']);
expect(filteredHit.get('data').item.map((item) => item.title)).toEqual(['match newer']);
expect(differentFilterHit.get('data').item.map((item) => item.title)).toEqual(['match older']);
expect(expanded.get('data').item).toHaveLength(3);
expect(sourceOrder.get('data').item.map((item) => item.title)).toEqual(['match older']);
expect(sourceOrderHit.get('data').item.map((item) => item.title)).toEqual(['match older']);
for (const ctx of [limitedHit, filteredHit, differentFilterHit, sourceOrderHit]) {
expect(ctx.res.headers.get('RSSHub-Cache-Status')).toBe('HIT');
}
expect(fetches).toBe(4);
});
it.each([false, true])('preserves ranked defaults and explicit date ordering with dateFirst=%s', async (dateFirst) => {
let fetches = 0;
const rankedEntries = [
{ title: 'Top ranked', link: 'https://example.com/top', pubDate: '2026-10-07T12:00:00Z' },
{ title: 'Second ranked', link: 'https://example.com/second', pubDate: '2026-10-08T12:00:00Z' },
{ title: 'Newest', link: 'https://example.com/newest', pubDate: '2026-10-09T12:00:00Z' },
];
const request = async (query = '') => {
const ctx = new Context(new Request(`https://rsshub.example/ranking?limit=1${query}`), { env: {}, path: '/ranking' });
await parameter(ctx, async () => {
await cache(ctx, () => {
if (ctx.get('data')) {
return Promise.resolve();
}
fetches++;
const sorted = ctx.req.query('sorted');
const candidates = sorted !== undefined && sorted !== 'false' ? rankedEntries : rankedEntries.slice(0, getRouteLimit(ctx, 3));
ctx.set('data', { title: 'Ranking', sortItems: false, item: structuredClone(candidates) });
return Promise.resolve();
});
});
return ctx;
};
await request(dateFirst ? '&sorted=true' : '');
await request(dateFirst ? '' : '&sorted=true');
const rankedHit = await request();
const datedHit = await request('&sorted=true');
const truthyHit = await request('&sorted=yes');
const explicitRank = await request('&sorted=false');
const explicitRankHit = await request('&sorted=false');
expect(rankedHit.get('data').item.map((item) => item.title)).toEqual(['Top ranked']);
expect(datedHit.get('data').item.map((item) => item.title)).toEqual(['Newest']);
expect(truthyHit.get('data').item.map((item) => item.title)).toEqual(['Newest']);
expect(explicitRank.get('data').item.map((item) => item.title)).toEqual(['Top ranked']);
for (const ctx of [rankedHit, datedHit, truthyHit, explicitRankHit]) {
expect(ctx.res.headers.get('RSSHub-Cache-Status')).toBe('HIT');
expect(ctx.get('data').sortItems).toBe(false);
expect(ctx.get('data').item[0].pubDate).toBeTruthy();
}
expect(fetches).toBe(3);
});
});