mirror of
https://github.com/DIYgod/RSSHub.git
synced 2026-10-18 14:29:01 +08:00
Tony
3bc1cc248d
* chore: bump to msw v3 * refactor: anti-slop * test: use vi.stubEnv for REDIS_URL in redis error test * refactor: move remote debugging registration into a conditional block * chore: add code coverage upload for github
432 lines
17 KiB
TypeScript
432 lines
17 KiB
TypeScript
import fs from 'node:fs';
|
|
import path from 'node:path';
|
|
|
|
import { Hono } from 'hono';
|
|
import { afterEach, assert, describe, expect, it, vi } from 'vitest';
|
|
|
|
import app from '@/app';
|
|
import { config } from '@/config';
|
|
import registryApp, { collectNamespaceRoots, namespaces, resolveModuleNamespace, sortRoutes } from '@/registry';
|
|
import type { Data } from '@/types';
|
|
|
|
// The dev registry lists lib/routes at startup; expose the fixture directory names there
|
|
const fakeTopDirectories = vi.hoisted(() => {
|
|
const names: string[] = [];
|
|
return { names };
|
|
});
|
|
|
|
const fsReaddirSync = fs.readdirSync;
|
|
vi.spyOn(fs, 'readdirSync').mockImplementation(((...args: Parameters<typeof fs.readdirSync>) => {
|
|
if (fakeTopDirectories.names.length > 0 && String(args[0]).endsWith(path.join('lib', 'routes'))) {
|
|
return fakeTopDirectories.names.map((name) => ({ name, isDirectory: () => true }));
|
|
}
|
|
return fsReaddirSync(...args);
|
|
}) as typeof fs.readdirSync);
|
|
|
|
describe('registry', () => {
|
|
// root
|
|
it('/', async () => {
|
|
const response = await app.request('/');
|
|
expect(response.status).toBe(200);
|
|
expect(response.headers.get('content-type')).toBe('text/html; charset=UTF-8');
|
|
expect(response.headers.get('cache-control')).toBe('no-cache');
|
|
});
|
|
|
|
// robots.txt
|
|
it('/robots.txt', async () => {
|
|
config.disallowRobot = false;
|
|
const response404 = await app.request('/robots.txt');
|
|
expect(response404.status).toBe(404);
|
|
|
|
config.disallowRobot = true;
|
|
const response = await app.request('/robots.txt');
|
|
expect(response.status).toBe(200);
|
|
expect(await response.text()).toBe('User-agent: *\nDisallow: /');
|
|
expect(response.headers.get('content-type')).toBe('text/plain; charset=UTF-8');
|
|
});
|
|
|
|
// favicon.ico
|
|
it('/favicon.ico', async () => {
|
|
const response = await app.request('/favicon.ico');
|
|
expect(response.status).toBe(200);
|
|
});
|
|
|
|
// healthz
|
|
it('/healthz', async () => {
|
|
const response = await app.request('/healthz');
|
|
expect(response.status).toBe(200);
|
|
expect(response.headers.get('cache-control')).toBe('no-cache');
|
|
expect(await response.text()).toBe('ok');
|
|
});
|
|
|
|
it('namespaces respects DISABLE_NSFW=true', async () => {
|
|
vi.resetModules();
|
|
vi.stubEnv('DISABLE_NSFW', 'true');
|
|
|
|
const { namespaces } = await import('./registry');
|
|
// @ts-ignore build artifact of pnpm build:routes
|
|
const routesModule = await import('../assets/build/routes.json');
|
|
const rawNamespaces = (routesModule.default ?? routesModule) as Record<string, { routes?: Record<string, { features?: { nsfw?: boolean } }> }>;
|
|
const nsfwNamespaces = Object.entries(rawNamespaces).filter(([, namespace]) => Object.values(namespace.routes ?? {}).some((route) => route.features?.nsfw));
|
|
|
|
// All routes in all namespaces should not have nsfw features
|
|
for (const ns of Object.values(namespaces)) {
|
|
for (const route of Object.values(ns.routes)) {
|
|
expect(route.features?.nsfw).not.toBe(true);
|
|
}
|
|
}
|
|
expect(nsfwNamespaces.length).toBeGreaterThan(0);
|
|
for (const [key] of nsfwNamespaces) {
|
|
expect(namespaces[key]).toBeUndefined();
|
|
}
|
|
});
|
|
|
|
it('namespaces includes NSFW routes when DISABLE_NSFW=false', async () => {
|
|
vi.resetModules();
|
|
vi.stubEnv('DISABLE_NSFW', 'false');
|
|
|
|
const { namespaces } = await import('./registry');
|
|
expect(namespaces['2048']).toBeDefined();
|
|
});
|
|
});
|
|
|
|
describe('namespace-resolution', () => {
|
|
const keys = [
|
|
'/github/namespace.ts',
|
|
'/github/issue.ts',
|
|
'/example/sub/namespace.ts',
|
|
'/example/sub/news.ts',
|
|
'/example/flat/typical.ts',
|
|
'/example/nested/namespace.ts',
|
|
'/example/nested/zzb.ts',
|
|
'/example/nested/deep/namespace.ts',
|
|
'/example/nested/deep/zwfw.ts',
|
|
];
|
|
const roots = collectNamespaceRoots(keys);
|
|
|
|
it('collects directories containing namespace.ts', () => {
|
|
expect(roots).toEqual(new Set(['github', 'example/sub', 'example/nested', 'example/nested/deep']));
|
|
});
|
|
|
|
it('resolves a flat module to its top directory', () => {
|
|
expect(resolveModuleNamespace('/github/issue.ts', roots)).toEqual({ namespace: 'github', location: 'issue.ts' });
|
|
});
|
|
|
|
it('resolves a nested module to its namespace root', () => {
|
|
expect(resolveModuleNamespace('/example/sub/news.ts', roots)).toEqual({ namespace: 'example/sub', location: 'news.ts' });
|
|
});
|
|
|
|
it('prefers the deepest matching root', () => {
|
|
expect(resolveModuleNamespace('/example/nested/deep/zwfw.ts', roots)).toEqual({ namespace: 'example/nested/deep', location: 'zwfw.ts' });
|
|
expect(resolveModuleNamespace('/example/nested/zzb.ts', roots)).toEqual({ namespace: 'example/nested', location: 'zzb.ts' });
|
|
});
|
|
|
|
it('falls back to the first segment when no root matches', () => {
|
|
expect(resolveModuleNamespace('/example/flat/typical.ts', roots)).toEqual({ namespace: 'example', location: 'flat/typical.ts' });
|
|
});
|
|
|
|
it('resolves namespace.ts itself to its own root', () => {
|
|
expect(resolveModuleNamespace('/example/sub/namespace.ts', roots)).toEqual({ namespace: 'example/sub', location: 'namespace.ts' });
|
|
});
|
|
});
|
|
|
|
describe('nested namespace mounting', () => {
|
|
it('registers deeper namespaces before shallower ones', () => {
|
|
const keys = Object.keys(namespaces).filter((key) => Object.keys(namespaces[key].routes ?? {}).length > 0);
|
|
const byDepth = keys.toSorted((a, b) => b.split('/').length - a.split('/').length);
|
|
const deep = byDepth[0];
|
|
const shallow = byDepth.at(-1);
|
|
assert(shallow);
|
|
expect(deep.split('/').length).toBeGreaterThan(shallow.split('/').length);
|
|
|
|
const paths = registryApp.routes.map((r) => r.path);
|
|
const deepIndex = paths.indexOf(`/${deep}${Object.keys(namespaces[deep].routes)[0]}`);
|
|
const shallowIndex = paths.indexOf(`/${shallow}${Object.keys(namespaces[shallow].routes)[0]}`);
|
|
expect(deepIndex).toBeGreaterThanOrEqual(0);
|
|
expect(shallowIndex).toBeGreaterThanOrEqual(0);
|
|
expect(deepIndex).toBeLessThan(shallowIndex);
|
|
});
|
|
});
|
|
|
|
const sortPaths = (paths: string[]) => sortRoutes(Object.fromEntries(paths.map((path) => [path, { path, name: path, maintainers: [], example: path, handler: () => null, location: path }]))).map(([path]) => path);
|
|
const permutations = (items: string[]): string[][] => (items.length <= 1 ? [items] : items.flatMap((item, i) => permutations(items.toSpliced(i, 1)).map((rest) => [item, ...rest])));
|
|
|
|
describe('sortRoutes', () => {
|
|
it('sorts regex-constrained params before plain params', () => {
|
|
expect(sortPaths(['/:category?', '/:id{[0-9]+}', '/static'])).toEqual(['/static', '/:id{[0-9]+}', '/:category?']);
|
|
});
|
|
|
|
// sehuatang, https://github.com/DIYgod/RSSHub/issues/18335
|
|
it('sorts literal segments before params when an empty path is present', () => {
|
|
expect(sortPaths(['/bt/:subforumid?', '/picture/:subforumid', '/:subforumid?/:type?', '/:subforumid?', '', '/user/:uid'])).toEqual([
|
|
'',
|
|
'/bt/:subforumid?',
|
|
'/picture/:subforumid',
|
|
'/user/:uid',
|
|
'/:subforumid?',
|
|
'/:subforumid?/:type?',
|
|
]);
|
|
});
|
|
|
|
// gcores
|
|
it('sorts literal segments before params among unrelated literal routes', () => {
|
|
expect(
|
|
sortPaths([
|
|
'/radios/:category?',
|
|
'/users/:id/radios',
|
|
'/users/:id/talks',
|
|
'/articles',
|
|
'/categories/:id/:tab?',
|
|
'/collections/:id/:tab?',
|
|
'/news',
|
|
'/radios/preview',
|
|
'/tags/:id/:tab?',
|
|
'/topics/:id/recommend',
|
|
'/topics/recommend',
|
|
'/videos',
|
|
])
|
|
).toEqual([
|
|
'/articles',
|
|
'/news',
|
|
'/videos',
|
|
'/radios/preview',
|
|
'/topics/recommend',
|
|
'/radios/:category?',
|
|
'/users/:id/radios',
|
|
'/users/:id/talks',
|
|
'/topics/:id/recommend',
|
|
'/categories/:id/:tab?',
|
|
'/collections/:id/:tab?',
|
|
'/tags/:id/:tab?',
|
|
]);
|
|
});
|
|
|
|
it('sorts the path that runs out of segments first unless it ends with a regex param', () => {
|
|
expect(sortPaths(['/news/:category?', '/news'])).toEqual(['/news', '/news/:category?']);
|
|
// discuz: `.+` spans segments, so `/:link{.+}` would shadow the longer paths
|
|
expect(sortPaths(['/:link{.+}', '/:ver{[7x]}/:link{.+}', '/:ver{[7x]}/:cid{[0-9]{2}}/:link{.+}'])).toEqual(['/:ver{[7x]}/:cid{[0-9]{2}}/:link{.+}', '/:ver{[7x]}/:link{.+}', '/:link{.+}']);
|
|
});
|
|
|
|
it('does not depend on the input order', () => {
|
|
const expected = ['', '/radios/preview', '/user/:uid', '/:subforumid?', '/:subforumid?/:type?'];
|
|
for (const paths of permutations(expected)) {
|
|
expect(sortPaths(paths)).toEqual(expected);
|
|
}
|
|
});
|
|
});
|
|
|
|
type FakeRouteModule = {
|
|
route: {
|
|
path: string | string[];
|
|
name: string;
|
|
handler?: () => Data;
|
|
module?: () => Promise<{ route: { handler: () => Response } }>;
|
|
};
|
|
};
|
|
|
|
type FakeApiRouteModule = {
|
|
apiRoute: {
|
|
path: string;
|
|
name: string;
|
|
handler?: () => { ok: boolean };
|
|
module?: () => Promise<{ apiRoute: { handler: () => { ok: boolean } } }>;
|
|
};
|
|
};
|
|
|
|
const perDirectoryMock = (fakeDirectories: Record<string, Record<string, FakeRouteModule | FakeApiRouteModule>>) => {
|
|
fakeTopDirectories.names = Object.keys(fakeDirectories);
|
|
return vi.fn(({ targetDirectoryPath }: { targetDirectoryPath: string }) => {
|
|
const name = path.basename(targetDirectoryPath);
|
|
return Promise.resolve(fakeDirectories[name]);
|
|
});
|
|
};
|
|
|
|
const wrap = (registry: Hono) => {
|
|
const app = new Hono<{ Variables: { data: Data; apiData: { ok: boolean } | { code: number } } }>();
|
|
app.use(async (ctx, next) => {
|
|
const response = await next();
|
|
const apiData = ctx.get('apiData');
|
|
if (apiData) {
|
|
return ctx.json(apiData);
|
|
}
|
|
const data = ctx.get('data');
|
|
if (data) {
|
|
return ctx.json(data);
|
|
}
|
|
return response;
|
|
});
|
|
app.route('/', registry);
|
|
return app;
|
|
};
|
|
|
|
describe('registry dynamic loading', () => {
|
|
afterEach(() => {
|
|
fakeTopDirectories.names = [];
|
|
});
|
|
|
|
it('loads production namespaces from build', async () => {
|
|
const originalEnv = process.env.NODE_ENV;
|
|
process.env.NODE_ENV = 'production';
|
|
vi.resetModules();
|
|
|
|
const { namespaces } = await import('@/registry');
|
|
expect(Object.keys(namespaces).length).toBeGreaterThan(0);
|
|
|
|
process.env.NODE_ENV = originalEnv;
|
|
});
|
|
|
|
it('lazily builds namespaces from directory import on first request', async () => {
|
|
const originalEnv = process.env.NODE_ENV;
|
|
process.env.NODE_ENV = 'development';
|
|
|
|
const directoryImportMock = perDirectoryMock({
|
|
nsRoute: {
|
|
'/route-array.ts': {
|
|
route: {
|
|
path: ['/a', '/b'],
|
|
name: 'Array',
|
|
handler: () => ({ title: 'array', link: 'https://example.com', item: [], allowEmpty: true }),
|
|
},
|
|
},
|
|
'/route-single.ts': {
|
|
route: {
|
|
path: '/single',
|
|
name: 'Single',
|
|
handler: () => ({ title: 'ok', link: 'https://example.com', item: [], allowEmpty: true }),
|
|
},
|
|
},
|
|
},
|
|
nsModule: {
|
|
'/route-module.ts': {
|
|
route: {
|
|
path: '/module',
|
|
name: 'Module',
|
|
module: () =>
|
|
Promise.resolve({
|
|
route: {
|
|
handler: () => new Response('module'),
|
|
},
|
|
}),
|
|
},
|
|
},
|
|
},
|
|
nsApi: {
|
|
'/api-single.ts': {
|
|
apiRoute: {
|
|
path: '/single',
|
|
name: 'ApiSingle',
|
|
handler: () => ({ ok: true }),
|
|
},
|
|
},
|
|
'/api-module.ts': {
|
|
apiRoute: {
|
|
path: '/module',
|
|
name: 'ApiModule',
|
|
module: () =>
|
|
Promise.resolve({
|
|
apiRoute: {
|
|
handler: () => ({ ok: true }),
|
|
},
|
|
}),
|
|
},
|
|
},
|
|
},
|
|
test: {
|
|
'/api-index.ts': {
|
|
apiRoute: {
|
|
path: '/',
|
|
name: 'ApiIndex',
|
|
},
|
|
},
|
|
},
|
|
});
|
|
vi.doMock('@/utils/directory-import', () => ({
|
|
directoryImport: directoryImportMock,
|
|
}));
|
|
vi.resetModules();
|
|
const { namespaces, default: registry } = await import('@/registry');
|
|
|
|
// The cold-start guarantee: importing the registry imports no route modules
|
|
expect(directoryImportMock).not.toHaveBeenCalled();
|
|
|
|
const app = wrap(registry);
|
|
|
|
const routeResponse = await app.request('/nsModule/module');
|
|
expect(await routeResponse.text()).toBe('module');
|
|
expect(directoryImportMock).toHaveBeenCalledTimes(1);
|
|
|
|
const singleResponse = await app.request('/nsRoute/single');
|
|
const singleBody = await singleResponse.json();
|
|
expect(singleBody.title).toBe('ok');
|
|
expect(namespaces.nsRoute.routes['/single']).toBeDefined();
|
|
expect(namespaces.nsRoute.routes['/a']).toBeDefined();
|
|
|
|
const apiResponse = await app.request('/api/nsApi/module');
|
|
const apiBody = await apiResponse.json();
|
|
expect(apiBody).toEqual({ ok: true });
|
|
expect(namespaces.nsApi.apiRoutes['/single']).toBeDefined();
|
|
|
|
// Handler resolution from disk in test env (real file lib/routes/test/api-index.ts)
|
|
process.env.NODE_ENV = 'test';
|
|
const apiTestResponse = await app.request('/api/test');
|
|
expect(await apiTestResponse.json()).toEqual({ code: 0 });
|
|
|
|
process.env.NODE_ENV = originalEnv;
|
|
vi.doUnmock('@/utils/directory-import');
|
|
});
|
|
|
|
// https://github.com/DIYgod/RSSHub/pull/18002
|
|
it('prioritizes literal segments over parameter segments in route matching', async () => {
|
|
const originalEnv = process.env.NODE_ENV;
|
|
process.env.NODE_ENV = 'development';
|
|
|
|
const directoryImportMock = perDirectoryMock({
|
|
specificity: {
|
|
'/param-route.ts': {
|
|
route: {
|
|
path: '/:category',
|
|
name: 'ParamRoute',
|
|
handler: () => ({ title: 'param', link: 'https://example.com', item: [], allowEmpty: true }),
|
|
},
|
|
},
|
|
'/literal-route.ts': {
|
|
route: {
|
|
path: '/news/:channel',
|
|
name: 'LiteralRoute',
|
|
handler: () => ({ title: 'literal', link: 'https://example.com', item: [], allowEmpty: true }),
|
|
},
|
|
},
|
|
'/news-route.ts': {
|
|
route: {
|
|
path: '/news',
|
|
name: 'NewsRoute',
|
|
handler: () => ({ title: 'news', link: 'https://example.com', item: [], allowEmpty: true }),
|
|
},
|
|
},
|
|
},
|
|
});
|
|
vi.doMock('@/utils/directory-import', () => ({
|
|
directoryImport: directoryImportMock,
|
|
}));
|
|
vi.resetModules();
|
|
const { default: registry } = await import('@/registry');
|
|
|
|
const app = wrap(registry);
|
|
|
|
// /news/sports should match /news/:channel (literal "news" wins over :category)
|
|
const literalResponse = await app.request('/specificity/news/sports');
|
|
expect((await literalResponse.json()).title).toBe('literal');
|
|
|
|
// /news should match /news (literal wins over :category)
|
|
const newsResponse = await app.request('/specificity/news');
|
|
expect((await newsResponse.json()).title).toBe('news');
|
|
|
|
// /products should match /:category
|
|
const paramResponse = await app.request('/specificity/products');
|
|
expect((await paramResponse.json()).title).toBe('param');
|
|
|
|
process.env.NODE_ENV = originalEnv;
|
|
vi.doUnmock('@/utils/directory-import');
|
|
});
|
|
});
|