Skip to content

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

14.2 KB
Raw Blame
import { describe, expect, it } from 'vitest';
import {
  QUALITY_FAIL_TTL_MS,
  QUALITY_TTL_MS,
  describeQualityBadge,
  failureReasonLabel,
  inferHeightFromBitrate,
  isQualityEntryFresh,
  isRetryableTimeout,
  mergeQualityEntries,
  qualityLabel,
  summarizeQuality,
} from './quality';
import { parseBestHeight, parseMediaPlaylist } from './quality-probe';
import type { QualityEntry } from './types';

/** master playlist 样例:三档,其中一个只有 BANDWIDTH 没有 RESOLUTION */
const MASTER = `#EXTM3U
#EXT-X-STREAM-INF:BANDWIDTH=1280000,RESOLUTION=1280x720
720/index.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=2560000,RESOLUTION=1920x1080
1080/index.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=800000
480/index.m3u8
`;

describe('qualityLabel', () => {
  it('按常见档位命名', () => {
    expect(qualityLabel(2160)).toBe('4K');
    expect(qualityLabel(1440)).toBe('2K');
    expect(qualityLabel(1080)).toBe('1080P');
    expect(qualityLabel(720)).toBe('720P');
    expect(qualityLabel(540)).toBe('540P');
    expect(qualityLabel(480)).toBe('480P');
    expect(qualityLabel(360)).toBe('360P');
  });

  it('轻微裁切仍归原档:1080P 裁掉上下边还是 1080P', () => {
    expect(qualityLabel(1040)).toBe('1080P'); // 1924×1040
    expect(qualityLabel(1030)).toBe('1080P');
    expect(qualityLabel(1110)).toBe('1080P');
  });

  it('1920×960 这类 2.0:1 裁切仍算 1080P(960 不是独立档位)', () => {
    expect(qualityLabel(960)).toBe('1080P');
    expect(qualityLabel(920)).toBe('1080P');
    expect(qualityLabel(1000)).toBe('1080P');
    expect(qualityLabel(700)).toBe('720P');
    expect(qualityLabel(680)).toBe('720P');
  });

  it('偏差过大时不抬档:低分辨率不会被算成 360P', () => {
    expect(qualityLabel(144)).toBe('144P');
    expect(qualityLabel(240)).toBe('240P');
    expect(qualityLabel(800)).toBe('720P');
  });

  it('缺失或非法高度返回 undefined(前端据此显示「未知」)', () => {
    expect(qualityLabel(undefined)).toBeUndefined();
    expect(qualityLabel(0)).toBeUndefined();
  });
});

describe('parseBestHeight', () => {
  it('取 master playlist 的最高档', () => {
    expect(parseBestHeight(MASTER)).toBe(1080);
  });

  it('只有 BANDWIDTH 的档位按转码参数反推高度', () => {
    const text = `#EXTM3U
#EXT-X-STREAM-INF:BANDWIDTH=6000000
only-bandwidth.m3u8
`;
    expect(parseBestHeight(text)).toBe(inferHeightFromBitrate(6_000_000));
  });

  it('单码率媒体列表没有 STREAM-INF,返回 undefined 而非猜一个档位', () => {
    const text = `#EXTM3U
#EXT-X-TARGETDURATION:10
#EXTINF:10.0,
seg0.ts
`;
    expect(parseBestHeight(text)).toBeUndefined();
  });

  it('空文本与纯注释返回 undefined', () => {
    expect(parseBestHeight('')).toBeUndefined();
    expect(parseBestHeight('#EXTM3U\n')).toBeUndefined();
  });

  it('变体行缺失时不被上一档的声明污染', () => {
    // STREAM-INF 后紧跟另一条 STREAM-INF(异常清单):不产生高度,避免误判
    const text = `#EXTM3U
#EXT-X-STREAM-INF:BANDWIDTH=1280000,RESOLUTION=1280x720
#EXT-X-STREAM-INF:BANDWIDTH=2560000,RESOLUTION=1920x1080
1080/index.m3u8
`;
    expect(parseBestHeight(text)).toBe(1080);
  });

  it('取短边:源站把宽高写反(720x1280)时拿到 720 而非 1280', () => {
    // 实际采集站常见 720P 源被标成 720x1280;之前按 height 取会得到 1280 → qualityLabel 成 2K
    const text = `#EXTM3U
#EXT-X-STREAM-INF:BANDWIDTH=1500000,RESOLUTION=720x1280
720p/index.m3u8
`;
    expect(parseBestHeight(text)).toBe(720);
  });

  it('取短边:正常的 1280x720 不受影响', () => {
    // 回归保护:取短边后档位判断与原本按 height 写在 16:9 视频上一致
    const text = `#EXTM3U
#EXT-X-STREAM-INF:BANDWIDTH=1500000,RESOLUTION=1280x720
720p/index.m3u8
`;
    expect(parseBestHeight(text)).toBe(720);
  });
});

describe('parseMediaPlaylist', () => {
  const MEDIA = `#EXTM3U
#EXT-X-TARGETDURATION:10
#EXT-X-MEDIA-SEQUENCE:17
#EXT-X-MAP:URI="init.mp4"
#EXTINF:10.0,
seg0.m4s
#EXTINF:10.0,
seg1.m4s
`;

  it('取到 init segment 与第一个分片(分片解析靠这两个)', () => {
    const info = parseMediaPlaylist(MEDIA);
    expect(info.initUri).toBe('init.mp4');
    expect(info.firstSegment).toBe('seg0.m4s'); // 只取第一个,第二个不关心
  });

  it('解析媒体序列号:未显式给 IV 时它就是 IV', () => {
    expect(parseMediaPlaylist(MEDIA).mediaSequence).toBe(17);
    expect(parseMediaPlaylist('#EXTM3U\nseg.ts\n').mediaSequence).toBe(0);
  });

  it('解析 AES-128 的方法、密钥地址与十六进制 IV', () => {
    const info = parseMediaPlaylist(`#EXTM3U
#EXT-X-KEY:METHOD=AES-128,URI="https://cdn.example/key.bin",IV=0x1a2b3c4d5e6f708192a3b4c5d6e7f809
seg0.ts
`);
    expect(info.keyMethod).toBe('AES-128');
    expect(info.keyUri).toBe('https://cdn.example/key.bin');
    expect(info.keyIv).toHaveLength(16);
    expect(info.keyIv![0]).toBe(0x1a);
    expect(info.keyIv![15]).toBe(0x09);
  });

  it('SAMPLE-AES 单独识别:服务端解不开,调用方据此放弃而不是解密出错', () => {
    const info = parseMediaPlaylist('#EXT-X-KEY:METHOD=SAMPLE-AES,URI="skd://x"\nseg.ts\n');
    expect(info.keyMethod).toBe('SAMPLE-AES');
    expect(info.keyUri).toBe('skd://x');
  });

  it('相对路径原样保留(拼接由调用方用 new URL 完成)', () => {
    expect(parseMediaPlaylist('#EXTM3U\n/2024/01/abc/index.ts\n').firstSegment).toBe('/2024/01/abc/index.ts');
  });

  it('m3u8 里没有分片时返回空,调用方据此判定测不出', () => {
    expect(parseMediaPlaylist('#EXTM3U\n#EXT-X-ENDLIST\n').firstSegment).toBeUndefined();
  });
});

describe('isQualityEntryFresh', () => {
  const T = 1_700_000_000_000;

  it('成功与「测不出」按长 TTL 判定', () => {
    const ok: QualityEntry = { height: 1080, from: 'probe', timestamp: T };
    const unknown: QualityEntry = { from: 'probe', timestamp: T };
    expect(isQualityEntryFresh(ok, T + QUALITY_TTL_MS - 1)).toBe(true);
    expect(isQualityEntryFresh(unknown, T + QUALITY_TTL_MS - 1)).toBe(true);
    expect(isQualityEntryFresh(ok, T + QUALITY_TTL_MS + 1)).toBe(false);
  });

  it('失败按短 TTL 判定:过期后允许重试', () => {
    const failed: QualityEntry = { from: 'probe', error: 'HTTP 403', timestamp: T };
    expect(isQualityEntryFresh(failed, T + QUALITY_FAIL_TTL_MS - 1)).toBe(true);
    expect(isQualityEntryFresh(failed, T + QUALITY_FAIL_TTL_MS + 1)).toBe(false);
  });

  it('读取路径靠它挡住持久化回来的过期条目', () => {
    // 刷新页面后旧条目直接从 localStorage 回到内存,写入时的清理没机会跑
    const stale: QualityEntry = { height: 720, from: 'play', timestamp: T };
    expect(isQualityEntryFresh(stale, T + QUALITY_TTL_MS * 2)).toBe(false);
  });
});

describe('mergeQualityEntries', () => {
  const T = 1_700_000_000_000;
  const probe = (height?: number, error?: string): QualityEntry => ({ height, from: 'probe', error, timestamp: T });
  const play = (height: number): QualityEntry => ({ height, from: 'play', timestamp: T });
  const KEY = 'huang:123';

  it('播放实测覆盖此前的「测不出」——单码率源的画质只能这样补上', () => {
    // 先探测:单码率 m3u8,没有画质信息(无 error、无 height)
    const afterProbe = mergeQualityEntries({}, { [KEY]: probe() }, T);
    expect(afterProbe[KEY].height).toBeUndefined();

    // 播放后拿到真实解码高度
    const afterPlay = mergeQualityEntries(afterProbe, { [KEY]: play(1080) }, T + 1000);
    expect(afterPlay[KEY]).toMatchObject({ height: 1080, from: 'play' });
  });

  it('实测值不被后续探测覆盖(m3u8 里写的是声明值,不如解码值可信)', () => {
    const current = { [KEY]: play(1080) };
    const next = mergeQualityEntries(current, { [KEY]: probe(720) }, T + 1000);
    expect(next[KEY]).toMatchObject({ height: 1080, from: 'play' });
  });

  it('多次实测取较大值:ABR 起播先选低档再升档,不能被起播档位低估', () => {
    const current = { [KEY]: play(720) };
    const next = mergeQualityEntries(current, { [KEY]: play(1080) }, T + 1000);
    expect(next[KEY].height).toBe(1080);

    // 反向:后来的低档位不该把已知的高档位拉低
    const back = mergeQualityEntries(next, { [KEY]: play(540) }, T + 2000);
    expect(back[KEY].height).toBe(1080);
  });

  it('已有明确档位时,不被「测不出」的探测抹掉', () => {
    const current = { [KEY]: probe(1080) };
    const next = mergeQualityEntries(current, { [KEY]: probe() }, T + 1000);
    expect(next[KEY].height).toBe(1080);
  });

  it('探测失败按短 TTL 淘汰,成功与「测不出」按长 TTL 保留', () => {
    const now = T + QUALITY_FAIL_TTL_MS + 1000;
    const merged = mergeQualityEntries(
      {
        failed: probe(undefined, 'HTTP 403'),
        unknown: probe(),
        ok: probe(1080),
      },
      {},
      now
    );
    // 失败记录已过期 → 允许重试;另外两条是有效结论,不能反复重探
    expect(merged.failed).toBeUndefined();
    expect(merged.unknown).toBeDefined();
    expect(merged.ok).toBeDefined();
    // 长 TTL 到期后同样清掉
    expect(mergeQualityEntries({ ok: probe(1080) }, {}, T + QUALITY_TTL_MS + 1000).ok).toBeUndefined();
  });

  it('保留未过期条目,避免每次写入都把已有缓存丢掉', () => {
    const current = { other: probe(720) };
    const next = mergeQualityEntries(current, { [KEY]: play(1080) }, T + 1000);
    expect(next.other).toMatchObject({ height: 720 });
    expect(next[KEY]).toMatchObject({ height: 1080 });
  });

  it('超过上限时淘汰最旧条目', () => {
    const current: Record<string, QualityEntry> = {};
    for (let i = 0; i < 400; i++) {
      current[`k${i}`] = { height: 720, from: 'probe', timestamp: T + i };
    }
    const next = mergeQualityEntries(current, { fresh: { height: 1080, from: 'probe', timestamp: T + 9999 } }, T + 9999);
    expect(Object.keys(next)).toHaveLength(400);
    expect(next.k0).toBeUndefined(); // 最旧的一条被淘汰
    expect(next.fresh).toBeDefined();
  });
});

describe('describeQualityBadge', () => {
  const entry = (patch: Partial<QualityEntry> = {}): QualityEntry => ({
    from: 'probe',
    timestamp: 1_700_000_000_000,
    ...patch,
  });

  it('探测中优先于已有结果:重试时不该还挂着旧结论', () => {
    expect(describeQualityBadge(entry({ height: 720 }), true)).toMatchObject({ kind: 'loading', retryable: false });
  });

  it('尚未探测时返回 undefined:不渲染,避免与「未知」混淆', () => {
    expect(describeQualityBadge(undefined, false)).toBeUndefined();
  });

  it('有档位:探测值与实测值的 tooltip 区分数据来源', () => {
    expect(describeQualityBadge(entry({ height: 1080 }))).toMatchObject({ kind: 'value', label: '1080P' });
    expect(describeQualityBadge(entry({ height: 1080, from: 'play' }))?.title).toContain('实测');
    expect(describeQualityBadge(entry({ height: 1080, from: 'probe' }))?.title).toContain('播放列表');
  });

  it('无高度无错误 = 未知,且不可重试(源站本就不给信息)', () => {
    const view = describeQualityBadge(entry());
    expect(view).toMatchObject({ kind: 'unknown', retryable: false });
    expect(view?.title).toContain('单码率');
  });

  it('有错误 = 未探到,可重试,且原因写进 tooltip', () => {
    const view = describeQualityBadge(entry({ error: 'HTTP 403' }));
    expect(view).toMatchObject({ kind: 'failed', retryable: true });
    expect(view?.title).toContain('HTTP 403');
  });

  it('失败但带有高度时按有档位展示(部分源先失败后回填)', () => {
    expect(describeQualityBadge(entry({ height: 720, error: 'HTTP 500' }))).toMatchObject({ kind: 'value', label: '720P' });
  });
});

describe('summarizeQuality', () => {
  const T = 1_700_000_000_000;
  const probe = (height?: number, error?: string): QualityEntry => ({ height, from: 'probe', error, timestamp: T });

  it('空输入:没有结论也不虚报总数', () => {
    expect(summarizeQuality([])).toEqual({ best: undefined, known: 0, failed: 0, total: 0 });
  });

  it('取最高档并统计命中/失败/总数', () => {
    const summary = summarizeQuality([probe(720), probe(1080), probe(), probe(undefined, 'HTTP 403')]);
    expect(summary).toEqual({ best: '1080P', known: 2, failed: 1, total: 4 });
  });

  it('未探测条目(undefined)不计入分母,进度不会显得永远差几条', () => {
    expect(summarizeQuality([probe(720), undefined, undefined])).toEqual({
      best: '720P',
      known: 1,
      failed: 0,
      total: 1,
    });
  });

  it('全部测不出时没有 best,但仍是有效结论(total 计入)', () => {
    expect(summarizeQuality([probe(), probe()])).toEqual({ best: undefined, known: 0, failed: 0, total: 2 });
  });

  it('实测与探测混合时取较大值(实测可把单码率源补上)', () => {
    const play: QualityEntry = { height: 2160, from: 'play', timestamp: T };
    expect(summarizeQuality([probe(720), play]).best).toBe('4K');
  });
});

describe('失败原因标签', () => {
  it('源站拒绝与超时各有短标签', () => {
    expect(failureReasonLabel('HTTP 403')).toBe('防盗链');
    expect(failureReasonLabel('画质探测超时')).toBe('超时');
    expect(failureReasonLabel('未找到播放资源')).toBe('无资源');
  });

  it('传输层失败也要有标签:否则线上只剩裸「未测到」,无从判断哪一环挂了', () => {
    expect(failureReasonLabel('探测请求被网关拦截(未收到任何响应)')).toBe('连接中断');
    expect(failureReasonLabel('探测连接中途被断开(已收到部分结果,多为网关超时)')).toBe('连接中断');
    expect(failureReasonLabel('探测请求没能送达服务器(网络或反向代理中断)')).toBe('连接中断');
    expect(failureReasonLabel('请求失败 (502)')).toBe('网关异常');
  });

  it('无法归类的错误不硬造标签', () => {
    expect(failureReasonLabel('fetch failed')).toBeUndefined();
    expect(failureReasonLabel(undefined)).toBeUndefined();
  });
});

describe('isRetryableTimeout', () => {
  it('只把超时视作值得自动补探的失败', () => {
    expect(isRetryableTimeout('画质探测超时')).toBe(true);
    expect(isRetryableTimeout('HTTP 403')).toBe(false);
    expect(isRetryableTimeout(undefined)).toBe(false);
  });
});