stream-chat-react-native-core 4.9.0-beta.2 → 4.9.0

package/src/contexts/messageInputContext/__tests__/__snapshots__/sendMessageAsync.test.tsx.snap

@@ -0,0 +1,33 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`MessageInputContext's sendMessageAsync sendImageAsync is been called with finished file upload state and checked for snapshot) 1`] = `
+Object {
+  "attachments": Array [
+    Object {
+      "image_url": "https://www.test.com",
+      "type": "image",
+    },
+  ],
+  "mentioned_users": Array [],
+  "parent_id": undefined,
+  "quoted_message_id": undefined,
+  "show_in_channel": undefined,
+  "text": "",
+}
+`;
+
+exports[`MessageInputContext's sendMessageAsync sendImageAsync is been called with uploaded file upload state and checked for snapshot) 1`] = `
+Object {
+  "attachments": Array [
+    Object {
+      "image_url": "https://www.test.com",
+      "type": "image",
+    },
+  ],
+  "mentioned_users": Array [],
+  "parent_id": undefined,
+  "quoted_message_id": undefined,
+  "show_in_channel": undefined,
+  "text": "",
+}
+`;

package/src/contexts/messageInputContext/__tests__/isValidMessage.test.tsx

@@ -0,0 +1,71 @@
+import React, { PropsWithChildren } from 'react';
+import { act } from 'react-test-renderer';
+
+import { renderHook } from '@testing-library/react-hooks';
+
+import {
+  generateFileUploadPreview,
+  generateImageUploadPreview,
+} from '../../../mock-builders/generator/attachment';
+import type { DefaultStreamChatGenerics } from '../../../types/types';
+import { FileState } from '../../../utils/utils';
+import {
+  InputMessageInputContextValue,
+  MessageInputContextValue,
+  MessageInputProvider,
+  useMessageInputContext,
+} from '../MessageInputContext';
+
+type WrapperType<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> =
+  Partial<InputMessageInputContextValue<StreamChatGenerics>>;
+
+const Wrapper = <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>({
+  children,
+  ...rest
+}: PropsWithChildren<WrapperType<StreamChatGenerics>>) => (
+  <MessageInputProvider
+    value={
+      {
+        ...rest,
+      } as MessageInputContextValue<StreamChatGenerics>
+    }
+  >
+    {children}
+  </MessageInputProvider>
+);
+
+describe("MessageInputContext's isValidMessage", () => {
+  const initialProps = {
+    editing: true,
+    hasImagePicker: true,
+  };
+
+  it.each([
+    [[], [], [], 0, '', false],
+    [[], [], [], 0, 'Dummy Text', true],
+    [[generateFileUploadPreview()], [], [], 0, '', true],
+    [[], [generateImageUploadPreview()], [], 0, '', true],
+    [[], [generateImageUploadPreview({ state: FileState.UPLOAD_FAILED })], [], 0, '', false],
+    [[generateFileUploadPreview({ state: FileState.UPLOAD_FAILED })], [], [], 0, '', false],
+    [[generateFileUploadPreview({ state: FileState.UPLOADING })], [], [], 0, '', false],
+    [[], [generateImageUploadPreview({ state: FileState.UPLOADING })], [], 0, '', false],
+  ])(
+    'isValidMessage with fileUploads %p, imageUploads %p, mentionedUsers %p, numberOfUploads %d, text %s gives %p',
+    (fileUploads, imageUploads, mentionedUsers, numberOfUploads, text, isValidMessageStatus) => {
+      const { result } = renderHook(() => useMessageInputContext(), {
+        initialProps,
+        wrapper: Wrapper,
+      });
+
+      act(() => {
+        result.current.setFileUploads(fileUploads);
+        result.current.setImageUploads(imageUploads);
+        result.current.setMentionedUsers(mentionedUsers);
+        result.current.setNumberOfUploads(numberOfUploads);
+        result.current.setText(text);
+      });
+
+      expect(result.current.isValidMessage()).toBe(isValidMessageStatus);
+    },
+  );
+});

package/src/contexts/messageInputContext/__tests__/pickFile.test.tsx

@@ -0,0 +1,67 @@
+import React, { PropsWithChildren } from 'react';
+import { Alert } from 'react-native';
+import { act } from 'react-test-renderer';
+
+import { renderHook } from '@testing-library/react-hooks';
+
+import type { DefaultStreamChatGenerics } from '../../../types/types';
+import {
+  InputMessageInputContextValue,
+  MessageInputContextValue,
+  MessageInputProvider,
+  useMessageInputContext,
+} from '../MessageInputContext';
+
+type WrapperType<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> =
+  Partial<InputMessageInputContextValue<StreamChatGenerics>>;
+
+const Wrapper = <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>({
+  children,
+  ...rest
+}: PropsWithChildren<WrapperType<StreamChatGenerics>>) => (
+  <MessageInputProvider
+    value={
+      {
+        ...rest,
+      } as MessageInputContextValue<StreamChatGenerics>
+    }
+  >
+    {children}
+  </MessageInputProvider>
+);
+
+afterEach(jest.clearAllMocks);
+
+describe("MessageInputContext's pickFile", () => {
+  jest.spyOn(Alert, 'alert');
+
+  const initialProps = {
+    editing: true,
+    maxNumberOfFiles: 2,
+  };
+
+  it.each([
+    [3, 1],
+    [1, 0],
+  ])(
+    'run pickFile when numberOfUploads is %d and alert is triggered %d number of times',
+    (numberOfUploads, numberOfTimesCalled) => {
+      const { rerender, result } = renderHook(() => useMessageInputContext(), {
+        initialProps,
+        wrapper: Wrapper,
+      });
+
+      act(() => {
+        result.current.setNumberOfUploads(numberOfUploads);
+      });
+
+      rerender({ editing: false, maxNumberOfFiles: 2 });
+
+      act(() => {
+        result.current.pickFile();
+      });
+
+      expect(Alert.alert).toHaveBeenCalledTimes(numberOfTimesCalled);
+    },
+  );
+});

package/src/contexts/messageInputContext/__tests__/removeFile.test.tsx

@@ -0,0 +1,82 @@
+import React, { PropsWithChildren } from 'react';
+import { act } from 'react-test-renderer';
+
+import { renderHook } from '@testing-library/react-hooks';
+
+import { waitFor } from '@testing-library/react-native';
+
+import { generateFileUploadPreview } from '../../../mock-builders/generator/attachment';
+import type { DefaultStreamChatGenerics } from '../../../types/types';
+import {
+  InputMessageInputContextValue,
+  MessageInputContextValue,
+  MessageInputProvider,
+  useMessageInputContext,
+} from '../MessageInputContext';
+
+type WrapperType<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> =
+  Partial<InputMessageInputContextValue<StreamChatGenerics>>;
+
+const Wrapper = <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>({
+  children,
+  ...rest
+}: PropsWithChildren<WrapperType<StreamChatGenerics>>) => (
+  <MessageInputProvider
+    value={
+      {
+        ...rest,
+      } as MessageInputContextValue<StreamChatGenerics>
+    }
+  >
+    {children}
+  </MessageInputProvider>
+);
+
+describe("MessageInputContext's removeFile", () => {
+  const initialProps = {
+    editing: true,
+  };
+
+  const file = generateFileUploadPreview({
+    file: {
+      id: 'test',
+      name: 'Test Image',
+      uri: 'https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/images/BigBuckBunny.jpg',
+    },
+  });
+
+  it.each([
+    [file.id, 0, 0],
+    ['dummy', 1, 1],
+  ])(
+    'removeFile is been called with %s and checked for expectedFileUploadsLength %i, and expectedNumberOfUploadsLength %i)',
+    async (fileId, expectedFileUploadsLength, expectedNumberOfUploadsLength) => {
+      const { rerender, result } = renderHook(() => useMessageInputContext(), {
+        initialProps,
+        wrapper: Wrapper,
+      });
+
+      act(() => {
+        result.current.setFileUploads([file]);
+        result.current.setNumberOfUploads(1);
+      });
+
+      rerender({ editing: false });
+
+      await waitFor(() => {
+        expect(result.current.fileUploads.length).toBe(1);
+      });
+
+      act(() => {
+        result.current.removeFile(fileId);
+      });
+
+      rerender({ editing: true });
+
+      await waitFor(() => {
+        expect(result.current.fileUploads.length).toBe(expectedFileUploadsLength);
+        expect(result.current.numberOfUploads).toBe(expectedNumberOfUploadsLength);
+      });
+    },
+  );
+});

package/src/contexts/messageInputContext/__tests__/removeImage.test.tsx

@@ -0,0 +1,80 @@
+import React, { PropsWithChildren } from 'react';
+import { act } from 'react-test-renderer';
+
+import { renderHook } from '@testing-library/react-hooks';
+
+import { waitFor } from '@testing-library/react-native';
+
+import { generateImageUploadPreview } from '../../../mock-builders/generator/attachment';
+import type { DefaultStreamChatGenerics } from '../../../types/types';
+import {
+  InputMessageInputContextValue,
+  MessageInputContextValue,
+  MessageInputProvider,
+  useMessageInputContext,
+} from '../MessageInputContext';
+
+type WrapperType<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> =
+  Partial<InputMessageInputContextValue<StreamChatGenerics>>;
+
+const Wrapper = <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>({
+  children,
+  ...rest
+}: PropsWithChildren<WrapperType<StreamChatGenerics>>) => (
+  <MessageInputProvider
+    value={
+      {
+        ...rest,
+      } as MessageInputContextValue<StreamChatGenerics>
+    }
+  >
+    {children}
+  </MessageInputProvider>
+);
+
+describe("MessageInputContext's removeImage", () => {
+  const initialProps = {
+    editing: true,
+  };
+  const image = generateImageUploadPreview({
+    file: {
+      id: 'test',
+      name: 'Test Image',
+      uri: 'https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/images/BigBuckBunny.jpg',
+    },
+  });
+  it.each([
+    [image.id, 0, 0],
+    ['dummy', 1, 1],
+  ])(
+    'removeImage is been called with %s and checked for expectedImageUploadsLength %i, and expectedNumberOfUploadsLength %i)',
+    async (imageId, expectedImageUploadsLength, expectedNumberOfUploadsLength) => {
+      const { rerender, result } = renderHook(() => useMessageInputContext(), {
+        initialProps,
+        wrapper: Wrapper,
+      });
+
+      act(() => {
+        result.current.setImageUploads([image]);
+        result.current.setNumberOfUploads(1);
+      });
+
+      rerender({ editing: false });
+
+      await waitFor(() => {
+        expect(result.current.imageUploads.length).toBe(1);
+      });
+
+      act(() => {
+        result.current.removeImage(imageId);
+      });
+
+      rerender({ editing: true });
+
+      await waitFor(() => {
+        expect(result.current.imageUploads.length).toBe(expectedImageUploadsLength);
+        expect(result.current.numberOfUploads).toBe(expectedNumberOfUploadsLength);
+      });
+    },
+  );
+});

package/src/contexts/messageInputContext/__tests__/sendMessage.test.tsx

@@ -0,0 +1,286 @@
+import React, { PropsWithChildren } from 'react';
+import { act } from 'react-test-renderer';
+
+import { renderHook } from '@testing-library/react-hooks';
+
+import type { MessageType } from '../../../components/MessageList/hooks/useMessageList';
+import {
+  generateFileUploadPreview,
+  generateImageUploadPreview,
+} from '../../../mock-builders/generator/attachment';
+import { generateMessage } from '../../../mock-builders/generator/message';
+import { generateUser } from '../../../mock-builders/generator/user';
+import type { DefaultStreamChatGenerics } from '../../../types/types';
+import { FileState } from '../../../utils/utils';
+import {
+  InputMessageInputContextValue,
+  MessageInputContextValue,
+  MessageInputProvider,
+  useMessageInputContext,
+} from '../MessageInputContext';
+
+type WrapperType<StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics> =
+  Partial<InputMessageInputContextValue<StreamChatGenerics>>;
+
+const Wrapper = <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>({
+  children,
+  ...rest
+}: PropsWithChildren<WrapperType<StreamChatGenerics>>) => (
+  <MessageInputProvider
+    value={
+      {
+        ...rest,
+      } as MessageInputContextValue<StreamChatGenerics>
+    }
+  >
+    {children}
+  </MessageInputProvider>
+);
+
+describe("MessageInputContext's sendMessage", () => {
+  const message: boolean | MessageType<DefaultStreamChatGenerics> = generateMessage({
+    created_at: 'Sat Jul 02 2022 23:55:13 GMT+0530 (India Standard Time)',
+    id: '7a85f744-cc89-4f82-a1d4-5456432cc8bf',
+    updated_at: 'Sat Jul 02 2022 23:55:13 GMT+0530 (India Standard Time)',
+    user: generateUser({
+      id: '5d6f6322-567e-4e1e-af90-97ef1ed5cc23',
+      image: 'fc86ddcb-bac4-400c-9afd-b0c0a1c0cd33',
+      name: '50cbdd0e-ca7e-4478-9e2c-be0f1ac6a995',
+    }),
+  }) as unknown as MessageType<DefaultStreamChatGenerics>;
+
+  it('exit sendMessage when file upload status failed', async () => {
+    const files = generateFileUploadPreview({ state: FileState.UPLOAD_FAILED });
+    const images = generateImageUploadPreview({ state: FileState.UPLOAD_FAILED });
+    const { result } = renderHook(() => useMessageInputContext(), {
+      initialProps: {
+        editing: true,
+      },
+      wrapper: Wrapper,
+    });
+
+    act(() => {
+      result.current.setFileUploads([files]);
+      result.current.setImageUploads([images]);
+    });
+
+    act(() => {
+      result.current.sendMessage();
+    });
+
+    await expect(result.current.sending.current).toBeFalsy();
+  });
+
+  it('exit sendMessage when image upload status is uploading', async () => {
+    const images = generateImageUploadPreview({ state: FileState.UPLOADING });
+
+    const { rerender, result } = renderHook(() => useMessageInputContext(), {
+      initialProps: {
+        editing: true,
+        sendImageAsync: true,
+      },
+      wrapper: Wrapper,
+    });
+
+    act(() => {
+      result.current.setImageUploads([images]);
+      result.current.setMentionedUsers([]);
+      result.current.setText('');
+    });
+
+    act(() => {
+      result.current.sendMessage();
+    });
+
+    rerender({ editing: false, sendImageAsync: true });
+
+    await expect(result.current.asyncIds).toHaveLength(1);
+    await expect(result.current.sending.current).toBeFalsy();
+  });
+
+  it('exit sendMessage when image upload status is uploading and sendImageAsync is available', async () => {
+    const images = generateImageUploadPreview({ state: FileState.UPLOADING });
+
+    const { result } = renderHook(() => useMessageInputContext(), {
+      initialProps: {
+        editing: true,
+      },
+      wrapper: Wrapper,
+    });
+
+    act(() => {
+      result.current.setImageUploads([images]);
+      result.current.setMentionedUsers([]);
+      result.current.setText('');
+    });
+
+    act(() => {
+      result.current.sendMessage();
+    });
+
+    await expect(result.current.sending.current).toBeFalsy();
+  });
+
+  it('exit sendMessage when file upload status is uploading', async () => {
+    const files = generateFileUploadPreview({ state: FileState.UPLOADING });
+    const { result } = renderHook(() => useMessageInputContext(), {
+      initialProps: {
+        editing: true,
+      },
+      wrapper: Wrapper,
+    });
+
+    act(() => {
+      result.current.setFileUploads([files]);
+      result.current.setMentionedUsers([]);
+      result.current.setText('');
+    });
+
+    act(() => {
+      result.current.sendMessage();
+    });
+
+    await expect(result.current.sending.current).toBeFalsy();
+  });
+
+  it('exit sendMessage when image upload status is uploaded successfully', () => {
+    const sendMessageMock = jest.fn();
+    const clearQuotedMessageStateMock = jest.fn();
+    const images = [
+      generateImageUploadPreview({ state: FileState.UPLOADED }),
+      generateImageUploadPreview({ state: FileState.FINISHED }),
+    ];
+    const { result } = renderHook(() => useMessageInputContext(), {
+      initialProps: {
+        clearQuotedMessageState: clearQuotedMessageStateMock,
+        editing: true,
+        quotedMessage: false,
+        sendMessage: sendMessageMock,
+      },
+      wrapper: Wrapper,
+    });
+
+    act(() => {
+      result.current.setImageUploads(images);
+      result.current.setMentionedUsers(['dummy1', 'dummy2']);
+      result.current.setText('');
+    });
+
+    act(() => {
+      result.current.sendMessage();
+    });
+
+    expect(sendMessageMock.mock.calls[0][0]).toMatchSnapshot();
+    expect(clearQuotedMessageStateMock).toHaveBeenCalled();
+    expect(result.current.sending.current).toBeFalsy();
+    expect(result.current.fileUploads.length).toBe(0);
+    expect(result.current.imageUploads.length).toBe(0);
+    expect(result.current.mentionedUsers.length).toBe(0);
+  });
+
+  it('exit sendMessage when image upload has an error and catch block is executed', () => {
+    const setQuotedMessageStateMock = jest.fn();
+    const clearQuotedMessageStateMock = jest.fn();
+    const generatedQuotedMessage: boolean | MessageType<DefaultStreamChatGenerics> = message;
+    const images = [
+      generateImageUploadPreview({ state: FileState.UPLOADED }),
+      generateImageUploadPreview({ state: FileState.FINISHED }),
+    ];
+    const { result } = renderHook(() => useMessageInputContext(), {
+      initialProps: {
+        clearQuotedMessageState: clearQuotedMessageStateMock,
+        editing: true,
+        quotedMessage: generatedQuotedMessage,
+        setQuotedMessageState: setQuotedMessageStateMock,
+      },
+      wrapper: Wrapper,
+    });
+
+    act(() => {
+      result.current.setImageUploads(images);
+      result.current.setMentionedUsers(['dummy1', 'dummy2']);
+      result.current.setText('');
+    });
+
+    act(() => {
+      result.current.sendMessage();
+    });
+
+    expect(setQuotedMessageStateMock).toHaveBeenCalled();
+    expect(result.current.sending.current).toBeFalsy();
+  });
+
+  it('exit sendMessage when edit message is not boolean image upload status is uploaded successfully', () => {
+    const sendMessageMock = jest.fn();
+    const clearQuotedMessageStateMock = jest.fn();
+    const clearEditingStateMock = jest.fn();
+    const editMessageMock = jest.fn().mockResolvedValue({ data: {} });
+    const images = generateImageUploadPreview({ state: FileState.UPLOADED });
+    const generatedMessage: boolean | MessageType<DefaultStreamChatGenerics> = message;
+    const { result } = renderHook(() => useMessageInputContext(), {
+      initialProps: {
+        clearEditingState: clearEditingStateMock,
+        clearQuotedMessageState: clearQuotedMessageStateMock,
+        editing: generatedMessage,
+        editMessage: editMessageMock,
+        quotedMessage: false,
+        sendMessage: sendMessageMock,
+      },
+      wrapper: Wrapper,
+    });
+
+    act(() => {
+      result.current.setImageUploads([images]);
+      result.current.setMentionedUsers(['dummy1', 'dummy2']);
+      result.current.setText('');
+    });
+
+    act(() => {
+      result.current.sendMessage();
+    });
+
+    expect(editMessageMock.mock.calls[0][0]).toMatchSnapshot();
+    expect(clearEditingStateMock).toHaveBeenCalled();
+    expect(result.current.sending.current).toBeFalsy();
+    expect(result.current.fileUploads.length).toBe(0);
+    expect(result.current.imageUploads.length).toBe(0);
+    expect(result.current.mentionedUsers.length).toBe(0);
+  });
+
+  it('exit sendMessage when file upload status is uploaded successfully', () => {
+    const files = [
+      generateFileUploadPreview({ state: FileState.UPLOADED }),
+      generateFileUploadPreview({ state: FileState.FINISHED, type: 'video/mp4' }),
+      generateFileUploadPreview({ state: FileState.UPLOADED, type: 'audio/mp3' }),
+      generateFileUploadPreview({ state: FileState.FINISHED, type: 'image/jpeg' }),
+    ];
+    const sendMessageMock = jest.fn();
+    const clearQuotedMessageStateMock = jest.fn();
+    const { result } = renderHook(() => useMessageInputContext(), {
+      initialProps: {
+        clearQuotedMessageState: clearQuotedMessageStateMock,
+        editing: true,
+        quotedMessage: false,
+        sendMessage: sendMessageMock,
+      },
+      wrapper: Wrapper,
+    });
+
+    act(() => {
+      result.current.setFileUploads(files);
+      result.current.setMentionedUsers(['dummy1', 'dummy2']);
+      result.current.setText('');
+    });
+
+    act(() => {
+      result.current.sendMessage();
+    });
+
+    expect(sendMessageMock.mock.calls[0][0]).toMatchSnapshot();
+    expect(clearQuotedMessageStateMock).toHaveBeenCalled();
+    expect(result.current.sending.current).toBeFalsy();
+    expect(result.current.fileUploads.length).toBe(0);
+    expect(result.current.imageUploads.length).toBe(0);
+    expect(result.current.mentionedUsers.length).toBe(0);
+  });
+});