TanTan
fa9c73363d
Dev Build / cleanup (push) Waiting to run
Dev Build / typecheck (push) Waiting to run
Publish MCP to npm / Build, test, and publish MCP (push) Waiting to run
Publish SDK to npm / Build, test, and publish SDK (push) Waiting to run
Sync action catalog to docs / sync (push) Waiting to run
Publish UI to npm / Build and publish UI (push) Waiting to run
Build and Release / preflight (push) Waiting to run
342 lines
14 KiB
TypeScript
342 lines
14 KiB
TypeScript
import { describe, expect, it, vi } from 'vitest';
|
|
import { protobuf_decode, protobuf_encode } from '@snowluma/proton';
|
|
import type { OidbBase } from '@snowluma/proto-defs/oidb';
|
|
import type {
|
|
AvatarInfo,
|
|
OidbUserInfoRequest,
|
|
OidbUserInfoByUidRequest,
|
|
OidbUserInfoResponse,
|
|
} from '@snowluma/proto-defs/oidb-actions/base';
|
|
import type { SendPacketResult } from '@snowluma/common/packet-sender';
|
|
|
|
import { FetchUserProfile } from '../../../src/oidb-services/contacts/fetch-user-profile';
|
|
import { FetchUserProfileByUid } from '../../../src/oidb-services/contacts/fetch-user-profile-by-uid';
|
|
|
|
function makeSender(body?: OidbUserInfoResponse) {
|
|
const responseData =
|
|
body !== undefined
|
|
? Buffer.from(protobuf_encode<OidbBase<OidbUserInfoResponse>>({ body }))
|
|
: Buffer.alloc(0);
|
|
const r: SendPacketResult = {
|
|
success: true,
|
|
gotResponse: true,
|
|
errorCode: 0,
|
|
errorMessage: '',
|
|
responseData,
|
|
};
|
|
return { sendRawPacket: vi.fn(async () => r) };
|
|
}
|
|
|
|
describe('FetchUserProfile namespace', () => {
|
|
it('declares 0xFE1_2 with uinForm=true', () => {
|
|
expect(FetchUserProfile.command).toBe(0xfe1);
|
|
expect(FetchUserProfile.subCommand).toBe(2);
|
|
expect(FetchUserProfile.uinForm).toBe(true);
|
|
});
|
|
|
|
describe('invoke (e2e)', () => {
|
|
it.each(['uin', 'uid'])(
|
|
'preserves registration and membership through the %s request',
|
|
async (form) => {
|
|
const sender = makeSender({
|
|
body: {
|
|
uin: 10001,
|
|
uid: 'u_test',
|
|
properties: {
|
|
numberProperties: [
|
|
{ number1: 20026, number2: 1_200_000_000 },
|
|
{ number1: 41756, number2: 0x103 },
|
|
{ number1: 41757, number2: 1 << 5 },
|
|
{ number1: 42241, number2: 0 },
|
|
],
|
|
},
|
|
},
|
|
});
|
|
const profile =
|
|
form === 'uin'
|
|
? await FetchUserProfile.invoke(sender, { uin: 10001 })
|
|
: await FetchUserProfileByUid.invoke(sender, { uid: 'u_test' });
|
|
expect(profile).toMatchObject({
|
|
regTime: 1_200_000_000,
|
|
vipFlag: true,
|
|
yearVipFlag: true,
|
|
svipFlag: true,
|
|
vipLevel: 7,
|
|
});
|
|
const [, bytes] = sender.sendRawPacket.mock.calls[0]!;
|
|
const request =
|
|
form === 'uin'
|
|
? protobuf_decode<OidbBase<OidbUserInfoRequest>>(bytes)
|
|
: protobuf_decode<OidbBase<OidbUserInfoByUidRequest>>(bytes);
|
|
expect(request.body?.keys?.map((k) => k.key)).toEqual(
|
|
expect.arrayContaining([20026, 41756, 41757, 42241]),
|
|
);
|
|
},
|
|
);
|
|
|
|
it.each([
|
|
[0, 0, 0],
|
|
[1, 0, 1],
|
|
[0x100, 1, 2],
|
|
[0x103, 0x801, 13],
|
|
])(
|
|
'decodes membership flags %i and level mask %i as level %i',
|
|
async (flags, mask, level) => {
|
|
const sender = makeSender({
|
|
body: {
|
|
uin: 10001,
|
|
properties: {
|
|
numberProperties: [
|
|
{ number1: 41756, number2: flags },
|
|
{ number1: 41757, number2: mask },
|
|
{ number1: 42241, number2: 0 },
|
|
],
|
|
},
|
|
},
|
|
});
|
|
expect(await FetchUserProfile.invoke(sender, { uin: 10001 })).toMatchObject({
|
|
vipFlag: !!(flags & 1),
|
|
yearVipFlag: !!(flags & 2),
|
|
svipFlag: !!(flags & 0x100),
|
|
vipLevel: level,
|
|
profile: { vipLevel: level },
|
|
});
|
|
},
|
|
);
|
|
|
|
it('keeps missing registration and membership fields unavailable', async () => {
|
|
const profile = await FetchUserProfile.invoke(makeSender({ body: { uin: 10001 } }), {
|
|
uin: 10001,
|
|
});
|
|
|
|
for (const name of [
|
|
'regTime',
|
|
'vipFlag',
|
|
'yearVipFlag',
|
|
'svipFlag',
|
|
'vipLevel',
|
|
'birthdayYear',
|
|
'birthdayMonth',
|
|
'birthdayDay',
|
|
]) {
|
|
expect(profile).not.toHaveProperty(name);
|
|
}
|
|
});
|
|
|
|
it.each(['uin', 'uid'])(
|
|
'decodes the birthday bytes-property through the %s request',
|
|
async (form) => {
|
|
const sender = makeSender({
|
|
body: {
|
|
uin: 10001,
|
|
uid: 'u_test',
|
|
properties: {
|
|
bytesProperties: [
|
|
{ code: 20031, value: new Uint8Array([0x07, 0xd0, 3, 15]) },
|
|
],
|
|
},
|
|
},
|
|
});
|
|
const profile =
|
|
form === 'uin'
|
|
? await FetchUserProfile.invoke(sender, { uin: 10001 })
|
|
: await FetchUserProfileByUid.invoke(sender, { uid: 'u_test' });
|
|
expect(profile).toMatchObject({
|
|
birthdayYear: 2000,
|
|
birthdayMonth: 3,
|
|
birthdayDay: 15,
|
|
});
|
|
},
|
|
);
|
|
|
|
it.each([
|
|
[12, 31],
|
|
[2, 29],
|
|
])('keeps a hidden-year birthday %i/%i', async (month, day) => {
|
|
const sender = makeSender({
|
|
body: {
|
|
uin: 10001,
|
|
properties: {
|
|
bytesProperties: [
|
|
{ code: 20031, value: new Uint8Array([0, 0, month, day]) },
|
|
],
|
|
},
|
|
},
|
|
});
|
|
const profile = await FetchUserProfile.invoke(sender, { uin: 10001 });
|
|
expect(profile).toMatchObject({ birthdayMonth: month, birthdayDay: day });
|
|
expect(profile).not.toHaveProperty('birthdayYear');
|
|
});
|
|
|
|
it.each([
|
|
['an unset birthday', [0x07, 0xd0, 0, 0]],
|
|
['an all-zero value', [0, 0, 0, 0]],
|
|
['an out-of-range month', [0x07, 0xd0, 13, 1]],
|
|
['an out-of-range day', [0x07, 0xd0, 1, 32]],
|
|
['April 31', [0x07, 0xd0, 4, 31]],
|
|
['a leap day in 1900', [0x07, 0x6c, 2, 29]],
|
|
['a truncated value', [0x07, 0xd0, 3]],
|
|
['an oversized value', [0x07, 0xd0, 3, 15, 0]],
|
|
])('leaves the birthday unavailable for %s', async (_case, value) => {
|
|
const sender = makeSender({
|
|
body: {
|
|
uin: 10001,
|
|
properties: {
|
|
bytesProperties: [{ code: 20031, value: new Uint8Array(value) }],
|
|
},
|
|
},
|
|
});
|
|
const profile = await FetchUserProfile.invoke(sender, { uin: 10001 });
|
|
|
|
for (const name of ['birthdayYear', 'birthdayMonth', 'birthdayDay']) {
|
|
expect(profile).not.toHaveProperty(name);
|
|
}
|
|
});
|
|
|
|
it('routes to OidbSvcTrpcTcp.0xfe1_2 with reserved=1', async () => {
|
|
const sender = makeSender({ body: { uin: 10001, uid: 'u' } as any });
|
|
await FetchUserProfile.invoke(sender, { uin: 10001 });
|
|
const [wireName, bytes] = sender.sendRawPacket.mock.calls[0]!;
|
|
expect(wireName).toBe('OidbSvcTrpcTcp.0xfe1_2');
|
|
const env = protobuf_decode<OidbBase<OidbUserInfoRequest>>(bytes);
|
|
expect(env.reserved).toBe(1);
|
|
});
|
|
|
|
it('requests every property key in the catalogue (nickname, level, …)', async () => {
|
|
const sender = makeSender({ body: { uin: 10001, uid: 'u' } as any });
|
|
await FetchUserProfile.invoke(sender, { uin: 10001 });
|
|
const [, bytes] = sender.sendRawPacket.mock.calls[0]!;
|
|
const env = protobuf_decode<OidbBase<OidbUserInfoRequest>>(bytes);
|
|
const keys = env.body?.keys?.map((k) => k.key);
|
|
expect(keys).toContain(20002); // nickname
|
|
expect(keys).toContain(105); // level
|
|
expect(keys).toContain(101); // avatar
|
|
expect(keys).toContain(102); // sign
|
|
expect(keys).toContain(103); // remark
|
|
expect(keys).toContain(20031); // birthday
|
|
expect(keys).toContain(40410); // qidian crew flag (企点员工标志)
|
|
expect(keys).toContain(42031); // qidian master flag (企点主号标志)
|
|
});
|
|
|
|
it('decodes qidian flags from number-properties (0 when absent)', async () => {
|
|
// 企点员工号：两个标志均为 1；普通账号服务器不返回这两个 key → 缺省 0
|
|
const qidian = makeSender({
|
|
body: {
|
|
uin: 10002,
|
|
uid: 'u',
|
|
properties: {
|
|
bytesProperties: [],
|
|
numberProperties: [
|
|
{ number1: 40410, number2: 1 },
|
|
{ number1: 42031, number2: 1 },
|
|
],
|
|
},
|
|
} as any,
|
|
});
|
|
const out = await FetchUserProfile.invoke(qidian, { uin: 10002 });
|
|
expect(out.qidianMasterFlag).toBe(1);
|
|
expect(out.qidianCrewFlag).toBe(1);
|
|
expect(out.qidianCrewFlag2).toBe(0);
|
|
|
|
// 普通账号：无企点 key → 全 0
|
|
const normal = makeSender({
|
|
body: {
|
|
uin: 10001,
|
|
uid: 'u',
|
|
properties: {
|
|
bytesProperties: [],
|
|
numberProperties: [{ number1: 20009, number2: 1 }],
|
|
},
|
|
} as any,
|
|
});
|
|
const out2 = await FetchUserProfile.invoke(normal, { uin: 10001 });
|
|
expect(out2.qidianMasterFlag).toBe(0);
|
|
expect(out2.qidianCrewFlag).toBe(0);
|
|
expect(out2.qidianCrewFlag2).toBe(0);
|
|
});
|
|
|
|
it('decodes nickname / remark / qid / sign from bytes-properties', async () => {
|
|
const enc = (s: string) => new TextEncoder().encode(s);
|
|
const sender = makeSender({
|
|
body: {
|
|
uin: 10001,
|
|
uid: 'u',
|
|
properties: {
|
|
bytesProperties: [
|
|
{ code: 20002, value: enc('Nick') },
|
|
{ code: 103, value: enc('Bestie') },
|
|
{ code: 27394, value: enc('myqid') },
|
|
{ code: 102, value: enc('Hello') },
|
|
],
|
|
numberProperties: [],
|
|
},
|
|
} as any,
|
|
});
|
|
const out = await FetchUserProfile.invoke(sender, { uin: 10001 });
|
|
expect(out.nickname).toBe('Nick');
|
|
expect(out.remark).toBe('Bestie');
|
|
expect(out.qid).toBe('myqid');
|
|
expect(out.sign).toBe('Hello');
|
|
});
|
|
|
|
it('decodes sex / age / level from number-properties (sex enum)', async () => {
|
|
const cases: Array<[number, string]> = [
|
|
[1, 'male'],
|
|
[2, 'female'],
|
|
[255, 'unknown'],
|
|
[0, 'unknown'],
|
|
];
|
|
|
|
for (const [sexNum, expected] of cases) {
|
|
const sender = makeSender({
|
|
body: {
|
|
uin: 1,
|
|
uid: 'u',
|
|
properties: {
|
|
bytesProperties: [],
|
|
numberProperties: [
|
|
{ number1: 20009, number2: sexNum },
|
|
{ number1: 20037, number2: 25 },
|
|
{ number1: 105, number2: 7 },
|
|
],
|
|
},
|
|
} as any,
|
|
});
|
|
const out = await FetchUserProfile.invoke(sender, { uin: 1 });
|
|
expect(out.sex).toBe(expected);
|
|
expect(out.age).toBe(25);
|
|
expect(out.level).toBe(7);
|
|
}
|
|
});
|
|
|
|
it('decodes the avatar URL with the "640" size suffix appended', async () => {
|
|
const avatarBytes = protobuf_encode<AvatarInfo>({ url: 'https://q.qlogo.cn/abc/' });
|
|
const sender = makeSender({
|
|
body: {
|
|
uin: 10001,
|
|
uid: 'u',
|
|
properties: {
|
|
bytesProperties: [{ code: 101, value: avatarBytes }],
|
|
numberProperties: [],
|
|
},
|
|
} as any,
|
|
});
|
|
const out = await FetchUserProfile.invoke(sender, { uin: 10001 });
|
|
expect(out.avatar).toBe('https://q.qlogo.cn/abc/640');
|
|
});
|
|
|
|
it('defaults uin to the requested value when the server omits its echo', async () => {
|
|
const sender = makeSender({ body: { uid: 'u' } as any });
|
|
const out = await FetchUserProfile.invoke(sender, { uin: 99999 });
|
|
expect(out.uin).toBe(99999);
|
|
});
|
|
|
|
it('throws when body is entirely missing from the envelope', async () => {
|
|
const sender = makeSender({});
|
|
await expect(FetchUserProfile.invoke(sender, { uin: 1 })).rejects.toThrow(
|
|
'user info response body missing',
|
|
);
|
|
});
|
|
});
|
|
});
|