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

package/src/hooks/__tests__/useChannelMuteActive.test.tsx

@@ -0,0 +1,149 @@
+import React, { PropsWithChildren } from 'react';
+
+import { renderHook } from '@testing-library/react-native';
+import type { Channel, ChannelMute, Mute } from 'stream-chat';
+
+import { ChatProvider } from '../../contexts/chatContext/ChatContext';
+import { useChannelMuteActive } from '../useChannelMuteActive';
+
+const CURRENT_USER_ID = 'current-user-id';
+const OTHER_USER_ID = 'other-user-id';
+const THIRD_USER_ID = 'third-user-id';
+const CHANNEL_CID = 'messaging:test';
+
+const createClient = ({
+  mutedChannels = [],
+  mutedUsers = [],
+}: { mutedChannels?: ChannelMute[]; mutedUsers?: Mute[] } = {}) =>
+  ({
+    mutedChannels,
+    mutedUsers,
+    on: jest.fn(() => ({ unsubscribe: jest.fn() })),
+    userID: CURRENT_USER_ID,
+  }) as never;
+
+const createChannel = (
+  client: ReturnType<typeof createClient>,
+  { isDirect = true, cid = CHANNEL_CID }: { isDirect?: boolean; cid?: string } = {},
+) =>
+  ({
+    cid,
+    getClient: () => client,
+    on: jest.fn(() => ({ unsubscribe: jest.fn() })),
+    state: {
+      members: isDirect
+        ? {
+            current: { user: { id: CURRENT_USER_ID } },
+            other: { user: { id: OTHER_USER_ID } },
+          }
+        : {
+            current: { user: { id: CURRENT_USER_ID } },
+            other1: { user: { id: OTHER_USER_ID } },
+            other2: { user: { id: THIRD_USER_ID } },
+          },
+    },
+  }) as unknown as Channel;
+
+const mutedChannelEntry = (cid: string) => ({ channel: { cid } }) as unknown as ChannelMute;
+
+const mutedUserEntry = (userId: string) =>
+  ({ target: { id: userId }, user: { id: CURRENT_USER_ID } }) as unknown as Mute;
+
+const createWrapper =
+  (client: unknown) =>
+  ({ children }: PropsWithChildren) => (
+    <ChatProvider value={{ client } as never}>{children}</ChatProvider>
+  );
+
+describe('useChannelMuteActive', () => {
+  describe('direct chat (2 members)', () => {
+    it('returns false when neither channel nor other user is muted', () => {
+      const client = createClient();
+      const channel = createChannel(client);
+      const { result } = renderHook(() => useChannelMuteActive(channel), {
+        wrapper: createWrapper(client),
+      });
+      expect(result.current).toBe(false);
+    });
+
+    it('returns true when the channel is muted but the user is not', () => {
+      const client = createClient({ mutedChannels: [mutedChannelEntry(CHANNEL_CID)] });
+      const channel = createChannel(client);
+      const { result } = renderHook(() => useChannelMuteActive(channel), {
+        wrapper: createWrapper(client),
+      });
+      expect(result.current).toBe(true);
+    });
+
+    it('returns true when the other user is muted but the channel is not', () => {
+      const client = createClient({ mutedUsers: [mutedUserEntry(OTHER_USER_ID)] });
+      const channel = createChannel(client);
+      const { result } = renderHook(() => useChannelMuteActive(channel), {
+        wrapper: createWrapper(client),
+      });
+      expect(result.current).toBe(true);
+    });
+
+    it('returns true when both the channel and the other user are muted', () => {
+      const client = createClient({
+        mutedChannels: [mutedChannelEntry(CHANNEL_CID)],
+        mutedUsers: [mutedUserEntry(OTHER_USER_ID)],
+      });
+      const channel = createChannel(client);
+      const { result } = renderHook(() => useChannelMuteActive(channel), {
+        wrapper: createWrapper(client),
+      });
+      expect(result.current).toBe(true);
+    });
+
+    it('ignores mutes targeting an unrelated user', () => {
+      const client = createClient({ mutedUsers: [mutedUserEntry('unrelated-user')] });
+      const channel = createChannel(client);
+      const { result } = renderHook(() => useChannelMuteActive(channel), {
+        wrapper: createWrapper(client),
+      });
+      expect(result.current).toBe(false);
+    });
+
+    it('ignores mutes targeting an unrelated channel', () => {
+      const client = createClient({ mutedChannels: [mutedChannelEntry('messaging:other')] });
+      const channel = createChannel(client);
+      const { result } = renderHook(() => useChannelMuteActive(channel), {
+        wrapper: createWrapper(client),
+      });
+      expect(result.current).toBe(false);
+    });
+  });
+
+  describe('group chat (3+ members)', () => {
+    it('returns true when the channel is muted (even if a member is also muted)', () => {
+      const client = createClient({
+        mutedChannels: [mutedChannelEntry(CHANNEL_CID)],
+        mutedUsers: [mutedUserEntry(OTHER_USER_ID)],
+      });
+      const channel = createChannel(client, { isDirect: false });
+      const { result } = renderHook(() => useChannelMuteActive(channel), {
+        wrapper: createWrapper(client),
+      });
+      expect(result.current).toBe(true);
+    });
+
+    it('returns false when only a member is muted but the channel is not', () => {
+      const client = createClient({ mutedUsers: [mutedUserEntry(OTHER_USER_ID)] });
+      const channel = createChannel(client, { isDirect: false });
+      const { result } = renderHook(() => useChannelMuteActive(channel), {
+        wrapper: createWrapper(client),
+      });
+      expect(result.current).toBe(false);
+    });
+
+    it('returns false when nothing is muted', () => {
+      const client = createClient();
+      const channel = createChannel(client, { isDirect: false });
+      const { result } = renderHook(() => useChannelMuteActive(channel), {
+        wrapper: createWrapper(client),
+      });
+      expect(result.current).toBe(false);
+    });
+  });
+});

package/src/hooks/__tests__/useIsChannelMember.test.tsx

@@ -0,0 +1,73 @@
+import { renderHook } from '@testing-library/react-native';
+import type { Channel, ChannelMemberResponse } from 'stream-chat';
+
+import { useChannelMembersState } from '../../components/ChannelList/hooks/useChannelMembersState';
+import { useIsChannelMember } from '../useIsChannelMember';
+
+jest.mock('../../components/ChannelList/hooks/useChannelMembersState');
+
+const mockedUseChannelMembersState = useChannelMembersState as jest.MockedFunction<
+  typeof useChannelMembersState
+>;
+
+const CURRENT_USER_ID = 'current-user-id';
+const OTHER_USER_ID = 'other-user-id';
+
+const channel = {} as Channel;
+
+const setMembers = (members: Record<string, ChannelMemberResponse>) => {
+  mockedUseChannelMembersState.mockReturnValue(members);
+};
+
+describe('useIsChannelMember', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('returns true when the user is a member of the channel', () => {
+    setMembers({
+      [CURRENT_USER_ID]: { user: { id: CURRENT_USER_ID } },
+      [OTHER_USER_ID]: { user: { id: OTHER_USER_ID } },
+    });
+
+    const { result } = renderHook(() => useIsChannelMember(channel, OTHER_USER_ID));
+
+    expect(result.current).toBe(true);
+  });
+
+  it('returns false when the user is not a member of the channel', () => {
+    setMembers({
+      [CURRENT_USER_ID]: { user: { id: CURRENT_USER_ID } },
+    });
+
+    const { result } = renderHook(() => useIsChannelMember(channel, 'unknown-user-id'));
+
+    expect(result.current).toBe(false);
+  });
+
+  it('returns false when no userId is provided', () => {
+    setMembers({
+      [CURRENT_USER_ID]: { user: { id: CURRENT_USER_ID } },
+    });
+
+    const { result } = renderHook(() => useIsChannelMember(channel));
+
+    expect(result.current).toBe(false);
+  });
+
+  it('returns false when the channel has no members', () => {
+    setMembers({});
+
+    const { result } = renderHook(() => useIsChannelMember(channel, OTHER_USER_ID));
+
+    expect(result.current).toBe(false);
+  });
+
+  it('passes the channel through to useChannelMembersState', () => {
+    setMembers({});
+
+    renderHook(() => useIsChannelMember(channel, OTHER_USER_ID));
+
+    expect(mockedUseChannelMembersState).toHaveBeenCalledWith(channel);
+  });
+});

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();
   });