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.
215 lines
7.0 KiB
TypeScript
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');
|
|
});
|
|
});
|
|
});
|