test: refactor tests (#22677)

* test: refactor tests

* test: run *.worker.ts unit tests inside workerd

Author: TonyRL

.github/workflows/test.yml

@@ -50,6 +50,8 @@ jobs:
               run: pnpm run vitest:coverage --reporter=github-actions
               env:
                   REDIS_URL: redis://localhost:${{ job.services.redis.ports['6379'] }}/
+            - name: Test worker runtime (workerd)
+              run: pnpm run vitest:workerd
             - name: Upload coverage to Codecov
               if: ${{ matrix.node-version == 'lts/*' }}
               uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f # v7.0.0

lib/api/namespace/all.test.ts

@@ -0,0 +1,22 @@
+import type { Next } from 'hono';
+import { describe, expect, it } from 'vitest';
+
+import { handler as allHandler } from '@/api/namespace/all';
+import { namespaces } from '@/registry';
+
+const noopNext: Next = () => Promise.resolve();
+
+const createCtx = (param: Record<string, string> = {}) =>
+    ({
+        req: {
+            valid: () => param,
+        },
+        json: (data: unknown) => data,
+    }) as any;
+
+describe('api/namespace/all', () => {
+    it('returns all namespaces', async () => {
+        const result = await allHandler(createCtx(), noopNext);
+        expect(result).toBe(namespaces);
+    });
+});

lib/api/namespace.test.ts lib/api/namespace/one.test.tslib/api/namespace.test.ts renamed to lib/api/namespace/one.test.ts

@@ -2,7 +2,6 @@ import type { Next } from 'hono';
 import { describe, expect, it } from 'vitest';
 
 import api from '@/api';
-import { handler as allHandler } from '@/api/namespace/all';
 import { handler as oneHandler } from '@/api/namespace/one';
 import { namespaces } from '@/registry';
 
@@ -16,14 +15,9 @@ const createCtx = (param: Record<string, string> = {}) =>
         json: (data: unknown) => data,
     }) as any;
 
-describe('api/namespace', () => {
+describe('api/namespace/one', () => {
     const nestedKey = Object.keys(namespaces).find((key) => key.includes('/')) as string;
 
-    it('returns all namespaces', async () => {
-        const result = await allHandler(createCtx(), noopNext);
-        expect(result).toBe(namespaces);
-    });
-
     it('returns a single namespace', async () => {
         const result = await oneHandler(createCtx({ namespace: 'test' }), noopNext);
         expect(result).toBe(namespaces.test);

lib/app.test.ts

@@ -1,9 +1,15 @@
+import Parser from 'rss-parser';
 import undici from 'undici';
 import { describe, expect, it, vi } from 'vitest';
 
 import app from '@/app';
+import { config } from '@/config';
 
 describe('index', () => {
+    it('exports app entrypoint', () => {
+        expect(typeof app.request).toBe('function');
+    });
+
     it('serve index', async () => {
         const res = await app.request('/');
         expect(res.status).toBe(200);
@@ -21,3 +27,84 @@ describe('request-rewriter', () => {
         expect(headers.get('user-agent')).toMatch(/Chrome/);
     });
 });
+
+const parser = new Parser();
+
+process.env.ALLOW_USER_SUPPLY_UNSAFE_DOMAIN = 'true';
+
+const routes = {
+    '/test/:id': '/test/1',
+};
+if (process.env.FULL_ROUTES_TEST) {
+    const { namespaces } = await import('@/registry');
+    for (const namespace in namespaces) {
+        for (const route in namespaces[namespace].routes) {
+            const requireConfig = namespaces[namespace].routes[route].features?.requireConfig;
+            let configs;
+            if (typeof requireConfig !== 'boolean') {
+                configs = requireConfig
+                    ?.filter((config) => !config.optional)
+                    .map((config) => config.name)
+                    .filter((name) => name !== 'ALLOW_USER_SUPPLY_UNSAFE_DOMAIN');
+            }
+            if (namespaces[namespace].routes[route].example && !configs?.length) {
+                routes[`/${namespace}${route}`] = namespaces[namespace].routes[route].example;
+            }
+        }
+    }
+}
+
+async function checkRSS(response) {
+    const checkDate = (date) => {
+        expect(date).toEqual(expect.any(String));
+        expect(Date.parse(date)).toEqual(expect.any(Number));
+        expect(Date.now() - +new Date(date)).toBeGreaterThan(-1000 * 60 * 60 * 24 * 5);
+        expect(Date.now() - +new Date(date)).toBeLessThan(1000 * 60 * 60 * 24 * 30 * 12 * 10);
+    };
+
+    const parsed = await parser.parseString(await response.text());
+
+    expect(parsed).toEqual(expect.any(Object));
+    expect(parsed.title).toEqual(expect.any(String));
+    expect(parsed.title).not.toBe('RSSHub');
+    expect(parsed.description).toEqual(expect.any(String));
+    expect(parsed.link).toEqual(expect.any(String));
+    expect(parsed.lastBuildDate).toEqual(expect.any(String));
+    expect(parsed.ttl).toEqual(Math.trunc(config.cache.routeExpire / 60) + '');
+    expect(parsed.items).toEqual(expect.any(Array));
+    checkDate(parsed.lastBuildDate);
+
+    // check items
+    const guids: Array<string | undefined> = [];
+    for (const item of parsed.items) {
+        expect(item).toEqual(expect.any(Object));
+        expect(item.title).toEqual(expect.any(String));
+        expect(item.link).toEqual(expect.any(String));
+        expect(item.content).toEqual(expect.any(String));
+        expect(item.guid).toEqual(expect.any(String));
+        if (item.pubDate) {
+            expect(item.pubDate).toEqual(expect.any(String));
+            checkDate(item.pubDate);
+        }
+
+        // guid must be unique
+        expect(guids).not.toContain(item.guid);
+        guids.push(item.guid);
+    }
+}
+
+describe('routes', () => {
+    for (const route in routes) {
+        it.concurrent(
+            route,
+            {
+                timeout: 60000,
+            },
+            async () => {
+                const response = await app.request(routes[route]);
+                expect(response.status).toBe(200);
+                await checkRSS(response);
+            }
+        );
+    }
+});