SnowLuma v2.4.2 source snapshot

packages/onebot/tests/request-actions.test.ts

@@ -0,0 +1,378 @@
+import { describe, expect, it, vi } from 'vitest';
+import { handleGroupAddRequest } from '../src/modules/request-actions';
+import type { BridgeInterface } from '../../src/bridge/bridge-interface';
+import type { GroupRequestInfo } from '@snowluma/protocol/qq-info';
+
+// See `contact-actions.test.ts` for the auto-promotion rationale.
+const APIS_ROUTING: Record<string, string> = {
+    fetchFriendList: 'contacts',
+    fetchGroupList: 'contacts',
+    fetchGroupMemberList: 'contacts',
+    fetchUserProfile: 'contacts',
+    fetchGroupRequests: 'contacts',
+    fetchGroupRequestsByUid: 'contacts',
+    fetchDownloadRKeys: 'contacts',
+    groupInvites: 'contacts',
+    findGroupInviteCardGroupBySequence: 'contacts',
+};
+
+function fakeBridge(overrides: Record<string, any> = {}): BridgeInterface {
+    const apisSynth: Record<string, Record<string, any>> = {};
+
+    for (const [k, v] of Object.entries(overrides)) {
+        const area = APIS_ROUTING[k];
+
+        if (area) {
+            if (!apisSynth[area]) {
+                apisSynth[area] = {};
+            }
+
+            apisSynth[area][k] = v;
+        }
+    }
+
+    const merged = { ...overrides, apis: { ...apisSynth, ...(overrides.apis ?? {}) } };
+    return new Proxy(merged as BridgeInterface, {
+        get(target, prop) {
+            if (prop in target) {
+                return (target as any)[prop];
+            }
+
+            throw new Error(`fakeBridge: '${String(prop)}' was not stubbed`);
+        },
+    });
+}
+
+function fakeRequest(overrides: Partial<GroupRequestInfo> = {}): GroupRequestInfo {
+    return {
+        groupId: 999,
+        groupName: 'g',
+        targetUid: 'u_t',
+        targetUin: 5555,
+        targetName: 'target',
+        invitorUid: 'u_i',
+        invitorUin: 7777,
+        invitorName: 'inviter',
+        operatorUid: 'u_o',
+        operatorUin: 8888,
+        operatorName: 'op',
+        sequence: 42,
+        state: 1,
+        eventType: 2,
+        comment: 'pls',
+        filtered: false,
+        ...overrides,
+    };
+}
+
+describe('onebot/modules/request-actions / handleGroupAddRequest', () => {
+    it('uses a canonical flag and keeps the tuple when the inbox has no match', async () => {
+        const setAddRequest = vi.fn(async () => {});
+        const fetchGroupRequests = vi.fn(async () => []);
+        const bridge = fakeBridge({
+            fetchGroupRequests,
+            apis: { groupAdmin: { setAddRequest } } as any,
+        });
+
+        await handleGroupAddRequest(bridge, 'slreq:1:123456:999:22:1', true, 'ok');
+
+        expect(fetchGroupRequests).toHaveBeenCalled();
+        expect(setAddRequest).toHaveBeenCalledWith(999, 123456, 22, true, 'ok', true, undefined);
+    });
+
+    it('corrects a stale canonical eventType from the live inbox', async () => {
+        const setAddRequest = vi.fn(async () => {});
+        const trans = Uint8Array.from([0xaa]);
+        const bridge = fakeBridge({
+            findGroupInviteCardGroupBySequence: vi.fn(() => undefined),
+            fetchGroupRequests: vi.fn(async (filtered: boolean) =>
+                filtered
+                    ? []
+                    : [
+                          fakeRequest({
+                              groupId: 999,
+                              sequence: 123456,
+                              notifyType: 7,
+                              eventType: 1,
+                              filtered: false,
+                              operateTransInfo: trans,
+                          }),
+                      ],
+            ),
+            apis: { groupAdmin: { setAddRequest } } as any,
+        });
+
+        await handleGroupAddRequest(bridge, 'slreq:1:123456:999:2:0', true, '');
+
+        expect(setAddRequest).toHaveBeenCalledWith(999, 123456, 1, true, '', false, trans);
+    });
+
+    it('accepts a NapCat numeric sequence and resolves the exact main-inbox request', async () => {
+        const setAddRequest = vi.fn(async () => {});
+        const bridge = fakeBridge({
+            findGroupInviteCardGroupBySequence: vi.fn(() => undefined),
+            fetchGroupRequests: vi.fn(async (filtered: boolean) =>
+                filtered
+                    ? []
+                    : [
+                          fakeRequest({
+                              groupId: 999,
+                              sequence: 261237407,
+                              eventType: 1,
+                              filtered: false,
+                          }),
+                      ],
+            ),
+            apis: { groupAdmin: { setAddRequest } } as any,
+        });
+
+        await handleGroupAddRequest(bridge, '261237407', false, 'no');
+
+        expect(setAddRequest).toHaveBeenCalledWith(
+            999,
+            261237407,
+            1,
+            false,
+            'no',
+            false,
+            undefined,
+        );
+    });
+
+    it('accepts a NapCat numeric sequence from the filtered inbox', async () => {
+        const setAddRequest = vi.fn(async () => {});
+        const bridge = fakeBridge({
+            findGroupInviteCardGroupBySequence: vi.fn(() => undefined),
+            fetchGroupRequests: vi.fn(async (filtered: boolean) =>
+                filtered
+                    ? [fakeRequest({ groupId: 999, sequence: 55, eventType: 2, filtered: true })]
+                    : [],
+            ),
+            apis: { groupAdmin: { setAddRequest } } as any,
+        });
+
+        await handleGroupAddRequest(bridge, '55', true, 'ok');
+
+        expect(setAddRequest).toHaveBeenCalledWith(999, 55, 2, true, 'ok', true, undefined);
+    });
+
+    it('resolves a private invite-card msgseq by its cached group', async () => {
+        const setAddRequest = vi.fn(async () => {});
+        const bridge = fakeBridge({
+            findGroupInviteCardGroupBySequence: vi.fn(() => 999),
+            fetchGroupRequests: vi.fn(async () => []),
+            apis: { groupAdmin: { setAddRequest } } as any,
+        });
+
+        await handleGroupAddRequest(bridge, '778899', true, 'ok');
+
+        expect(setAddRequest).toHaveBeenCalledWith(999, 778899, 2, true, 'ok', false, undefined);
+    });
+
+    it('matches add requests by groupId and targetUid', async () => {
+        const setAddRequest = vi.fn(async () => {});
+        const fetchGroupRequestsByUid = vi.fn(async () => [
+            fakeRequest({ sequence: 41, targetUid: 'u_t', eventType: 2 }),
+            fakeRequest({
+                groupId: 999,
+                targetUid: 'u_t',
+                sequence: 42,
+                eventType: 1,
+                filtered: false,
+            }),
+        ]);
+        const bridge = fakeBridge({
+            fetchGroupRequestsByUid,
+            apis: { groupAdmin: { setAddRequest } } as any,
+        });
+
+        await handleGroupAddRequest(bridge, 'add:999:u_t', true, 'ok');
+
+        expect(setAddRequest).toHaveBeenCalledOnce();
+        expect(setAddRequest).toHaveBeenCalledWith(999, 42, 1, true, 'ok', false, undefined);
+        expect(fetchGroupRequestsByUid).toHaveBeenCalledWith(false, 100);
+        expect(fetchGroupRequestsByUid).toHaveBeenCalledWith(true, 100);
+    });
+
+    it('matches invite requests by groupId and invitorUid', async () => {
+        const setAddRequest = vi.fn(async () => {});
+        const bridge = fakeBridge({
+            fetchGroupRequestsByUid: vi.fn(async () => [
+                fakeRequest({ sequence: 96, invitorUid: 'u_i', eventType: 1 }),
+                fakeRequest({
+                    groupId: 999,
+                    invitorUid: 'u_i',
+                    sequence: 97,
+                    eventType: 22,
+                    filtered: false,
+                }),
+            ]),
+            groupInvites: { getSelfInviteNotice: vi.fn(() => undefined) },
+            apis: { groupAdmin: { setAddRequest } } as any,
+        });
+
+        await handleGroupAddRequest(bridge, 'invite:999:u_i', false, 'no');
+
+        expect(setAddRequest).toHaveBeenCalledOnce();
+        expect(setAddRequest).toHaveBeenCalledWith(999, 97, 22, false, 'no', false, undefined);
+    });
+
+    it('finds a request that only lives in the filtered inbox (#197)', async () => {
+        const setAddRequest = vi.fn(async () => {});
+        const bridge = fakeBridge({
+            // Main inbox empty; the invite sits only in the spam-filtered inbox.
+            fetchGroupRequestsByUid: vi.fn(async (filtered: boolean) =>
+                filtered
+                    ? [
+                          fakeRequest({
+                              groupId: 999,
+                              invitorUid: 'u_i',
+                              sequence: 55,
+                              eventType: 2,
+                              filtered: true,
+                          }),
+                      ]
+                    : [],
+            ),
+            groupInvites: { getSelfInviteNotice: vi.fn(() => undefined) },
+            apis: { groupAdmin: { setAddRequest } } as any,
+        });
+
+        await handleGroupAddRequest(bridge, 'invite:999:u_i', true, 'ok');
+
+        // Approved through the filtered inbox (subCommand 2 → last arg true).
+        expect(setAddRequest).toHaveBeenCalledOnce();
+        expect(setAddRequest).toHaveBeenCalledWith(999, 55, 2, true, 'ok', true, undefined);
+    });
+
+    it('surfaces "not found" only when neither inbox has the request', async () => {
+        const bridge = fakeBridge({
+            fetchGroupRequestsByUid: vi.fn(async () => []),
+            groupInvites: { getSelfInviteNotice: vi.fn(() => undefined) },
+            apis: { groupAdmin: { setAddRequest: vi.fn(async () => {}) } } as any,
+        });
+        await expect(handleGroupAddRequest(bridge, 'invite:999:u_i', true, 'ok')).rejects.toThrow(
+            /matching group request not found/,
+        );
+    });
+
+    it('never picks one of two different pending invitations with the same legacy flag', async () => {
+        const setAddRequest = vi.fn();
+        const bridge = fakeBridge({
+            groupInvites: { getSelfInviteNotice: vi.fn(() => undefined) },
+            fetchGroupRequestsByUid: vi.fn(async (filtered: boolean) =>
+                filtered ? [] : [fakeRequest({ sequence: 123 }), fakeRequest({ sequence: 124 })],
+            ),
+            apis: { groupAdmin: { setAddRequest } },
+        });
+        await expect(handleGroupAddRequest(bridge, 'invite:999:u_i', true, '')).rejects.toThrow(
+            'multiple pending group requests',
+        );
+        expect(setAddRequest).not.toHaveBeenCalled();
+    });
+
+    it('skips processed requests when approving a legacy notice', async () => {
+        const setAddRequest = vi.fn();
+        const bridge = fakeBridge({
+            groupInvites: { getSelfInviteNotice: vi.fn(() => undefined) },
+            fetchGroupRequestsByUid: vi.fn(async (filtered: boolean) =>
+                filtered
+                    ? []
+                    : [fakeRequest({ sequence: 123, state: 2 }), fakeRequest({ sequence: 124 })],
+            ),
+            apis: { groupAdmin: { setAddRequest } },
+        });
+        await handleGroupAddRequest(bridge, 'invite:999:u_i', true, '');
+        expect(setAddRequest).toHaveBeenCalledExactlyOnceWith(
+            999,
+            124,
+            2,
+            true,
+            '',
+            false,
+            undefined,
+        );
+    });
+
+    it('does not treat an inviter QQ number as a request sequence (#213)', async () => {
+        const setAddRequest = vi.fn(async () => {});
+        const bridge = fakeBridge({
+            findGroupInviteCardGroupBySequence: vi.fn(() => undefined),
+            fetchGroupRequests: vi.fn(async () => [
+                fakeRequest({ groupId: 888, invitorUin: 261237407, sequence: 123456 }),
+            ]),
+            apis: { groupAdmin: { setAddRequest } } as any,
+        });
+
+        await expect(handleGroupAddRequest(bridge, '261237407', true, 'ok')).rejects.toThrow(
+            /sequence 261237407 not found/,
+        );
+        expect(setAddRequest).not.toHaveBeenCalled();
+    });
+
+    it('does not fall back to another request from the same group', async () => {
+        const setAddRequest = vi.fn(async () => {});
+        const bridge = fakeBridge({
+            fetchGroupRequestsByUid: vi.fn(async () => [
+                fakeRequest({ groupId: 999, targetUid: 'u_someone_else' }),
+            ]),
+            apis: { groupAdmin: { setAddRequest } } as any,
+        });
+
+        await expect(
+            handleGroupAddRequest(bridge, 'add:999:u_missing', true, 'ok'),
+        ).rejects.toThrow(/matching group request not found/);
+        expect(setAddRequest).not.toHaveBeenCalled();
+    });
+
+    it('uses the surviving inbox when the other request lookup fails', async () => {
+        const setAddRequest = vi.fn(async () => {});
+        const bridge = fakeBridge({
+            findGroupInviteCardGroupBySequence: vi.fn(() => undefined),
+            fetchGroupRequests: vi.fn(async (filtered: boolean) => {
+                if (!filtered) {
+                    throw new Error('main inbox down');
+                }
+
+                return [fakeRequest({ groupId: 999, sequence: 55, eventType: 2, filtered: true })];
+            }),
+            apis: { groupAdmin: { setAddRequest } } as any,
+        });
+
+        await handleGroupAddRequest(bridge, '55', true, 'ok');
+
+        expect(setAddRequest).toHaveBeenCalledWith(999, 55, 2, true, 'ok', true, undefined);
+    });
+
+    it('does not report not-found when an unavailable inbox may contain the request', async () => {
+        const bridge = fakeBridge({
+            findGroupInviteCardGroupBySequence: vi.fn(() => undefined),
+            fetchGroupRequests: vi.fn(async (filtered: boolean) => {
+                if (filtered) {
+                    throw new Error('filtered inbox down');
+                }
+
+                return [];
+            }),
+            apis: { groupAdmin: { setAddRequest: vi.fn(async () => {}) } } as any,
+        });
+
+        await expect(handleGroupAddRequest(bridge, '55', true, 'ok')).rejects.toThrow(
+            /lookup incomplete/,
+        );
+    });
+
+    it('distinguishes request-queue failure from a genuine missing request', async () => {
+        const bridge = fakeBridge({
+            findGroupInviteCardGroupBySequence: vi.fn(() => undefined),
+            fetchGroupRequests: vi.fn(async () => {
+                throw new Error('OIDB unavailable');
+            }),
+            apis: { groupAdmin: { setAddRequest: vi.fn(async () => {}) } } as any,
+        });
+
+        await expect(handleGroupAddRequest(bridge, '55', true, 'ok')).rejects.toThrow(
+            /failed to fetch group requests/,
+        );
+    });
+});