stream-chat-react-native-core 4.0.0 → 4.1.0

package/src/components/Channel/__tests__/Channel.test.js

@@ -1,26 +1,29 @@
 import React, { useContext, useEffect } from 'react';
 import { View } from 'react-native';
-import { cleanup, render, waitFor } from '@testing-library/react-native';
-import { StreamChat } from 'stream-chat';
-
-import { Channel } from '../Channel';
 
-import { Attachment } from '../../Attachment/Attachment';
-import { Chat } from '../../Chat/Chat';
+import { act, cleanup, render, waitFor } from '@testing-library/react-native';
+import { StreamChat } from 'stream-chat';
 
 import { ChannelContext, ChannelProvider } from '../../../contexts/channelContext/ChannelContext';
+import { ChannelsStateProvider } from '../../../contexts/channelsStateContext/ChannelsStateContext';
 import {
   MessagesContext,
   MessagesProvider,
 } from '../../../contexts/messagesContext/MessagesContext';
+
 import { ThreadContext, ThreadProvider } from '../../../contexts/threadContext/ThreadContext';
-import { useMockedApis } from '../../../mock-builders/api/useMockedApis';
+
 import { getOrCreateChannelApi } from '../../../mock-builders/api/getOrCreateChannel';
-import { generateChannel } from '../../../mock-builders/generator/channel';
+import { useMockedApis } from '../../../mock-builders/api/useMockedApis';
+import dispatchChannelDeletedEvent from '../../../mock-builders/event/channelDeleted';
+import { generateChannelResponse } from '../../../mock-builders/generator/channel';
 import { generateMember } from '../../../mock-builders/generator/member';
 import { generateMessage } from '../../../mock-builders/generator/message';
 import { generateUser } from '../../../mock-builders/generator/user';
 import { getTestClientWithUser } from '../../../mock-builders/mock';
+import { Attachment } from '../../Attachment/Attachment';
+import { Chat } from '../../Chat/Chat';
+import { Channel } from '../Channel';
 
 // This component is used for performing effects in a component that consumes ChannelContext,
 // i.e. making use of the callbacks & values provided by the Channel component.
@@ -47,24 +50,27 @@ const messages = [generateMessage({ user })];
 
 const renderComponent = (props = {}, callback = () => {}, context = ChannelContext) =>
   render(
-    <Chat client={chatClient}>
-      <Channel {...props}>
-        {props.children}
-        <CallbackEffectWithContext {...{ callback, context }} />
-      </Channel>
-    </Chat>,
+    <ChannelsStateProvider>
+      <Chat client={chatClient}>
+        <Channel {...props}>
+          {props.children}
+          <CallbackEffectWithContext {...{ callback, context }} />
+        </Channel>
+      </Chat>
+    </ChannelsStateProvider>,
   );
 
 describe('Channel', () => {
   beforeEach(async () => {
     const members = [generateMember({ user })];
-    const mockedChannel = generateChannel({
+    const mockedChannel = generateChannelResponse({
       members,
       messages,
     });
     chatClient = await getTestClientWithUser(user);
     useMockedApis(chatClient, [getOrCreateChannelApi(mockedChannel)]);
     channel = chatClient.channel('messaging', mockedChannel.id);
+    channel.cid = mockedChannel.channel.cid;
   });
 
   afterEach(() => {
@@ -73,10 +79,20 @@ describe('Channel', () => {
   });
 
   it('should render a simple text error if the channel id does not exist', async () => {
-    const nullChannel = { ...channel, cid: null };
+    const nullChannel = {
+      ...channel,
+      cid: null,
+      off: () => {},
+      on: () => ({
+        unsubscribe: () => null,
+      }),
+      watch: () => {},
+    };
     const { getByTestId } = renderComponent({ channel: nullChannel });
 
-    await waitFor(() => expect(getByTestId('no-channel')).toBeTruthy());
+    await waitFor(() => {
+      expect(getByTestId('no-channel')).toBeTruthy();
+    });
   });
 
   it('should watch the current channel on mount', async () => {
@@ -120,38 +136,12 @@ describe('Channel', () => {
     await waitFor(() => expect(channelOnSpy).toHaveBeenCalledWith(expect.any(Function)));
   });
 
-  it('should mark a channel as read if the user inits a channel with unread messages', async () => {
-    const watchSpy = jest.spyOn(channel, 'watch');
-    const countUnreadSpy = jest.spyOn(channel, 'countUnread').mockImplementationOnce(() => 1);
-    const markReadSpy = jest.spyOn(channel, 'markRead');
-
-    renderComponent({ channel });
-
-    await waitFor(() => {
-      expect(watchSpy).toHaveBeenCalledWith();
-      expect(countUnreadSpy).toHaveBeenCalledWith();
-      expect(markReadSpy).toHaveBeenCalledWith();
-    });
-  });
-
-  it('should use the doMarkReadRequest prop to mark channel as read', async () => {
-    jest.spyOn(channel, 'countUnread').mockImplementationOnce(() => 1);
-    const doMarkReadRequest = jest.fn();
-
-    renderComponent({
-      channel,
-      doMarkReadRequest,
-    });
-
-    await waitFor(() => expect(doMarkReadRequest).toHaveBeenCalledTimes(1));
-  });
-
   it('should be able to open threads', async () => {
     const threadMessage = messages[0];
     const hasThread = jest.fn();
     // this renders Channel, calls openThread from a child context consumer with a message,
     // and then calls hasThread with the thread id if it was set.
-    renderComponent(
+    const { rerender } = renderComponent(
       { channel },
       ({ openThread, thread }) => {
         if (!thread) {
@@ -162,13 +152,32 @@ describe('Channel', () => {
       },
       ThreadContext,
     );
+
+    rerender(
+      <ChannelsStateProvider>
+        <Chat client={chatClient}>
+          <Channel channel={channel}>
+            <CallbackEffectWithContext
+              callback={({ openThread, thread }) => {
+                if (!thread) {
+                  openThread(threadMessage);
+                } else {
+                  hasThread(thread.id);
+                }
+              }}
+              context={ThreadContext}
+            />
+          </Channel>
+        </Chat>
+      </ChannelsStateProvider>,
+    );
     await waitFor(() => expect(hasThread).toHaveBeenCalledWith(threadMessage.id));
   });
 
   const queryChannelWithNewMessages = (newMessages) =>
     // generate new channel mock from existing channel with new messages added
     getOrCreateChannelApi(
-      generateChannel({
+      generateChannelResponse({
         channel: {
           config: channel.getConfig(),
           id: channel.id,
@@ -177,7 +186,6 @@ describe('Channel', () => {
         messages: newMessages,
       }),
     );
-  const limit = 10;
 
   it('should call the channel query method to load more messages', async () => {
     const channelQuerySpy = jest.spyOn(channel, 'query');
@@ -186,9 +194,8 @@ describe('Channel', () => {
 
     renderComponent(
       { channel },
-      ({ loadMoreEarlier }) => {
+      () => {
         useMockedApis(chatClient, [queryChannelWithNewMessages(newMessages)]);
-        loadMoreEarlier(limit);
       },
       MessagesContext,
     );
@@ -196,59 +203,15 @@ describe('Channel', () => {
     await waitFor(() => expect(channelQuerySpy).toHaveBeenCalled());
   });
 
-  it('should enable editing messages', async () => {
-    const newText = 'something entirely different';
-    const updatedMessage = { ...messages[0], text: newText };
-    const clientUpdateMessageSpy = jest.spyOn(chatClient, 'updateMessage');
-
-    renderComponent(
-      { channel },
-      ({ editMessage }) => {
-        editMessage(updatedMessage);
-      },
-      MessagesContext,
-    );
-
-    await waitFor(() => expect(clientUpdateMessageSpy).toHaveBeenCalledWith(updatedMessage));
-  });
-
-  it('should use doUpdateMessageRequest for the editMessage callback if provided', async () => {
-    const doUpdateMessageRequest = jest.fn((channelId, message) => message);
-    renderComponent(
-      { channel, doUpdateMessageRequest },
-      ({ editMessage }) => {
-        editMessage(messages[0]);
-      },
-      MessagesContext,
-    );
-
-    await waitFor(() =>
-      expect(doUpdateMessageRequest).toHaveBeenCalledWith(channel.cid, messages[0]),
-    );
-  });
-
-  it('should allow removing messages', async () => {
-    let allMessagesRemoved = false;
-    const removeSpy = jest.spyOn(channel.state, 'removeMessage');
-
-    renderComponent(
-      { channel },
-      ({ messages: contextMessages, removeMessage }) => {
-        if (contextMessages.length > 0) {
-          // if there are messages passed as the context, remove them
-          removeMessage({ id: contextMessages[0].id });
-        } else {
-          // once they're all gone, set to true so we can verify that we no longer have messages
-          allMessagesRemoved = true;
-        }
-      },
-      MessagesContext,
-    );
-
-    await waitFor(() => {
-      expect(removeSpy).toHaveBeenCalledWith({ id: messages[0].id });
-      expect(allMessagesRemoved).toBe(true);
+  it('should render null if channel gets deleted', async () => {
+    const { getByTestId, queryByTestId } = renderComponent({
+      channel,
+      children: <View testID='children' />,
     });
+
+    await waitFor(() => expect(getByTestId('children')).toBeTruthy());
+    act(() => dispatchChannelDeletedEvent(chatClient, channel));
+    expect(queryByTestId('children')).toBeNull();
   });
 
   describe('ChannelContext', () => {

package/src/components/Channel/__tests__/ownCapabilities.test.js

@@ -0,0 +1,376 @@
+import React from 'react';
+import { FlatList } from 'react-native';
+
+import { act, fireEvent, render, waitFor } from '@testing-library/react-native';
+
+import { OverlayProvider } from '../../../contexts/overlayContext/OverlayProvider';
+import { allOwnCapabilities } from '../../../contexts/ownCapabilitiesContext/OwnCapabilitiesContext';
+import { getOrCreateChannelApi } from '../../../mock-builders/api/getOrCreateChannel';
+import { sendMessageApi } from '../../../mock-builders/api/sendMessage';
+import { useMockedApis } from '../../../mock-builders/api/useMockedApis';
+import { generateChannelResponse } from '../../../mock-builders/generator/channel';
+import { generateMessage } from '../../../mock-builders/generator/message';
+import { generateUser } from '../../../mock-builders/generator/user';
+import { getTestClientWithUser } from '../../../mock-builders/mock';
+import { registerNativeHandlers } from '../../../native';
+import { Channel } from '../../Channel/Channel';
+import { Chat } from '../../Chat/Chat';
+import { MessageInput } from '../../MessageInput/MessageInput';
+import { MessageList } from '../../MessageList/MessageList';
+
+describe('Own capabilities', () => {
+  const clientUser = generateUser();
+  const otherUser = generateUser();
+
+  const sentMessage = generateMessage({
+    user: clientUser,
+  });
+  const receivedMessage = generateMessage({
+    user: otherUser,
+  });
+
+  let chatClient;
+  let channel;
+
+  const initializeChannel = async (c) => {
+    useMockedApis(chatClient, [getOrCreateChannelApi(c)]);
+    channel = chatClient.channel('messaging');
+
+    await channel.watch();
+  };
+
+  beforeEach(async () => {
+    chatClient = await getTestClientWithUser(clientUser);
+    registerNativeHandlers({
+      FlatList,
+    });
+  });
+
+  const getComponent = (props = {}) => (
+    <OverlayProvider>
+      <Chat client={chatClient}>
+        <Channel channel={channel} {...props}>
+          <MessageList FlatList={FlatList} />
+          <MessageInput />
+        </Channel>
+      </Chat>
+    </OverlayProvider>
+  );
+
+  const generateChannelWithCapabilities = async (capabilities = []) => {
+    const c = generateChannelResponse({
+      channel: {
+        own_capabilities: capabilities,
+      },
+      messages: [sentMessage, receivedMessage],
+    });
+    await initializeChannel(c);
+  };
+
+  const renderChannelAndOpenMessageActionsList = async (targetMessage, props = {}) => {
+    const { findByTestId, queryByTestId, queryByText, unmount } = render(getComponent(props));
+    await waitFor(() => queryByText(targetMessage.text));
+
+    act(() => {
+      fireEvent(queryByText(targetMessage.text), 'onLongPress');
+    });
+
+    await waitFor(() => expect(!!queryByTestId('message-action-list')).toBeTruthy());
+
+    return { findByTestId, queryByTestId, queryByText, unmount };
+  };
+
+  describe(`${allOwnCapabilities.sendReply} capability`, () => {
+    it(`should render "Thread Reply" message action when ${allOwnCapabilities.sendReply} capability is enabled`, async () => {
+      await generateChannelWithCapabilities([allOwnCapabilities.sendReply]);
+      const { queryByTestId } = await renderChannelAndOpenMessageActionsList(sentMessage);
+      expect(!!queryByTestId('threadReply-list-item')).toBeTruthy();
+    });
+
+    it('should not render "Thread Reply" message action when "send-reply" capability is disabled', async () => {
+      await generateChannelWithCapabilities();
+
+      const { queryByTestId } = await renderChannelAndOpenMessageActionsList(sentMessage);
+      expect(!!queryByTestId('threadReply-list-item')).toBeFalsy();
+    });
+
+    it('should override capability from "overrideOwnCapability.sendReply" prop', async () => {
+      await generateChannelWithCapabilities([allOwnCapabilities.sendReply]);
+
+      const { queryByTestId } = await renderChannelAndOpenMessageActionsList(sentMessage, {
+        overrideOwnCapabilities: {
+          sendReply: false,
+        },
+      });
+      expect(!!queryByTestId('threadReply-list-item')).toBeFalsy();
+    });
+  });
+
+  describe(`${allOwnCapabilities.banChannelMembers} capability`, () => {
+    it(`should render "Block User" message action when ${allOwnCapabilities.banChannelMembers} capability is enabled`, async () => {
+      await generateChannelWithCapabilities([allOwnCapabilities.banChannelMembers]);
+      const { queryByTestId } = await renderChannelAndOpenMessageActionsList(receivedMessage);
+      expect(!!queryByTestId('blockUser-list-item')).toBeTruthy();
+    });
+
+    it(`should not render "Block User" message action when ${allOwnCapabilities.banChannelMembers} capability is disabled`, async () => {
+      await generateChannelWithCapabilities();
+
+      const { queryByTestId } = await renderChannelAndOpenMessageActionsList(receivedMessage);
+      expect(!!queryByTestId('blockUser-list-item')).toBeFalsy();
+    });
+
+    it(`should override capability from "overrideOwnCapability.banChannelMembers" prop`, async () => {
+      await generateChannelWithCapabilities([allOwnCapabilities.banChannelMembers]);
+
+      const { queryByTestId } = await renderChannelAndOpenMessageActionsList(receivedMessage, {
+        overrideOwnCapabilities: {
+          banChannelMembers: false,
+        },
+      });
+      expect(!!queryByTestId('blockUser-list-item')).toBeFalsy();
+    });
+  });
+
+  describe(`${allOwnCapabilities.deleteAnyMessage} capability`, () => {
+    it(`should render "Delete Message" action for received message when "${allOwnCapabilities.deleteAnyMessage}" capability is enabled`, async () => {
+      await generateChannelWithCapabilities(['delete-any-message']);
+      const { queryByTestId } = await renderChannelAndOpenMessageActionsList(receivedMessage);
+      expect(!!queryByTestId('deleteMessage-list-item')).toBeTruthy();
+    });
+
+    it(`should not render "Delete Message" action for received message when "${allOwnCapabilities.deleteAnyMessage}" capability is disabled`, async () => {
+      await generateChannelWithCapabilities();
+
+      const { queryByTestId } = await renderChannelAndOpenMessageActionsList(receivedMessage);
+      expect(!!queryByTestId('deleteMessage-list-item')).toBeFalsy();
+    });
+
+    it('should override capability from "overrideOwnCapability.deleteAnyMessage" prop', async () => {
+      await generateChannelWithCapabilities([allOwnCapabilities.deleteAnyMessage]);
+
+      const { queryByTestId } = await renderChannelAndOpenMessageActionsList(receivedMessage, {
+        overrideOwnCapabilities: {
+          deleteAnyMessage: false,
+        },
+      });
+      expect(!!queryByTestId('deleteMessage-list-item')).toBeFalsy();
+    });
+  });
+
+  describe(`${allOwnCapabilities.deleteOwnMessage} capability`, () => {
+    it(`should render "Delete Message" action for sent message when "${allOwnCapabilities.deleteOwnMessage}" capability is enabled`, async () => {
+      await generateChannelWithCapabilities([allOwnCapabilities.deleteOwnMessage]);
+      const { queryByTestId } = await renderChannelAndOpenMessageActionsList(sentMessage);
+      expect(!!queryByTestId('deleteMessage-list-item')).toBeTruthy();
+    });
+
+    it(`should not render "Delete Message" action for sent message when "${allOwnCapabilities.deleteOwnMessage}" capability is disabled`, async () => {
+      await generateChannelWithCapabilities();
+
+      const { queryByTestId } = await renderChannelAndOpenMessageActionsList(sentMessage);
+      expect(!!queryByTestId('deleteMessage-list-item')).toBeFalsy();
+    });
+
+    it('should override capability from "overrideOwnCapability.deleteOwnMessage" prop', async () => {
+      await generateChannelWithCapabilities([allOwnCapabilities.deleteOwnMessage]);
+
+      const { queryByTestId } = await renderChannelAndOpenMessageActionsList(sentMessage, {
+        overrideOwnCapabilities: {
+          deleteOwnMessage: false,
+        },
+      });
+      expect(!!queryByTestId('deleteMessage-list-item')).toBeFalsy();
+    });
+  });
+
+  describe(`${allOwnCapabilities.updateAnyMessage} capability`, () => {
+    it(`should render "Edit Message" action for received message when "${allOwnCapabilities.updateAnyMessage}" capability is enabled`, async () => {
+      await generateChannelWithCapabilities([allOwnCapabilities.updateAnyMessage]);
+      const { queryByTestId } = await renderChannelAndOpenMessageActionsList(receivedMessage);
+      expect(!!queryByTestId('editMessage-list-item')).toBeTruthy();
+    });
+
+    it(`should not render "Edit Message" action for received message when "${allOwnCapabilities.updateAnyMessage}" capability is disabled`, async () => {
+      await generateChannelWithCapabilities();
+
+      const { queryByTestId } = await renderChannelAndOpenMessageActionsList(receivedMessage);
+      expect(!!queryByTestId('editMessage-list-item')).toBeFalsy();
+    });
+
+    it('should override capability from "overrideOwnCapability.updateAnyMessage" prop', async () => {
+      await generateChannelWithCapabilities([allOwnCapabilities.updateAnyMessage]);
+
+      const { queryByTestId } = await renderChannelAndOpenMessageActionsList(receivedMessage, {
+        overrideOwnCapabilities: {
+          updateAnyMessage: false,
+        },
+      });
+      expect(!!queryByTestId('editMessage-list-item')).toBeFalsy();
+    });
+  });
+
+  describe(`${allOwnCapabilities.flagMessage} capability`, () => {
+    it(`should render "Flag Message" action for sent message when "${allOwnCapabilities.flagMessage}" capability is enabled`, async () => {
+      await generateChannelWithCapabilities([allOwnCapabilities.flagMessage]);
+      const { queryByTestId } = await renderChannelAndOpenMessageActionsList(receivedMessage);
+      expect(!!queryByTestId('flagMessage-list-item')).toBeTruthy();
+    });
+
+    it(`should not render "Flag Message" action for sent message when "${allOwnCapabilities.flagMessage}" capability is disabled`, async () => {
+      await generateChannelWithCapabilities();
+
+      const { queryByTestId } = await renderChannelAndOpenMessageActionsList(receivedMessage);
+      expect(!!queryByTestId('flagMessage-list-item')).toBeFalsy();
+    });
+
+    it('should override capability from "overrideOwnCapability.deleteOwnMessage" prop', async () => {
+      await generateChannelWithCapabilities([allOwnCapabilities.flagMessage]);
+
+      const { queryByTestId } = await renderChannelAndOpenMessageActionsList(receivedMessage, {
+        overrideOwnCapabilities: {
+          flagMessage: false,
+        },
+      });
+      expect(!!queryByTestId('flagMessage-list-item')).toBeFalsy();
+    });
+  });
+
+  describe(`${allOwnCapabilities.pinMessage} capability`, () => {
+    it(`should render "Pin Message" action for sent message when "${allOwnCapabilities.pinMessage}" capability is enabled`, async () => {
+      await generateChannelWithCapabilities([allOwnCapabilities.pinMessage]);
+      const { queryByTestId } = await renderChannelAndOpenMessageActionsList(receivedMessage);
+      expect(!!queryByTestId('pinMessage-list-item')).toBeTruthy();
+    });
+
+    it(`should not render "Pin Message" action for sent message when "${allOwnCapabilities.pinMessage}" capability is disabled`, async () => {
+      await generateChannelWithCapabilities();
+
+      const { queryByTestId } = await renderChannelAndOpenMessageActionsList(receivedMessage);
+      expect(!!queryByTestId('pinMessage-list-item')).toBeFalsy();
+    });
+
+    it('should override capability from "overrideOwnCapability.pinMessage" prop', async () => {
+      await generateChannelWithCapabilities([allOwnCapabilities.pinMessage]);
+
+      const { queryByTestId } = await renderChannelAndOpenMessageActionsList(receivedMessage, {
+        overrideOwnCapabilities: {
+          pinMessage: false,
+        },
+      });
+      expect(!!queryByTestId('pinMessage-list-item')).toBeFalsy();
+    });
+  });
+
+  describe(`${allOwnCapabilities.quoteMessage} capability`, () => {
+    it(`should render "Reply" action for sent message when "${allOwnCapabilities.quoteMessage}" capability is enabled`, async () => {
+      await generateChannelWithCapabilities([allOwnCapabilities.quoteMessage]);
+      const { queryByTestId } = await renderChannelAndOpenMessageActionsList(receivedMessage);
+      expect(!!queryByTestId('quotedReply-list-item')).toBeTruthy();
+    });
+
+    it(`should not render "Reply" action for sent message when "${allOwnCapabilities.quoteMessage}" capability is disabled`, async () => {
+      await generateChannelWithCapabilities();
+
+      const { queryByTestId } = await renderChannelAndOpenMessageActionsList(receivedMessage);
+      expect(!!queryByTestId('quotedReply-list-item')).toBeFalsy();
+    });
+
+    it('should override capability from "overrideOwnCapability.quoteMessage" prop', async () => {
+      await generateChannelWithCapabilities([allOwnCapabilities.quoteMessage]);
+
+      const { queryByTestId } = await renderChannelAndOpenMessageActionsList(receivedMessage, {
+        overrideOwnCapabilities: {
+          quoteMessage: false,
+        },
+      });
+      expect(!!queryByTestId('quotedReply-list-item')).toBeFalsy();
+    });
+  });
+
+  describe(`${allOwnCapabilities.sendReaction} capability`, () => {
+    it(`should render reaction selector when "${allOwnCapabilities.sendReaction}" capability is enabled`, async () => {
+      await generateChannelWithCapabilities([allOwnCapabilities.sendReaction]);
+      const { queryByTestId } = await renderChannelAndOpenMessageActionsList(receivedMessage);
+      expect(!!queryByTestId('overlay-reaction-list')).toBeTruthy();
+    });
+
+    it(`should not render reaction selector when "${allOwnCapabilities.sendReaction}" capability is disabled`, async () => {
+      await generateChannelWithCapabilities();
+
+      const { queryByTestId } = await renderChannelAndOpenMessageActionsList(receivedMessage);
+      expect(!!queryByTestId('overlay-reaction-list')).toBeFalsy();
+    });
+
+    it('should override capability from "overrideOwnCapability.sendReaction" prop', async () => {
+      await generateChannelWithCapabilities([allOwnCapabilities.sendReaction]);
+
+      const { queryByTestId } = await renderChannelAndOpenMessageActionsList(receivedMessage, {
+        overrideOwnCapabilities: {
+          sendReaction: false,
+        },
+      });
+      expect(!!queryByTestId('overlay-reaction-list')).toBeFalsy();
+    });
+  });
+
+  describe(`${allOwnCapabilities.sendMessage} capability`, () => {
+    it(`should not render SendMessageDisallowedIndicator when "${allOwnCapabilities.sendMessage}" capability is enabled`, async () => {
+      await generateChannelWithCapabilities([allOwnCapabilities.sendMessage]);
+      const { queryByTestId } = render(getComponent());
+
+      await waitFor(() => expect(!!queryByTestId('send-message-disallowed-indicator')).toBeFalsy());
+    });
+
+    it(`should render SendMessageDisallowedIndicator when "${allOwnCapabilities.sendMessage}" capability is disabled`, async () => {
+      await generateChannelWithCapabilities();
+      const { queryByTestId } = render(getComponent());
+
+      await waitFor(() =>
+        expect(!!queryByTestId('send-message-disallowed-indicator')).toBeTruthy(),
+      );
+    });
+  });
+
+  describe(`${allOwnCapabilities.sendLinks} capability`, () => {
+    it(`should not allow sending links when "${allOwnCapabilities.sendLinks}" capability is disabled`, async () => {
+      await generateChannelWithCapabilities([allOwnCapabilities.sendMessage]);
+      const { queryByTestId } = render(
+        getComponent({
+          initialValue: 'Awesome repository https://github.com/GetStream/stream-chat-react-native',
+        }),
+      );
+
+      const sendMessage = jest.fn();
+      channel.sendMessage = sendMessage;
+      act(() => {
+        fireEvent(queryByTestId('send-button'), 'onPress');
+      });
+
+      await waitFor(() => expect(sendMessage).toHaveBeenCalledTimes(0));
+    });
+  });
+
+  it(`should allow sending links when "${allOwnCapabilities.sendLinks}" capability is enabled`, async () => {
+    await generateChannelWithCapabilities([
+      allOwnCapabilities.sendMessage,
+      allOwnCapabilities.sendLinks,
+    ]);
+    const mockFn = jest.fn();
+    const { queryByTestId } = render(
+      getComponent({
+        doSendMessageRequest: () => {
+          mockFn();
+          return sendMessageApi();
+        },
+        initialValue: 'Awesome repository https://github.com/GetStream/stream-chat-react-native',
+      }),
+    );
+
+    act(() => {
+      fireEvent(queryByTestId('send-button'), 'onPress');
+    });
+
+    await waitFor(() => expect(mockFn).toHaveBeenCalledTimes(1));
+  });
+});