mirror of
https://github.com/hansjone/dsh-im-ops.git
synced 2026-10-09 04:13:17 +08:00
694 lines
23 KiB
JavaScript
694 lines
23 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { Readable } from 'node:stream';
|
|
import {
|
|
conversationKey,
|
|
extractInboundMessage,
|
|
extractText,
|
|
isAllowedSender,
|
|
isBotSender,
|
|
splitText,
|
|
} from '../../../src/channels/feishu/message-utils.mjs';
|
|
|
|
const PNG_1X1 = Buffer.from(
|
|
'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=',
|
|
'base64',
|
|
);
|
|
|
|
test('extractText removes bot mentions', () => {
|
|
const event = {
|
|
message: {
|
|
message_type: 'text',
|
|
content: JSON.stringify({ text: '@_user_1 你好' }),
|
|
mentions: [{ key: '@_user_1' }],
|
|
},
|
|
};
|
|
assert.equal(extractText(event), '你好');
|
|
});
|
|
|
|
test('extractInboundMessage lazily downloads a Feishu image resource as a bounded stream', async () => {
|
|
const calls = [];
|
|
const event = {
|
|
message: {
|
|
message_id: 'om_image',
|
|
message_type: 'image',
|
|
content: JSON.stringify({ image_key: 'img_test' }),
|
|
},
|
|
};
|
|
const client = { im: { v1: { messageResource: { get: async (request) => {
|
|
calls.push(request);
|
|
return {
|
|
headers: { 'content-length': String(PNG_1X1.length) },
|
|
getReadableStream: () => Readable.from([
|
|
PNG_1X1.subarray(0, 12),
|
|
PNG_1X1.subarray(12),
|
|
]),
|
|
};
|
|
} } } } };
|
|
|
|
const message = extractInboundMessage(event, client);
|
|
assert.equal(message.content, '');
|
|
assert.equal(message.images.length, 1);
|
|
assert.deepEqual(await message.images[0].load({ maxBytes: 1024 }), PNG_1X1);
|
|
assert.deepEqual(calls, [{
|
|
path: { message_id: 'om_image', file_key: 'img_test' },
|
|
params: { type: 'image' },
|
|
}]);
|
|
});
|
|
|
|
test('extractInboundMessage preserves visible Feishu post text and every embedded image', async () => {
|
|
const calls = [];
|
|
const event = {
|
|
message: {
|
|
message_id: 'om_post',
|
|
message_type: 'post',
|
|
mentions: [{ key: '@_bot_1' }],
|
|
content: JSON.stringify({
|
|
title: '截图比较',
|
|
content: [
|
|
[
|
|
{ tag: 'at', user_id: '@_bot_1', user_name: '机器人' },
|
|
{ tag: 'text', text: '@_bot_1 请查看 ' },
|
|
{ tag: 'a', text: '第一处', href: 'https://example.com/one' },
|
|
{ tag: 'link', text: ' 和第二处', href: 'https://example.com/two' },
|
|
],
|
|
[{ tag: 'img', image_key: 'img_first' }],
|
|
[{ tag: 'text', text: '补充说明' }],
|
|
[
|
|
{ tag: 'img', image_key: 'img_second' },
|
|
{ tag: 'img', image_key: ' ' },
|
|
],
|
|
],
|
|
}),
|
|
},
|
|
};
|
|
const client = { im: { v1: { messageResource: { get: async (request) => {
|
|
calls.push(request);
|
|
return {
|
|
headers: { 'content-length': String(PNG_1X1.length) },
|
|
getReadableStream: () => Readable.from([PNG_1X1]),
|
|
};
|
|
} } } } };
|
|
|
|
const message = extractInboundMessage(event, client);
|
|
assert.equal(extractText(event), null, 'rich posts must not become interaction replies');
|
|
assert.equal(message.content, '截图比较\n请查看 第一处 和第二处\n补充说明');
|
|
assert.equal(message.images.length, 2);
|
|
assert.deepEqual(await Promise.all(message.images.map((image) => image.load({ maxBytes: 1024 }))), [
|
|
PNG_1X1,
|
|
PNG_1X1,
|
|
]);
|
|
assert.deepEqual(calls, [
|
|
{
|
|
path: { message_id: 'om_post', file_key: 'img_first' },
|
|
params: { type: 'image' },
|
|
},
|
|
{
|
|
path: { message_id: 'om_post', file_key: 'img_second' },
|
|
params: { type: 'image' },
|
|
},
|
|
]);
|
|
});
|
|
|
|
test('extractInboundMessage exposes a lazy Feishu reply reference and loads the direct parent', async () => {
|
|
const calls = [];
|
|
const event = {
|
|
message: {
|
|
message_id: 'om_current',
|
|
parent_id: 'om_parent',
|
|
root_id: 'om_root',
|
|
chat_id: 'oc_same',
|
|
message_type: 'text',
|
|
content: JSON.stringify({ text: '继续解释' }),
|
|
},
|
|
};
|
|
const client = { im: { v1: { message: { get: async (request) => {
|
|
calls.push(request);
|
|
return {
|
|
code: 0,
|
|
data: {
|
|
items: [{
|
|
message_id: 'om_parent',
|
|
chat_id: 'oc_same',
|
|
msg_type: 'text',
|
|
sender: { id: 'ou_author', sender_name: '引用作者' },
|
|
body: { content: JSON.stringify({ text: '被引用的内容' }) },
|
|
}],
|
|
},
|
|
};
|
|
} } } } };
|
|
|
|
const message = extractInboundMessage(event, client);
|
|
assert.equal(message.content, '继续解释');
|
|
assert.equal(message.replyTo.messageId, 'om_parent');
|
|
assert.equal(calls.length, 0, 'quoted message lookup stays lazy');
|
|
assert.deepEqual(await message.replyTo.load(), {
|
|
messageId: 'om_parent',
|
|
authorId: 'ou_author',
|
|
authorName: '引用作者',
|
|
content: '被引用的内容',
|
|
attachments: [],
|
|
});
|
|
assert.deepEqual(calls, [{
|
|
path: { message_id: 'om_parent' },
|
|
params: {
|
|
with_sender_name: true,
|
|
card_msg_content_type: 'raw_card_content',
|
|
},
|
|
}]);
|
|
});
|
|
|
|
test('Feishu reply reference reads raw CardKit 2.0 markdown without hidden card data', async () => {
|
|
const calls = [];
|
|
const client = { im: { v1: { message: { get: async (request) => {
|
|
calls.push(request);
|
|
return {
|
|
code: 0,
|
|
data: { items: [{
|
|
message_id: 'om_card_2',
|
|
chat_id: 'oc_same',
|
|
msg_type: 'interactive',
|
|
sender: { id: 'ou_bot', sender_name: '回答机器人' },
|
|
body: { content: JSON.stringify({
|
|
card_schema: 2,
|
|
json_attachment: JSON.stringify({ secret: 'hidden-attachment' }),
|
|
json_card: JSON.stringify({
|
|
schema: '2.0',
|
|
config: { streaming_mode: false, secret: 'hidden-config' },
|
|
body: {
|
|
id: '_2',
|
|
property: {
|
|
elements: [{
|
|
id: 'stream_md',
|
|
tag: 'markdown',
|
|
property: {
|
|
elements: [{
|
|
id: 'stream_md_0',
|
|
tag: 'plain_text',
|
|
property: {
|
|
content: '这是机器人最终回答\n\n模型是 **doubao-seed**。',
|
|
},
|
|
}],
|
|
value: { token: 'hidden-callback-value' },
|
|
},
|
|
}],
|
|
},
|
|
},
|
|
}),
|
|
}) },
|
|
}] },
|
|
};
|
|
} } } } };
|
|
|
|
const reply = await extractInboundMessage({
|
|
message: {
|
|
message_id: 'om_current',
|
|
parent_id: 'om_card_2',
|
|
chat_id: 'oc_same',
|
|
message_type: 'text',
|
|
content: JSON.stringify({ text: '这说的是什么模型？' }),
|
|
},
|
|
}, client).replyTo.load();
|
|
|
|
assert.deepEqual(reply, {
|
|
messageId: 'om_card_2',
|
|
authorId: 'ou_bot',
|
|
authorName: '回答机器人',
|
|
content: '这是机器人最终回答\n\n模型是 **doubao-seed**。',
|
|
attachments: [],
|
|
});
|
|
assert.doesNotMatch(
|
|
reply.content,
|
|
/hidden-config|hidden-attachment|hidden-callback-value|stream_md|streaming_mode/u,
|
|
);
|
|
assert.deepEqual(calls, [{
|
|
path: { message_id: 'om_card_2' },
|
|
params: {
|
|
with_sender_name: true,
|
|
card_msg_content_type: 'raw_card_content',
|
|
},
|
|
}]);
|
|
});
|
|
|
|
test('Feishu reply reference reads a historical Card 1.0 and exposes visible labels only', async () => {
|
|
const client = { im: { v1: { message: { get: async () => ({
|
|
code: 0,
|
|
data: { items: [{
|
|
message_id: 'om_card_1',
|
|
chat_id: 'oc_same',
|
|
msg_type: 'interactive',
|
|
body: { content: JSON.stringify({
|
|
header: { title: { tag: 'plain_text', content: '历史回答' } },
|
|
elements: [
|
|
{ tag: 'div', text: { tag: 'lark_md', content: '这是很久以前的机器人正文。' } },
|
|
{
|
|
tag: 'action',
|
|
actions: [{
|
|
tag: 'button',
|
|
text: { tag: 'plain_text', content: '查看详情' },
|
|
value: { token: 'hidden-callback-value' },
|
|
url: 'https://secret.example.invalid',
|
|
}],
|
|
},
|
|
],
|
|
}) },
|
|
}] },
|
|
}) } } } };
|
|
|
|
const reply = await extractInboundMessage({
|
|
message: {
|
|
message_id: 'om_current',
|
|
parent_id: 'om_card_1',
|
|
chat_id: 'oc_same',
|
|
message_type: 'text',
|
|
content: JSON.stringify({ text: '概括一下' }),
|
|
},
|
|
}, client).replyTo.load();
|
|
|
|
assert.equal(reply.content, '历史回答\n这是很久以前的机器人正文。\n查看详情');
|
|
assert.doesNotMatch(reply.content, /hidden-callback-value|secret\.example/u);
|
|
});
|
|
|
|
test('Feishu reply reference reads visible i18n and markdown_v1 fallback card text', async (t) => {
|
|
for (const [name, element, expected] of [
|
|
['localized text', {
|
|
tag: 'plain_text',
|
|
property: {
|
|
i18nContent: { zh_cn: '旧卡片中文正文', en_us: 'old card text' },
|
|
value: 'hidden-localized-value',
|
|
},
|
|
}, '旧卡片中文正文'],
|
|
['markdown_v1 fallback', {
|
|
tag: 'markdown_v1',
|
|
property: { value: 'hidden-markdown-value' },
|
|
fallback: {
|
|
tag: 'plain_text',
|
|
property: { content: '旧卡片可见降级正文' },
|
|
},
|
|
}, '旧卡片可见降级正文'],
|
|
]) {
|
|
await t.test(name, async () => {
|
|
const client = { im: { v1: { message: { get: async () => ({
|
|
code: 0,
|
|
data: { items: [{
|
|
message_id: 'om_old_card',
|
|
chat_id: 'oc_same',
|
|
msg_type: 'interactive',
|
|
body: { content: JSON.stringify({
|
|
card_schema: 2,
|
|
json_card: JSON.stringify({
|
|
schema: '2.0',
|
|
body: { property: { elements: [element] } },
|
|
}),
|
|
}) },
|
|
}] },
|
|
}) } } } };
|
|
const reply = await extractInboundMessage({
|
|
message: {
|
|
message_id: 'om_current',
|
|
parent_id: 'om_old_card',
|
|
chat_id: 'oc_same',
|
|
message_type: 'text',
|
|
content: JSON.stringify({ text: '继续' }),
|
|
},
|
|
}, client).replyTo.load();
|
|
assert.equal(reply.content, expected);
|
|
assert.doesNotMatch(reply.content, /hidden-/u);
|
|
});
|
|
}
|
|
});
|
|
|
|
test('Feishu reply reference reads ordinary two-dimensional fallback card text', async () => {
|
|
const client = { im: { v1: { message: { get: async () => ({
|
|
code: 0,
|
|
data: { items: [{
|
|
message_id: 'om_fallback_card',
|
|
chat_id: 'oc_same',
|
|
msg_type: 'interactive',
|
|
body: { content: JSON.stringify({
|
|
title: '降级卡片',
|
|
elements: [[
|
|
{ tag: 'text', text: '第一段' },
|
|
{ tag: 'text', text: '第二段' },
|
|
]],
|
|
}) },
|
|
}] },
|
|
}) } } } };
|
|
const reply = await extractInboundMessage({
|
|
message: {
|
|
message_id: 'om_current',
|
|
parent_id: 'om_fallback_card',
|
|
chat_id: 'oc_same',
|
|
message_type: 'text',
|
|
content: JSON.stringify({ text: '继续' }),
|
|
},
|
|
}, client).replyTo.load();
|
|
assert.equal(reply.content, '降级卡片\n第一段 第二段');
|
|
});
|
|
|
|
test('Feishu reply reference marks unreadable interactive cards as unsupported', async (t) => {
|
|
for (const [name, content] of [
|
|
['CardKit id pointer', JSON.stringify({ type: 'card', data: { card_id: 'card_secret' } })],
|
|
['empty Card 2.0', JSON.stringify({ schema: '2.0', body: { elements: [{ tag: 'hr' }] } })],
|
|
['upgrade placeholder', JSON.stringify({
|
|
title: null,
|
|
elements: [[{ tag: 'text', text: '请升级至最新版本客户端，以查看内容' }]],
|
|
})],
|
|
['malformed card JSON', '{not-json'],
|
|
]) {
|
|
await t.test(name, async () => {
|
|
const client = { im: { v1: { message: { get: async () => ({
|
|
code: 0,
|
|
data: { items: [{
|
|
message_id: 'om_card',
|
|
chat_id: 'oc_same',
|
|
msg_type: 'interactive',
|
|
sender: { sender_name: '回答机器人' },
|
|
body: { content },
|
|
}] },
|
|
}) } } } };
|
|
const reply = await extractInboundMessage({
|
|
message: {
|
|
message_id: 'om_current',
|
|
parent_id: 'om_card',
|
|
chat_id: 'oc_same',
|
|
message_type: 'text',
|
|
content: JSON.stringify({ text: '继续' }),
|
|
},
|
|
}, client).replyTo.load();
|
|
assert.deepEqual(reply, {
|
|
messageId: 'om_card',
|
|
authorName: '回答机器人',
|
|
attachments: [],
|
|
unavailableReason: 'unsupported',
|
|
});
|
|
});
|
|
}
|
|
});
|
|
|
|
test('Feishu reply reference falls back to root_id and keeps quoted media as metadata only', async () => {
|
|
let resourceDownloads = 0;
|
|
const event = {
|
|
message: {
|
|
message_id: 'om_current',
|
|
root_id: 'om_root',
|
|
chat_id: 'oc_same',
|
|
message_type: 'text',
|
|
content: JSON.stringify({ text: '这两张图说明什么？' }),
|
|
},
|
|
};
|
|
const client = { im: { v1: {
|
|
message: { get: async () => ({
|
|
data: {
|
|
items: [{
|
|
message_id: 'om_root',
|
|
chat_id: 'oc_same',
|
|
msg_type: 'post',
|
|
body: { content: JSON.stringify({
|
|
title: '原消息',
|
|
content: [
|
|
[{ tag: 'text', text: '请比较截图' }],
|
|
[{ tag: 'img', image_key: 'img_one' }, { tag: 'img', image_key: 'img_two' }],
|
|
],
|
|
}) },
|
|
}],
|
|
},
|
|
}) },
|
|
messageResource: { get: async () => {
|
|
resourceDownloads += 1;
|
|
throw new Error('quoted media must not be downloaded');
|
|
} },
|
|
} } };
|
|
|
|
const reply = await extractInboundMessage(event, client).replyTo.load();
|
|
assert.equal(reply.messageId, 'om_root');
|
|
assert.equal(reply.content, '原消息\n请比较截图');
|
|
assert.deepEqual(reply.attachments, [{ kind: 'image' }, { kind: 'image' }]);
|
|
assert.equal(resourceDownloads, 0);
|
|
});
|
|
|
|
test('Feishu reply lookup degrades deleted, foreign, and permission failures', async (t) => {
|
|
const event = {
|
|
message: {
|
|
message_id: 'om_current',
|
|
parent_id: 'om_parent',
|
|
chat_id: 'oc_same',
|
|
message_type: 'text',
|
|
content: JSON.stringify({ text: '继续' }),
|
|
},
|
|
};
|
|
for (const [name, response, unavailableReason] of [
|
|
['deleted message', {
|
|
data: { items: [{ message_id: 'om_parent', chat_id: 'oc_same', deleted: true }] },
|
|
}, 'deleted'],
|
|
['foreign chat', {
|
|
data: { items: [{ message_id: 'om_parent', chat_id: 'oc_other', msg_type: 'text' }] },
|
|
}, 'not-found'],
|
|
['missing chat identity', {
|
|
data: { items: [{ message_id: 'om_parent', msg_type: 'text' }] },
|
|
}, 'not-found'],
|
|
['missing permission', { code: 99991672 }, 'permission-denied'],
|
|
]) {
|
|
await t.test(name, async () => {
|
|
const client = { im: { v1: { message: { get: async () => response } } } };
|
|
assert.deepEqual(await extractInboundMessage(event, client).replyTo.load(), {
|
|
messageId: 'om_parent',
|
|
unavailableReason,
|
|
});
|
|
});
|
|
}
|
|
});
|
|
|
|
test('Feishu reply lookup maps a thrown missing-scope response without failing the current turn', async () => {
|
|
const providerError = new Error('Request failed with status code 400');
|
|
providerError.response = {
|
|
status: 400,
|
|
data: Readable.from([Buffer.from(JSON.stringify({ code: 99991672 }))]),
|
|
};
|
|
const client = { im: { v1: { message: { get: async () => { throw providerError; } } } } };
|
|
const message = extractInboundMessage({
|
|
message: {
|
|
message_id: 'om_current',
|
|
parent_id: 'om_parent',
|
|
chat_id: 'oc_same',
|
|
message_type: 'text',
|
|
content: JSON.stringify({ text: '继续' }),
|
|
},
|
|
}, client);
|
|
|
|
assert.deepEqual(await message.replyTo.load(), {
|
|
messageId: 'om_parent',
|
|
unavailableReason: 'permission-denied',
|
|
});
|
|
});
|
|
|
|
test('Feishu reply lookup fails closed when the current event has no chat identity', async () => {
|
|
const client = { im: { v1: { message: { get: async () => ({
|
|
code: 0,
|
|
data: { items: [{
|
|
message_id: 'om_parent',
|
|
chat_id: 'oc_secret',
|
|
msg_type: 'text',
|
|
body: { content: JSON.stringify({ text: '不能泄露的跨聊天内容' }) },
|
|
}] },
|
|
}) } } } };
|
|
const message = extractInboundMessage({
|
|
message: {
|
|
message_id: 'om_current',
|
|
parent_id: 'om_parent',
|
|
message_type: 'text',
|
|
content: JSON.stringify({ text: '继续' }),
|
|
},
|
|
}, client);
|
|
|
|
assert.deepEqual(await message.replyTo.load(), {
|
|
messageId: 'om_parent',
|
|
unavailableReason: 'not-found',
|
|
});
|
|
});
|
|
|
|
test('Feishu does not treat the current thread root as its own reply reference', () => {
|
|
const message = extractInboundMessage({
|
|
message: {
|
|
message_id: 'om_root',
|
|
root_id: 'om_root',
|
|
message_type: 'text',
|
|
content: JSON.stringify({ text: '主题首条' }),
|
|
},
|
|
}, {});
|
|
assert.equal('replyTo' in message, false);
|
|
});
|
|
|
|
test('extractInboundMessage exposes a native Feishu file as a lazy unbounded resource download', async () => {
|
|
const calls = [];
|
|
const bytes = Buffer.from('ordinary-file-payload');
|
|
const event = {
|
|
message: {
|
|
message_id: 'om_file',
|
|
message_type: 'file',
|
|
content: JSON.stringify({ file_key: 'file_test', file_name: 'report.bin' }),
|
|
},
|
|
};
|
|
const client = { im: { v1: { messageResource: { get: async (request) => {
|
|
calls.push(request);
|
|
return {
|
|
getReadableStream: () => Readable.from([bytes.subarray(0, 4), bytes.subarray(4)]),
|
|
};
|
|
} } } } };
|
|
|
|
const message = extractInboundMessage(event, client);
|
|
assert.equal(message.content, '');
|
|
assert.deepEqual(message.images, []);
|
|
assert.equal(message.files.length, 1);
|
|
assert.equal(message.files[0].name, 'report.bin');
|
|
assert.equal(calls.length, 0, 'file download stays lazy');
|
|
assert.deepEqual(await message.files[0].load({}), bytes);
|
|
assert.deepEqual(calls, [{
|
|
path: { message_id: 'om_file', file_key: 'file_test' },
|
|
params: { type: 'file' },
|
|
}]);
|
|
});
|
|
|
|
test('Feishu image loading rejects declared or streamed data above the caller limit', async () => {
|
|
for (const resource of [
|
|
{
|
|
headers: { 'content-length': '5' },
|
|
getReadableStream: () => Readable.from([Buffer.alloc(5)]),
|
|
},
|
|
{
|
|
headers: {},
|
|
getReadableStream: () => Readable.from([Buffer.alloc(2), Buffer.alloc(3)]),
|
|
},
|
|
]) {
|
|
const message = extractInboundMessage({
|
|
message: {
|
|
message_id: 'om_large',
|
|
message_type: 'image',
|
|
content: JSON.stringify({ image_key: 'img_large' }),
|
|
},
|
|
}, { im: { v1: { messageResource: { get: async () => resource } } } });
|
|
await assert.rejects(message.images[0].load({ maxBytes: 4 }), /limit|exceeds/);
|
|
}
|
|
});
|
|
|
|
test('Feishu image loading maps the missing message scope to an actionable error', async () => {
|
|
const providerError = new Error('Request failed with status code 400');
|
|
const body = Buffer.from(JSON.stringify({
|
|
code: 99991672,
|
|
msg: 'missing required tenant scope',
|
|
}));
|
|
providerError.response = {
|
|
status: 400,
|
|
data: Readable.from([body.subarray(0, 9), body.subarray(9)]),
|
|
};
|
|
const message = extractInboundMessage({
|
|
message: {
|
|
message_id: 'om_permission',
|
|
message_type: 'image',
|
|
content: JSON.stringify({ image_key: 'img_permission' }),
|
|
},
|
|
}, { im: { v1: { messageResource: { get: async () => { throw providerError; } } } } });
|
|
|
|
await assert.rejects(message.images[0].load({ maxBytes: 1024 }), (error) => {
|
|
assert.equal(error.code, 'feishu-image-permission-required');
|
|
assert.match(error.userMessage, /im:message:readonly/);
|
|
assert.match(error.userMessage, /\/repair/);
|
|
assert.match(error.userMessage, /「IM机器人」设置页/);
|
|
assert.match(error.userMessage, /补全权限/);
|
|
assert.match(error.userMessage, /发布新版本/);
|
|
assert.equal(error.cause, providerError);
|
|
return true;
|
|
});
|
|
});
|
|
|
|
test('Feishu image loading leaves unrelated provider failures on the generic path', async () => {
|
|
const providerError = new Error('Request failed with status code 400');
|
|
providerError.response = {
|
|
status: 400,
|
|
data: Readable.from([Buffer.from(JSON.stringify({ code: 99991400 }))]),
|
|
};
|
|
const message = extractInboundMessage({
|
|
message: {
|
|
message_id: 'om_other_error',
|
|
message_type: 'image',
|
|
content: JSON.stringify({ image_key: 'img_other_error' }),
|
|
},
|
|
}, { im: { v1: { messageResource: { get: async () => { throw providerError; } } } } });
|
|
|
|
await assert.rejects(
|
|
message.images[0].load({ maxBytes: 1024 }),
|
|
(error) => error === providerError,
|
|
);
|
|
});
|
|
|
|
test('malformed Feishu image content does not create a downloadable image reference', () => {
|
|
assert.deepEqual(extractInboundMessage({
|
|
message: { message_type: 'image', content: '{not-json' },
|
|
}, {}), { content: '', images: [], files: [] });
|
|
assert.deepEqual(extractInboundMessage({
|
|
message: { message_type: 'post', content: '{not-json' },
|
|
}, {}), { content: '', images: [], files: [] });
|
|
});
|
|
|
|
test('conversationKey isolates p2p users and groups', () => {
|
|
assert.equal(conversationKey({
|
|
sender: { sender_id: { open_id: 'ou_test' } },
|
|
message: { chat_type: 'p2p', chat_id: 'oc_private' },
|
|
}), 'p2p:ou_test');
|
|
assert.equal(conversationKey({
|
|
sender: { sender_id: { open_id: 'ou_test' } },
|
|
message: { chat_type: 'group', chat_id: 'oc_group' },
|
|
}), 'group:oc_group');
|
|
});
|
|
|
|
test('conversationKey isolates topic-group threads without affecting regular groups', () => {
|
|
// Topic groups: each message belongs to a thread, so every topic gets its own session.
|
|
assert.equal(conversationKey({
|
|
sender: { sender_id: { open_id: 'ou_test' } },
|
|
message: { chat_type: 'group', chat_id: 'oc_topic_group', thread_id: 'om_thread_a' },
|
|
}), 'group:oc_topic_group:thread:om_thread_a');
|
|
assert.equal(conversationKey({
|
|
sender: { sender_id: { open_id: 'ou_other' } },
|
|
message: { chat_type: 'group', chat_id: 'oc_topic_group', thread_id: 'om_thread_b' },
|
|
}), 'group:oc_topic_group:thread:om_thread_b');
|
|
assert.notEqual(
|
|
conversationKey({
|
|
sender: { sender_id: { open_id: 'ou_test' } },
|
|
message: { chat_type: 'group', chat_id: 'oc_topic_group', thread_id: 'om_thread_a' },
|
|
}),
|
|
conversationKey({
|
|
sender: { sender_id: { open_id: 'ou_test' } },
|
|
message: { chat_type: 'group', chat_id: 'oc_topic_group', thread_id: 'om_thread_b' },
|
|
}),
|
|
);
|
|
// Regular group chats: no thread_id keeps the single shared group key.
|
|
assert.equal(conversationKey({
|
|
sender: { sender_id: { open_id: 'ou_test' } },
|
|
message: { chat_type: 'group', chat_id: 'oc_group' },
|
|
}), 'group:oc_group');
|
|
// Blank thread_id values fall back to the shared group key.
|
|
assert.equal(conversationKey({
|
|
sender: { sender_id: { open_id: 'ou_test' } },
|
|
message: { chat_type: 'group', chat_id: 'oc_group', thread_id: ' ' },
|
|
}), 'group:oc_group');
|
|
});
|
|
|
|
test('splitText preserves all text', () => {
|
|
const input = `${'a'.repeat(12)}\n${'b'.repeat(12)}`;
|
|
const chunks = splitText(input, 15);
|
|
assert.equal(chunks.join('\n'), input);
|
|
assert.ok(chunks.every((chunk) => chunk.length <= 15));
|
|
});
|
|
|
|
test('isBotSender rejects bot loops', () => {
|
|
assert.equal(isBotSender({ sender: { sender_type: 'bot' } }), true);
|
|
assert.equal(isBotSender({ sender: { sender_type: 'user' } }), false);
|
|
});
|
|
|
|
test('isAllowedSender enforces an open-id allowlist', () => {
|
|
const event = { sender: { sender_id: { open_id: 'ou_allowed' } } };
|
|
assert.equal(isAllowedSender(event, new Set()), false);
|
|
assert.equal(isAllowedSender(event, new Set(['ou_allowed'])), true);
|
|
assert.equal(isAllowedSender(event, new Set(['ou_other'])), false);
|
|
assert.equal(isAllowedSender(event, new Set(['*'])), true);
|
|
});
|