add test

src/components/dialogs/GroupDialog/__tests__/useGroupBatchOperations.test.js

@@ -0,0 +1,272 @@
+import { ref } from 'vue';
+import { describe, expect, test, vi } from 'vitest';
+
+vi.mock('vue-sonner', () => ({ toast: { success: vi.fn(), error: vi.fn() } }));
+
+import { useGroupBatchOperations } from '../useGroupBatchOperations';
+
+/**
+ *
+ * @param overrides
+ */
+function createDeps(overrides = {}) {
+    return {
+        selectedUsersArray: ref([
+            {
+                userId: 'usr_1',
+                displayName: 'Alice',
+                roleIds: ['role_1'],
+                managerNotes: ''
+            },
+            {
+                userId: 'usr_2',
+                displayName: 'Bob',
+                roleIds: ['role_1'],
+                managerNotes: ''
+            }
+        ]),
+        currentUser: ref({ id: 'usr_self' }),
+        groupMemberModeration: ref({ id: 'grp_test' }),
+        deselectedUsers: vi.fn(),
+        groupRequest: {
+            banGroupMember: vi.fn().mockResolvedValue(undefined),
+            unbanGroupMember: vi.fn().mockResolvedValue(undefined),
+            kickGroupMember: vi.fn().mockResolvedValue(undefined),
+            setGroupMemberProps: vi.fn().mockResolvedValue(undefined),
+            removeGroupMemberRole: vi.fn().mockResolvedValue(undefined),
+            addGroupMemberRole: vi.fn().mockResolvedValue(undefined),
+            deleteSentGroupInvite: vi.fn().mockResolvedValue(undefined),
+            acceptGroupInviteRequest: vi.fn().mockResolvedValue(undefined),
+            rejectGroupInviteRequest: vi.fn().mockResolvedValue(undefined),
+            blockGroupInviteRequest: vi.fn().mockResolvedValue(undefined),
+            deleteBlockedGroupRequest: vi.fn().mockResolvedValue(undefined)
+        },
+        handleGroupMemberRoleChange: vi.fn(),
+        handleGroupMemberProps: vi.fn(),
+        ...overrides
+    };
+}
+
+describe('useGroupBatchOperations', () => {
+    describe('runBatchOperation (via groupMembersBan)', () => {
+        test('calls action for each selected user', async () => {
+            const deps = createDeps();
+            const { groupMembersBan } = useGroupBatchOperations(deps);
+
+            await groupMembersBan();
+
+            expect(deps.groupRequest.banGroupMember).toHaveBeenCalledTimes(2);
+            expect(deps.groupRequest.banGroupMember).toHaveBeenCalledWith({
+                groupId: 'grp_test',
+                userId: 'usr_1'
+            });
+            expect(deps.groupRequest.banGroupMember).toHaveBeenCalledWith({
+                groupId: 'grp_test',
+                userId: 'usr_2'
+            });
+        });
+
+        test('skips self user', async () => {
+            const deps = createDeps({
+                selectedUsersArray: ref([
+                    {
+                        userId: 'usr_self',
+                        displayName: 'Self',
+                        roleIds: [],
+                        managerNotes: ''
+                    },
+                    {
+                        userId: 'usr_1',
+                        displayName: 'Alice',
+                        roleIds: [],
+                        managerNotes: ''
+                    }
+                ])
+            });
+            const { groupMembersBan } = useGroupBatchOperations(deps);
+
+            await groupMembersBan();
+
+            expect(deps.groupRequest.banGroupMember).toHaveBeenCalledTimes(1);
+            expect(deps.groupRequest.banGroupMember).toHaveBeenCalledWith({
+                groupId: 'grp_test',
+                userId: 'usr_1'
+            });
+        });
+
+        test('calls onComplete callback', async () => {
+            const deps = createDeps();
+            const onComplete = vi.fn();
+            const { groupMembersBan } = useGroupBatchOperations(deps);
+
+            await groupMembersBan({ onComplete });
+
+            expect(onComplete).toHaveBeenCalled();
+        });
+
+        test('handles errors gracefully', async () => {
+            const deps = createDeps();
+            deps.groupRequest.banGroupMember
+                .mockRejectedValueOnce(new Error('fail'))
+                .mockResolvedValueOnce(undefined);
+            const { groupMembersBan } = useGroupBatchOperations(deps);
+
+            await groupMembersBan();
+
+            // should still attempt the second user
+            expect(deps.groupRequest.banGroupMember).toHaveBeenCalledTimes(2);
+        });
+
+        test('tracks progress during operation', async () => {
+            const deps = createDeps();
+            const { groupMembersBan, progressTotal, progressCurrent } =
+                useGroupBatchOperations(deps);
+
+            expect(progressTotal.value).toBe(0);
+            const p = groupMembersBan();
+            await p;
+            // After completion, progress resets to 0
+            expect(progressTotal.value).toBe(0);
+            expect(progressCurrent.value).toBe(0);
+        });
+    });
+
+    describe('groupMembersUnban', () => {
+        test('calls unbanGroupMember for each user', async () => {
+            const deps = createDeps();
+            const { groupMembersUnban } = useGroupBatchOperations(deps);
+
+            await groupMembersUnban();
+
+            expect(deps.groupRequest.unbanGroupMember).toHaveBeenCalledTimes(2);
+        });
+    });
+
+    describe('groupMembersKick', () => {
+        test('calls kickGroupMember for each user', async () => {
+            const deps = createDeps();
+            const { groupMembersKick } = useGroupBatchOperations(deps);
+
+            await groupMembersKick();
+
+            expect(deps.groupRequest.kickGroupMember).toHaveBeenCalledTimes(2);
+        });
+    });
+
+    describe('groupMembersSaveNote', () => {
+        test('calls setGroupMemberProps with note value', async () => {
+            const deps = createDeps();
+            const { groupMembersSaveNote } = useGroupBatchOperations(deps);
+
+            await groupMembersSaveNote('Test note');
+
+            expect(deps.groupRequest.setGroupMemberProps).toHaveBeenCalledTimes(
+                2
+            );
+            expect(deps.groupRequest.setGroupMemberProps).toHaveBeenCalledWith(
+                'usr_1',
+                'grp_test',
+                {
+                    managerNotes: 'Test note'
+                }
+            );
+        });
+    });
+
+    describe('groupMembersAddRoles', () => {
+        test('calls addGroupMemberRole for each role per user', async () => {
+            const deps = createDeps();
+            const { groupMembersAddRoles } = useGroupBatchOperations(deps);
+
+            await groupMembersAddRoles(['role_1', 'role_2']);
+
+            // Both users already have role_1, so only role_2 gets added → 2 calls
+            expect(deps.groupRequest.addGroupMemberRole).toHaveBeenCalledTimes(
+                2
+            );
+        });
+    });
+
+    describe('groupMembersRemoveRoles', () => {
+        test('calls removeGroupMemberRole for each role per user', async () => {
+            const deps = createDeps();
+            const { groupMembersRemoveRoles } = useGroupBatchOperations(deps);
+
+            await groupMembersRemoveRoles(['role_1']);
+
+            expect(
+                deps.groupRequest.removeGroupMemberRole
+            ).toHaveBeenCalledTimes(2);
+        });
+    });
+
+    describe('groupMembersDeleteSentInvite', () => {
+        test('calls deleteSentGroupInvite for each user', async () => {
+            const deps = createDeps();
+            const { groupMembersDeleteSentInvite } =
+                useGroupBatchOperations(deps);
+
+            await groupMembersDeleteSentInvite();
+
+            expect(
+                deps.groupRequest.deleteSentGroupInvite
+            ).toHaveBeenCalledTimes(2);
+        });
+    });
+
+    describe('groupMembersAcceptInviteRequest', () => {
+        test('calls acceptGroupInviteRequest for each user', async () => {
+            const deps = createDeps();
+            const { groupMembersAcceptInviteRequest } =
+                useGroupBatchOperations(deps);
+
+            await groupMembersAcceptInviteRequest();
+
+            expect(
+                deps.groupRequest.acceptGroupInviteRequest
+            ).toHaveBeenCalledTimes(2);
+        });
+    });
+
+    describe('groupMembersRejectInviteRequest', () => {
+        test('calls rejectGroupInviteRequest for each user', async () => {
+            const deps = createDeps();
+            const { groupMembersRejectInviteRequest } =
+                useGroupBatchOperations(deps);
+
+            await groupMembersRejectInviteRequest();
+
+            expect(
+                deps.groupRequest.rejectGroupInviteRequest
+            ).toHaveBeenCalledTimes(2);
+        });
+    });
+
+    describe('groupMembersBlockJoinRequest', () => {
+        test('calls blockGroupInviteRequest for each user', async () => {
+            const deps = createDeps();
+            const { groupMembersBlockJoinRequest } =
+                useGroupBatchOperations(deps);
+
+            await groupMembersBlockJoinRequest();
+
+            expect(
+                deps.groupRequest.blockGroupInviteRequest
+            ).toHaveBeenCalledTimes(2);
+        });
+    });
+
+    describe('groupMembersDeleteBlockedRequest', () => {
+        test('calls deleteBlockedGroupRequest for each user', async () => {
+            const deps = createDeps();
+            const { groupMembersDeleteBlockedRequest } =
+                useGroupBatchOperations(deps);
+
+            await groupMembersDeleteBlockedRequest();
+
+            expect(
+                deps.groupRequest.deleteBlockedGroupRequest
+            ).toHaveBeenCalledTimes(2);
+        });
+    });
+});

src/components/dialogs/GroupDialog/__tests__/useGroupModerationSelection.test.js

@@ -0,0 +1,206 @@
+import { describe, expect, test } from 'vitest';
+
+import { useGroupModerationSelection } from '../useGroupModerationSelection';
+
+function createTables() {
+    return {
+        members: { data: [] },
+        bans: { data: [] },
+        invites: { data: [] },
+        joinRequests: { data: [] },
+        blocked: { data: [] }
+    };
+}
+
+describe('useGroupModerationSelection', () => {
+    describe('setSelectedUsers', () => {
+        test('adds a user to selection', () => {
+            const tables = createTables();
+            const { selectedUsers, selectedUsersArray, setSelectedUsers } =
+                useGroupModerationSelection(tables);
+
+            setSelectedUsers('usr_1', { userId: 'usr_1', name: 'Alice' });
+
+            expect(selectedUsers['usr_1']).toEqual({
+                userId: 'usr_1',
+                name: 'Alice'
+            });
+            expect(selectedUsersArray.value).toHaveLength(1);
+        });
+
+        test('ignores null user', () => {
+            const tables = createTables();
+            const { selectedUsersArray, setSelectedUsers } =
+                useGroupModerationSelection(tables);
+
+            setSelectedUsers('usr_1', null);
+
+            expect(selectedUsersArray.value).toHaveLength(0);
+        });
+
+        test('adds multiple users', () => {
+            const tables = createTables();
+            const { selectedUsersArray, setSelectedUsers } =
+                useGroupModerationSelection(tables);
+
+            setSelectedUsers('usr_1', { userId: 'usr_1', name: 'Alice' });
+            setSelectedUsers('usr_2', { userId: 'usr_2', name: 'Bob' });
+
+            expect(selectedUsersArray.value).toHaveLength(2);
+        });
+    });
+
+    describe('deselectedUsers', () => {
+        test('removes a specific user', () => {
+            const tables = createTables();
+            const {
+                selectedUsers,
+                selectedUsersArray,
+                setSelectedUsers,
+                deselectedUsers
+            } = useGroupModerationSelection(tables);
+
+            setSelectedUsers('usr_1', { userId: 'usr_1', name: 'Alice' });
+            setSelectedUsers('usr_2', { userId: 'usr_2', name: 'Bob' });
+            deselectedUsers('usr_1');
+
+            expect(selectedUsers['usr_1']).toBeUndefined();
+            expect(selectedUsersArray.value).toHaveLength(1);
+            expect(selectedUsersArray.value[0].name).toBe('Bob');
+        });
+
+        test('removes all users when isAll=true', () => {
+            const tables = createTables();
+            const { selectedUsersArray, setSelectedUsers, deselectedUsers } =
+                useGroupModerationSelection(tables);
+
+            setSelectedUsers('usr_1', { userId: 'usr_1', name: 'Alice' });
+            setSelectedUsers('usr_2', { userId: 'usr_2', name: 'Bob' });
+            deselectedUsers(null, true);
+
+            expect(selectedUsersArray.value).toHaveLength(0);
+        });
+    });
+
+    describe('onSelectionChange', () => {
+        test('selects user when row.$selected is true', () => {
+            const tables = createTables();
+            const { selectedUsersArray, onSelectionChange } =
+                useGroupModerationSelection(tables);
+
+            onSelectionChange({
+                userId: 'usr_1',
+                name: 'Alice',
+                $selected: true
+            });
+
+            expect(selectedUsersArray.value).toHaveLength(1);
+        });
+
+        test('deselects user when row.$selected is false', () => {
+            const tables = createTables();
+            const { selectedUsersArray, setSelectedUsers, onSelectionChange } =
+                useGroupModerationSelection(tables);
+
+            setSelectedUsers('usr_1', { userId: 'usr_1', name: 'Alice' });
+            onSelectionChange({ userId: 'usr_1', $selected: false });
+
+            expect(selectedUsersArray.value).toHaveLength(0);
+        });
+    });
+
+    describe('deselectInTables', () => {
+        test('deselects specific user in table data', () => {
+            const tables = createTables();
+            tables.members.data = [
+                { userId: 'usr_1', $selected: true },
+                { userId: 'usr_2', $selected: true }
+            ];
+            const { deselectInTables } = useGroupModerationSelection(tables);
+
+            deselectInTables('usr_1');
+
+            expect(tables.members.data[0].$selected).toBe(false);
+            expect(tables.members.data[1].$selected).toBe(true);
+        });
+
+        test('deselects all users when no userId', () => {
+            const tables = createTables();
+            tables.members.data = [
+                { userId: 'usr_1', $selected: true },
+                { userId: 'usr_2', $selected: true }
+            ];
+            tables.bans.data = [{ userId: 'usr_3', $selected: true }];
+            const { deselectInTables } = useGroupModerationSelection(tables);
+
+            deselectInTables();
+
+            expect(tables.members.data[0].$selected).toBe(false);
+            expect(tables.members.data[1].$selected).toBe(false);
+            expect(tables.bans.data[0].$selected).toBe(false);
+        });
+
+        test('handles null table gracefully', () => {
+            const tables = createTables();
+            tables.members = null;
+            const { deselectInTables } = useGroupModerationSelection(tables);
+
+            expect(() => deselectInTables('usr_1')).not.toThrow();
+        });
+    });
+
+    describe('deleteSelectedUser', () => {
+        test('removes user from selection and tables', () => {
+            const tables = createTables();
+            tables.members.data = [{ userId: 'usr_1', $selected: true }];
+            const { selectedUsersArray, setSelectedUsers, deleteSelectedUser } =
+                useGroupModerationSelection(tables);
+
+            setSelectedUsers('usr_1', { userId: 'usr_1', name: 'Alice' });
+            deleteSelectedUser({ userId: 'usr_1' });
+
+            expect(selectedUsersArray.value).toHaveLength(0);
+            expect(tables.members.data[0].$selected).toBe(false);
+        });
+    });
+
+    describe('clearAllSelected', () => {
+        test('clears all selections and table states', () => {
+            const tables = createTables();
+            tables.members.data = [
+                { userId: 'usr_1', $selected: true },
+                { userId: 'usr_2', $selected: true }
+            ];
+            tables.bans.data = [{ userId: 'usr_3', $selected: true }];
+            const { selectedUsersArray, setSelectedUsers, clearAllSelected } =
+                useGroupModerationSelection(tables);
+
+            setSelectedUsers('usr_1', { userId: 'usr_1' });
+            setSelectedUsers('usr_2', { userId: 'usr_2' });
+            setSelectedUsers('usr_3', { userId: 'usr_3' });
+
+            clearAllSelected();
+
+            expect(selectedUsersArray.value).toHaveLength(0);
+            expect(tables.members.data.every((r) => !r.$selected)).toBe(true);
+            expect(tables.bans.data.every((r) => !r.$selected)).toBe(true);
+        });
+    });
+
+    describe('selectAll', () => {
+        test('selects all rows in a table', () => {
+            const tables = createTables();
+            const tableData = [
+                { userId: 'usr_1', $selected: false },
+                { userId: 'usr_2', $selected: false }
+            ];
+            const { selectedUsersArray, selectAll } =
+                useGroupModerationSelection(tables);
+
+            selectAll(tableData);
+
+            expect(tableData.every((r) => r.$selected)).toBe(true);
+            expect(selectedUsersArray.value).toHaveLength(2);
+        });
+    });
+});