rsshub 1.0.0-master.fc1b99f → 1.0.0-master.fc2cf18

package/lib/utils/request-rewriter.test.ts

@@ -0,0 +1,151 @@
+import { describe, expect, it, vi } from 'vitest';
+import undici from 'undici';
+import got from 'got';
+import http from 'node:http';
+
+process.env.PROXY_URI = 'http://rsshub.proxy:2333/';
+process.env.PROXY_AUTH = 'rsshubtest';
+process.env.PROXY_URL_REGEX = 'headers';
+
+await import('@/utils/request-rewriter');
+const { config } = await import('@/config');
+const { default: ofetch } = await import('@/utils/ofetch');
+
+describe('request-rewriter', () => {
+    it('fetch', async () => {
+        const fetchSpy = vi.spyOn(undici, 'fetch');
+
+        try {
+            await (await fetch('http://rsshub.test/headers')).json();
+        } catch {
+            // ignore
+        }
+
+        // headers
+        const headers: Headers = fetchSpy.mock.lastCall?.[0].headers;
+        expect(headers.get('user-agent')).toBe(config.ua);
+        expect(headers.get('accept')).toBe('*/*');
+        expect(headers.get('referer')).toBe('http://rsshub.test');
+
+        // proxy
+        const options = fetchSpy.mock.lastCall?.[1];
+        const agentKey = Object.getOwnPropertySymbols(options?.dispatcher).find((s) => s.description === 'proxy agent options');
+        const agentUri = agentKey ? options?.dispatcher?.[agentKey].uri : null;
+        expect(agentUri).toBe(process.env.PROXY_URI);
+
+        // proxy auth
+        const headersKey = Object.getOwnPropertySymbols(options?.dispatcher).find((s) => s.description === 'proxy headers');
+        const agentHeaders = headersKey ? options?.dispatcher?.[headersKey] : null;
+        expect(agentHeaders['proxy-authorization']).toBe(`Basic ${process.env.PROXY_AUTH}`);
+
+        // url regex not match
+        {
+            try {
+                await (await fetch('http://rsshub.test/rss')).json();
+            } catch {
+                // ignore
+            }
+            const options = fetchSpy.mock.lastCall?.[1];
+            expect(options?.dispatcher).toBeUndefined();
+        }
+    });
+
+    it('ofetch', async () => {
+        const fetchSpy = vi.spyOn(undici, 'fetch');
+
+        try {
+            await ofetch('http://rsshub.test/headers', {
+                retry: 0,
+            });
+        } catch {
+            // ignore
+        }
+
+        // headers
+        const headers: Headers = fetchSpy.mock.lastCall?.[0].headers;
+        expect(headers.get('user-agent')).toBe(config.ua);
+        expect(headers.get('accept')).toBe('*/*');
+        expect(headers.get('referer')).toBe('http://rsshub.test');
+
+        // proxy
+        const options = fetchSpy.mock.lastCall?.[1];
+        const agentKey = Object.getOwnPropertySymbols(options?.dispatcher).find((s) => s.description === 'proxy agent options');
+        const agentUri = agentKey ? options?.dispatcher?.[agentKey].uri : null;
+        expect(agentUri).toBe(process.env.PROXY_URI);
+
+        // proxy auth
+        const headersKey = Object.getOwnPropertySymbols(options?.dispatcher).find((s) => s.description === 'proxy headers');
+        const agentHeaders = headersKey ? options?.dispatcher?.[headersKey] : null;
+        expect(agentHeaders['proxy-authorization']).toBe(`Basic ${process.env.PROXY_AUTH}`);
+
+        // url regex not match
+        {
+            try {
+                await ofetch('http://rsshub.test/rss', {
+                    retry: 0,
+                });
+            } catch {
+                // ignore
+            }
+            const options = fetchSpy.mock.lastCall?.[1];
+            expect(options?.dispatcher).toBeUndefined();
+        }
+    });
+
+    it('http', async () => {
+        const httpSpy = vi.spyOn(http, 'request');
+
+        try {
+            await got.get('http://rsshub.test/headers', {
+                headers: {
+                    'user-agent': undefined,
+                    accept: undefined,
+                },
+            });
+        } catch {
+            // ignore
+        }
+
+        // headers
+        const options = httpSpy.mock.lastCall?.[1];
+        const headers = options?.headers;
+        expect(headers?.['user-agent']).toBe(config.ua);
+        expect(headers?.accept).toBe('*/*');
+        expect(headers?.referer).toBe('http://rsshub.test');
+
+        // proxy
+        const agentUri = options?.agent?.proxy?.href;
+        expect(agentUri).toBe(process.env.PROXY_URI);
+        expect(options?.agent?.proxyHeaders['proxy-authorization']).toBe(`Basic ${process.env.PROXY_AUTH}`);
+
+        // url regex not match
+        {
+            try {
+                await got.get('http://rsshub.test/rss', {
+                    headers: {
+                        'user-agent': undefined,
+                        accept: undefined,
+                    },
+                });
+            } catch {
+                // ignore
+            }
+            const options = httpSpy.mock.lastCall?.[1];
+            expect(options?.agent).toBeUndefined();
+        }
+    });
+
+    it('rate limiter', async () => {
+        const time = Date.now();
+        await Promise.all(
+            Array.from({ length: 20 }).map(async () => {
+                try {
+                    await fetch('http://rsshub.test/headers');
+                } catch {
+                    // ignore
+                }
+            })
+        );
+        expect(Date.now() - time).toBeGreaterThan(1500);
+    });
+});

package/lib/utils/rss-parser.test.ts

@@ -1,17 +1,9 @@
 import { describe, expect, it } from 'vitest';
 import parser from '@/utils/rss-parser';
-import { config } from '@/config';
-import nock from 'nock';
 
-describe('got', () => {
-    it('headers', async () => {
-        nock('http://rsshub.test')
-            .get('/test')
-            .reply(function () {
-                expect(this.req.headers['user-agent']).toBe(config.ua);
-                return [200, '<rss version="2.0"><channel><item></item></channel></rss>'];
-            });
-
-        await parser.parseURL('http://rsshub.test/test');
+describe('rss-parser', () => {
+    it('rss', async () => {
+        const result = await parser.parseURL('http://rsshub.test/rss');
+        expect(result).toBeTruthy();
     });
 });

package/lib/utils/timezone.ts

@@ -3,7 +3,7 @@ import { strict as assert } from 'assert';
 const millisInAnHour = 60 * 60 * 1000;
 const serverTimezone = -new Date().getTimezoneOffset() / 60;
 
-export default function (date, timezone = serverTimezone) {
+export default function timezone(date, timezone = serverTimezone) {
     if (typeof date === 'string') {
         date = new Date(date);
     }

package/lib/utils/wechat-mp.test.ts

@@ -1,7 +1,29 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi, afterEach } from 'vitest';
 import { load } from 'cheerio';
-import nock from 'nock';
-import { fixArticleContent, fetchArticle, finishArticleItem, normalizeUrl } from '@/utils/wechat-mp';
+import Parser from 'rss-parser';
+import InvalidParameterError from '@/errors/types/invalid-parameter';
+import { exportedForTestingOnly, WeChatMpError, fetchArticle, finishArticleItem, fixArticleContent, normalizeUrl } from '@/utils/wechat-mp';
+const { toggleWerror, ExtractMetadata, showTypeMapReverse } = exportedForTestingOnly;
+
+vi.mock('@/utils/request-rewriter', () => ({ default: null }));
+const { default: app } = await import('@/app');
+const parser = new Parser();
+
+afterEach(() => toggleWerror(false));
+
+const expectedItem: {
+    title: string;
+    summary: string;
+    author: string;
+    mpName: string;
+    link: string;
+} = {
+    title: 'title',
+    summary: 'summary',
+    author: 'author',
+    mpName: 'mpName',
+    link: '', // to be filled
+};
 
 // date from the cache will be an ISO8601 string, so we need to use this function
 const compareDate = (date1, date2) => {
@@ -9,8 +31,227 @@ const compareDate = (date1, date2) => {
     date2 = typeof date2 === 'string' ? new Date(date2) : date2;
     return date1.getTime() === date2.getTime();
 };
+const genScriptHtmlStr = (script: string) => `
+    <html lang="">
+        <script type="text/javascript" nonce="123456789">
+        ${script}
+        </script>
+    </html>
+`;
+const testFetchArticleFinishArticleItem = async (path: string, { setMpNameAsAuthor = false, skipLink = false } = {}) => {
+    const ct = 1_636_626_300;
+    const httpsUrl = `https://mp.weixin.qq.com/rsshub_test${path}`;
+    const httpUrl = 'http' + httpsUrl.slice(5);
+
+    const expectedDate = new Date(ct * 1000);
+
+    const expectedItem_ = {
+        ...expectedItem,
+        link: httpsUrl,
+    };
+
+    const fetchArticleItem = await fetchArticle(httpUrl);
+    expect(compareDate(fetchArticleItem.pubDate, expectedDate)).toBe(true);
+    expect(fetchArticleItem).toMatchObject(expectedItem_);
+
+    const ToBeFinishedArticleItem = { link: httpUrl };
+    const expectedFinishedArticleItem = { ...fetchArticleItem };
+    expectedFinishedArticleItem.author = setMpNameAsAuthor ? <string>expectedFinishedArticleItem.mpName : expectedFinishedArticleItem.author;
+    expectedFinishedArticleItem.link = skipLink ? ToBeFinishedArticleItem.link : expectedFinishedArticleItem.link;
+
+    const finishedArticleItem = await finishArticleItem(ToBeFinishedArticleItem, setMpNameAsAuthor, skipLink);
+    expect(compareDate(finishedArticleItem.pubDate, fetchArticleItem.pubDate)).toBe(true);
+    delete expectedFinishedArticleItem.pubDate;
+    expect(finishedArticleItem).toMatchObject(expectedFinishedArticleItem);
+
+    return fetchArticleItem;
+};
 
 describe('wechat-mp', () => {
+    it('ExtractMetadata.common', () => {
+        expect(ExtractMetadata.common(load(''))).toStrictEqual({});
+
+        expect(
+            ExtractMetadata.common(
+                load(
+                    genScriptHtmlStr(`
+            window.fake_item_show_type = '5' || '';
+            window.fake_real_item_show_type = '5' || '';
+            window.fake_ct = '1713009660' || '';
+        `)
+                )
+            )
+        ).toMatchObject({});
+
+        expect(
+            ExtractMetadata.common(
+                load(
+                    genScriptHtmlStr(`
+            window.item_show_type = '5' || '';
+            window.real_item_show_type = '5' || '';
+            window.ct = '1713009660' || '';
+        `)
+                )
+            )
+        ).toMatchObject({
+            showType: showTypeMapReverse['5'],
+            realShowType: showTypeMapReverse['5'],
+            createTime: '1713009660',
+        });
+
+        expect(
+            ExtractMetadata.common(
+                load(
+                    genScriptHtmlStr(`
+            var item_show_type = "5";
+            var real_item_show_type = "5";
+            var ct = "1713009660";
+            var msg_source_url = 'https://mp.weixin.qq.com/rsshub_test/fake';
+        `)
+                )
+            )
+        ).toMatchObject({
+            showType: showTypeMapReverse['5'],
+            realShowType: showTypeMapReverse['5'],
+            createTime: '1713009660',
+            sourceUrl: 'https://mp.weixin.qq.com/rsshub_test/fake',
+        });
+
+        expect(
+            ExtractMetadata.common(
+                load(
+                    genScriptHtmlStr(`
+            var item_show_type = "998877665544332211";
+            var real_item_show_type = "112233445566778899";
+            var ct = "1713009660";
+        `)
+                )
+            )
+        ).toMatchObject({
+            showType: '998877665544332211',
+            realShowType: '112233445566778899',
+            createTime: '1713009660',
+        });
+    });
+    it('ExtractMetadata.img', () => {
+        expect(ExtractMetadata.img(load(''))).toStrictEqual({});
+
+        expect(
+            ExtractMetadata.img(
+                load(
+                    genScriptHtmlStr(`
+            window.picture_page_info_list = [
+            {
+              cdn_url: 'https://mmbiz.qpic.cn/rsshub_test/fake_img_1/0?wx_fmt=jpeg',
+            },
+            {
+              cdn_url: 'https://mmbiz.qpic.cn/rsshub_test/fake_img_2/0?wx_fmt=jpeg',
+            },
+            ].slice(0, 20);
+        `)
+                )
+            )
+        ).toMatchObject({
+            imgUrls: ['https://mmbiz.qpic.cn/rsshub_test/fake_img_1/0?wx_fmt=jpeg', 'https://mmbiz.qpic.cn/rsshub_test/fake_img_2/0?wx_fmt=jpeg'],
+        });
+    });
+    it('ExtractMetadata.audio', () => {
+        expect(ExtractMetadata.audio(load(''))).toStrictEqual({});
+
+        expect(
+            ExtractMetadata.audio(
+                load(
+                    genScriptHtmlStr(`
+            reportOpt = {
+              voiceid: "",
+              uin: "",
+              biz: "",
+              mid: "",
+              idx: ""
+            };
+        `)
+                )
+            )
+        ).toMatchObject({});
+
+        expect(
+            ExtractMetadata.audio(
+                load(
+                    genScriptHtmlStr(`
+            window.cgiData = {
+              voiceid: "rsshub_test_voiceid_1",
+              duration: "6567" * 1,
+            };
+        `)
+                )
+            )
+        ).toMatchObject({
+            voiceId: 'rsshub_test_voiceid_1',
+            duration: '6567',
+        });
+
+        expect(
+            ExtractMetadata.audio(
+                load(
+                    genScriptHtmlStr(`
+            window.cgiData = {
+              voiceid: "rsshub_test_voiceid_1",
+            };
+        `)
+                )
+            )
+        ).toMatchObject({
+            voiceId: 'rsshub_test_voiceid_1',
+            duration: null,
+        });
+
+        expect(
+            ExtractMetadata.audio(
+                load(
+                    genScriptHtmlStr(`
+            reportOpt = {
+              voiceid: "",
+              uin: "",
+              biz: "",
+              mid: "",
+              idx: ""
+            };
+            window.cgiData = {
+              voiceid: "rsshub_test_voiceid_1",
+              duration: "6567" * 1,
+            };
+        `)
+                )
+            )
+        ).toMatchObject({
+            voiceId: 'rsshub_test_voiceid_1',
+            duration: '6567',
+        });
+    });
+    it('ExtractMetadata.location', () => {
+        expect(ExtractMetadata.location(load(''))).toStrictEqual({});
+
+        expect(
+            ExtractMetadata.location(
+                load(
+                    genScriptHtmlStr(`
+            window.ip_wording = {
+              countryName: '中国',
+              countryId: '156',
+              provinceName: '广东',
+              provinceId: '',
+              cityName: '',
+              cityId: ''
+            };
+        `)
+                )
+            )
+        ).toMatchObject({
+            countryName: '中国',
+            provinceName: '广东',
+            cityName: '',
+        });
+    });
     it('fixArticleContent', () => {
         const divHeader = '<div class="rich_media_content " id="js_content">';
         const divFooter = '</div>';
@@ -85,57 +326,178 @@ describe('wechat-mp', () => {
         expect(normalizeUrl(somethingElseWithHash.replace('https://', 'http://'))).toBe(somethingElse);
 
         const notWechatMp = 'https://im.not.wechat.mp/and/an/error/is/expected';
-        expect(() => normalizeUrl(notWechatMp)).toThrow();
+        expect(() => normalizeUrl(notWechatMp)).toThrow('URL host must be "mp.weixin.qq.com"');
         expect(normalizeUrl(notWechatMp, true)).toBe(notWechatMp);
+
+        const unknownSearchParam = mpArticleRoot + '?unknown=param';
+        toggleWerror(false);
+        expect(normalizeUrl(unknownSearchParam)).toBe(unknownSearchParam);
+        toggleWerror(true);
+        expect(() => normalizeUrl(unknownSearchParam)).toThrow('WarningAsError: unknown URL search parameters');
+
+        const unknownPath = mpRoot + '/unknown/path';
+        toggleWerror(false);
+        expect(normalizeUrl(unknownPath)).toBe(unknownPath);
+        toggleWerror(true);
+        expect(() => normalizeUrl(unknownPath, true)).toThrow('WarningAsError: unknown URL path');
+
+        const ampEscapedUrl = longUrl.replaceAll('&', '&amp;');
+        expect(normalizeUrl(ampEscapedUrl)).toBe(longUrlShortened);
     });
 
-    it('fetchArticle_&_finishArticleItem', async () => {
-        const ct = 1_636_626_300;
-        const exampleMpArticlePage =
-            '\n' +
-            '<meta name="description" content="summary" />\n' +
-            '<meta name="author" content="author" />\n' +
-            '<meta property="og:title" content="title" />\n' +
-            '<meta property="twitter:card" content="summary" />\n' +
-            '<div class="rich_media_content" id="js_content" style="visibility: hidden;">description</div>\n' +
-            '<div class="profile_inner"><strong class="profile_nickname">mpName</strong></div>\n' +
-            '<script type="text/javascript" nonce="000000000">\n' +
-            'var appmsg_type = "9";\n' +
-            `var ct = "${ct}";\n` +
-            '</script>';
-
-        nock('https://mp.weixin.qq.com')
-            .get('/rsshub_test/wechatMp_fetchArticle')
-            .reply(() => [200, exampleMpArticlePage]);
-        const httpsUrl = 'https://mp.weixin.qq.com/rsshub_test/wechatMp_fetchArticle';
-        const httpUrl = httpsUrl.replace(/^https:\/\//, 'http://');
-
-        const expectedItem: {
-            title: string;
-            summary: string;
-            author: string;
-            description: string;
-            mpName?: string;
-            link: string;
-        } = {
+    it('fetchArticle_&_finishArticleItem_appMsg', async () => {
+        const fetchArticleItem = await testFetchArticleFinishArticleItem('/appMsg');
+        const $ = load(fetchArticleItem.description);
+        expect($('iframe').attr()).toMatchObject({
+            src:
+                'https://v.qq.com/txp/iframe/player.html?origin=https%3A%2F%2Fmp.weixin.qq.com' +
+                '&containerId=js_tx_video_container_0.3863487104715233&vid=fake&width=677&height=380.8125' +
+                '&autoplay=false&allowFullScreen=true&chid=17&full=true&show1080p=false&isDebugIframe=false',
+            width: '677',
+            height: '380.8125',
+        });
+        expect($('audio').attr()).toMatchObject({
+            src: 'https://res.wx.qq.com/voice/getvoice?mediaid=rsshub_test',
             title: 'title',
-            summary: 'summary',
-            author: 'author',
-            description: 'description',
-            mpName: 'mpName',
-            link: httpsUrl,
+        });
+        expect($('a').attr()).toMatchObject({
+            href: 'https://mp.weixin.qq.com/rsshub_test/fake',
+        });
+        expect(fetchArticleItem.description).toContain('description');
+        expect(fetchArticleItem.description).toContain('📍发表于：中国 福建');
+        expect(fetchArticleItem.description).toContain('🔗️ 阅读原文');
+    });
+
+    it('fetchArticle_&_finishArticleItem_img', async () => {
+        const fetchArticleItem = await testFetchArticleFinishArticleItem('/img');
+        const $ = load(fetchArticleItem.description);
+        expect($.text()).toBe('summary');
+        expect($('img:nth-of-type(1)').attr()).toMatchObject({
+            src: 'https://mmbiz.qpic.cn/rsshub_test/fake_img_1/0?wx_fmt=jpeg',
+        });
+        expect($('img:nth-of-type(2)').attr()).toMatchObject({
+            src: 'https://mmbiz.qpic.cn/rsshub_test/fake_img_2/0?wx_fmt=jpeg',
+        });
+    });
+
+    it('fetchArticle_&_finishArticleItem_audio', async () => {
+        const fetchArticleItem = await testFetchArticleFinishArticleItem('/audio');
+        const $ = load(fetchArticleItem.description);
+        expect($.text()).toBe('summary');
+        expect($('audio').attr()).toMatchObject({
+            controls: '',
+            src: 'https://res.wx.qq.com/voice/getvoice?mediaid=rsshub_test_voiceid_1',
+            style: 'width:100%',
+            title: 'title',
+        });
+        expect(fetchArticleItem).toMatchObject({
+            enclosure_type: 'audio/mp3',
+            enclosure_url: 'https://res.wx.qq.com/voice/getvoice?mediaid=rsshub_test_voiceid_1',
+            itunes_duration: '6567',
+        });
+    });
+
+    it('fetchArticle_&_finishArticleItem_video', async () => {
+        const fetchArticleItem = await testFetchArticleFinishArticleItem('/video');
+        const $ = load(fetchArticleItem.description);
+        expect($.text()).toBe('summary');
+        expect($('img').attr()).toMatchObject({
+            src: 'https://mmbiz.qpic.cn/rsshub_test/og_img_1/0?wx_fmt=jpeg',
+        });
+    });
+
+    it('fetchArticle_&_finishArticleItem_fallback', async () => {
+        const fetchArticleItem = await testFetchArticleFinishArticleItem('/fallback');
+        const $ = load(fetchArticleItem.description);
+        expect($.text()).toBe('summary');
+        expect($('img').attr()).toMatchObject({
+            src: 'https://mmbiz.qpic.cn/rsshub_test/og_img_1/0?wx_fmt=jpeg',
+        });
+    });
+
+    it('finishArticleItem_param', async () => {
+        await testFetchArticleFinishArticleItem('/fallback', { setMpNameAsAuthor: false, skipLink: false });
+        await testFetchArticleFinishArticleItem('/fallback', { setMpNameAsAuthor: true, skipLink: false });
+        await testFetchArticleFinishArticleItem('/fallback', { setMpNameAsAuthor: false, skipLink: true });
+        await testFetchArticleFinishArticleItem('/fallback', { setMpNameAsAuthor: true, skipLink: true });
+    });
+
+    it('hit_waf', async () => {
+        try {
+            await fetchArticle('https://mp.weixin.qq.com/s/rsshub_test_hit_waf');
+            expect.unreachable('Should throw an error');
+        } catch (error) {
+            expect(error).toBeInstanceOf(WeChatMpError);
+            expect((<WeChatMpError>error).message).not.toContain('console.log');
+            expect((<WeChatMpError>error).message).not.toContain('.style');
+            expect((<WeChatMpError>error).message).not.toContain('Consider raise an issue');
+            expect((<WeChatMpError>error).message).toContain('request blocked by WAF:');
+            expect((<WeChatMpError>error).message).toContain('/mp/rsshub_test/waf');
+            expect((<WeChatMpError>error).message).toContain('Title');
+            expect((<WeChatMpError>error).message).toContain('环境异常');
+        }
+    });
+
+    it('unknown_page', async () => {
+        const unknownPageUrl = 'https://mp.weixin.qq.com/s/unknown_page';
+        try {
+            await fetchArticle(unknownPageUrl);
+            expect.unreachable('Should throw an error');
+        } catch (error) {
+            expect(error).toBeInstanceOf(WeChatMpError);
+            expect((<WeChatMpError>error).message).not.toContain('console.log');
+            expect((<WeChatMpError>error).message).not.toContain('.style');
+            expect((<WeChatMpError>error).message).toContain('Consider raise an issue');
+            expect((<WeChatMpError>error).message).toContain('unknown page,');
+            expect((<WeChatMpError>error).message).toContain('Title Unknown paragraph');
+            expect((<WeChatMpError>error).message).toContain(unknownPageUrl);
+        }
+    });
+
+    it('deleted_page', async () => {
+        const deletedPageUrl = 'https://mp.weixin.qq.com/s/deleted_page';
+
+        try {
+            await fetchArticle(deletedPageUrl);
+            expect.unreachable('Should throw an error');
+        } catch (error) {
+            expect(error).toBeInstanceOf(WeChatMpError);
+            expect((<WeChatMpError>error).message).not.toContain('console.log');
+            expect((<WeChatMpError>error).message).not.toContain('.style');
+            expect((<WeChatMpError>error).message).not.toContain('Consider raise an issue');
+            expect((<WeChatMpError>error).message).toContain('deleted by author:');
+            expect((<WeChatMpError>error).message).toContain('Title 该内容已被发布者删除');
+            expect((<WeChatMpError>error).message).toContain(deletedPageUrl);
+        }
+    });
+
+    it('redirect', () => {
+        expect(fetchArticle('https://mp.weixin.qq.com/s/rsshub_test_redirect_no_location')).rejects.toThrow('redirect without location');
+        expect(fetchArticle('https://mp.weixin.qq.com/s/rsshub_test_recursive_redirect')).rejects.toThrow('too many redirects');
+    });
+
+    it('route_test', async () => {
+        try {
+            await app.request('/test/wechat-mp');
+        } catch (error) {
+            expect(error).toBeInstanceOf(InvalidParameterError);
+        }
+
+        const responseShort = await app.request('/test/wechat-mp/rsshub_test');
+        const parsedShort = await parser.parseString(await responseShort.text());
+        const expectedItemShort = {
+            author: expectedItem.author,
+            title: expectedItem.title,
+            link: 'https://mp.weixin.qq.com/s/rsshub_test',
+        };
+        expect(parsedShort.items[0]).toMatchObject(expectedItemShort);
+
+        const responseLong = await app.request('/test/wechat-mp/__biz=rsshub_test&mid=1&idx=1&sn=1');
+        const parsedLong = await parser.parseString(await responseLong.text());
+        const expectedItemLong = {
+            ...expectedItemShort,
+            link: 'https://mp.weixin.qq.com/s?__biz=rsshub_test&mid=1&idx=1&sn=1',
         };
-        const expectedDate = new Date(ct * 1000);
-
-        const fetchArticleItem = await fetchArticle(httpUrl);
-        expect(compareDate(fetchArticleItem.pubDate, expectedDate)).toBe(true);
-        delete fetchArticleItem.pubDate;
-        expect(fetchArticleItem).toEqual(expectedItem);
-
-        delete expectedItem.mpName;
-        const finishedArticleItem = await finishArticleItem({ link: httpUrl });
-        expect(compareDate(finishedArticleItem.pubDate, expectedDate)).toBe(true);
-        delete finishedArticleItem.pubDate;
-        expect(finishedArticleItem).toEqual(expectedItem);
+        expect(parsedLong.items[0]).toMatchObject(expectedItemLong);
     });
 });