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

package/src/components/ChannelDetails/__tests__/members/useChannelAllMembers.test.tsx

@@ -0,0 +1,234 @@
+import React from 'react';
+
+import { act, renderHook, waitFor } from '@testing-library/react-native';
+import type { Channel, ChannelMemberResponse } from 'stream-chat';
+
+import { TranslationProvider } from '../../../../contexts/translationContext/TranslationContext';
+import { generateMember } from '../../../../mock-builders/generator/member';
+import { generateUser } from '../../../../mock-builders/generator/user';
+import { useNotificationApi } from '../../../Notifications/hooks/useNotificationApi';
+import { useChannelAllMembers } from '../../hooks/members/useChannelAllMembers';
+
+jest.mock('../../../Notifications/hooks/useNotificationApi', () => ({
+  useNotificationApi: jest.fn(() => ({ addNotification: jest.fn() })),
+}));
+
+const t = ((key: string) => key) as never;
+
+const translationWrapper = ({ children }: { children: React.ReactNode }) => (
+  <TranslationProvider
+    value={{ t, tDateTimeParser: ((input: unknown) => input) as never, userLanguage: 'en' }}
+  >
+    {children}
+  </TranslationProvider>
+);
+
+type QueryMembersMock = jest.Mock<
+  Promise<{ members: ChannelMemberResponse[] }>,
+  [unknown, unknown, unknown]
+>;
+
+const buildChannel = ({
+  members,
+  memberCount,
+  queryMembers,
+}: {
+  members: ChannelMemberResponse[];
+  memberCount?: number;
+  queryMembers?: QueryMembersMock;
+}): Channel =>
+  ({
+    cid: 'messaging:test',
+    data: memberCount == null ? {} : { member_count: memberCount },
+    on: () => ({ unsubscribe: () => undefined }),
+    queryMembers: queryMembers ?? jest.fn(),
+    state: {
+      members: Object.fromEntries(
+        members.map((m) => [m.user?.id ?? m.user_id ?? '', m]).filter(([k]) => Boolean(k)),
+      ),
+    },
+  }) as unknown as Channel;
+
+const buildMembers = (count: number, prefix = 'u') =>
+  Array.from({ length: count }, (_, i) =>
+    generateMember({ user: generateUser({ id: `${prefix}-${i}`, name: `User ${i}` }) }),
+  );
+
+describe('useChannelAllMembers', () => {
+  let addNotification: jest.Mock;
+
+  beforeEach(() => {
+    addNotification = jest.fn();
+    (useNotificationApi as jest.Mock).mockReturnValue({ addNotification });
+  });
+
+  describe('local mode', () => {
+    it('returns local members when member_count matches the loaded count', () => {
+      const members = buildMembers(3);
+      const queryMembers: QueryMembersMock = jest.fn();
+      const channel = buildChannel({ memberCount: 3, members, queryMembers });
+
+      const { result } = renderHook(() => useChannelAllMembers({ channel }));
+
+      expect(queryMembers).not.toHaveBeenCalled();
+      expect(result.current.results.map((m) => m.user?.id)).toEqual(['u-0', 'u-1', 'u-2']);
+      expect(result.current.hasMore).toBe(false);
+      expect(result.current.loading).toBe(false);
+    });
+
+    it('treats undefined member_count as fully loaded', () => {
+      const members = buildMembers(2);
+      const queryMembers: QueryMembersMock = jest.fn();
+      const channel = buildChannel({ members, queryMembers });
+
+      const { result } = renderHook(() => useChannelAllMembers({ channel }));
+
+      expect(queryMembers).not.toHaveBeenCalled();
+      expect(result.current.results).toHaveLength(2);
+      expect(result.current.hasMore).toBe(false);
+    });
+
+    it('loadMore is a no-op in local mode', () => {
+      const members = buildMembers(1);
+      const queryMembers: QueryMembersMock = jest.fn();
+      const channel = buildChannel({ memberCount: 1, members, queryMembers });
+
+      const { result } = renderHook(() => useChannelAllMembers({ channel }));
+
+      act(() => result.current.loadMore());
+      expect(queryMembers).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('paginated mode', () => {
+    it('fetches the first page on mount and exposes loading state', async () => {
+      const loaded = buildMembers(25, 'loaded');
+      const firstPage = buildMembers(25, 'page1');
+      const queryMembers: QueryMembersMock = jest.fn().mockResolvedValue({ members: firstPage });
+      const channel = buildChannel({ memberCount: 250, members: loaded, queryMembers });
+
+      const { result } = renderHook(() => useChannelAllMembers({ channel }));
+
+      expect(result.current.loading).toBe(true);
+      expect(result.current.hasMore).toBe(true);
+
+      await waitFor(() => expect(queryMembers).toHaveBeenCalledTimes(1));
+      expect(queryMembers).toHaveBeenCalledWith({}, { created_at: 1 }, { limit: 25, offset: 0 });
+
+      await waitFor(() => expect(result.current.loading).toBe(false));
+      expect(result.current.results).toHaveLength(25);
+      expect(result.current.results[0]?.user?.id).toBe('page1-0');
+      expect(result.current.hasMore).toBe(true);
+    });
+
+    it('appends the next page on loadMore with the correct offset and dedupes', async () => {
+      const firstPage = buildMembers(25, 'page1');
+      const overlap = firstPage[firstPage.length - 1];
+      const secondPageFresh = buildMembers(10, 'page2');
+      const secondPage = overlap ? [overlap, ...secondPageFresh] : secondPageFresh;
+      const queryMembers: QueryMembersMock = jest
+        .fn()
+        .mockResolvedValueOnce({ members: firstPage })
+        .mockResolvedValueOnce({ members: secondPage });
+      const channel = buildChannel({
+        memberCount: 300,
+        members: buildMembers(25, 'loaded'),
+        queryMembers,
+      });
+
+      const { result } = renderHook(() => useChannelAllMembers({ channel }));
+
+      await waitFor(() => expect(result.current.loading).toBe(false));
+      expect(result.current.results).toHaveLength(25);
+
+      act(() => result.current.loadMore());
+
+      await waitFor(() => expect(queryMembers).toHaveBeenCalledTimes(2));
+      expect(queryMembers).toHaveBeenNthCalledWith(
+        2,
+        {},
+        { created_at: 1 },
+        { limit: 25, offset: 25 },
+      );
+
+      await waitFor(() => expect(result.current.loading).toBe(false));
+      expect(result.current.results).toHaveLength(35);
+      expect(result.current.hasMore).toBe(false);
+    });
+
+    it('marks hasMore=false when the first page is shorter than PAGE_SIZE', async () => {
+      const firstPage = buildMembers(10, 'page1');
+      const queryMembers: QueryMembersMock = jest.fn().mockResolvedValue({ members: firstPage });
+      const channel = buildChannel({
+        memberCount: 200,
+        members: buildMembers(25, 'loaded'),
+        queryMembers,
+      });
+
+      const { result } = renderHook(() => useChannelAllMembers({ channel }));
+
+      await waitFor(() => expect(result.current.loading).toBe(false));
+      expect(result.current.hasMore).toBe(false);
+
+      act(() => result.current.loadMore());
+      expect(queryMembers).toHaveBeenCalledTimes(1);
+    });
+
+    it('guards against concurrent loadMore calls', async () => {
+      let resolveSecond: ((value: { members: ChannelMemberResponse[] }) => void) | undefined;
+      const queryMembers: QueryMembersMock = jest
+        .fn()
+        .mockResolvedValueOnce({ members: buildMembers(25, 'page1') })
+        .mockReturnValueOnce(
+          new Promise<{ members: ChannelMemberResponse[] }>((resolve) => {
+            resolveSecond = resolve;
+          }),
+        );
+      const channel = buildChannel({
+        memberCount: 500,
+        members: buildMembers(25, 'loaded'),
+        queryMembers,
+      });
+
+      const { result } = renderHook(() => useChannelAllMembers({ channel }));
+
+      await waitFor(() => expect(result.current.loading).toBe(false));
+
+      act(() => result.current.loadMore());
+      await waitFor(() => expect(result.current.loading).toBe(true));
+      expect(result.current.results.length).toBeGreaterThan(0);
+
+      act(() => result.current.loadMore());
+      act(() => result.current.loadMore());
+
+      expect(queryMembers).toHaveBeenCalledTimes(2);
+
+      act(() => resolveSecond?.({ members: buildMembers(25, 'page2') }));
+      await waitFor(() => expect(result.current.loading).toBe(false));
+    });
+
+    it('recovers from a queryMembers rejection and notifies the user', async () => {
+      const queryMembers: QueryMembersMock = jest.fn().mockRejectedValue(new Error('boom'));
+      const channel = buildChannel({
+        memberCount: 200,
+        members: buildMembers(25, 'loaded'),
+        queryMembers,
+      });
+
+      const { result } = renderHook(() => useChannelAllMembers({ channel }), {
+        wrapper: translationWrapper,
+      });
+
+      await waitFor(() => expect(result.current.loading).toBe(false));
+      expect(result.current.results).toEqual([]);
+      expect(addNotification).toHaveBeenCalledWith(
+        expect.objectContaining({
+          options: expect.objectContaining({
+            severity: 'error',
+            type: 'api:channel:query-members:failed',
+          }),
+        }),
+      );
+    });
+  });
+});

package/src/components/ChannelDetails/__tests__/members/useMemberRoleLabel.test.tsx

@@ -0,0 +1,130 @@
+import React from 'react';
+
+import { renderHook } from '@testing-library/react-native';
+import type { Channel, ChannelMemberResponse } from 'stream-chat';
+
+import { ChannelDetailsContextProvider } from '../../../../contexts/channelDetailsContext/channelDetailsContext';
+import { TranslationProvider } from '../../../../contexts/translationContext/TranslationContext';
+import { generateMember } from '../../../../mock-builders/generator/member';
+import { generateUser } from '../../../../mock-builders/generator/user';
+import type { GetMemberRoleLabel } from '../../ChannelDetails';
+import { useMemberRoleLabel } from '../../hooks/members/useMemberRoleLabel';
+
+const buildChannel = (createdById = 'creator'): Channel =>
+  ({
+    cid: 'messaging:test',
+    data: { created_by: { id: createdById } },
+    on: () => ({ unsubscribe: () => undefined }),
+  }) as unknown as Channel;
+
+const buildMember = (
+  overrides: {
+    user?: Partial<NonNullable<ChannelMemberResponse['user']>>;
+    channel_role?: ChannelMemberResponse['channel_role'];
+  } = {},
+): ChannelMemberResponse =>
+  generateMember({
+    channel_role: overrides.channel_role,
+    user: generateUser({ id: 'alice', name: 'Alice', ...(overrides.user ?? {}) }),
+  });
+
+const t = ((key: string) => key) as never;
+
+const renderRoleLabel = (
+  member: ChannelMemberResponse,
+  {
+    channel = buildChannel(),
+    getMemberRoleLabel,
+  }: { channel?: Channel; getMemberRoleLabel?: GetMemberRoleLabel } = {},
+) =>
+  renderHook(() => useMemberRoleLabel(member), {
+    wrapper: ({ children }) => (
+      <TranslationProvider
+        value={{ t, tDateTimeParser: ((input: unknown) => input) as never, userLanguage: 'en' }}
+      >
+        <ChannelDetailsContextProvider value={{ channel, getMemberRoleLabel }}>
+          {children}
+        </ChannelDetailsContextProvider>
+      </TranslationProvider>
+    ),
+  });
+
+describe('useMemberRoleLabel', () => {
+  describe('default rules', () => {
+    it('returns "Owner" when the member is the channel creator', () => {
+      const { result } = renderRoleLabel(buildMember(), { channel: buildChannel('alice') });
+      expect(result.current).toBe('Owner');
+    });
+
+    it('returns "Admin" when the member has the admin user role', () => {
+      const { result } = renderRoleLabel(buildMember({ user: { role: 'admin' } }));
+      expect(result.current).toBe('Admin');
+    });
+
+    it('returns "Moderator" when the member has the channel_moderator channel_role', () => {
+      const { result } = renderRoleLabel(buildMember({ channel_role: 'channel_moderator' }));
+      expect(result.current).toBe('Moderator');
+    });
+
+    it('returns null for a plain member', () => {
+      const { result } = renderRoleLabel(buildMember());
+      expect(result.current).toBeNull();
+    });
+
+    it('prefers Owner over Admin when both rules match', () => {
+      const { result } = renderRoleLabel(buildMember({ user: { role: 'admin' } }), {
+        channel: buildChannel('alice'),
+      });
+      expect(result.current).toBe('Owner');
+    });
+
+    it('prefers Admin over Moderator when both rules match', () => {
+      const { result } = renderRoleLabel(
+        buildMember({ channel_role: 'channel_moderator', user: { role: 'admin' } }),
+      );
+      expect(result.current).toBe('Admin');
+    });
+
+    it('does not match Owner when the member has no user id', () => {
+      const member = generateMember({ user: undefined, user_id: 'orphan' });
+      const { result } = renderRoleLabel(member, { channel: buildChannel('orphan') });
+      expect(result.current).toBeNull();
+    });
+  });
+
+  describe('custom getMemberRoleLabel', () => {
+    it('uses the return value of the custom function', () => {
+      const { result } = renderRoleLabel(buildMember({ user: { role: 'admin' } }), {
+        channel: buildChannel('alice'),
+        getMemberRoleLabel: () => 'VIP',
+      });
+      expect(result.current).toBe('VIP');
+    });
+
+    it('returns null when the custom function returns null', () => {
+      const { result } = renderRoleLabel(buildMember({ user: { role: 'admin' } }), {
+        getMemberRoleLabel: () => null,
+      });
+      expect(result.current).toBeNull();
+    });
+
+    it('returns null when the custom function returns undefined', () => {
+      const { result } = renderRoleLabel(buildMember({ user: { role: 'admin' } }), {
+        getMemberRoleLabel: () => undefined,
+      });
+      expect(result.current).toBeNull();
+    });
+
+    it('passes channel, member, and t to the custom function', () => {
+      const channel = buildChannel('alice');
+      const member = buildMember({ user: { role: 'admin' } });
+      const getMemberRoleLabel = jest.fn(() => 'Custom');
+      renderRoleLabel(member, { channel, getMemberRoleLabel });
+      expect(getMemberRoleLabel).toHaveBeenCalledWith({
+        channel,
+        member,
+        t: expect.any(Function),
+      });
+    });
+  });
+});

package/src/components/ChannelDetails/__tests__/useChannelDetailsActionItems.test.tsx

@@ -0,0 +1,177 @@
+import { renderHook } from '@testing-library/react-native';
+import type { Channel } from 'stream-chat';
+
+import * as channelDetailsContextModule from '../../../contexts/channelDetailsContext/channelDetailsContext';
+import type {
+  ChannelActionItem,
+  GetChannelActionItems,
+} from '../../../hooks/actions/useChannelActionItems';
+import * as useChannelActionItemsModule from '../../../hooks/actions/useChannelActionItems';
+import { useChannelDetailsActionItems } from '../hooks/useChannelDetailsActionItems';
+
+const NoopIcon = () => null;
+
+const buildItem = (overrides: Partial<ChannelActionItem>): ChannelActionItem => ({
+  action: jest.fn(),
+  Icon: NoopIcon,
+  id: 'mute',
+  label: 'Mute',
+  placement: 'sheet',
+  type: 'standard',
+  ...overrides,
+});
+
+const channel = { id: 'channel-id' } as unknown as Channel;
+
+const mockContext = (
+  overrides: Partial<channelDetailsContextModule.ChannelDetailsContextValue> = {},
+) => {
+  const value: channelDetailsContextModule.ChannelDetailsContextValue = {
+    channel,
+    onChannelDismiss: jest.fn(),
+    ...overrides,
+  };
+  jest.spyOn(channelDetailsContextModule, 'useChannelDetailsContext').mockReturnValue(value);
+  return value;
+};
+
+const mockUseChannelActionItems = (items: ChannelActionItem[]) =>
+  jest.spyOn(useChannelActionItemsModule, 'useChannelActionItems').mockReturnValue(items);
+
+describe('useChannelDetailsActionItems', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+    jest.restoreAllMocks();
+  });
+
+  it('passes the channel and undefined getChannelActionItems through when the prop is not set', () => {
+    mockContext();
+    const spy = mockUseChannelActionItems([]);
+
+    renderHook(() => useChannelDetailsActionItems());
+
+    expect(spy).toHaveBeenCalledTimes(1);
+    expect(spy).toHaveBeenCalledWith({
+      channel,
+      getChannelActionItems: undefined,
+      surface: 'details',
+    });
+  });
+
+  it('forwards the getChannelActionItems prop from context unchanged', () => {
+    const getChannelActionItems: GetChannelActionItems = ({ defaultItems }) => defaultItems;
+    mockContext({ getChannelActionItems });
+    const spy = mockUseChannelActionItems([]);
+
+    renderHook(() => useChannelDetailsActionItems());
+
+    expect(spy).toHaveBeenCalledWith({ channel, getChannelActionItems, surface: 'details' });
+  });
+
+  it('returns non-leave/non-delete items referentially unchanged', () => {
+    mockContext();
+    const muteItem = buildItem({ id: 'mute' });
+    const customItem = buildItem({ id: 'archive' });
+    mockUseChannelActionItems([muteItem, customItem]);
+
+    const { result } = renderHook(() => useChannelDetailsActionItems());
+
+    expect(result.current).toHaveLength(2);
+    expect(result.current[0]).toBe(muteItem);
+    expect(result.current[1]).toBe(customItem);
+  });
+
+  it.each([
+    { id: 'leave', label: 'Leave Group' },
+    { id: 'deleteChannel', label: 'Delete Group' },
+    { id: 'block', label: 'Block User' },
+  ])(
+    'wraps the $id action to call onChannelDismiss after the original action resolves',
+    async ({ id, label }) => {
+      const { onChannelDismiss } = mockContext();
+
+      const callOrder: string[] = [];
+      let resolveAction: (() => void) | undefined;
+      const originalAction = jest.fn(
+        (options?: { onSuccess?: () => unknown }) =>
+          new Promise<void>((resolve) => {
+            callOrder.push('action-start');
+            resolveAction = async () => {
+              callOrder.push('action-resolved');
+              await options?.onSuccess?.();
+              resolve();
+            };
+          }),
+      );
+      (onChannelDismiss as jest.Mock).mockImplementation(() => {
+        callOrder.push('onChannelDismiss');
+      });
+
+      const item = buildItem({ action: originalAction, id, label, type: 'destructive' });
+      mockUseChannelActionItems([item]);
+
+      const { result } = renderHook(() => useChannelDetailsActionItems());
+      const [wrapped] = result.current;
+
+      expect(wrapped).not.toBe(item);
+      expect(wrapped.id).toBe(id);
+      expect(wrapped.label).toBe(label);
+      expect(wrapped.type).toBe('destructive');
+
+      const pending = wrapped.action();
+      expect(originalAction).toHaveBeenCalledTimes(1);
+      expect(onChannelDismiss).not.toHaveBeenCalled();
+
+      resolveAction!();
+      await pending;
+
+      expect(onChannelDismiss).toHaveBeenCalledTimes(1);
+      expect(onChannelDismiss).toHaveBeenCalledWith();
+      expect(callOrder).toEqual(['action-start', 'action-resolved', 'onChannelDismiss']);
+    },
+  );
+
+  it('composes a caller-supplied onSuccess with onChannelDismiss and passes other options through', () => {
+    const { onChannelDismiss } = mockContext();
+    const originalLeave = jest.fn();
+    mockUseChannelActionItems([buildItem({ action: originalLeave, id: 'leave' })]);
+
+    const { result } = renderHook(() => useChannelDetailsActionItems());
+    const callerOnSuccess = jest.fn();
+    const callerOnFailure = jest.fn();
+    result.current[0].action({
+      // @ts-expect-error - extra caller-supplied option to ensure the wrapper merges options
+      extra: 'value',
+      onFailure: callerOnFailure,
+      onSuccess: callerOnSuccess,
+    });
+
+    expect(originalLeave).toHaveBeenCalledTimes(1);
+    const passedOptions = (originalLeave as jest.Mock).mock.calls[0][0];
+    // Caller-supplied options (including onFailure) pass through untouched.
+    expect(passedOptions).toMatchObject({ extra: 'value', onFailure: callerOnFailure });
+    // onSuccess is composed: it runs the caller's callback and then onChannelDismiss.
+    expect(typeof passedOptions.onSuccess).toBe('function');
+
+    passedOptions.onSuccess();
+    expect(callerOnSuccess).toHaveBeenCalledTimes(1);
+    expect(onChannelDismiss).toHaveBeenCalledTimes(1);
+  });
+
+  it.each([{ id: 'leave' }, { id: 'deleteChannel' }])(
+    'does not throw when onChannelDismiss is undefined on the $id path',
+    async ({ id }) => {
+      mockContext({ onChannelDismiss: undefined });
+      const originalAction = jest.fn().mockResolvedValue(undefined);
+      mockUseChannelActionItems([buildItem({ action: originalAction, id })]);
+
+      const { result } = renderHook(() => useChannelDetailsActionItems());
+
+      await expect(result.current[0].action()).resolves.toBeUndefined();
+      expect(originalAction).toHaveBeenCalledTimes(1);
+      const passedOptions = (originalAction as jest.Mock).mock.calls[0][0];
+      expect(typeof passedOptions.onSuccess).toBe('function');
+      expect(() => passedOptions.onSuccess()).not.toThrow();
+    },
+  );
+});

package/src/components/ChannelDetails/__tests__/useChannelDetailsMemberStatusText.test.tsx

@@ -0,0 +1,117 @@
+import React from 'react';
+
+import { renderHook } from '@testing-library/react-native';
+import type { Channel } from 'stream-chat';
+
+import { TranslationProvider } from '../../../contexts/translationContext/TranslationContext';
+import { useChannelMemberCount } from '../../../hooks/useChannelMemberCount';
+import { useIsDirectChat } from '../../../hooks/useIsDirectChat';
+import { useChannelMembersState } from '../../ChannelList/hooks/useChannelMembersState';
+import { useChannelOnlineMemberCount } from '../../ChannelList/hooks/useChannelOnlineMemberCount';
+import { useChannelDetailsMemberStatusText } from '../hooks/useChannelDetailsMemberStatusText';
+
+jest.mock('../../../hooks/useChannelMemberCount', () => ({
+  useChannelMemberCount: jest.fn(),
+}));
+
+jest.mock('../../../hooks/useIsDirectChat', () => ({
+  useIsDirectChat: jest.fn(() => false),
+}));
+
+jest.mock('../../ChannelList/hooks/useChannelMembersState', () => ({
+  useChannelMembersState: jest.fn(() => ({})),
+}));
+
+jest.mock('../../ChannelList/hooks/useChannelOnlineMemberCount', () => ({
+  useChannelOnlineMemberCount: jest.fn(),
+}));
+
+const t = ((key: string, options?: Record<string, unknown>) => {
+  if (options && typeof options === 'object') {
+    return Object.entries(options).reduce((acc, [k, v]) => acc.replace(`{{${k}}}`, String(v)), key);
+  }
+  return key;
+}) as never;
+
+const OWN_USER_ID = 'own-user';
+const channel = {
+  cid: 'messaging:test',
+  getClient: () => ({ userID: OWN_USER_ID }),
+} as unknown as Channel;
+
+const renderStatusText = () => {
+  const wrapper = ({ children }: { children: React.ReactNode }) => (
+    <TranslationProvider
+      value={{ t, tDateTimeParser: ((input: unknown) => input) as never, userLanguage: 'en' }}
+    >
+      {children}
+    </TranslationProvider>
+  );
+  return renderHook(() => useChannelDetailsMemberStatusText(channel), { wrapper });
+};
+
+describe('useChannelDetailsMemberStatusText', () => {
+  afterEach(() => jest.clearAllMocks());
+
+  it('formats the reactive member count and online count', () => {
+    (useChannelMemberCount as jest.Mock).mockReturnValue(5);
+    (useChannelOnlineMemberCount as jest.Mock).mockReturnValue(2);
+    (useChannelMembersState as jest.Mock).mockReturnValue({});
+
+    const { result } = renderStatusText();
+
+    expect(result.current).toBe('5 members, 2 online');
+  });
+
+  it('recomputes when the online count changes', () => {
+    (useChannelMemberCount as jest.Mock).mockReturnValue(4);
+    (useChannelOnlineMemberCount as jest.Mock).mockReturnValue(0);
+    (useChannelMembersState as jest.Mock).mockReturnValue({});
+
+    const { result, rerender } = renderStatusText();
+    expect(result.current).toBe('4 members, 0 online');
+
+    (useChannelOnlineMemberCount as jest.Mock).mockReturnValue(3);
+    rerender({});
+
+    expect(result.current).toBe('4 members, 3 online');
+  });
+
+  describe('direct chats', () => {
+    beforeEach(() => {
+      (useIsDirectChat as jest.Mock).mockReturnValue(true);
+    });
+
+    it('returns "Online" when the other member is online', () => {
+      (useChannelMembersState as jest.Mock).mockReturnValue({
+        [OWN_USER_ID]: { user: { id: OWN_USER_ID, online: true } },
+        other: { user: { id: 'other-user', online: true } },
+      });
+
+      const { result } = renderStatusText();
+
+      expect(result.current).toBe('Online');
+    });
+
+    it('returns an empty string when the other member is offline', () => {
+      (useChannelMembersState as jest.Mock).mockReturnValue({
+        [OWN_USER_ID]: { user: { id: OWN_USER_ID, online: true } },
+        other: { user: { id: 'other-user', online: false } },
+      });
+
+      const { result } = renderStatusText();
+
+      expect(result.current).toBe('');
+    });
+
+    it('ignores the current user when resolving the other member', () => {
+      (useChannelMembersState as jest.Mock).mockReturnValue({
+        [OWN_USER_ID]: { user: { id: OWN_USER_ID, online: true } },
+      });
+
+      const { result } = renderStatusText();
+
+      expect(result.current).toBe('');
+    });
+  });
+});