Skip to content

一分钟搭建影视站,支持Docker等部署方式

14.3 KB
Raw Blame
import { describe, expect, it } from 'vitest';
import { MAX_LIVE_SOURCES, MAX_VOD_SOURCES } from './source-list';
import {
  describeParseStats,
  isSourceCatalogPayload,
  isTvboxPayload,
  parseSubscriptionJson,
  parseSubscriptionPayload,
  parseTvboxPayload,
  withSkipped,
} from './tvbox-parser';

const vodSite = (url: string, extra: Record<string, unknown> = {}) => ({
  name: `站点 ${url}`,
  type: 1,
  api: url,
  ...extra,
});

describe('isTvboxPayload', () => {
  it('顶层含 sites / lives 数组即判定为 TVBOX 配置', () => {
    expect(isTvboxPayload({ sites: [], lives: [] })).toBe(true);
    expect(isTvboxPayload({ sites: [{ key: 'a' }] })).toBe(true);
    expect(isTvboxPayload({ lives: [] })).toBe(true);
  });

  it('LibreTV 订阅与非法输入不误判', () => {
    expect(isTvboxPayload({ sources: [], liveSources: [] })).toBe(false);
    expect(isTvboxPayload([{ url: 'https://a.example.com/vod' }])).toBe(false);
    expect(isTvboxPayload(null)).toBe(false);
    expect(isTvboxPayload('text')).toBe(false);
  });
});

describe('parseTvboxPayload', () => {
  it('导入 type=1 点播源与 type=0 直播源(含 EPG)', () => {
    const result = parseTvboxPayload({
      sites: [vodSite('https://vod.example.com/api.php/provide/vod')],
      lives: [
        { name: '直播A', type: 0, url: 'https://live.example.com/list.m3u' },
        {
          name: '直播B',
          type: 0,
          url: 'https://live.example.com/tv.m3u8',
          epg: 'https://live.example.com/epg.xml.gz',
        },
      ],
    });

    expect(result.sources).toEqual([
      { name: '站点 https://vod.example.com/api.php/provide/vod', url: 'https://vod.example.com/api.php/provide/vod' },
    ]);
    expect(result.liveSources).toEqual([
      { name: '直播A', url: 'https://live.example.com/list.m3u', epg: undefined },
      { name: '直播B', url: 'https://live.example.com/tv.m3u8', epg: 'https://live.example.com/epg.xml.gz' },
    ]);
    expect(result.stats).toMatchObject({ format: 'tvbox', skipped: 0, truncated: 0 });
  });

  it('类型缺失或写成 XML,但地址命中 Apple CMS 特征时宽容导入', () => {
    const result = parseTvboxPayload({
      sites: [
        { name: '省略类型', api: 'https://a.example.com/api.php/provide/vod' },
        { name: 'XML 类型', type: 0, api: 'https://b.example.com/api.php/provide/vod/' },
      ],
    });

    expect(result.sources.map((s) => s.url)).toEqual([
      'https://a.example.com/api.php/provide/vod',
      // 点播地址沿用「去尾部斜杠」的既有归一化规则
      'https://b.example.com/api.php/provide/vod',
    ]);
    expect(result.stats?.skipped).toBe(0);
  });

  it('Spider、本地资源、XML 与非 CMS 外链站点跳过并分类计数', () => {
    const result = parseTvboxPayload({
      sites: [
        { name: '正版源', type: 1, api: 'https://ok.example.com/api.php/provide/vod' },
        { name: '蜘蛛A', type: 3, api: 'csp_AppYs' },
        { name: '蜘蛛B', api: 'https://cdn.example.com/spider.jar' },
        { name: '本地JS', type: 1, api: './json/heimuer.js' },
        { name: 'XML站', type: 0, api: 'https://xml.example.com/api.php/provide/vod/at/xml' },
        { name: '外链站', type: 4, api: 'https://api.example.com/v1/list' },
      ],
    });

    expect(result.sources.map((s) => s.name)).toEqual(['正版源']);
    expect(result.stats?.skipped).toBe(5);
    expect(result.stats?.skippedByReason).toEqual({ spider: 4, xml: 1 });
    expect(result.stats?.skippedSamples).toEqual(['蜘蛛A', '蜘蛛B', '本地JS']);
  });

  it('声明不可搜索的站点跳过', () => {
    const result = parseTvboxPayload({
      sites: [
        vodSite('https://a.example.com/api.php/provide/vod'),
        vodSite('https://b.example.com/api.php/provide/vod', { searchable: 0 }),
      ],
    });

    expect(result.sources).toHaveLength(1);
    expect(result.stats?.skippedByReason).toEqual({ unsearchable: 1 });
  });

  it('直播:单仓 JSON 与 txt 频道列表跳过,非 M3U 地址计入 invalidUrl', () => {
    const result = parseTvboxPayload({
      sites: [vodSite('https://a.example.com/api.php/provide/vod')],
      lives: [
        { name: '直播A', type: 0, url: 'https://live.example.com/list.m3u' },
        { name: '单仓', type: 1, url: 'https://live.example.com/all.json' },
        { name: 'txt列表', type: 0, url: 'https://live.example.com/tv.txt' },
        { name: '坏地址', type: 0, url: 'ftp://live.example.com/list.m3u' },
      ],
    });

    expect(result.liveSources.map((s) => s.name)).toEqual(['直播A']);
    expect(result.stats?.skipped).toBe(3);
    expect(result.stats?.skippedByReason).toEqual({ nonM3uLive: 2, invalidUrl: 1 });
  });

  it('按地址去重(点播去尾部斜杠后比较,直播保留原样)', () => {
    const result = parseTvboxPayload({
      sites: [
        vodSite('https://a.example.com/api.php/provide/vod'),
        vodSite('https://a.example.com/api.php/provide/vod/'),
      ],
      lives: [
        { name: 'A', type: 0, url: 'https://live.example.com/list.m3u' },
        { name: 'A 重复', type: 0, url: 'https://live.example.com/list.m3u' },
      ],
    });

    expect(result.sources).toHaveLength(1);
    expect(result.liveSources).toHaveLength(1);
    // 重复条目静默跳过,不计入跳过统计
    expect(result.stats?.skipped).toBe(0);
  });

  it('超出上限时截断并计入 truncated(去重后计数)', () => {
    const sites = [
      ...Array.from({ length: 10 }, () => vodSite('https://dup.example.com/api.php/provide/vod')),
      ...Array.from({ length: MAX_VOD_SOURCES + 5 }, (_, i) => vodSite(`https://vod${i}.example.com/api.php/provide/vod`)),
    ];
    const lives = Array.from({ length: MAX_LIVE_SOURCES + 3 }, (_, i) => ({
      name: `直播${i}`,
      type: 0,
      url: `https://live${i}.example.com/list.m3u`,
    }));

    const result = parseTvboxPayload({ sites, lives });

    expect(result.sources).toHaveLength(MAX_VOD_SOURCES);
    expect(result.liveSources).toHaveLength(MAX_LIVE_SOURCES);
    // 前段重复只占 1 个名额:1 + 99 达到上限,余下 6 个点播与 3 个直播被截断
    expect(result.stats?.truncated).toBe(9);
  });

  it('全部不可导入时抛错并带原因计数', () => {
    expect(() =>
      parseTvboxPayload({ sites: [{ name: '蜘蛛A', type: 3, api: 'csp_AppYs' }] })
    ).toThrow(/已跳过 1 个条目(Spider 引擎 1)/);
  });

  it('sites / lives 均为空时提示无可用站点', () => {
    expect(() => parseTvboxPayload({ sites: [], lives: [] })).toThrow(/没有可用的站点/);
    expect(() => parseTvboxPayload({})).toThrow(/没有可用的站点/);
  });

  it('TVBOX 顶层 name 作为订阅名透传', () => {
    const result = parseTvboxPayload({
      name: '某大佬的接口',
      sites: [vodSite('https://a.example.com/api.php/provide/vod')],
    });
    expect(result.name).toBe('某大佬的接口');
  });
});

describe('parseSubscriptionPayload', () => {
  it('TVBOX 配置走 TVBOX 分支', () => {
    const result = parseSubscriptionPayload({
      sites: [{ name: '正版源', type: 1, api: 'https://a.example.com/api.php/provide/vod' }],
      lives: [{ name: '直播', type: 0, url: 'https://live.example.com/list.m3u' }],
    });

    expect(result.stats?.format).toBe('tvbox');
    expect(result.sources).toHaveLength(1);
    expect(result.liveSources).toHaveLength(1);
  });

  it('LibreTV 订阅仍按原逻辑解析并带默认统计', () => {
    const result = parseSubscriptionPayload({
      name: '我的源列表',
      sources: [{ name: '点播', url: 'https://a.example.com/api.php/provide/vod' }],
      liveSources: [{ name: '直播', url: 'https://live.example.com/list.m3u' }],
    });

    expect(result.name).toBe('我的源列表');
    expect(result.sources).toHaveLength(1);
    expect(result.liveSources).toHaveLength(1);
    expect(result.stats).toEqual({ format: 'libretv', skipped: 0, skippedByReason: {}, truncated: 0 });
  });

  it('裸数组老格式仍按 LibreTV 解析', () => {
    const result = parseSubscriptionPayload([{ url: 'https://a.example.com/api.php/provide/vod' }]);
    expect(result.sources).toHaveLength(1);
    expect(result.stats?.format).toBe('libretv');
  });

  it('两种格式都不匹配时抛格式错误', () => {
    expect(() => parseSubscriptionPayload({ name: '空的' })).toThrow(/格式不正确/);
    expect(() => parseSubscriptionPayload(null)).toThrow(/格式不正确/);
  });
});

describe('接口目录(source-catalog)', () => {
  const api = (host: string) => `https://${host}/api.php/provide/vod`;

  it('识别:非空裸数组且每个条目都带 baseUrl', () => {
    expect(isSourceCatalogPayload([{ baseUrl: api('a.example.com') }])).toBe(true);
    expect(isSourceCatalogPayload([{ url: api('a.example.com') }])).toBe(false);
    expect(isSourceCatalogPayload([{ baseUrl: api('a.example.com') }, { url: api('b.example.com') }])).toBe(false);
    expect(isSourceCatalogPayload([])).toBe(false);
    expect(isSourceCatalogPayload({ sites: [] })).toBe(false);
  });

  it('解析为点播源,名称缺省用主机名,格式标记为 source-catalog', () => {
    const result = parseSubscriptionPayload([
      { name: '接口A', baseUrl: api('a.example.com') },
      { baseUrl: `${api('b.example.com')}/` },
    ]);

    expect(result.stats?.format).toBe('source-catalog');
    expect(result.name).toBeUndefined();
    expect(result.sources).toEqual([
      { name: '接口A', url: api('a.example.com') },
      { name: 'b.example.com', url: api('b.example.com') },
    ]);
    expect(result.liveSources).toEqual([]);
  });

  it('enabled: false 的条目跳过并计入「已停用」,缺省视为启用', () => {
    const result = parseSubscriptionPayload([
      { name: '可用', baseUrl: api('a.example.com') },
      { name: '停用', baseUrl: api('b.example.com'), enabled: false },
      { name: '显式启用', baseUrl: api('c.example.com'), enabled: true },
    ]);

    expect(result.sources.map((s) => s.name)).toEqual(['可用', '显式启用']);
    expect(result.stats).toMatchObject({
      format: 'source-catalog',
      skipped: 1,
      skippedByReason: { disabled: 1 },
      skippedSamples: ['停用'],
      truncated: 0,
    });
  });

  it('非法 baseUrl 计入「地址不可用」,重复地址按归一化后去重', () => {
    const result = parseSubscriptionPayload([
      { name: '坏地址', baseUrl: 'ftp://a.example.com/vod' },
      { name: '重复A', baseUrl: api('dup.example.com') },
      { name: '重复B', baseUrl: `${api('dup.example.com')}?#` },
    ]);

    expect(result.sources).toEqual([{ name: '重复A', url: api('dup.example.com') }]);
    expect(result.stats?.skipped).toBe(1);
    expect(result.stats?.skippedByReason).toEqual({ invalidUrl: 1 });
  });

  it('超出上限时截断并计数', () => {
    const entries = Array.from({ length: MAX_VOD_SOURCES + 5 }, (_, i) => ({
      baseUrl: `https://vod${i}.example.com/api.php/provide/vod`,
    }));

    const result = parseSubscriptionPayload(entries);

    expect(result.sources).toHaveLength(MAX_VOD_SOURCES);
    expect(result.stats?.truncated).toBe(5);
  });

  it('混用 baseUrl 与 url 时直接报错,不静默丢条目', () => {
    expect(() =>
      parseSubscriptionPayload([{ baseUrl: api('a.example.com') }, { url: api('b.example.com') }])
    ).toThrow(/混用了 baseUrl 与 url/);
  });

  it('全部条目都不可导入时报错并给出原因明细', () => {
    expect(() =>
      parseSubscriptionPayload([{ name: '停用', baseUrl: api('a.example.com'), enabled: false }])
    ).toThrow(/已跳过 1 个条目(已停用 1)/);
    expect(() => parseSubscriptionPayload([{ baseUrl: '' }])).toThrow(/已跳过 1 个条目(地址不可用 1)/);
  });
});

describe('describeParseStats / withSkipped', () => {
  it('无异常时返回空串,有跳过时给出原因与示例', () => {
    expect(describeParseStats(undefined)).toBe('');
    expect(describeParseStats({ format: 'libretv', skipped: 0, skippedByReason: {}, truncated: 0 })).toBe('');

    const stats = {
      format: 'tvbox' as const,
      skipped: 4,
      skippedByReason: { spider: 3, xml: 1 },
      skippedSamples: ['蜘蛛A', 'XML站'],
      truncated: 2,
    };
    expect(describeParseStats(stats)).toBe('跳过 4 个不可用条目(Spider 引擎 3、XML 接口 1),如「蜘蛛A」「XML站」,超出上限截断 2 条');
    // toast 场景:省略示例名以保持文案精简
    expect(describeParseStats(stats, { includeSamples: false })).toBe('跳过 4 个不可用条目(Spider 引擎 3、XML 接口 1),超出上限截断 2 条');
  });

  it('withSkipped 累加原因计数且不修改原对象', () => {
    const base = { format: 'tvbox' as const, skipped: 1, skippedByReason: { spider: 1 }, truncated: 0 };
    const merged = withSkipped(base, 'invalidUrl', 2);

    expect(merged).toEqual({ format: 'tvbox', skipped: 3, skippedByReason: { spider: 1, invalidUrl: 2 }, truncated: 0 });
    expect(base.skipped).toBe(1);
    expect(withSkipped(undefined, 'invalidUrl', 0)).toEqual({ format: 'libretv', skipped: 0, skippedByReason: {}, truncated: 0 });
  });
});

describe('parseSubscriptionJson', () => {
  it('容忍行注释、块注释与尾随逗号(共享配置常见)', () => {
    const text = [
      '{',
      '  // 站点列表',
      '  "sites": [',
      '    { "name": "A", "type": 1, "api": "https://a.example.com/api.php/provide/vod" }, // 行内注释',
      '  ],',
      '  /* 直播源 */',
      '  "lives": [],',
      '}',
    ].join('\n');

    const json = parseSubscriptionJson(text) as { sites: { api: string }[] };
    expect(json.sites).toHaveLength(1);
    expect(json.sites[0].api).toBe('https://a.example.com/api.php/provide/vod');
  });

  it('字符串内的裸换行/制表符被转义(共享配置的实际写法)', () => {
    const json = parseSubscriptionJson('{"name":"优\n酷","tab":"a\tb"}') as Record<string, string>;
    expect(json.name).toBe('优\n酷');
    expect(json.tab).toBe('a\tb');
  });

  it('字符串内的 // 与转义引号不被误伤', () => {
    const json = parseSubscriptionJson('{"a":"https://x//y","b":"say \\"hi\\""}') as Record<string, string>;
    expect(json.a).toBe('https://x//y');
    expect(json.b).toBe('say "hi"');
  });

  it('非法内容抛出可读错误', () => {
    expect(() => parseSubscriptionJson('<html>403 Forbidden</html>')).toThrow(/不是合法的 JSON/);
  });
});