Files
SnowLuma/packages/core/tests/element-builder.test.ts
T
DrSmoothl 27c527976b fix(onebot): reject ambiguous video message combinations
Prevent ordinary messages and forwarded nodes from combining video content with visible sibling segments or additional videos. Invalid combinations now fail before parsing side effects, media work, or bridge sends, while exact empty text placeholders remain compatible with a single video.

Cover group, private, temporary-session, CQ string, nested forward, cached forward, and protocol-builder paths. Preserve the existing standalone window-shake behavior and keep valid single-video messages unchanged.
2026-08-05 23:55:55 +08:00

384 lines
14 KiB
TypeScript

// Regression test for the c2c-vs-group businessType asymmetry that made
// private-chat video / record sends bounce with `send private message
// rejected: result=79`. The receive-side decoder
// (msg-push/rich-body-decoder.ts) explicitly treats the businessType
// pairs as:
//
// image : c2c=10, group=20
// video : c2c=11, group=21
// record : c2c=12, group=22
//
// `makeImageElem` always honoured this split (`isGroup ? 20 : 10`).
// `makeVideoElem` and `makePttElem` used to hardcode the group value
// for both scenes, so any c2c video / private voice send arrived at the
// QQ NT server with a businessType the c2c routing path did not
// recognise and got rejected with result=79.
import { describe, expect, it, vi } from 'vitest';
import { inflateSync } from 'zlib';
vi.mock('@snowluma/protocol/highway/image-upload', () => ({
uploadImageMsgInfo: vi.fn(async () => new Uint8Array([7, 8, 9])),
}));
vi.mock('@snowluma/protocol/highway/ptt-upload', () => ({
uploadPttMsgInfo: vi.fn(async () => new Uint8Array([4, 5, 6])),
}));
vi.mock('@snowluma/protocol/highway/video-upload', () => ({
uploadVideoMsgInfo: vi.fn(async () => new Uint8Array([1, 2, 3])),
}));
import { buildSendElems } from '@snowluma/protocol/element-builder';
import { MessageElementValidationError } from '@snowluma/protocol/element-manifest';
import { uploadImageMsgInfo } from '@snowluma/protocol/highway/image-upload';
import { uploadVideoMsgInfo } from '@snowluma/protocol/highway/video-upload';
const fakeBridge = {} as any;
function commonElem(elem: any): { serviceType: number; businessType: number; pbElem: Uint8Array } {
return elem.commonElem;
}
function inflatePrefixedPayload(data: Uint8Array): string {
expect(data[0]).toBe(0x01);
return inflateSync(Buffer.from(data.subarray(1))).toString('utf8');
}
describe('element-builder / rich card encoding', () => {
it('encodes json segments as deflated LightApp payloads and preserves non-ASCII text', async () => {
const card = JSON.stringify({
app: 'com.tencent.structmsg',
view: 'music',
prompt: '[音乐]起风了',
meta: { music: { title: '起风了', desc: '买辣椒也用券' } },
});
const [elem] = await buildSendElems(
[{ type: 'json', text: card } as any],
{ bridge: fakeBridge, groupId: 12345 },
);
expect(elem.lightApp).toBeDefined();
expect((elem as any).richMsg).toBeUndefined();
expect(inflatePrefixedPayload(elem.lightApp!.data!)).toBe(card);
});
it('encodes xml richMsg payloads by UTF-8 bytes, not JavaScript string length', async () => {
const xml = '<msg serviceID="35" brief="[分享]中文卡片"></msg>';
const [elem] = await buildSendElems(
[{ type: 'xml', text: xml, subType: 35 } as any],
{ bridge: fakeBridge, groupId: 12345 },
);
expect(elem.richMsg?.serviceId).toBe(35);
expect(inflatePrefixedPayload(elem.richMsg!.template1!)).toBe(xml);
});
});
describe('element-builder / commonElem.businessType per scene', () => {
describe('private window shake', () => {
it('encodes poke type 1 as CommonElem service 2 with the verified payload', async () => {
const [elem] = await buildSendElems(
[{ type: 'poke', subType: 1 }],
{ bridge: fakeBridge, userUid: 'u_peer', scene: 'direct-private' },
);
expect(commonElem(elem)).toMatchObject({
serviceType: 2,
businessType: 1,
});
expect(Array.from(commonElem(elem).pbElem)).toEqual([0x08, 0x01]);
});
it('rejects mixed window-shake content before uploading an earlier media segment', async () => {
vi.mocked(uploadImageMsgInfo).mockClear();
await expect(buildSendElems([
{ type: 'image', url: 'file:///tmp/must-not-upload.png' },
{ type: 'poke', subType: 1 },
], {
bridge: fakeBridge,
userUid: 'u_peer',
scene: 'direct-private',
})).rejects.toMatchObject({
code: 'UNSENDABLE_TYPE',
elementType: 'poke',
message: expect.stringContaining('only segment'),
});
expect(uploadImageMsgInfo).not.toHaveBeenCalled();
});
});
describe('image', () => {
it('c2c → businessType 10', async () => {
const [elem] = await buildSendElems(
[{ type: 'image', url: 'file:///tmp/a.png' } as any],
{ bridge: fakeBridge, userUid: 'u_peer' },
);
expect(commonElem(elem).serviceType).toBe(48);
expect(commonElem(elem).businessType).toBe(10);
});
it('group → businessType 20', async () => {
const [elem] = await buildSendElems(
[{ type: 'image', url: 'file:///tmp/a.png' } as any],
{ bridge: fakeBridge, groupId: 12345 },
);
expect(commonElem(elem).businessType).toBe(20);
});
});
describe('video', () => {
it('c2c → businessType 11 (regression: was 21, server returned result=79)', async () => {
const [elem] = await buildSendElems(
[{ type: 'video', url: 'file:///tmp/clip.mp4' } as any],
{ bridge: fakeBridge, userUid: 'u_peer' },
);
expect(commonElem(elem).serviceType).toBe(48);
expect(commonElem(elem).businessType).toBe(11);
});
it('group → businessType 21', async () => {
const [elem] = await buildSendElems(
[{ type: 'video', url: 'file:///tmp/clip.mp4' } as any],
{ bridge: fakeBridge, groupId: 12345 },
);
expect(commonElem(elem).businessType).toBe(21);
});
});
describe('record', () => {
it('c2c → businessType 12 (regression: was 22)', async () => {
const [elem] = await buildSendElems(
[{ type: 'record', url: 'file:///tmp/voice.amr' } as any],
{ bridge: fakeBridge, userUid: 'u_peer' },
);
expect(commonElem(elem).serviceType).toBe(48);
expect(commonElem(elem).businessType).toBe(12);
});
it('group → businessType 22', async () => {
const [elem] = await buildSendElems(
[{ type: 'record', url: 'file:///tmp/voice.amr' } as any],
{ bridge: fakeBridge, groupId: 12345 },
);
expect(commonElem(elem).businessType).toBe(22);
});
});
});
describe('element-builder / all-message validation preflight', () => {
it('rejects hidden siblings and duplicate videos before uploading', async () => {
vi.mocked(uploadVideoMsgInfo).mockClear();
await expect(buildSendElems([
{ type: 'video', url: 'file:///tmp/clip.mp4' },
{ type: 'text', text: 'must not become hidden content' },
], { bridge: fakeBridge, groupId: 12345 })).rejects.toMatchObject({
code: 'UNSENDABLE_TYPE',
elementType: 'video',
message: expect.stringContaining('only segment'),
});
await expect(buildSendElems([
{ type: 'video', url: 'file:///tmp/first.mp4' },
{ type: 'video', url: 'file:///tmp/second.mp4' },
], { bridge: fakeBridge, groupId: 12345 })).rejects.toMatchObject({
code: 'UNSENDABLE_TYPE',
elementType: 'video',
message: expect.stringContaining('only once'),
});
expect(uploadVideoMsgInfo).not.toHaveBeenCalled();
});
it('keeps empty canonical text invalid instead of sending it beside a video', async () => {
vi.mocked(uploadVideoMsgInfo).mockClear();
await expect(buildSendElems([
{ type: 'text', text: '' },
{ type: 'video', url: 'file:///tmp/clip.mp4' },
], { bridge: fakeBridge, groupId: 12345 })).rejects.toMatchObject({
code: 'INVALID_FIELD',
elementType: 'text',
});
expect(uploadVideoMsgInfo).not.toHaveBeenCalled();
});
it('applies standalone-video validation to forward nodes', async () => {
vi.mocked(uploadVideoMsgInfo).mockClear();
await expect(buildSendElems([
{ type: 'video', url: 'file:///tmp/clip.mp4' },
{ type: 'text', text: 'must not survive bot forwarding' },
], {
bridge: fakeBridge,
groupId: 12345,
forwardFake: true,
scene: 'forward',
})).rejects.toMatchObject({
code: 'UNSENDABLE_TYPE',
elementType: 'video',
});
expect(uploadVideoMsgInfo).not.toHaveBeenCalled();
});
it('does not upload an early image when a later segment is unsendable', async () => {
vi.mocked(uploadImageMsgInfo).mockClear();
await expect(buildSendElems([
{ type: 'image', url: 'file:///tmp/valid-before-invalid.png' },
{ type: 'poke', subType: 1 },
] as any, { bridge: fakeBridge, groupId: 12345 })).rejects.toMatchObject({
code: 'UNSENDABLE_TYPE',
elementType: 'poke',
});
expect(uploadImageMsgInfo).not.toHaveBeenCalled();
});
it('accepts a received imageUrl-only element for re-send', async () => {
vi.mocked(uploadImageMsgInfo).mockClear();
await buildSendElems(
[{ type: 'image', imageUrl: 'https://gchat.qpic.cn/received.jpg' }],
{ bridge: fakeBridge, groupId: 12345 },
);
expect(uploadImageMsgInfo).toHaveBeenCalledWith(
fakeBridge,
true,
12345,
expect.objectContaining({ imageUrl: 'https://gchat.qpic.cn/received.jpg' }),
);
});
it('does not upload an early image when a later fast-only media element lacks hashes', async () => {
vi.mocked(uploadImageMsgInfo).mockClear();
await expect(buildSendElems([
{ type: 'image', url: 'file:///tmp/valid-before-invalid.png' },
{
type: 'image',
url: 'file:///tmp/must-not-fallback.png',
noByteFallback: true,
},
] as any, { bridge: fakeBridge, groupId: 12345 })).rejects.toMatchObject({
code: 'MISSING_FIELD',
elementType: 'image',
field: 'md5Hex',
});
expect(uploadImageMsgInfo).not.toHaveBeenCalled();
});
});
describe('element-builder / file element is no longer carried in elems[]', () => {
// Regression for the `result=79` class: previously the element-builder
// emitted a `transElem(elemType=24, ...)` for `{type:'file'}` segments
// and the QQ-NT server rejected the outgoing PbSendMsg with that wire
// shape. The fix moves group-file publishing onto a dedicated OIDB
// call (`OidbSvcTrpcTcp.0x6d9_4`), driven from the OneBot layer in
// `modules/message-actions.ts::sendGroupMessage` after the file
// segment is split off. The element-builder therefore must NOT emit
// any element for `{type:'file'}` anymore — if it does, the message
// ships with a transElem(24) payload and result=79 returns.
it('fails fast when a live {type:"file"} reaches the element builder', async () => {
await expect(buildSendElems(
[{
type: 'file',
fileId: 'fid-abc',
fileName: 'doc.txt',
fileSize: 123,
md5Hex: 'aabbccddeeff00112233445566778899',
sha1Hex: '0102030405060708090a0b0c0d0e0f1011121314',
} as any],
{ bridge: fakeBridge, groupId: 12345 },
)).rejects.toMatchObject({
name: 'MessageElementValidationError',
code: 'UNSENDABLE_TYPE',
elementType: 'file',
});
});
});
describe('element-builder / forward preview (com.tencent.multimsg LightApp)', () => {
// The forward preview is the bubble the recipient renders in chat
// before tapping to expand. It MUST be the modern LightApp /
// `com.tencent.multimsg` JSON (not the older `richMsg serviceID=35`
// XML) because nested forwards rely on `meta.detail.uniseq` to link
// each inner preview to the matching `actionCommand` piggyback on
// the outer's LongMsgResult — without uniseq the QQ-NT client has
// no way to walk the tree and has to re-fetch each inner resId.
function decodeLightApp(elem: any): unknown {
return JSON.parse(inflatePrefixedPayload(elem.lightApp.data));
}
it('emits a lightApp.data blob with prefix=0x01 (deflated JSON, not XML/serviceID=35)', async () => {
const [elem] = await buildSendElems(
[{ type: 'forward', resId: 'res-XYZ' } as any],
{ bridge: fakeBridge, groupId: 12345 },
);
expect(elem.lightApp).toBeDefined();
expect((elem as any).richMsg).toBeUndefined();
expect(elem.lightApp!.data![0]).toBe(0x01);
});
it('places resid + uniseq inside meta.detail (and uniseq matches extra.filename)', async () => {
const [elem] = await buildSendElems(
[{ type: 'forward', resId: 'res-XYZ', forwardUuid: 'fixed-uuid-1234' } as any],
{ bridge: fakeBridge, groupId: 12345 },
);
const json = decodeLightApp(elem) as any;
expect(json.app).toBe('com.tencent.multimsg');
expect(json.meta.detail.resid).toBe('res-XYZ');
expect(json.meta.detail.uniseq).toBe('fixed-uuid-1234');
// `extra` is a JSON string holding {filename, tsum}; filename must
// round-trip the same uniseq so the QQ-NT client links them.
const extra = JSON.parse(json.extra);
expect(extra.filename).toBe('fixed-uuid-1234');
});
it('autogenerates a uniseq when the element omits forwardUuid (flat forward — cosmetic)', async () => {
const [elem] = await buildSendElems(
[{ type: 'forward', resId: 'res-flat' } as any],
{ bridge: fakeBridge, groupId: 12345 },
);
const json = decodeLightApp(elem) as any;
expect(json.meta.detail.resid).toBe('res-flat');
// Auto-generated UUID — non-empty, non-trivial.
expect(json.meta.detail.uniseq).toMatch(/^[0-9a-f-]{36}$/i);
const extra = JSON.parse(json.extra);
expect(extra.filename).toBe(json.meta.detail.uniseq);
});
it('threads forwardSource / forwardSummary / forwardPrompt / forwardNews / forwardTSum verbatim', async () => {
const [elem] = await buildSendElems(
[{
type: 'forward', resId: 'r1', forwardUuid: 'u1',
forwardSource: 'alice和bob的聊天记录',
forwardSummary: '查看3条转发消息',
forwardPrompt: '[聊天记录]',
forwardNews: [{ text: 'alice: hi' }, { text: 'bob: hey' }],
forwardTSum: 3,
} as any],
{ bridge: fakeBridge, groupId: 12345 },
);
const json = decodeLightApp(elem) as any;
expect(json.meta.detail.source).toBe('alice和bob的聊天记录');
expect(json.meta.detail.summary).toBe('查看3条转发消息');
expect(json.meta.detail.news).toEqual([{ text: 'alice: hi' }, { text: 'bob: hey' }]);
expect(json.desc).toBe('[聊天记录]');
expect(json.prompt).toBe('[聊天记录]');
expect(JSON.parse(json.extra).tsum).toBe(3);
});
it('rejects a forward element when resId is missing', async () => {
await expect(buildSendElems(
[{ type: 'forward' } as any],
{ bridge: fakeBridge, groupId: 12345 },
)).rejects.toBeInstanceOf(MessageElementValidationError);
});
});