Moving a friend who is already in the target category still succeeds. Media upload preflight now uses the same envelope success and error rules as other OIDB calls.
228 lines
8.3 KiB
TypeScript
228 lines
8.3 KiB
TypeScript
// MessageApi recall + markRead coverage. (The send* paths live in their
|
|
// own test file because they need element-builder fixtures the recall
|
|
// paths don't.) Renamed from the legacy `actions/group-message` shape
|
|
// after #6 commit 1 moved the recall + markRead helpers onto MessageApi
|
|
// and #6 commit 6 absorbed setEssence into InteractionApi.
|
|
|
|
import { describe, it, expect, vi, beforeEach } from 'vitest';
|
|
import { protobuf_decode, protobuf_encode } from '@snowluma/proton';
|
|
import type {
|
|
C2CRecallRequest,
|
|
SsoReadedReportReq,
|
|
SsoReadedReportResp,
|
|
} from '@snowluma/proto-defs/oidb-actions/base';
|
|
|
|
vi.mock('@snowluma/protocol/bridge-oidb', () => ({
|
|
makeOidbEnvelope: vi.fn((_oidbCmd, _subCmd, body) => ({ body })),
|
|
encodeOidbEnv: vi.fn(() => new Uint8Array()),
|
|
decodeOidbEnv: vi.fn(() => ({ body: {} })),
|
|
}));
|
|
|
|
import { MessageApi } from '../../src/bridge/apis/message';
|
|
import { mockBridge } from './_helpers';
|
|
|
|
function readReportResult(response: SsoReadedReportResp) {
|
|
return {
|
|
success: true,
|
|
gotResponse: true,
|
|
errorCode: 0,
|
|
errorMessage: '',
|
|
responseData: Buffer.from(protobuf_encode<SsoReadedReportResp>(response)),
|
|
};
|
|
}
|
|
|
|
describe('apis/message — recall + markRead', () => {
|
|
beforeEach(() => {
|
|
// No global mock state to reset — sendRawPacket is per-bridge.
|
|
});
|
|
|
|
it('recallGroup sends to SsoGroupRecallMsg with the group sequence', async () => {
|
|
const bridge = mockBridge();
|
|
await new MessageApi(bridge as any).recallGroup(12345, 999);
|
|
expect(bridge.sendRawPacket).toHaveBeenCalledOnce();
|
|
const [serviceCmd] = bridge.sendRawPacket.mock.calls[0]!;
|
|
expect(serviceCmd).toBe('trpc.msg.msg_svc.MsgService.SsoGroupRecallMsg');
|
|
});
|
|
|
|
it('recallGroup throws when sendRawPacket reports failure', async () => {
|
|
const bridge = mockBridge({
|
|
sendRawPacket: vi.fn(async () => ({
|
|
success: false,
|
|
gotResponse: false,
|
|
errorCode: -1,
|
|
errorMessage: 'network down',
|
|
responseData: null,
|
|
})) as any,
|
|
});
|
|
await expect(new MessageApi(bridge as any).recallGroup(12345, 999))
|
|
.rejects.toThrow(/network down/);
|
|
});
|
|
|
|
it('recallPrivate resolves the target UID before dispatch', async () => {
|
|
const bridge = mockBridge();
|
|
await new MessageApi(bridge as any).recallPrivate(10001, 100, 200, 123, 1700000000);
|
|
expect(bridge.resolveUserUid).toHaveBeenCalledWith(10001);
|
|
const [serviceCmd] = bridge.sendRawPacket.mock.calls[0]!;
|
|
expect(serviceCmd).toBe('trpc.msg.msg_svc.MsgService.SsoC2CRecallMsg');
|
|
});
|
|
|
|
it('recallPrivate keeps the 64-bit message id exact for any random', async () => {
|
|
const random = 0x1234567;
|
|
const bridge = mockBridge();
|
|
await new MessageApi(bridge as any).recallPrivate(10001, 11110, 200, random, 1700000000);
|
|
|
|
const [, body] = bridge.sendRawPacket.mock.calls[0]!;
|
|
const request = protobuf_decode<C2CRecallRequest>(body);
|
|
expect(request.info?.random).toBe(random);
|
|
expect(request.info?.messageId).toBe(0x0100000001234567n);
|
|
});
|
|
|
|
it('probes and confirms group plus private reads in the same packets', async () => {
|
|
const sendRawPacket = vi.fn()
|
|
.mockResolvedValueOnce(readReportResult({
|
|
groupList: [{ groupUin: 1081372778n, readSeq: 66569n, latestSeq: 66629n }],
|
|
c2cList: [{
|
|
uid: 'resolved-uid',
|
|
readSeq: 160n,
|
|
latestSeq: 171n,
|
|
lastMsgTime: 1783952859n,
|
|
}],
|
|
}))
|
|
.mockResolvedValueOnce(readReportResult({
|
|
groupList: [{ groupUin: 1081372778n, readSeq: 66629n, latestSeq: 66629n }],
|
|
c2cList: [{
|
|
uid: 'resolved-uid',
|
|
readSeq: 171n,
|
|
latestSeq: 171n,
|
|
lastMsgTime: 1783952859n,
|
|
}],
|
|
}));
|
|
const bridge = mockBridge({ sendRawPacket });
|
|
|
|
await new MessageApi(bridge as any).markAllRead([1081372778], [10001]);
|
|
|
|
expect(sendRawPacket).toHaveBeenCalledTimes(2);
|
|
expect(sendRawPacket.mock.calls.map((call: any) => call[0])).toEqual([
|
|
'trpc.msg.msg_svc.MsgService.SsoReadedReport',
|
|
'trpc.msg.msg_svc.MsgService.SsoReadedReport',
|
|
]);
|
|
expect(bridge.resolveUserUid).toHaveBeenCalledWith(10001);
|
|
|
|
const probeBytes = sendRawPacket.mock.calls[0]![1];
|
|
expect(Buffer.from(probeBytes).toString('hex')).toBe(
|
|
'0a0608eae0d18304120e120c7265736f6c7665642d756964',
|
|
);
|
|
const probe = protobuf_decode<SsoReadedReportReq>(probeBytes);
|
|
expect(probe).toEqual({
|
|
groupList: [{ groupUin: 1081372778n, lastReadSeq: null }],
|
|
c2cList: [{ uid: 'resolved-uid', lastReadTime: null, lastReadSeq: null }],
|
|
});
|
|
|
|
const confirm = protobuf_decode<SsoReadedReportReq>(sendRawPacket.mock.calls[1]![1]);
|
|
expect(confirm).toEqual({
|
|
groupList: [{ groupUin: 1081372778n, lastReadSeq: 66629n }],
|
|
c2cList: [{
|
|
uid: 'resolved-uid',
|
|
lastReadTime: 1783952859n,
|
|
lastReadSeq: 171n,
|
|
}],
|
|
});
|
|
});
|
|
|
|
it('does not send a confirm packet when every read marker is current', async () => {
|
|
const sendRawPacket = vi.fn(async () => readReportResult({
|
|
groupList: [{ groupUin: 12345n, readSeq: 50n, latestSeq: 50n }],
|
|
}));
|
|
const bridge = mockBridge({ sendRawPacket });
|
|
|
|
await new MessageApi(bridge as any).markGroupRead(12345);
|
|
|
|
expect(sendRawPacket).toHaveBeenCalledOnce();
|
|
});
|
|
|
|
it('markGroupRead rejects a transport success with no business response', async () => {
|
|
const bridge = mockBridge();
|
|
await expect(new MessageApi(bridge as any).markGroupRead(12345))
|
|
.rejects.toThrow(/response is empty/);
|
|
});
|
|
|
|
it('markGroupRead surfaces the per-group business error', async () => {
|
|
const bridge = mockBridge({
|
|
sendRawPacket: vi.fn(async () => readReportResult({
|
|
groupList: [{ resultCode: 100000010, errorMessage: 'send group msg failed, ret:2' }],
|
|
})),
|
|
});
|
|
await expect(new MessageApi(bridge as any).markGroupRead(1))
|
|
.rejects.toThrow(/send group msg failed, ret:2/);
|
|
});
|
|
|
|
it('rejects a top-level success when the private read marker did not advance', async () => {
|
|
const sendRawPacket = vi.fn()
|
|
.mockResolvedValueOnce(readReportResult({
|
|
c2cList: [{
|
|
uid: 'resolved-uid',
|
|
readSeq: 160n,
|
|
latestSeq: 171n,
|
|
lastMsgTime: 1783952859n,
|
|
}],
|
|
}))
|
|
.mockResolvedValueOnce(readReportResult({
|
|
c2cList: [{
|
|
uid: 'resolved-uid',
|
|
readSeq: 160n,
|
|
latestSeq: 171n,
|
|
lastMsgTime: 1783952859n,
|
|
}],
|
|
}));
|
|
const bridge = mockBridge({ sendRawPacket });
|
|
|
|
await expect(new MessageApi(bridge as any).markPrivateRead(10001))
|
|
.rejects.toThrow(/confirmed sequence 160 before requested 171/);
|
|
});
|
|
|
|
it('caps mixed read reports at 100 + 100 and confirms each page before probing the next', async () => {
|
|
const sendRawPacket = vi.fn(async (_cmd: string, body: Uint8Array) => {
|
|
const request = protobuf_decode<SsoReadedReportReq>(body);
|
|
return readReportResult({
|
|
groupList: request.groupList?.map(item => {
|
|
const requested = item.lastReadSeq ?? 0n;
|
|
return {
|
|
groupUin: item.groupUin,
|
|
readSeq: requested,
|
|
latestSeq: requested === 0n ? 1n : requested,
|
|
};
|
|
}),
|
|
c2cList: request.c2cList?.map(item => {
|
|
const requested = item.lastReadSeq ?? 0n;
|
|
return {
|
|
uid: item.uid,
|
|
readSeq: requested,
|
|
latestSeq: requested === 0n ? 1n : requested,
|
|
lastMsgTime: 1700000000n,
|
|
};
|
|
}),
|
|
});
|
|
});
|
|
const resolveUserUid = vi.fn(async (userId: number) => `uid-${userId}`);
|
|
const bridge = mockBridge({ sendRawPacket, resolveUserUid });
|
|
const groups = Array.from({ length: 101 }, (_, i) => 1000 + i);
|
|
const users = Array.from({ length: 101 }, (_, i) => 2000 + i);
|
|
|
|
await new MessageApi(bridge as any).markAllRead(groups, users);
|
|
|
|
expect(sendRawPacket).toHaveBeenCalledTimes(4);
|
|
const requests = sendRawPacket.mock.calls.map((call: any) =>
|
|
protobuf_decode<SsoReadedReportReq>(call[1]));
|
|
expect(requests.map(request => [request.groupList?.length, request.c2cList?.length])).toEqual([
|
|
[100, 100],
|
|
[100, 100],
|
|
[1, 1],
|
|
[1, 1],
|
|
]);
|
|
expect(requests[0]!.groupList![0]!.lastReadSeq).toBeNull();
|
|
expect(requests[1]!.groupList![0]!.lastReadSeq).toBe(1n);
|
|
expect(requests[2]!.groupList![0]!.lastReadSeq).toBeNull();
|
|
expect(requests[3]!.groupList![0]!.lastReadSeq).toBe(1n);
|
|
});
|
|
});
|