SnowLuma v2.4.2 source snapshot

packages/sdk/tests/media.test.ts

@@ -0,0 +1,382 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import {
+    SnowLumaAbortError,
+    SnowLumaApiError,
+    SnowLumaHttpClient,
+    SnowLumaMediaSendError,
+    SnowLumaTimeoutError,
+    type JsonObject,
+} from '../src/index.js';
+import { localFile } from '../src/node/index.js';
+
+function server(
+    options: {
+        failUpload?: boolean;
+        failSend?: boolean;
+        sendResponse?: (init?: RequestInit) => Promise<Response>;
+    } = {},
+) {
+    const calls: Array<{ action: string; params: JsonObject }> = [];
+    let first: JsonObject;
+    const fetch = vi.fn(async (_input: string | URL | Request, init?: RequestInit) => {
+        const { action, params } = JSON.parse(String(init?.body)) as {
+            action: string;
+            params: JsonObject;
+        };
+        calls.push({ action, params });
+
+        if (action !== 'upload_file_stream') {
+            if (options.sendResponse) {
+                return options.sendResponse(init);
+            }
+
+            return Response.json(
+                options.failSend
+                    ? { status: 'failed', retcode: 123, data: null, wording: 'send rejected' }
+                    : {
+                          status: 'ok',
+                          retcode: 0,
+                          data: action.startsWith('upload_')
+                              ? { file_id: 'file-id' }
+                              : { message_id: -42 },
+                      },
+            );
+        }
+
+        if (params.chunk_index === 0) {
+            first = params;
+        }
+
+        if (options.failUpload) {
+            return new Response(
+                JSON.stringify({ status: 'failed', retcode: 321, data: null }) + '\r\n\r\n',
+            );
+        }
+
+        const data = params.is_complete
+            ? {
+                  type: 'response',
+                  status: 'file_complete',
+                  stream_id: first.stream_id,
+                  received_chunks: first.total_chunks,
+                  total_chunks: first.total_chunks,
+                  file_size: first.file_size,
+                  file_path: '/server/staged.bin',
+                  file_name: first.filename ?? 'generated.bin',
+                  sha256: 'a'.repeat(64),
+              }
+            : {
+                  type: 'stream',
+                  status: 'chunk_received',
+                  stream_id: params.stream_id,
+                  received_chunks: Number(params.chunk_index) + 1,
+                  total_chunks: params.total_chunks,
+              };
+
+        return new Response(
+            JSON.stringify({ status: 'ok', retcode: 0, stream: 'stream-action', data }) +
+                '\r\n\r\n',
+        );
+    });
+    return { client: new SnowLumaHttpClient({ fetch }), calls, fetch };
+}
+
+describe('one-step media sends', () => {
+    it.each([
+        ['sendGroupImage', 'send_group_msg', 'group_id', 'image'],
+        ['sendPrivateImage', 'send_private_msg', 'user_id', 'image'],
+        ['sendGroupRecord', 'send_group_msg', 'group_id', 'record'],
+        ['sendPrivateRecord', 'send_private_msg', 'user_id', 'record'],
+        ['sendGroupVideo', 'send_group_msg', 'group_id', 'video'],
+        ['sendPrivateVideo', 'send_private_msg', 'user_id', 'video'],
+    ] as const)(
+        '%s sends only after every chunk and final ACK',
+        async (method, action, id, type) => {
+            const { client, calls } = server();
+            const progress = vi.fn();
+            await expect(
+                client[method](123, new Uint8Array([1, 2, 3]), {
+                    chunkSize: 2,
+                    onProgress: progress,
+                }),
+            ).resolves.toEqual({ message_id: -42 });
+            expect(calls.map((call) => call.action)).toEqual([
+                'upload_file_stream',
+                'upload_file_stream',
+                'upload_file_stream',
+                action,
+            ]);
+            expect(calls.slice(0, 2).map((call) => call.params.chunk_data)).toEqual([
+                'AQI=',
+                'Aw==',
+            ]);
+            expect(calls[2].params.is_complete).toBe(true);
+            expect(calls[3].params).toEqual({
+                [id]: 123,
+                message: [{ type, data: { file: '/server/staged.bin' } }],
+            });
+            expect(progress).toHaveBeenLastCalledWith(
+                expect.objectContaining({ uploadedBytes: 3 }),
+            );
+        },
+    );
+
+    it('preserves media attributes and does not mutate options', async () => {
+        const { client, calls } = server();
+        const image = Object.freeze({ subType: 1, summary: 'picture' });
+        await client.sendGroupImage(123, new Blob(['bytes']), { image });
+        expect(calls.at(-1)?.params.message).toEqual([
+            { type: 'image', data: { file: '/server/staged.bin', subType: 1, summary: 'picture' } },
+        ]);
+        await client.sendPrivateVideo(456, new Uint8Array([1]), {
+            video: { thumb: '/server/thumb' },
+        });
+        expect(calls.at(-1)?.params.message).toEqual([
+            { type: 'video', data: { file: '/server/staged.bin', thumb: '/server/thumb' } },
+        ]);
+    });
+
+    it('keeps the uploaded file authoritative when callers pass wider attribute objects', async () => {
+        const { client, calls } = server();
+        // Structurally typed options may include extra fields from an existing segment.
+        const image = { file: '/wrong/image', summary: 'picture' };
+        const record = { file: '/wrong/record', url: 'https://example.test/voice' };
+        const video = { file: '/wrong/video', thumb: '/server/thumb' };
+        const source = new Uint8Array([1]);
+        await client.sendGroupImage(123, source, { image });
+        await client.sendPrivateImage(123, source, { image });
+        await client.sendGroupRecord(123, source, { record });
+        await client.sendPrivateRecord(123, source, { record });
+        await client.sendGroupVideo(123, source, { video });
+        await client.sendPrivateVideo(123, source, { video });
+        const sends = calls.filter((call) => call.action.startsWith('send_'));
+        expect(sends).toHaveLength(6);
+
+        for (const send of sends) {
+            expect(send.params.message).toEqual([
+                expect.objectContaining({
+                    data: expect.objectContaining({ file: '/server/staged.bin' }),
+                }),
+            ]);
+        }
+
+        expect(image.file).toBe('/wrong/image');
+    });
+
+    it('preserves File names and uses the existing file publishing actions exactly once', async () => {
+        const { client, calls } = server();
+        await expect(
+            client.sendGroupFile(123, new File(['bytes'], '报告.txt'), {
+                folderId: '/folder',
+            }),
+        ).resolves.toEqual({ file_id: 'file-id' });
+        expect(calls[0].params.filename).toBe('报告.txt');
+        expect(calls.at(-1)).toEqual({
+            action: 'upload_group_file',
+            params: {
+                group_id: 123,
+                file: '/server/staged.bin',
+                name: '报告.txt',
+                folder_id: '/folder',
+                upload_file: true,
+            },
+        });
+        await client.sendPrivateFile(
+            456,
+            { source: new Uint8Array([1]), filename: 'original.txt' },
+            {
+                filename: 'staged.txt',
+                name: '发送.txt',
+            },
+        );
+        expect(calls[3].params.filename).toBe('staged.txt');
+        expect(calls.at(-1)).toEqual({
+            action: 'upload_private_file',
+            params: {
+                user_id: 456,
+                file: '/server/staged.bin',
+                name: '发送.txt',
+                upload_file: true,
+            },
+        });
+    });
+
+    it('keeps async sources incremental and accepts declared sizes', async () => {
+        const { client, calls } = server();
+        const source = (async function* () {
+            yield new Uint8Array([1]);
+            expect(calls).toHaveLength(1);
+            yield new Uint8Array([2]);
+        })();
+        await client.sendGroupImage(123, source, { fileSize: 2, chunkSize: 1 });
+        expect(calls).toHaveLength(4);
+    });
+
+    it('reports upload failure with its cause and never dispatches the message', async () => {
+        const { client, calls } = server({ failUpload: true });
+        await expect(client.sendGroupImage(123, new Uint8Array([1]))).rejects.toMatchObject({
+            name: 'SnowLumaMediaSendError',
+            stage: 'upload',
+            upload: undefined,
+            cause: expect.any(SnowLumaApiError),
+        });
+        expect(calls).toHaveLength(1);
+    });
+
+    it('retains the completed upload and original send error without retrying', async () => {
+        const { client, calls } = server({ failSend: true });
+        await expect(client.sendGroupImage(123, new Uint8Array([1]))).rejects.toMatchObject({
+            stage: 'send',
+            upload: { file_path: '/server/staged.bin' },
+            cause: expect.objectContaining({ retcode: 123 }),
+        });
+        expect(calls).toHaveLength(3);
+    });
+
+    it('prevents dispatch when cancellation occurs between upload and send', async () => {
+        const controller = new AbortController();
+        const { client, calls } = server();
+        const upload = client.uploadFileStream.bind(client);
+        vi.spyOn(client, 'uploadFileStream').mockImplementation(async (...args) => {
+            const result = await upload(...args);
+            controller.abort('stop');
+            return result;
+        });
+        await expect(
+            client.sendGroupImage(123, new Uint8Array([1]), {
+                signal: controller.signal,
+            }),
+        ).rejects.toMatchObject({ stage: 'send', cause: expect.any(SnowLumaAbortError) });
+        expect(calls.every((call) => call.action === 'upload_file_stream')).toBe(true);
+    });
+
+    it('passes cancellation to the upload and stops before any later stage', async () => {
+        const controller = new AbortController();
+        const { client, calls } = server();
+        await expect(
+            client.sendPrivateFile(123, new Uint8Array([1, 2]), {
+                chunkSize: 1,
+                signal: controller.signal,
+                onProgress: () => controller.abort(),
+            }),
+        ).rejects.toMatchObject({ stage: 'upload', cause: expect.any(SnowLumaAbortError) });
+        expect(calls).toHaveLength(1);
+    });
+
+    it('passes request controls to both stages', async () => {
+        const { client } = server();
+        const upload = vi.spyOn(client, 'uploadFileStream');
+        const send = vi.spyOn(client, 'sendGroupMessage');
+        const controls = { signal: new AbortController().signal, timeoutMs: 1234, echo: 'media' };
+        await client.sendGroupImage(123, new Uint8Array([1]), controls);
+        expect(upload.mock.calls[0][1]).toMatchObject(controls);
+        expect(send.mock.calls[0][2]).toEqual(controls);
+    });
+
+    it.each(['abort', 'timeout'] as const)(
+        'retains upload metadata when an in-flight send ends by %s',
+        async (mode) => {
+            vi.useFakeTimers();
+
+            try {
+                const controller = new AbortController();
+                const { client, calls } = server({
+                    sendResponse: (init) =>
+                        new Promise((_resolve, reject) => {
+                            init?.signal?.addEventListener(
+                                'abort',
+                                () => reject(init.signal?.reason),
+                                { once: true },
+                            );
+                        }),
+                });
+                const result = client.sendGroupImage(123, new Uint8Array([1]), {
+                    signal: controller.signal,
+                    timeoutMs: 1000,
+                });
+                const rejected = expect(result).rejects.toMatchObject({
+                    stage: 'send',
+                    upload: { file_path: '/server/staged.bin' },
+                    cause:
+                        mode === 'abort'
+                            ? expect.any(SnowLumaAbortError)
+                            : expect.any(SnowLumaTimeoutError),
+                });
+                await vi.waitFor(() => expect(calls.at(-1)?.action).toBe('send_group_msg'));
+
+                if (mode === 'abort') {
+                    controller.abort();
+                } else {
+                    await vi.advanceTimersByTimeAsync(1000);
+                }
+
+                await rejected;
+                expect(calls).toHaveLength(3);
+                expect(vi.getTimerCount()).toBe(0);
+            } finally {
+                vi.useRealTimers();
+            }
+        },
+    );
+
+    it('never treats a string as a local path', async () => {
+        const { client, fetch } = server();
+        // @ts-expect-error A local path must be explicitly opened with localFile().
+        await expect(client.sendGroupImage(123, './local.png')).rejects.toBeInstanceOf(
+            SnowLumaMediaSendError,
+        );
+        expect(fetch).not.toHaveBeenCalled();
+    });
+});
+
+describe('Node localFile source', () => {
+    let directory: string | undefined;
+
+    afterEach(async () => {
+        if (directory) {
+            await rm(directory, { recursive: true, force: true });
+        }
+    });
+
+    async function fixture() {
+        directory = await mkdtemp(join(tmpdir(), 'sdk-local-media-'));
+        const path = join(directory, '图片.bin');
+        await writeFile(path, new Uint8Array([7, 8, 9]));
+        return path;
+    }
+
+    it('sends file-backed bytes from paths and file URLs without leaking the local path', async () => {
+        const path = await fixture();
+
+        for (const location of [path, pathToFileURL(path)]) {
+            const source = await localFile(location);
+            const { client, calls } = server();
+            await client.sendPrivateImage(123, source);
+            expect(calls[0].params).toMatchObject({
+                filename: '图片.bin',
+                file_size: 3,
+                chunk_data: 'BwgJ',
+            });
+            expect(JSON.stringify(calls)).not.toContain(directory);
+        }
+    });
+
+    it('reports missing files and rejects directories before uploading', async () => {
+        const path = await fixture();
+        await expect(localFile(path + '.missing')).rejects.toMatchObject({ code: 'ENOENT' });
+        await expect(localFile(directory!)).rejects.toThrow('regular file');
+    });
+
+    it('fails if the file changes after the source is created', async () => {
+        const path = await fixture();
+        const source = await localFile(path);
+        await writeFile(path, 'modified file');
+        const { client, fetch } = server();
+        await expect(client.sendGroupFile(123, source)).rejects.toMatchObject({ stage: 'upload' });
+        expect(fetch).not.toHaveBeenCalled();
+    });
+});