stream-chat-react-native-core 9.3.1 → 9.4.0-beta.1

package/src/{components/ChannelList/hooks → hooks/actions}/__tests__/useChannelActionItems.test.tsx

@@ -1,10 +1,14 @@
 import { Alert, AlertButton } from 'react-native';
 
 import { renderHook } from '@testing-library/react-native';
-import type { Channel } from 'stream-chat';
+import type { Channel, Mute } from 'stream-chat';
 
-import type { TranslationContextValue } from '../../../../contexts/translationContext/TranslationContext';
-import * as TranslationContext from '../../../../contexts/translationContext/TranslationContext';
+import * as useMutedUsersModule from '../../../components/ChannelList/hooks/useMutedUsers';
+import * as useIsChannelMutedModule from '../../../components/ChannelPreview/hooks/useIsChannelMuted';
+import type { TranslationContextValue } from '../../../contexts/translationContext/TranslationContext';
+import * as TranslationContext from '../../../contexts/translationContext/TranslationContext';
+import * as useChannelMembershipStateModule from '../../useChannelMembershipState';
+import * as useIsDirectChatModule from '../../useIsDirectChat';
 import {
   GetChannelActionItems,
   buildDefaultChannelActionItems,
@@ -12,11 +16,10 @@ import {
   useChannelActionItems,
 } from '../useChannelActionItems';
 import * as useChannelActionsModule from '../useChannelActions';
-import * as useChannelMembershipStateModule from '../useChannelMembershipState';
-import * as useChannelMuteActiveModule from '../useChannelMuteActive';
-import * as useIsDirectChatModule from '../useIsDirectChat';
 
 const createChannelActions = (): useChannelActionsModule.ChannelActions => ({
+  addMembers: jest.fn(),
+  removeMembers: jest.fn(),
   archive: jest.fn(),
   blockUser: jest.fn(),
   deleteChannel: jest.fn(),
@@ -29,6 +32,8 @@ const createChannelActions = (): useChannelActionsModule.ChannelActions => ({
   unmuteChannel: jest.fn(),
   unmuteUser: jest.fn(),
   unpin: jest.fn(),
+  updateImage: jest.fn(),
+  updateName: jest.fn(),
 });
 
 const createChannelMock = (params?: {
@@ -50,6 +55,7 @@ const createChannelMock = (params?: {
     getClient: () => ({
       blockedUsers: {
         getLatestValue: () => ({ userIds: blockedUserIds }),
+        subscribeWithSelector: () => () => {},
       },
       userID: ownUserId,
     }),
@@ -78,7 +84,12 @@ describe('useChannelActionItems', () => {
       archived_at: undefined,
       pinned_at: undefined,
     } as never);
-    jest.spyOn(useChannelMuteActiveModule, 'useChannelMuteActive').mockReturnValue(false);
+    jest.spyOn(useIsChannelMutedModule, 'useIsChannelMuted').mockReturnValue({
+      createdAt: null,
+      expiresAt: null,
+      muted: false,
+    });
+    jest.spyOn(useMutedUsersModule, 'useMutedUsers').mockReturnValue([] as Mute[]);
     jest.spyOn(useIsDirectChatModule, 'useIsDirectChat').mockReturnValue(false);
     jest.spyOn(useChannelActionsModule, 'useChannelActions').mockReturnValue(channelActions);
   });
@@ -105,6 +116,71 @@ describe('useChannelActionItems', () => {
     expect(result.current.map((item) => item.placement)).toEqual(['swipe', 'sheet', 'sheet']);
   });
 
+  it('returns muteUser only in direct chats', () => {
+    jest.spyOn(useIsDirectChatModule, 'useIsDirectChat').mockReturnValue(true);
+
+    const { result } = renderHook(() => useChannelActionItems({ channel }));
+
+    expect(result.current.map((item) => item.id)).toEqual([
+      'mute',
+      'muteUser',
+      'block',
+      'leave',
+      'deleteChannel',
+    ]);
+    expect(result.current.find((item) => item.id === 'muteUser')?.action).toBe(
+      channelActions.muteUser,
+    );
+    expect(result.current.find((item) => item.id === 'muteUser')?.placement).toBe('sheet');
+  });
+
+  it('mute action always targets the channel and muteUser toggles independently', () => {
+    jest.spyOn(useIsDirectChatModule, 'useIsDirectChat').mockReturnValue(true);
+    jest.spyOn(useIsChannelMutedModule, 'useIsChannelMuted').mockReturnValue({
+      createdAt: null,
+      expiresAt: null,
+      muted: true,
+    });
+    jest.spyOn(useMutedUsersModule, 'useMutedUsers').mockReturnValue([] as Mute[]);
+
+    const { result } = renderHook(() => useChannelActionItems({ channel }));
+
+    const muteItem = result.current.find((item) => item.id === 'mute');
+    const muteUserItem = result.current.find((item) => item.id === 'muteUser');
+    expect(muteItem?.action).toBe(channelActions.unmuteChannel);
+    expect(muteUserItem?.action).toBe(channelActions.muteUser);
+  });
+
+  it('forwards options from item.action to the underlying channel action', async () => {
+    const { result } = renderHook(() => useChannelActionItems({ channel }));
+
+    const muteItem = result.current.find((item) => item.id === 'mute');
+    expect(muteItem).toBeDefined();
+    const onSuccess = jest.fn();
+    await muteItem?.action({ onSuccess });
+
+    expect(channelActions.muteChannel).toHaveBeenCalledWith({ onSuccess });
+  });
+
+  it('marks block as destructive when user is not blocked', () => {
+    jest.spyOn(useIsDirectChatModule, 'useIsDirectChat').mockReturnValue(true);
+
+    const { result } = renderHook(() => useChannelActionItems({ channel }));
+
+    const blockItem = result.current.find((item) => item.id === 'block');
+    expect(blockItem?.type).toBe('destructive');
+  });
+
+  it('keeps block standard when user is already blocked', () => {
+    jest.spyOn(useIsDirectChatModule, 'useIsDirectChat').mockReturnValue(true);
+    const blockedChannel = createChannelMock({ blockedUserIds: ['other-user-id'] });
+
+    const { result } = renderHook(() => useChannelActionItems({ channel: blockedChannel }));
+
+    const blockItem = result.current.find((item) => item.id === 'block');
+    expect(blockItem?.type).toBe('standard');
+  });
+
   it('uses custom getChannelActionItems with context and defaultItems when provided', () => {
     const customGetChannelActionItems = jest.fn(
       ({ defaultItems }: Parameters<GetChannelActionItems>[0]) => defaultItems.slice(0, 1),
@@ -121,11 +197,13 @@ describe('useChannelActionItems', () => {
       context: {
         actions: channelActions,
         channel,
+        channelMuteActive: false,
         isArchived: false,
+        isBlocked: undefined,
         isDirectChat: false,
         isPinned: false,
-        muteActive: false,
         t: expect.any(Function),
+        userMuteActive: false,
       },
       defaultItems: expect.any(Array),
     });
@@ -145,21 +223,25 @@ describe('getChannelActionItems', () => {
     const defaultItems = buildDefaultChannelActionItems({
       actions: channelActions,
       channel,
+      channelMuteActive: false,
       isArchived: false,
+      isBlocked: undefined,
       isDirectChat: false,
       isPinned: false,
-      muteActive: false,
       t: ((value: string) => value) as TranslationContextValue['t'],
+      userMuteActive: false,
     });
     const actionItems = getChannelActionItems({
       context: {
         actions: channelActions,
         channel,
+        channelMuteActive: false,
         isArchived: false,
+        isBlocked: undefined,
         isDirectChat: false,
         isPinned: false,
-        muteActive: false,
         t: ((value: string) => value) as TranslationContextValue['t'],
+        userMuteActive: false,
       },
       defaultItems,
     });
@@ -182,38 +264,72 @@ describe('getChannelActionItems', () => {
     const actionItems = buildDefaultChannelActionItems({
       actions: channelActions,
       channel: createChannelMock({ blockedUserIds: ['other-user-id'] }),
+      channelMuteActive: true,
       isArchived: true,
+      isBlocked: true,
       isDirectChat: true,
       isPinned: false,
-      muteActive: true,
       t: ((value: string) => value) as TranslationContextValue['t'],
+      userMuteActive: true,
     });
 
-    expect(actionItems.map((item) => item.id)).toEqual(['mute', 'block', 'leave', 'deleteChannel']);
+    expect(actionItems.map((item) => item.id)).toEqual([
+      'mute',
+      'muteUser',
+      'block',
+      'leave',
+      'deleteChannel',
+    ]);
     expect(actionItems.map((item) => item.action)).toEqual([
+      channelActions.unmuteChannel,
       channelActions.unmuteUser,
       channelActions.unblockUser,
       channelActions.leave,
       expect.any(Function),
     ]);
     expect(actionItems.map((item) => item.label)).toEqual([
+      'Unmute Chat',
       'Unmute User',
       'Unblock User',
       'Leave Chat',
       'Delete Chat',
     ]);
-    expect(actionItems.map((item) => item.placement)).toEqual(['sheet', 'sheet', 'sheet', 'sheet']);
+    expect(actionItems.map((item) => item.placement)).toEqual([
+      'swipe',
+      'sheet',
+      'sheet',
+      'sheet',
+      'sheet',
+    ]);
+  });
+
+  it('omits muteUser when not a direct chat', () => {
+    const actionItems = buildDefaultChannelActionItems({
+      actions: createChannelActions(),
+      channel,
+      channelMuteActive: false,
+      isArchived: false,
+      isBlocked: undefined,
+      isDirectChat: false,
+      isPinned: false,
+      t: ((value: string) => value) as TranslationContextValue['t'],
+      userMuteActive: false,
+    });
+
+    expect(actionItems.map((item) => item.id)).not.toContain('muteUser');
   });
 
   it('omits delete action when current user is not the channel creator', () => {
     const actionItems = buildDefaultChannelActionItems({
       actions: createChannelActions(),
       channel: createChannelMock({ createdById: 'someone-else' }),
+      channelMuteActive: false,
       isArchived: false,
+      isBlocked: undefined,
       isDirectChat: false,
       isPinned: false,
-      muteActive: false,
       t: ((value: string) => value) as TranslationContextValue['t'],
+      userMuteActive: false,
     });
 
     expect(actionItems.map((item) => item.id)).toEqual(['mute', 'leave']);
@@ -224,11 +340,13 @@ describe('getChannelActionItems', () => {
     const actionItems = buildDefaultChannelActionItems({
       actions: channelActions,
       channel,
+      channelMuteActive: true,
       isArchived: true,
+      isBlocked: undefined,
       isDirectChat: false,
       isPinned: false,
-      muteActive: true,
       t: ((value: string) => value) as TranslationContextValue['t'],
+      userMuteActive: false,
     });
 
     expect(actionItems[0].action).toBe(channelActions.unmuteChannel);
@@ -240,6 +358,29 @@ describe('getChannelActionItems', () => {
     expect(actionItems[1].placement).toBe('sheet');
   });
 
+  it('mute and muteUser reflect their respective active states independently', () => {
+    const channelActions = createChannelActions();
+    const actionItems = buildDefaultChannelActionItems({
+      actions: channelActions,
+      channel,
+      channelMuteActive: false,
+      isArchived: false,
+      isBlocked: undefined,
+      isDirectChat: true,
+      isPinned: false,
+      t: ((value: string) => value) as TranslationContextValue['t'],
+      userMuteActive: true,
+    });
+
+    const muteItem = actionItems.find((item) => item.id === 'mute');
+    const muteUserItem = actionItems.find((item) => item.id === 'muteUser');
+
+    expect(muteItem?.action).toBe(channelActions.muteChannel);
+    expect(muteItem?.label).toBe('Mute Chat');
+    expect(muteUserItem?.action).toBe(channelActions.unmuteUser);
+    expect(muteUserItem?.label).toBe('Unmute User');
+  });
+
   it('shows delete confirmation and calls deleteChannel on destructive confirm', async () => {
     const alertSpy = jest.spyOn(Alert, 'alert').mockImplementation(jest.fn());
     const channelActions = createChannelActions();
@@ -247,16 +388,19 @@ describe('getChannelActionItems', () => {
     const actionItems = buildDefaultChannelActionItems({
       actions: channelActions,
       channel,
+      channelMuteActive: false,
       isArchived: false,
+      isBlocked: undefined,
       isDirectChat: false,
       isPinned: false,
-      muteActive: false,
       t: ((value: string) => value) as TranslationContextValue['t'],
+      userMuteActive: false,
     });
 
     const deleteItem = actionItems.find((item) => item.id === 'deleteChannel');
     expect(deleteItem).toBeDefined();
-    deleteItem?.action();
+    const onSuccess = jest.fn();
+    await deleteItem?.action({ onSuccess });
 
     expect(alertSpy).toHaveBeenCalledWith(
       'Delete group',
@@ -270,6 +414,7 @@ describe('getChannelActionItems', () => {
     expect(destructiveButton?.text).toBe('Delete');
     await destructiveButton?.onPress?.();
     expect(channelActions.deleteChannel).toHaveBeenCalledTimes(1);
+    expect(channelActions.deleteChannel).toHaveBeenCalledWith({ onSuccess });
 
     alertSpy.mockRestore();
   });