RSSHub/lib/utils/proxy/index.test.ts

import { PacProxyAgent } from 'pac-proxy-agent';
import { SocksProxyAgent } from 'socks-proxy-agent';
import { ProxyAgent } from 'undici';
import { afterEach, describe, expect, it, vi } from 'vitest';

const loadProxy = async (env: Record<string, string>) => {
    vi.resetModules();
    for (const [key, value] of Object.entries(env)) {
        vi.stubEnv(key, value);
    }
    return (await import('@/utils/proxy')).default;
};

const requestTlsOf = (dispatcher: ProxyAgent) => dispatcher[Object.getOwnPropertySymbols(dispatcher).find((s) => s.description === 'request tls settings')!];

describe('proxy', () => {
    afterEach(() => {
        vi.clearAllTimers();
        vi.useRealTimers();
        vi.unstubAllEnvs();
    });

    it('uses PAC proxy when PAC_URI is set', async () => {
        const proxy = await loadProxy({
            PAC_URI: 'http://example.com/proxy.pac',
            PROXY_URIS: '',
            PROXY_URI: '',
        });

        expect(proxy.agent).toBeInstanceOf(PacProxyAgent);
        expect(proxy.dispatcher).toBeNull();
        expect(proxy.proxyUri).toBe('http://example.com/proxy.pac');

        const current = proxy.getCurrentProxy();
        expect(current?.uri).toBe('http://example.com/proxy.pac');
    });

    it('handles multi-proxy selection and updates after failures', async () => {
        const proxy = await loadProxy({
            PROXY_URIS: 'http://proxy1.local:8080,http://proxy2.local:8081',
            PAC_URI: '',
            PROXY_URI: '',
        });

        expect(proxy.multiProxy).toBeDefined();
        const current = proxy.getCurrentProxy();
        expect(current).not.toBeNull();
        expect(proxy.getDispatcherForProxy(current!)).toBeInstanceOf(ProxyAgent);
        expect(proxy.getAgentForProxy({ uri: 'socks5://proxy.local:1080', isActive: true, failureCount: 0 })).toBeInstanceOf(SocksProxyAgent);

        proxy.markProxyFailed(current!.uri);
        const next = proxy.getCurrentProxy();
        expect(next).not.toBeNull();
    });

    it('clears proxy when multi-proxy has no valid entries', async () => {
        const proxy = await loadProxy({
            PROXY_URIS: 'http://inv lid.test',
            PAC_URI: '',
            PROXY_URI: '',
        });

        expect(proxy.getCurrentProxy()).toBeNull();
        proxy.markProxyFailed('http://inv lid.test');
        expect(proxy.agent).toBeNull();
        expect(proxy.dispatcher).toBeNull();
        expect(proxy.proxyUri).toBeUndefined();
    });

    it('creates a socks proxy agent for single proxy settings', async () => {
        const proxy = await loadProxy({
            PROXY_URI: 'socks5://proxy.local:1080',
            PROXY_URIS: '',
            PAC_URI: '',
        });

        expect(proxy.agent).toBeInstanceOf(SocksProxyAgent);
        expect(proxy.dispatcher).toBeInstanceOf(ProxyAgent);
        expect(proxy.getCurrentProxy()?.uri).toBe('socks5://proxy.local:1080');
        expect(requestTlsOf(proxy.dispatcher!).ALPNProtocols).toEqual(['h2', 'http/1.1']);
    });

    it('creates a socks5 dispatcher for socks5h proxies', async () => {
        const proxy = await loadProxy({
            PROXY_URI: 'socks5h://proxy.local:1080',
            PROXY_URIS: '',
            PAC_URI: '',
        });

        expect(proxy.agent).toBeInstanceOf(SocksProxyAgent);
        expect(proxy.dispatcher).toBeInstanceOf(ProxyAgent);
        expect(proxy.getCurrentProxy()?.uri).toBe('socks5h://proxy.local:1080');
    });

    it('disables socks4 proxies instead of failing to start', async () => {
        const proxy = await loadProxy({
            PROXY_URI: 'socks4://proxy.local:1080',
            PROXY_URIS: '',
            PAC_URI: '',
        });

        expect(proxy.agent).toBeNull();
        expect(proxy.dispatcher).toBeNull();
        expect(proxy.getCurrentProxy()).toBeNull();
    });

    it('prefers h2 on the http proxy dispatcher', async () => {
        const proxy = await loadProxy({
            PROXY_URI: 'http://proxy.local:8080',
            PROXY_URIS: '',
            PAC_URI: '',
        });

        expect(proxy.dispatcher).toBeInstanceOf(ProxyAgent);
        expect(requestTlsOf(proxy.dispatcher!).preferH2).toBe(true);
    });

    it('applies minVersion to the proxy dispatcher request tls', async () => {
        const proxy = await loadProxy({
            PROXY_URI: 'http://proxy.local:8080',
            PROXY_URIS: '',
            PAC_URI: '',
        });

        const dispatcher = proxy.getDispatcherForProxy(proxy.getCurrentProxy()!, 'TLSv1.3')!;
        expect(requestTlsOf(dispatcher).minVersion).toBe('TLSv1.3');
        expect(requestTlsOf(proxy.dispatcher!).minVersion).toBeUndefined();
    });

    it('returns null agent for unsupported proxy protocol', async () => {
        const proxy = await loadProxy({
            PROXY_URI: '',
            PROXY_URIS: '',
            PAC_URI: '',
        });

        expect(proxy.getAgentForProxy({ uri: 'ftp://proxy.local:21', isActive: true, failureCount: 0 })).toBeNull();
    });
});