Files
SnowLuma/packages/onebot/tests/message-store.test.ts
T
DrSmoothl defe15694b feat(onebot): implement mark all as read
Replace the compatibility no-op with a real batched read action for current groups and observed incoming private conversations.

Exclude stale groups, group temporary sessions, and sent-message echoes from private targets, then expose the functional action through the generated MCP catalog.

Add action and message-store regressions for target selection and delegation.
2026-07-13 23:02:08 +08:00

215 lines
7.0 KiB
TypeScript

import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { MessageStore } from '../src/message-store';
import { hashMessageIdInt32, GROUP_MESSAGE_EVENT, PRIVATE_MESSAGE_EVENT } from '../src/message-id';
import fs from 'fs';
import path from 'path';
describe('MessageStore', () => {
const testDbPath = path.join('data', 'test', 'messages-test.db');
let store: MessageStore;
beforeEach(() => {
// Clean up any existing test database
try {
fs.unlinkSync(testDbPath);
} catch {
// Ignore if file doesn't exist
}
store = new MessageStore(testDbPath);
});
afterEach(() => {
store.close();
// Clean up test database
try {
fs.unlinkSync(testDbPath);
} catch {
// Ignore cleanup errors
}
});
describe('resolveReplySequence', () => {
it('resolves group message reply sequence', () => {
const groupId = 123456;
const sequence = 100;
const messageId = hashMessageIdInt32(sequence, groupId, GROUP_MESSAGE_EVENT);
// Store a group message
store.storeMeta(messageId, {
isGroup: true,
targetId: groupId,
sequence,
eventName: GROUP_MESSAGE_EVENT,
clientSequence: 0,
random: 0,
timestamp: Date.now(),
});
// Resolve the reply sequence
const resolved = store.resolveReplySequence(true, groupId, messageId);
expect(resolved).toBe(sequence);
});
it('resolves private message reply sequence without session_id matching', () => {
// Simulate receiving a private message from user 111111
const senderUin = 111111;
const sequence = 200;
const messageId = hashMessageIdInt32(sequence, senderUin, PRIVATE_MESSAGE_EVENT);
// Store the received message (session_id is sender's UIN)
store.storeMeta(messageId, {
isGroup: false,
targetId: senderUin,
sequence,
eventName: PRIVATE_MESSAGE_EVENT,
clientSequence: 0,
random: 0,
timestamp: Date.now(),
});
// When replying to this message, we send to the sender (who becomes the recipient)
// The key fix: resolveReplySequence should work even when sessionId doesn't match
const resolved = store.resolveReplySequence(false, senderUin, messageId);
expect(resolved).toBe(sequence);
// More importantly: it should also work when we pass a different sessionId
// (which was the bug - we were passing recipient UIN instead of sender UIN)
const differentUin = 999999;
const resolvedWithDifferentSession = store.resolveReplySequence(false, differentUin, messageId);
expect(resolvedWithDifferentSession).toBe(sequence);
});
it('returns null for non-existent message', () => {
const resolved = store.resolveReplySequence(true, 123456, 999999);
expect(resolved).toBeNull();
});
it('returns null for invalid messageId', () => {
const resolved = store.resolveReplySequence(true, 123456, 0);
expect(resolved).toBeNull();
});
it('returns null for invalid sessionId', () => {
const messageId = hashMessageIdInt32(100, 123456, GROUP_MESSAGE_EVENT);
const resolved = store.resolveReplySequence(true, 0, messageId);
expect(resolved).toBeNull();
});
it('distinguishes between group and private messages', () => {
const sessionId = 123456;
const sequence = 300;
// Store a group message
const groupMessageId = hashMessageIdInt32(sequence, sessionId, GROUP_MESSAGE_EVENT);
store.storeMeta(groupMessageId, {
isGroup: true,
targetId: sessionId,
sequence,
eventName: GROUP_MESSAGE_EVENT,
clientSequence: 0,
random: 0,
timestamp: Date.now(),
});
// Store a private message with same sequence but different hash
const privateMessageId = hashMessageIdInt32(sequence, sessionId, PRIVATE_MESSAGE_EVENT);
store.storeMeta(privateMessageId, {
isGroup: false,
targetId: sessionId,
sequence,
eventName: PRIVATE_MESSAGE_EVENT,
clientSequence: 0,
random: 0,
timestamp: Date.now(),
});
// Should resolve correctly based on isGroup flag
const groupResolved = store.resolveReplySequence(true, sessionId, groupMessageId);
expect(groupResolved).toBe(sequence);
const privateResolved = store.resolveReplySequence(false, sessionId, privateMessageId);
expect(privateResolved).toBe(sequence);
// Should not cross-resolve
const wrongGroupResolve = store.resolveReplySequence(true, sessionId, privateMessageId);
expect(wrongGroupResolve).toBeNull();
const wrongPrivateResolve = store.resolveReplySequence(false, sessionId, groupMessageId);
expect(wrongPrivateResolve).toBeNull();
});
});
describe('storeEvent and findEvent', () => {
it('stores and retrieves event data', () => {
const messageId = 12345;
const event = {
post_type: 'message',
message_type: 'group',
message_id: messageId,
group_id: 123456,
message: 'test message',
time: Date.now(),
};
store.storeEvent(messageId, true, 123456, 100, GROUP_MESSAGE_EVENT, event);
const retrieved = store.findEvent(messageId);
expect(retrieved).toEqual(event);
});
it('returns null for non-existent event', () => {
const retrieved = store.findEvent(999999);
expect(retrieved).toBeNull();
});
});
describe('storeMeta and findMeta', () => {
it('stores and retrieves message meta', () => {
const messageId = 54321;
const meta = {
isGroup: true,
targetId: 123456,
sequence: 100,
eventName: GROUP_MESSAGE_EVENT,
clientSequence: 1,
random: 12345,
timestamp: Date.now(),
};
store.storeMeta(messageId, meta);
const retrieved = store.findMeta(messageId);
expect(retrieved).toEqual(meta);
});
it('returns null for non-existent meta', () => {
const retrieved = store.findMeta(999999);
expect(retrieved).toBeNull();
});
});
describe('listReadSessions', () => {
it('uses current groups and only genuine incoming friend sessions', () => {
const event = (postType: string, subType: string) => ({
time: 1700000000,
post_type: postType,
message_type: 'private',
sub_type: subType,
});
store.storeEvent(1001, false, 40001, 1, PRIVATE_MESSAGE_EVENT, event('message', 'friend'));
store.storeEvent(1002, false, 40001, 2, PRIVATE_MESSAGE_EVENT, event('message', 'friend'));
store.storeEvent(1003, false, 40002, 3, PRIVATE_MESSAGE_EVENT, event('message', 'group'));
store.storeEvent(1004, false, 40003, 4, PRIVATE_MESSAGE_EVENT, event('message_sent', 'friend'));
expect(store.listReadSessions([30002, 30001, 30002])).toEqual({
groupIds: [30002, 30001],
privateUserIds: [40001],
});
});
it('fails on a corrupt current group target', () => {
expect(() => store.listReadSessions([0])).toThrow('invalid group id 0');
});
});
});