SnowLuma v2.4.2 source snapshot

packages/core/tests/highway/video-upload.test.ts

@@ -0,0 +1,338 @@
+import {
+    getVideoUploadConcurrency,
+    setVideoUploadConcurrency,
+} from '@snowluma/protocol/highway/upload-settings';
+// video-upload tests cover the fingerprint (fast-upload) path. The
+// regular load path exercises ffmpeg + the OS temp dir + a streaming
+// SHA1 implementation; that machinery has its own seams worth testing
+// separately, and isn't what makes video-upload distinct at the API
+// surface.
+//
+// What we're checking here: the two-sub-file shape (main + thumb), the
+// thumb's source routing (`upload.subFileInfos[0]`), the per-sub-file
+// fastOnlyError difference (main has it; thumb doesn't — FALLBACK_THUMB
+// always provides bytes), and the video-specific OIDB fields.
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { promises as fsp } from 'fs';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { pathToFileURL } from 'url';
+import { computeHashes } from '@snowluma/protocol/highway/utils';
+
+vi.mock('@snowluma/protocol/highway/pipeline', () => ({
+    runNtv2Upload: vi.fn(async () => ({ msgInfo: { msgInfoBody: [], extBizInfo: {} } })),
+    finalizeMediaMsgInfo: vi.fn(() => new Uint8Array([0x12, 0x34])),
+    hexToBytes: vi.fn((hex: string) => new Uint8Array(hex.length / 2)),
+}));
+
+import * as pipeline from '@snowluma/protocol/highway/pipeline';
+import {
+    uploadVideoMsgInfo,
+    GROUP_VIDEO_CMD_ID,
+    GROUP_VIDEO_THUMB_CMD_ID,
+    PRIVATE_VIDEO_CMD_ID,
+    PRIVATE_VIDEO_THUMB_CMD_ID,
+} from '@snowluma/protocol/highway/video-upload';
+
+const FINGERPRINT = {
+    noByteFallback: true,
+    md5Hex: 'aa',
+    sha1Hex: 'bb',
+    fileSize: 1024,
+    width: 320,
+    height: 240,
+    duration: 10,
+    videoFormat: 0,
+} as any;
+
+describe('video-upload', () => {
+    afterEach(() => setVideoUploadConcurrency(1));
+    beforeEach(() => {
+        vi.mocked(pipeline.runNtv2Upload).mockClear();
+        vi.mocked(pipeline.finalizeMediaMsgInfo).mockClear();
+    });
+
+    it('snapshots the global concurrency for video bodies without parallelizing covers', async () => {
+        expect(getVideoUploadConcurrency()).toBe(1);
+        setVideoUploadConcurrency(4);
+        const first = uploadVideoMsgInfo({} as any, true, 12345, FINGERPRINT);
+        setVideoUploadConcurrency(2);
+        await first;
+        const firstUpload = vi.mocked(pipeline.runNtv2Upload).mock.calls[0]![0];
+        expect(firstUpload.uploads[0]!.concurrency).toBe(4);
+        expect(firstUpload.uploads[1]!.concurrency).toBeUndefined();
+        await uploadVideoMsgInfo({} as any, false, 'recipient-uid', FINGERPRINT);
+        const secondUpload = vi.mocked(pipeline.runNtv2Upload).mock.calls[1]![0];
+        expect(secondUpload.uploads[0]!.concurrency).toBe(2);
+        expect(secondUpload.uploads[1]!.concurrency).toBeUndefined();
+    });
+
+    it('retains successful upload metadata for self-sent history', async () => {
+        const node = { fileUuid: 'uploaded-resource', storeId: 1, info: { fileSize: 1234 } };
+        vi.mocked(pipeline.runNtv2Upload).mockResolvedValueOnce({
+            msgInfo: { msgInfoBody: [{ index: node }] },
+        } as any);
+        const element = { ...FINGERPRINT };
+        await uploadVideoMsgInfo({} as any, true, 12345, element);
+        expect(element).toMatchObject({
+            fileId: 'uploaded-resource',
+            mediaNode: node,
+            md5Hex: 'aa',
+            sha1Hex: 'bb',
+        });
+        expect(element.fileName).toBeTruthy();
+    });
+
+    it('group: 0x11EA_100 + GROUP_VIDEO_CMD_ID for main, GROUP_VIDEO_THUMB_CMD_ID for thumb', async () => {
+        await uploadVideoMsgInfo({} as any, true, 12345, FINGERPRINT);
+        const args = vi.mocked(pipeline.runNtv2Upload).mock.calls[0]![0];
+        expect(args.oidbCmd).toBe(0x11ea);
+        expect(args.serviceCmd).toBe('OidbSvcTrpcTcp.0x11ea_100');
+        expect(args.requestId).toBe(3);
+        expect(args.businessType).toBe(2);
+        expect(args.compatQmsgSceneType).toBe(2);
+        expect(args.uploads).toHaveLength(2);
+        expect(args.uploads[0]!.cmdId).toBe(GROUP_VIDEO_CMD_ID);
+        expect(args.uploads[1]!.cmdId).toBe(GROUP_VIDEO_THUMB_CMD_ID);
+    });
+
+    it('c2c: 0x11E9_100 + PRIVATE cmd ids', async () => {
+        await uploadVideoMsgInfo({} as any, false, 'recipient-uid', FINGERPRINT);
+        const args = vi.mocked(pipeline.runNtv2Upload).mock.calls[0]![0];
+        expect(args.oidbCmd).toBe(0x11e9);
+        expect(args.uploads[0]!.cmdId).toBe(PRIVATE_VIDEO_CMD_ID);
+        expect(args.uploads[1]!.cmdId).toBe(PRIVATE_VIDEO_THUMB_CMD_ID);
+    });
+
+    it('main file routes via "top", thumb routes via subFileInfos[0]', async () => {
+        await uploadVideoMsgInfo({} as any, true, 12345, FINGERPRINT);
+        const uploads = vi.mocked(pipeline.runNtv2Upload).mock.calls[0]![0].uploads;
+        expect(uploads[0]!.source).toBe('top');
+        expect(uploads[0]!.subFileIndex).toBe(0);
+        expect(uploads[1]!.source).toBe(0);
+        expect(uploads[1]!.subFileIndex).toBe(1);
+    });
+
+    it('main fastOnlyError is set; thumb is silent (FALLBACK_THUMB always has bytes)', async () => {
+        await uploadVideoMsgInfo({} as any, true, 12345, FINGERPRINT);
+        const uploads = vi.mocked(pipeline.runNtv2Upload).mock.calls[0]![0].uploads;
+        expect(uploads[0]!.fastOnlyError).toMatch(/video fast-upload not available/);
+        expect(uploads[1]!.fastOnlyError).toBeUndefined();
+    });
+
+    it('does NOT set a force-full retry flag on the main file (#145 — proven ineffective)', async () => {
+        // The old forceFullOnFastPath retry was removed: real-machine + kernel RE
+        // showed it never forces a fresh upload (the server fast-paths by md5
+        // metadata regardless of tryFastUploadCompleted). An expired-but-indexed
+        // video resource is a platform limitation, not an upload-flow fix.
+        await uploadVideoMsgInfo({} as any, true, 12345, FINGERPRINT);
+        const uploads = vi.mocked(pipeline.runNtv2Upload).mock.calls[0]![0].uploads;
+        expect(
+            (uploads[0] as unknown as Record<string, unknown>).forceFullOnFastPath,
+        ).toBeUndefined();
+    });
+
+    it('uploadInfo carries TWO entries (main mp4 + thumb jpg) with subFileType 0 and 100', async () => {
+        await uploadVideoMsgInfo({} as any, true, 12345, FINGERPRINT);
+        const uploadInfo = vi.mocked(pipeline.runNtv2Upload).mock.calls[0]![0].uploadInfo;
+        expect(uploadInfo).toHaveLength(2);
+        expect((uploadInfo[0] as any).subFileType).toBe(0);
+        expect((uploadInfo[1] as any).subFileType).toBe(100);
+        expect((uploadInfo[0] as any).fileInfo.type.type).toBe(2); // video
+        expect((uploadInfo[1] as any).fileInfo.type.type).toBe(1); // pic (thumb)
+    });
+
+    it('[#145] group video carries real width/height; c2c stays 0/0', async () => {
+        // A real QQ group video's MsgInfo has real dimensions (e.g. 296x640);
+        // sending 0x0 makes QQ-NT receivers render 文件已过期 even though the
+        // resource is fresh (verified on tempserver: 0x0 → expired, real dims →
+        // renders). c2c is left at 0 — the server rejects non-zero dims there.
+        await uploadVideoMsgInfo({} as any, true, 12345, FINGERPRINT);
+        const groupInfo = vi.mocked(pipeline.runNtv2Upload).mock.calls[0]![0].uploadInfo;
+        expect((groupInfo[0] as any).fileInfo.width).toBe(320); // FINGERPRINT.width
+        expect((groupInfo[0] as any).fileInfo.height).toBe(240); // FINGERPRINT.height
+
+        vi.mocked(pipeline.runNtv2Upload).mockClear();
+        await uploadVideoMsgInfo({} as any, false, 'recipient-uid', FINGERPRINT);
+        const c2cInfo = vi.mocked(pipeline.runNtv2Upload).mock.calls[0]![0].uploadInfo;
+        expect((c2cInfo[0] as any).fileInfo.width).toBe(0);
+        expect((c2cInfo[0] as any).fileInfo.height).toBe(0);
+    });
+
+    it('[#145] fast-upload with 0x0 dims (e.g. forwarding a dimensionless video) falls back to portrait for group', async () => {
+        // A forwarded video whose cached dims are 0 must NOT ship 0x0 to a group
+        // (→ 文件已过期). videoPayloadFromFingerprint substitutes a neutral 720x1280
+        // portrait; c2c stays 0 (server rejects non-zero there).
+        const noDims = { ...FINGERPRINT, width: 0, height: 0 } as any;
+        await uploadVideoMsgInfo({} as any, true, 12345, noDims);
+        const groupInfo = vi.mocked(pipeline.runNtv2Upload).mock.calls[0]![0].uploadInfo;
+        expect((groupInfo[0] as any).fileInfo.width).toBe(720);
+        expect((groupInfo[0] as any).fileInfo.height).toBe(1280);
+
+        vi.mocked(pipeline.runNtv2Upload).mockClear();
+        await uploadVideoMsgInfo({} as any, false, 'recipient-uid', noDims);
+        const c2cInfo = vi.mocked(pipeline.runNtv2Upload).mock.calls[0]![0].uploadInfo;
+        expect((c2cInfo[0] as any).fileInfo.width).toBe(0);
+        expect((c2cInfo[0] as any).fileInfo.height).toBe(0);
+    });
+
+    it('[#145] zero-trust: fallback cover declared dims equal the video fallback (content == declared)', async () => {
+        // The fast-upload cover is a real 720x1280 image; the thumb sub-file must
+        // declare those same pixels, not a 1x1 lying about its size, and they match
+        // the video fallback so tile + cover agree.
+        const noDims = { ...FINGERPRINT, width: 0, height: 0 } as any;
+        await uploadVideoMsgInfo({} as any, true, 12345, noDims);
+        const info = vi.mocked(pipeline.runNtv2Upload).mock.calls[0]![0].uploadInfo;
+        expect((info[0] as any).fileInfo.width).toBe(720); // video tile
+        expect((info[0] as any).fileInfo.height).toBe(1280);
+        expect((info[1] as any).fileInfo.width).toBe(720); // cover sub-file (subFileType 100)
+        expect((info[1] as any).fileInfo.height).toBe(1280);
+    });
+
+    it('[#145] zero-trust: cached duration 0 → time 1, never 00:00', async () => {
+        const noDur = { ...FINGERPRINT, duration: 0 } as any;
+        await uploadVideoMsgInfo({} as any, true, 12345, noDur);
+        const info = vi.mocked(pipeline.runNtv2Upload).mock.calls[0]![0].uploadInfo;
+        expect((info[0] as any).fileInfo.time).toBe(1);
+    });
+
+    it('[#145] real video dims are preserved on the main file even though the cover is the 720x1280 fallback', async () => {
+        // FINGERPRINT has real 320x240 dims; the fast-upload cover is always the
+        // 720x1280 fallback (no real cover cached on the forward path). The video
+        // tile keeps the real dims — the cover/tile aspect mismatch is tolerated,
+        // only a 0x0 MAIN file triggers 文件已过期.
+        await uploadVideoMsgInfo({} as any, true, 12345, FINGERPRINT);
+        const info = vi.mocked(pipeline.runNtv2Upload).mock.calls[0]![0].uploadInfo;
+        expect((info[0] as any).fileInfo.width).toBe(320); // main video: real dims preserved
+        expect((info[0] as any).fileInfo.height).toBe(240);
+        expect((info[1] as any).fileInfo.width).toBe(720); // cover: fallback
+        expect((info[1] as any).fileInfo.height).toBe(1280);
+    });
+
+    it('main video carries the real `time` (duration in seconds) — regression: was 0', async () => {
+        // NTV2 server bakes the `time` field into the resulting MsgInfo
+        // bytes that ride along as `commonElem.pbElem`; the receiver
+        // reads it back via `VideoFile.fileTime` and renders it as the
+        // playable duration. NapCat ships `time: 0` only because it sits
+        // on top of QQ-NT's IPC layer which patches the value in before
+        // the wire send; we're a protocol-direct client (same position
+        // as acidify) and must populate it ourselves. Without this the
+        // receiver shows "00:00" on every video the bot sends.
+        await uploadVideoMsgInfo({} as any, true, 12345, FINGERPRINT);
+        const uploadInfo = vi.mocked(pipeline.runNtv2Upload).mock.calls[0]![0].uploadInfo;
+        expect((uploadInfo[0] as any).fileInfo.time).toBe(10); // matches FINGERPRINT.duration
+        expect((uploadInfo[1] as any).fileInfo.time).toBe(0); // thumb stays at 0 (matches acidify)
+    });
+
+    it('thumb falls back to a synthesized 1x1 PNG with real bytes', async () => {
+        await uploadVideoMsgInfo({} as any, true, 12345, FINGERPRINT);
+        const uploads = vi.mocked(pipeline.runNtv2Upload).mock.calls[0]![0].uploads;
+        expect(uploads[1]!.bytes.length).toBeGreaterThan(0); // FALLBACK_THUMB is non-empty
+    });
+
+    it('main file uses per-1MB-block sha1 (an Uint8Array[]) — fingerprint path uses an empty array', async () => {
+        await uploadVideoMsgInfo({} as any, true, 12345, FINGERPRINT);
+        const uploads = vi.mocked(pipeline.runNtv2Upload).mock.calls[0]![0].uploads;
+        // The fingerprint payload sets sha1Blocks: [] (no real bytes to chunk).
+        expect(Array.isArray(uploads[0]!.sha1)).toBe(true);
+        expect((uploads[0]!.sha1 as Uint8Array[]).length).toBe(0);
+    });
+
+    it('fingerprint mode rejects when md5Hex or sha1Hex is missing', async () => {
+        await expect(
+            uploadVideoMsgInfo({} as any, true, 12345, { noByteFallback: true } as any),
+        ).rejects.toThrow(/requires md5Hex/);
+    });
+
+    it('finalize is called without a defaultPic', async () => {
+        await uploadVideoMsgInfo({} as any, true, 12345, FINGERPRINT);
+        const args = vi.mocked(pipeline.finalizeMediaMsgInfo).mock.calls[0]!;
+        expect(args[1]).toBeUndefined();
+    });
+});
+
+describe('video-upload — streaming path (real on-disk source)', () => {
+    beforeEach(() => {
+        vi.mocked(pipeline.runNtv2Upload).mockClear();
+    });
+
+    it('stages + stream-hashes the source and PUTs via fileSource, never buffering bytes', async () => {
+        const dir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sl-vidstream-'));
+        const file = path.join(dir, 'clip.mp4');
+        const data = Buffer.alloc(3 * 1024 * 1024 + 77); // multi-1MiB-block + tail
+
+        for (let i = 0; i < data.length; i++) {
+            data[i] = (i * 37 + 5) & 0xff;
+        }
+
+        fs.writeFileSync(file, data);
+
+        try {
+            const bridge = { identity: { uin: '10001' } } as any;
+            await uploadVideoMsgInfo(bridge, true, 12345, {
+                type: 'video',
+                url: pathToFileURL(file).href,
+            } as any);
+
+            const args = vi.mocked(pipeline.runNtv2Upload).mock.calls.at(-1)![0];
+            const main = args.uploads[0]!;
+            // Main file streams from disk — fileSource set, no in-memory bytes.
+            expect(main.fileSource).toBeDefined();
+            expect(main.fileSource!.fileSize).toBe(data.length);
+            expect(main.bytes.length).toBe(0);
+            // The OIDB fileInfo carries the STREAMED hashes/size — must equal the
+            // buffered hash of the same bytes (byte-identical guarantee end-to-end).
+            const fi = (args.uploadInfo[0] as any).fileInfo;
+            expect(fi.fileSize).toBe(data.length);
+            expect(fi.fileHash).toBe(computeHashes(data).md5Hex);
+            expect(fi.fileSha1).toBe(computeHashes(data).sha1Hex);
+            // The staged temp is a copy/hardlink under the stage dir (NOT the source)
+            // and is cleaned up after the send.
+            expect(main.fileSource!.filePath).not.toBe(file);
+            expect(fs.existsSync(main.fileSource!.filePath)).toBe(false);
+        } finally {
+            await fsp.rm(dir, { recursive: true, force: true });
+        }
+    });
+
+    it('cleans up the staged temp even when the upload throws', async () => {
+        const dir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sl-vidfail-'));
+        const file = path.join(dir, 'clip.mp4');
+        fs.writeFileSync(file, Buffer.alloc(2048, 7));
+
+        try {
+            vi.mocked(pipeline.runNtv2Upload).mockRejectedValueOnce(new Error('upload boom'));
+            await expect(
+                uploadVideoMsgInfo({ identity: { uin: '1' } } as any, true, 12345, {
+                    type: 'video',
+                    url: pathToFileURL(file).href,
+                } as any),
+            ).rejects.toThrow(/upload boom/);
+            // The staged temp created in loadVideo must be removed by the finally.
+            const args = vi.mocked(pipeline.runNtv2Upload).mock.calls.at(-1)![0];
+            const stagedPath = args.uploads[0]!.fileSource!.filePath;
+            expect(fs.existsSync(stagedPath)).toBe(false);
+        } finally {
+            await fsp.rm(dir, { recursive: true, force: true });
+        }
+    });
+
+    it('rejects an empty video source (0 bytes)', async () => {
+        const dir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sl-vidempty-'));
+        const file = path.join(dir, 'empty.mp4');
+        fs.writeFileSync(file, new Uint8Array(0));
+
+        try {
+            await expect(
+                uploadVideoMsgInfo({ identity: { uin: '1' } } as any, true, 12345, {
+                    type: 'video',
+                    url: pathToFileURL(file).href,
+                } as any),
+            ).rejects.toThrow(/empty/);
+        } finally {
+            await fsp.rm(dir, { recursive: true, force: true });
+        }
+    });
+});