SnowLuma v2.4.2 source snapshot

packages/protocol/tests/oidb-services/group-admin/set-member-invite-policy.test.ts

@@ -0,0 +1,109 @@
+import { describe, expect, it, vi } from 'vitest';
+import { protobuf_decode } from '@snowluma/proton';
+import type { SendPacketResult } from '@snowluma/common/packet-sender';
+import type { OidbBase } from '@snowluma/proto-defs/oidb';
+import type { Oidb0x89a_0InvitePolicy } from '@snowluma/proto-defs/oidb-actions/base';
+
+import {
+    MEMBER_INVITE_PRIVILEGE_MASK,
+    decodeMemberInvitePolicy,
+    mergeMemberInvitePrivilegeFlag,
+    SetMemberInvitePolicy,
+    type GroupMemberInvitePolicy,
+} from '../../../src/oidb-services/group-admin/set-member-invite-policy';
+
+function makeSender() {
+    const r: SendPacketResult = {
+        success: true,
+        gotResponse: true,
+        errorCode: 0,
+        errorMessage: '',
+        responseData: Buffer.alloc(0),
+    };
+    return { sendRawPacket: vi.fn(async () => r) };
+}
+
+describe('SetMemberInvitePolicy namespace', () => {
+    it.each<[GroupMemberInvitePolicy, number, number]>([
+        ['disabled', 0x04000000, 0],
+        ['require_approval', 0, 1],
+        ['no_approval', 0x00100000, 1],
+        ['no_approval_under_100', 0x02000000, 1],
+    ])('maps %s to the verified privilege bits', async (policy, policyBits, allowMemberInvite) => {
+        const sender = makeSender();
+        const unrelatedBits = 0x80000001;
+
+        await SetMemberInvitePolicy.invoke(sender, {
+            groupId: 12345,
+            currentPrivilegeFlag: unrelatedBits + 0x06100000,
+            policy,
+        });
+
+        const [cmd, bytes] = sender.sendRawPacket.mock.calls[0]!;
+        expect(cmd).toBe('OidbSvcTrpcTcp.0x89a_0');
+        const env = protobuf_decode<OidbBase<Oidb0x89a_0InvitePolicy>>(bytes);
+        expect(env.command).toBe(0x89a);
+        expect(env.body?.groupUin).toBe(12345n);
+        expect(env.body?.settings).toEqual({
+            appPrivilegeFlag: unrelatedBits + policyBits,
+            appPrivilegeMask: MEMBER_INVITE_PRIVILEGE_MASK,
+            allowMemberInvite,
+        });
+    });
+
+    it('preserves unrelated bits while replacing only the member-invite mask', () => {
+        expect(mergeMemberInvitePrivilegeFlag(0xe7100001, 'require_approval')).toBe(0xe1000001);
+    });
+
+    it.each<[number, GroupMemberInvitePolicy]>([
+        [0x04000000, 'disabled'],
+        [0, 'require_approval'],
+        [0x00100000, 'no_approval'],
+        [0x02000000, 'no_approval_under_100'],
+        [0x80100001, 'no_approval'],
+        [0x84000001, 'disabled'],
+    ])('decodes privilege %# as %s', (privilegeFlag, policy) => {
+        expect(decodeMemberInvitePolicy(privilegeFlag)).toBe(policy);
+    });
+
+    it('round-trips each invite policy through merge then decode', () => {
+        const policies: GroupMemberInvitePolicy[] = [
+            'disabled',
+            'require_approval',
+            'no_approval',
+            'no_approval_under_100',
+        ];
+
+        for (const policy of policies) {
+            expect(
+                decodeMemberInvitePolicy(mergeMemberInvitePrivilegeFlag(0x80000001, policy)),
+            ).toBe(policy);
+        }
+    });
+
+    it('keeps explicit zero fields on the wire', async () => {
+        const sender = makeSender();
+        await SetMemberInvitePolicy.invoke(sender, {
+            groupId: 1,
+            currentPrivilegeFlag: MEMBER_INVITE_PRIVILEGE_MASK,
+            policy: 'require_approval',
+        });
+        const env = protobuf_decode<OidbBase<Oidb0x89a_0InvitePolicy>>(
+            sender.sendRawPacket.mock.calls[0]![1],
+        );
+        expect(env.body?.settings?.appPrivilegeFlag).toBe(0);
+        expect(env.body?.settings?.allowMemberInvite).toBe(1);
+    });
+
+    it('rejects an invalid current flag before sending a packet', async () => {
+        const sender = makeSender();
+        await expect(
+            SetMemberInvitePolicy.invoke(sender, {
+                groupId: 1,
+                currentPrivilegeFlag: -1,
+                policy: 'disabled',
+            }),
+        ).rejects.toThrow(/unsigned 32-bit/);
+        expect(sender.sendRawPacket).not.toHaveBeenCalled();
+    });
+});