// Regression coverage for nested forward (forward-inside-forward). // // `parseForwardNodes` detects an all-`{type:'node'}` content array, // recursively builds the inner `ForwardNodePayload[]`, and attaches it // to the outer node as `innerForward`. `uploadForwardNodes` then drives // the recursive long-msg upload + ARK-preview generation + msgBody // piggyback in one pass over the tree — modelled on NapCat's // `uploadForwardedNodesPacket` (`dev/NapCatQQ/.../SendMsg.ts:208`). // // These tests stub `bridge.uploadForwardNodes` so we can inspect the // payload that the upload pipeline receives: outer nodes carry an // `innerForward` field holding the parsed inner chain, and the // upload helper is invoked exactly ONCE (the recursive walk happens // inside the real implementation; mocks see only the top call). import { describe, expect, it, vi } from 'vitest'; import type { BridgeInterface } from '../../src/bridge/bridge-interface'; import type { OneBotInstanceContext } from '../src/instance-context'; import { forwardSingleMessage, sendGroupForwardMessage, sendPrivateForwardMessage, } from '../src/modules/message-actions'; function fakeBridge(overrides: Partial = {}): BridgeInterface { return new Proxy(overrides as BridgeInterface, { get(target, prop) { if (prop in target) return (target as any)[prop]; throw new Error(`fakeBridge: '${String(prop)}' was not stubbed for this test`); }, }); } function makeCtx(bridge: BridgeInterface): OneBotInstanceContext { return { uin: '10001', selfId: 10001, bridge, messageStore: { findMedia: () => null, findEvent: () => null } as any, cacheMessageMeta: vi.fn(), mediaStore: {} as any, musicSignUrl: '', } as unknown as OneBotInstanceContext; } describe('forward — nested {type:"node"} content', () => { it('group: nested forward attaches inner chain to outer node via `innerForward`', async () => { // Single upload call, but the outer payload now carries an // `innerForward` field with the recursively-parsed inner chain. // The real `uploadForwardNodes` (the production module) walks // that tree and does the recursive long-msg uploads with NapCat // piggyback — we're just testing the parse-side handoff here. const uploadForwardNodes = vi.fn(async (_nodes: any[], _groupId?: number, _userId?: number) => 'OUTER_RESID'); const sendGroupMessage = vi.fn(async () => ({ messageId: 1, sequence: 100, clientSequence: 0, random: 1, timestamp: 1700000000, })); const bridge = fakeBridge({ apis: { message: { sendGroup: sendGroupMessage }, forward: { upload: uploadForwardNodes } } } as any); const ctx = makeCtx(bridge); const messages = [{ type: 'node', data: { user_id: 111, nickname: 'outer', content: [{ type: 'node', data: { user_id: 222, nickname: 'inner', content: [{ type: 'text', data: { text: 'hello from inner' } }], }, }], }, }]; const result = await sendGroupForwardMessage(ctx, 12345, messages as any); // Exactly one upload call: the production-side recursive walker // owns the inner upload, the OneBot parser just hands off the tree. expect(uploadForwardNodes).toHaveBeenCalledOnce(); const [outerNodes, outerGroupId] = uploadForwardNodes.mock.calls[0]!; expect(outerGroupId).toBe(12345); const outerNode = (outerNodes as any[])[0]!; expect(outerNode.userUin).toBe(111); // Outer node's `elements` is empty — the upload pipeline replaces // it with the real ARK preview once it has the inner res_id. expect(outerNode.elements).toEqual([]); // The inner chain rides along as `innerForward`. expect(Array.isArray(outerNode.innerForward)).toBe(true); expect(outerNode.innerForward).toHaveLength(1); expect(outerNode.innerForward[0]).toMatchObject({ userUin: 222, nickname: 'inner', elements: [{ type: 'text', text: 'hello from inner' }], }); expect(result.forwardId).toBe('OUTER_RESID'); expect(sendGroupMessage).toHaveBeenCalledOnce(); }); it('threads an explicit data.time onto the node payload, leaving absent ones for the default (#209)', async () => { const uploadForwardNodes = vi.fn(async (_nodes: any[], _groupId?: number, _userId?: number) => 'RESID'); const sendGroupMessage = vi.fn(async () => ({ messageId: 1, sequence: 100, clientSequence: 0, random: 1, timestamp: 1700000000, })); const bridge = fakeBridge({ apis: { message: { sendGroup: sendGroupMessage }, forward: { upload: uploadForwardNodes } } } as any); const ctx = makeCtx(bridge); const messages = [ { type: 'node', data: { user_id: 111, nickname: 'a', time: 1600000000, content: [{ type: 'text', data: { text: 'hi' } }] } }, { type: 'node', data: { user_id: 222, nickname: 'b', content: [{ type: 'text', data: { text: 'yo' } }] } }, { type: 'node', data: { user_id: 333, nickname: 'c', time: 1700000000000, content: [{ type: 'text', data: { text: 'ms' } }] } }, // ms → out of uint32 range { type: 'node', data: { user_id: 444, nickname: 'd', time: -5, content: [{ type: 'text', data: { text: 'neg' } }] } }, ]; await sendGroupForwardMessage(ctx, 12345, messages as any); const [nodes] = uploadForwardNodes.mock.calls[0]!; expect((nodes as any[])[0].time).toBe(1600000000); // explicit seconds carried through expect((nodes as any[])[1].time).toBeUndefined(); // absent → default to now expect((nodes as any[])[2].time).toBeUndefined(); // millisecond input rejected (uint32 overflow guard) expect((nodes as any[])[3].time).toBeUndefined(); // negative rejected → default to now }); it('private: nested forward threads userId into uploadForwardNodes', async () => { // Same shape but routed via sendPrivateForwardMessage. The c2c path // passes `userId` instead of `groupId` so the upload pipeline can // pick up the recipient's UID scene for any inner media element. const uploadForwardNodes = vi.fn(async (_nodes: any[], _groupId?: number, _userId?: number) => 'RESID'); const sendPrivateMessage = vi.fn(async () => ({ messageId: 1, sequence: 100, clientSequence: 0, random: 1, timestamp: 1700000000, })); const bridge = fakeBridge({ apis: { message: { sendPrivate: sendPrivateMessage }, forward: { upload: uploadForwardNodes } } } as any); const ctx = makeCtx(bridge); const messages = [{ type: 'node', data: { user_id: 111, nickname: 'outer', content: [{ type: 'node', data: { user_id: 222, nickname: 'inner', content: [{ type: 'text', data: { text: 'hi' } }], }, }], }, }]; await sendPrivateForwardMessage(ctx, 67890, messages as any); // Single call, c2c-scoped (groupId undefined, userId = recipient). expect(uploadForwardNodes).toHaveBeenCalledOnce(); const call = uploadForwardNodes.mock.calls[0]!; expect(call[1]).toBeUndefined(); expect(call[2]).toBe(67890); // Inner chain attached via `innerForward`. const outerNode = (call[0] as any[])[0]!; expect(outerNode.innerForward).toHaveLength(1); expect(outerNode.innerForward[0]!.userUin).toBe(222); }); it('rejects nesting deeper than 3 levels', async () => { // Build a 4-level nested chain. NapCat caps at 3 too, going further // wastes long-msg uploads and risks one inner upload timing out // and aborting the whole tree. Better to fail loud here. const uploadForwardNodes = vi.fn(async (_nodes: any[], _groupId?: number, _userId?: number) => 'X'); const sendGroupMessage = vi.fn(async () => ({ messageId: 1, sequence: 100, clientSequence: 0, random: 1, timestamp: 0, })); const bridge = fakeBridge({ apis: { message: { sendGroup: sendGroupMessage }, forward: { upload: uploadForwardNodes } } } as any); const ctx = makeCtx(bridge); function wrap(content: any, depth: number): any { if (depth === 0) return [{ type: 'text', data: { text: 'leaf' } }]; return [{ type: 'node', data: { user_id: 100 + depth, nickname: `lvl-${depth}`, content: wrap(content, depth - 1) }, }]; } await expect( sendGroupForwardMessage(ctx, 12345, wrap(null, 4) as any), ).rejects.toThrow(/depth/); }); it('flat content (no nesting) still goes through the unchanged path', async () => { // Backwards-compat: a single-level forward with plain text nodes // calls uploadForwardNodes exactly once and never touches the // recursive branch. const uploadForwardNodes = vi.fn(async (_nodes: any[], _groupId?: number, _userId?: number) => 'RES'); const sendGroupMessage = vi.fn(async () => ({ messageId: 1, sequence: 100, clientSequence: 0, random: 1, timestamp: 0, })); const bridge = fakeBridge({ apis: { message: { sendGroup: sendGroupMessage }, forward: { upload: uploadForwardNodes } } } as any); const ctx = makeCtx(bridge); const messages = [ { type: 'node', data: { user_id: 111, nickname: 'a', content: [{ type: 'text', data: { text: 'one' } }] } }, { type: 'node', data: { user_id: 222, nickname: 'b', content: [{ type: 'text', data: { text: 'two' } }] } }, ]; await sendGroupForwardMessage(ctx, 12345, messages as any); expect(uploadForwardNodes).toHaveBeenCalledOnce(); const [nodes] = uploadForwardNodes.mock.calls[0]!; expect((nodes as any[])).toHaveLength(2); expect((nodes as any[])[0]!.elements).toEqual([{ type: 'text', text: 'one' }]); expect((nodes as any[])[1]!.elements).toEqual([{ type: 'text', text: 'two' }]); }); it('rejects video with hidden siblings before uploading a forward', async () => { const uploadForwardNodes = vi.fn(async () => 'RES'); const sendGroupMessage = vi.fn(); const bridge = fakeBridge({ apis: { message: { sendGroup: sendGroupMessage }, forward: { upload: uploadForwardNodes } }, } as any); const ctx = makeCtx(bridge); await expect(sendGroupForwardMessage(ctx, 12345, [{ type: 'node', data: { user_id: 111, nickname: 'mixed-video', content: [ { type: 'video', data: { file: 'https://example.com/video.mp4' } }, { type: 'text', data: { text: 'must not survive bot forwarding' } }, ], }, }] as any)).rejects.toMatchObject({ code: 'UNSENDABLE_TYPE', elementType: 'video', }); expect(uploadForwardNodes).not.toHaveBeenCalled(); expect(sendGroupMessage).not.toHaveBeenCalled(); }); it('regenerates a cached merged forward for the target chat (#437)', async () => { const fetch = vi.fn(async (resId: string) => { expect(resId).toBe('OLD_RES'); return [{ userUin: 111, nickname: 'alice', elements: [{ type: 'text', text: 'hi' }], }]; }); const upload = vi.fn(async (nodes: any[], groupId?: number, userId?: number) => { expect(groupId).toBeUndefined(); expect(userId).toBe(67890); expect(nodes).toEqual([expect.objectContaining({ userUin: 111, elements: [{ type: 'text', text: 'hi' }], })]); return 'NEW_RES'; }); const sendPrivate = vi.fn(async () => ({ messageId: 1, sequence: 100, clientSequence: 14, random: 1, timestamp: 1700000000, })); const bridge = fakeBridge({ apis: { message: { sendPrivate }, forward: { fetch, upload } }, } as any); const ctx = makeCtx(bridge); (ctx as any).messageStore = { findMedia: () => null, findEvent: () => ({ message: [{ type: 'forward', data: { id: 'OLD_RES' } }], }), }; const result = await forwardSingleMessage(ctx, 77, { userId: 67890 }); expect(result.messageId).not.toBe(0); expect(fetch).toHaveBeenCalledOnce(); expect(upload).toHaveBeenCalledOnce(); expect(sendPrivate).toHaveBeenCalledOnce(); expect(sendPrivate.mock.calls[0]![1]).toEqual([ expect.objectContaining({ type: 'forward', resId: 'NEW_RES' }), ]); }); it('fails a merged-forward single send when the inner tree cannot be fetched (#437)', async () => { const fetch = vi.fn(async () => { throw new Error('download forward message failed'); }); const upload = vi.fn(async () => 'NEW_RES'); const sendPrivate = vi.fn(); const bridge = fakeBridge({ apis: { message: { sendPrivate }, forward: { fetch, upload } }, } as any); const ctx = makeCtx(bridge); (ctx as any).messageStore = { findMedia: () => null, findEvent: () => ({ message: [{ type: 'forward', data: { id: 'OLD_RES' } }], }), }; await expect(forwardSingleMessage(ctx, 77, { userId: 67890 })) .rejects.toThrow(/download forward message failed/); expect(upload).not.toHaveBeenCalled(); expect(sendPrivate).not.toHaveBeenCalled(); }); it('expands a nested forward card into an inner tree before upload (#437)', async () => { const fetch = vi.fn(async (resId: string) => { if (resId === 'OUTER') { return [{ userUin: 111, nickname: 'outer', elements: [{ type: 'forward', resId: 'INNER' }], }]; } if (resId === 'INNER') { return [{ userUin: 222, nickname: 'inner', elements: [{ type: 'text', text: 'leaf' }], }]; } throw new Error(`unexpected fetch ${resId}`); }); const upload = vi.fn(async (nodes: any[]) => { expect(nodes[0]).toMatchObject({ userUin: 111, elements: [], innerForward: [ expect.objectContaining({ userUin: 222, elements: [{ type: 'text', text: 'leaf' }], }), ], }); return 'NEW_OUTER'; }); const sendGroup = vi.fn(async () => ({ messageId: 1, sequence: 100, clientSequence: 0, random: 1, timestamp: 1700000000, })); const bridge = fakeBridge({ apis: { message: { sendGroup }, forward: { fetch, upload } }, } as any); const ctx = makeCtx(bridge); (ctx as any).messageStore = { findMedia: () => null, findEvent: () => ({ message: [{ type: 'forward', data: { id: 'OUTER' } }], }), }; await forwardSingleMessage(ctx, 88, { groupId: 12345 }); expect(fetch).toHaveBeenCalledTimes(2); expect(upload).toHaveBeenCalledOnce(); expect(upload.mock.calls[0]![1]).toBe(12345); expect(sendGroup).toHaveBeenCalledWith(12345, [ expect.objectContaining({ type: 'forward', resId: 'NEW_OUTER' }), ]); }); it('rejects hidden siblings before forwarding a cached video message', async () => { const sendGroupMessage = vi.fn(); const findVideo = vi.fn(); const bridge = fakeBridge({ apis: { message: { sendGroup: sendGroupMessage } } } as any); const ctx = makeCtx(bridge); (ctx as any).messageStore = { findMedia: () => null, findEvent: () => ({ message: [ { type: 'video', data: { file: 'cached-video-id' } }, { type: 'text', data: { text: 'must not survive bot forwarding' } }, ], }), }; (ctx as any).mediaStore = { findVideo }; await expect(forwardSingleMessage(ctx, 77, { groupId: 12345 })) .rejects.toMatchObject({ code: 'UNSENDABLE_TYPE', elementType: 'video', }); expect(findVideo).not.toHaveBeenCalled(); expect(sendGroupMessage).not.toHaveBeenCalled(); }); it('rejects an unknown top-level entry before uploading valid siblings', async () => { const uploadForwardNodes = vi.fn(async () => 'RES'); const sendGroupMessage = vi.fn(); const bridge = fakeBridge({ apis: { message: { sendGroup: sendGroupMessage }, forward: { upload: uploadForwardNodes } }, } as any); const ctx = makeCtx(bridge); const messages = [ { type: 'node', data: { user_id: 111, nickname: 'valid', content: [{ type: 'text', data: { text: 'must not upload' } }], }, }, { type: 'surprise', data: { content: 'silently dropped before' } }, ]; await expect(sendGroupForwardMessage(ctx, 12345, messages as any)).rejects.toMatchObject({ code: 'UNKNOWN_TYPE', elementType: 'surprise', }); expect(uploadForwardNodes).not.toHaveBeenCalled(); expect(sendGroupMessage).not.toHaveBeenCalled(); }); it('rejects object-valued node metadata before uploading', async () => { const uploadForwardNodes = vi.fn(async () => 'RES'); const sendGroupMessage = vi.fn(); const bridge = fakeBridge({ apis: { message: { sendGroup: sendGroupMessage }, forward: { upload: uploadForwardNodes } }, } as any); const ctx = makeCtx(bridge); await expect(sendGroupForwardMessage(ctx, 12345, [{ type: 'node', data: { user_id: { accidental: 111 }, nickname: 'invalid', content: [{ type: 'text', data: { text: 'must not upload' } }], }, }] as any)).rejects.toMatchObject({ code: 'INVALID_FIELD', elementType: 'node', field: 'user_id', }); expect(uploadForwardNodes).not.toHaveBeenCalled(); expect(sendGroupMessage).not.toHaveBeenCalled(); }); it('rejects a cached message node with no valid sender instead of dropping it', async () => { const uploadForwardNodes = vi.fn(async () => 'RES'); const sendGroupMessage = vi.fn(); const bridge = fakeBridge({ apis: { message: { sendGroup: sendGroupMessage }, forward: { upload: uploadForwardNodes } }, } as any); const ctx = makeCtx(bridge); (ctx as any).messageStore = { findMedia: () => null, findEvent: () => ({ user_id: 0, message_type: 'group', message: [{ type: 'text', data: { text: 'cached' } }], sender: { nickname: 'missing-id' }, }), }; await expect(sendGroupForwardMessage(ctx, 12345, [ { type: 'node', data: { id: 7 } }, { type: 'node', data: { user_id: 222, content: [{ type: 'text', data: { text: 'sibling' } }] } }, ] as any)).rejects.toMatchObject({ code: 'INVALID_FIELD', elementType: 'node', field: 'user_id', }); expect(uploadForwardNodes).not.toHaveBeenCalled(); expect(sendGroupMessage).not.toHaveBeenCalled(); }); it('resolves a cached node by a signed negative OneBot message_id', async () => { const uploadForwardNodes = vi.fn(async () => 'RES'); const sendGroupMessage = vi.fn(async () => ({ messageId: 1, sequence: 1, clientSequence: 0, random: 1, timestamp: 1, })); const findEvent = vi.fn((id: number) => id === -123 ? ({ user_id: 111, message_id: -123, message_seq: 42, message_type: 'group', group_id: 12345, time: 1700000000, message: [{ type: 'text', data: { text: 'cached negative id' } }], sender: { nickname: 'alice' }, }) : null); const bridge = fakeBridge({ apis: { message: { sendGroup: sendGroupMessage }, forward: { upload: uploadForwardNodes } }, } as any); const ctx = makeCtx(bridge); (ctx as any).messageStore = { findEvent, findMedia: () => null }; await sendGroupForwardMessage(ctx, 12345, [ { type: 'node', data: { id: -123 } }, ] as any); expect(findEvent).toHaveBeenCalledWith(-123); const [nodes] = uploadForwardNodes.mock.calls[0]!; expect((nodes as any[])[0]).toMatchObject({ userUin: 111, msgId: -123, elements: [{ type: 'text', text: 'cached negative id' }], }); }); it('[#372] empty group card does not replace a cached sender nickname with the QQ number', async () => { // Group events always store sender.card as "" when the member has no // card. `??` treats that empty string as present and then // `nickname || String(userUin)` collapses the display name to the QQ // number — the get_forward_msg symptom in #372. const uploadForwardNodes = vi.fn(async () => 'RES'); const sendGroupMessage = vi.fn(async () => ({ messageId: 1, sequence: 1, clientSequence: 0, random: 1, timestamp: 1, })); const findEvent = vi.fn((id: number) => id === 7 ? ({ user_id: 22222, message_id: 7, message_seq: 42, message_type: 'group', group_id: 12345, time: 1700000000, message: [{ type: 'text', data: { text: 'cached' } }], sender: { user_id: 22222, nickname: 'alice', card: '' }, }) : id === 8 ? ({ user_id: 33333, message_id: 8, message_seq: 43, message_type: 'group', group_id: 12345, time: 1700000000, message: [{ type: 'text', data: { text: 'nameless' } }], sender: { user_id: 33333, nickname: '', card: '' }, }) : null); const bridge = fakeBridge({ apis: { message: { sendGroup: sendGroupMessage }, forward: { upload: uploadForwardNodes } }, } as any); const ctx = makeCtx(bridge); (ctx as any).messageStore = { findEvent, findMedia: () => null }; await sendGroupForwardMessage(ctx, 12345, [ { type: 'node', data: { id: 7, nickname: 'node-override' } }, { type: 'node', data: { id: 8, nickname: 'node-fallback' } }, ] as any); const [nodes] = uploadForwardNodes.mock.calls[0]!; expect((nodes as any[])[0]).toMatchObject({ userUin: 22222, nickname: 'alice' }); expect((nodes as any[])[1]).toMatchObject({ userUin: 33333, nickname: 'node-fallback' }); }); it('reports a missing cached message_id as caller-invalid before upload', async () => { const uploadForwardNodes = vi.fn(async () => 'RES'); const sendGroupMessage = vi.fn(); const bridge = fakeBridge({ apis: { message: { sendGroup: sendGroupMessage }, forward: { upload: uploadForwardNodes } }, } as any); const ctx = makeCtx(bridge); await expect(sendGroupForwardMessage(ctx, 12345, [ { type: 'node', data: { id: -404 } }, ] as any)).rejects.toMatchObject({ code: 'INVALID_FIELD', elementType: 'node', field: 'message_id', }); expect(uploadForwardNodes).not.toHaveBeenCalled(); expect(sendGroupMessage).not.toHaveBeenCalled(); }); it('rejects mixed node/non-node content instead of partially dropping the node', async () => { // Recursion only kicks in when *all* content entries are nodes — // mixed content is ambiguous (do the non-node parts belong to the // outer node or are they parallel siblings?), so we keep the legacy // behaviour is ambiguous, so reject it before upload. A user who wants a // nested forward must pass a pure node list. const uploadForwardNodes = vi.fn(async (_nodes: any[], _groupId?: number, _userId?: number) => 'RES'); const sendGroupMessage = vi.fn(async () => ({ messageId: 1, sequence: 100, clientSequence: 0, random: 1, timestamp: 0, })); const bridge = fakeBridge({ apis: { message: { sendGroup: sendGroupMessage }, forward: { upload: uploadForwardNodes } } } as any); const ctx = makeCtx(bridge); const messages = [{ type: 'node', data: { user_id: 111, nickname: 'mixed', content: [ { type: 'text', data: { text: 'a sibling' } }, { type: 'node', data: { user_id: 222, content: [{ type: 'text', data: { text: 'lost' } }] } }, ], }, }]; await expect(sendGroupForwardMessage(ctx, 12345, messages as any)).rejects.toMatchObject({ code: 'UNSENDABLE_TYPE', elementType: 'node', }); expect(uploadForwardNodes).not.toHaveBeenCalled(); expect(sendGroupMessage).not.toHaveBeenCalled(); }); it('[#203] node with user_id "0" or missing falls back to the bot self_id', async () => { // Upstream frameworks (AstrBot etc.) send fake forward nodes with // user_id "0" or omit it; the protocol端 knows self_id, so default to it // instead of rejecting (matches NapCat/LLBot + the core builder). const uploadForwardNodes = vi.fn(async (_nodes: any[]) => 'RESID'); const sendGroupMessage = vi.fn(async () => ({ messageId: 1, sequence: 100, clientSequence: 0, random: 1, timestamp: 1700000000, })); const bridge = fakeBridge({ apis: { message: { sendGroup: sendGroupMessage }, forward: { upload: uploadForwardNodes } } } as any); const ctx = makeCtx(bridge); const messages = [ { type: 'node', data: { user_id: '0', nickname: 'PixivBot', content: [{ type: 'text', data: { text: 'a' } }] } }, { type: 'node', data: { nickname: 'PixivBot', content: [{ type: 'text', data: { text: 'b' } }] } }, // user_id omitted ]; await sendGroupForwardMessage(ctx, 12345, messages as any); const [nodes] = uploadForwardNodes.mock.calls[0]!; expect((nodes as any[])[0].userUin).toBe(10001); // "0" → self_id expect((nodes as any[])[0].nickname).toBe('PixivBot'); // custom nickname preserved expect((nodes as any[])[1].userUin).toBe(10001); // omitted → self_id }); it('accepts node metadata `news` preview arrays (OneBot ecosystem compat)', async () => { // Upstream frameworks (NapCat / LLOneBot / AstrBot etc.) attach // `news: [{ text }]` preview metadata to forward nodes. Only scalar // metadata was allowed before, so a standard OneBot-style node was // rejected with `forward messages[i].news must be a scalar value`. const uploadForwardNodes = vi.fn(async (_nodes: any[]) => 'RESID'); const sendGroupMessage = vi.fn(async () => ({ messageId: 1, sequence: 100, clientSequence: 0, random: 1, timestamp: 1700000000, })); const bridge = fakeBridge({ apis: { message: { sendGroup: sendGroupMessage }, forward: { upload: uploadForwardNodes } } } as any); const ctx = makeCtx(bridge); const messages = [{ type: 'node', data: { user_id: 111, nickname: 'outer', news: [{ text: '预览行 1' }, { text: '预览行 2' }], summary: '共 2 条', content: [{ type: 'node', data: { user_id: 222, nickname: 'inner', content: [{ type: 'text', data: { text: 'hi' } }] } }], }, }]; await sendGroupForwardMessage(ctx, 12345, messages as any); expect(uploadForwardNodes).toHaveBeenCalledOnce(); const [nodes] = uploadForwardNodes.mock.calls[0]!; expect((nodes as any[])[0].userUin).toBe(111); expect((nodes as any[])[0].innerForward).toHaveLength(1); }); it('rejects non-scalar node metadata that is not an accepted preview field', async () => { // The news carve-out must stay narrow: any other non-scalar metadata // (e.g. an accidental nested object) is still rejected up front. const uploadForwardNodes = vi.fn(async (_nodes: any[]) => 'RESID'); const sendGroupMessage = vi.fn(); const bridge = fakeBridge({ apis: { message: { sendGroup: sendGroupMessage }, forward: { upload: uploadForwardNodes } }, } as any); const ctx = makeCtx(bridge); const messages = [{ type: 'node', data: { user_id: 111, nickname: 'bad', arbitrary: { nested: true }, content: [{ type: 'text', data: { text: 'hi' } }], }, }]; await expect(sendGroupForwardMessage(ctx, 12345, messages as any)).rejects.toMatchObject({ code: 'INVALID_FIELD', elementType: 'node', field: 'arbitrary', }); expect(uploadForwardNodes).not.toHaveBeenCalled(); expect(sendGroupMessage).not.toHaveBeenCalled(); }); it.each([ ['news', 123], ['news', 'preview'], ['news', null], ['news', [{ text: false }]], ['news', [null]], ['title', 123], ['source', false], ['summary', []], ['prompt', null], ])('rejects malformed %s preview metadata before upload', async (field, value) => { const upload = vi.fn(); const sendGroup = vi.fn(); const ctx = makeCtx(fakeBridge({ apis: { message: { sendGroup }, forward: { upload } } } as any)); await expect(sendGroupForwardMessage(ctx, 12345, [{ type: 'node', data: { user_id: 111, nickname: 'sender', [field as string]: value, content: [{ type: 'text', data: { text: 'hello' } }], }, }] as any)).rejects.toMatchObject({ code: 'INVALID_FIELD', field }); expect(upload).not.toHaveBeenCalled(); expect(sendGroup).not.toHaveBeenCalled(); }); it('validates nested preview metadata before parsing an earlier contact card', async () => { const getGroupRecommendArk = vi.fn(); const upload = vi.fn(); const sendGroup = vi.fn(); const ctx = makeCtx(fakeBridge({ apis: { message: { sendGroup }, forward: { upload }, contacts: { getGroupRecommendArk }, } } as any)); await expect(sendGroupForwardMessage(ctx, 12345, [ { type: 'node', data: { user_id: 111, content: [{ type: 'contact', data: { type: 'group', id: 12345 } }] } }, { type: 'node', data: { user_id: 222, content: [ { type: 'node', data: { user_id: 333, source: false, content: [{ type: 'text', data: { text: 'hello' } }] } }, ] } }, ])).rejects.toMatchObject({ code: 'INVALID_FIELD', field: 'source' }); expect(getGroupRecommendArk).not.toHaveBeenCalled(); expect(upload).not.toHaveBeenCalled(); expect(sendGroup).not.toHaveBeenCalled(); }); });