@amityco/ts-sdk 6.35.3-f8f74ab5.0 → 6.35.3

package/src/messageRepository/observers/tests/getMessages.test.ts

@@ -0,0 +1,1193 @@
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  messages,
+  generateRawMessage,
+  convertRawMessage,
+  pause,
+  messagesDesc,
+} from '~/utils/tests';
+
+import { queryMessages } from '../../api/queryMessages';
+import { getMessages } from '../getMessages';
+import * as getMessageMarkers from '../../../marker/api/getMessageMarkers';
+
+describe('getMessages', () => {
+  beforeAll(() => {
+    connectClient();
+
+    jest.spyOn(getMessageMarkers, 'getMessageMarkers').mockImplementation(() =>
+      Promise.resolve({
+        data: [],
+        cachedAt: undefined,
+      }),
+    );
+  });
+
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  const { subChannelId } = messages;
+  const returnValue: Amity.RawMessage[] = [generateRawMessage({ messageId: messages.page1[0] })];
+  const rawMessage = generateRawMessage({
+    messageId: returnValue[0].messageId,
+    messageFeedId: subChannelId,
+  });
+  const message = convertRawMessage(rawMessage);
+
+  test('it should show message if cache not enabled', () => {
+    /*
+     * NOTE: at the time of writing this test cache is diabled by default, but
+     * there is a proposal to enable cache by default. So I'm disabling cache
+     * here to ensure cache is disabled
+     */
+    disableCache();
+
+    const callback = jest.fn();
+    jest.spyOn(global.console, 'log');
+    client.http.get = jest.fn();
+
+    // call getMessages check if mocked console get's called with the correct
+    // message
+    client.use();
+    getMessages({ subChannelId }, callback);
+
+    expect(console.log).toBeCalledWith(ENABLE_CACHE_MESSAGE);
+  });
+
+  test('it should return message collection', async () => {
+    // mock response of queryMessages and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        messages: returnValue,
+        paging: {},
+      },
+    });
+
+    getMessages({ subChannelId }, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    expect(callback).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        data: [],
+        error: undefined,
+        loading: true,
+      }),
+    );
+
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        data: returnValue.map(convertRawMessage),
+        error: undefined,
+        loading: false,
+      }),
+    );
+  });
+
+  test('it should return error on api failure', async () => {
+    const error = new ASCApiError(
+      'server error!',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    // mock response of queryMessages and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockRejectedValue(error);
+
+    getMessages({ subChannelId }, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: [],
+        error: undefined,
+        loading: true,
+      }),
+    );
+
+    await expect(queryMessages({ subChannelId })).rejects.toThrow();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    expect(callback).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        error,
+        data: [],
+        loading: false,
+      }),
+    );
+  });
+
+  test('it should filter deleted messages based on param', async () => {
+    // mock response of queryMessages with a deleted message
+    const returnValue = [
+      { messageId: messages.page1[0], isDeleted: true },
+      { messageId: messages.page1[1], isDeleted: false },
+    ];
+
+    // mock response of queryMessages and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        messages: returnValue,
+        paging: {},
+      },
+    });
+
+    getMessages({ subChannelId, includeDeleted: false }, callback);
+    await pause();
+
+    // not use queryMessages anymore
+    // await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        data: [],
+        error: undefined,
+        loading: true,
+      }),
+    );
+
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        // @ts-ignore
+        data: [returnValue[1]].map(convertRawMessage),
+        error: undefined,
+        loading: false,
+      }),
+    );
+  });
+
+  test('it should return method to fetch next page', async () => {
+    const returnValue2 = [{ messageId: messages.page2[0] }];
+
+    const callback = jest.fn();
+    client.http.get = jest
+      .fn()
+      .mockResolvedValue({
+        data: {
+          messages: returnValue,
+          paging: {
+            previous: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDM5MTExMTAwMDAwMH0',
+            next: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDM5MTExMTAwMDAwMH0',
+          },
+        },
+      })
+      .mockResolvedValueOnce({
+        data: {
+          messages: returnValue2,
+          paging: {
+            previous: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDM5MTExMTAwMDAwMH0',
+            next: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDM5MTExMTAwMDAwMH0',
+          },
+        },
+      });
+
+    getMessages({ subChannelId, includeDeleted: true }, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalled();
+
+    // await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
+
+    expect(callback.mock.lastCall).toHaveLength(1);
+
+    const { onNextPage, hasNextPage } = callback.mock.lastCall[0];
+
+    expect(hasNextPage).toBe(true);
+    expect(onNextPage).toBeTruthy();
+
+    onNextPage();
+    await pause();
+
+    // await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
+
+    // 4 -> becuase 1 local & server call each per call (2)
+    expect(callback).toHaveBeenCalledTimes(4);
+
+    expect(callback).toHaveBeenNthCalledWith(
+      4,
+      expect.objectContaining({
+        // @ts-ignore
+        data: [...returnValue2, ...returnValue].map(convertRawMessage),
+        error: undefined,
+        loading: false,
+      }),
+    );
+  });
+
+  // skip this test for now because onFecth should not add a new message to the collection
+  test.skip('it should add new message to collection onFetch', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        messages: returnValue,
+        paging: {},
+      },
+    });
+
+    getMessages({ subChannelId }, callback);
+    await pause();
+
+    // await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    client.emitter.emit('local.message.fetched', { messages: [message] });
+
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: [message],
+        error: undefined,
+        loading: false,
+      }),
+    );
+  });
+
+  test('it should add new message to collection onCreate', async () => {
+    const rawNewMessage = generateRawMessage({
+      messageId: 'new-message-id',
+      messageFeedId: message.subChannelId,
+    });
+    const newMessage = convertRawMessage(rawNewMessage);
+
+    // mock response of queryMessages and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        messages: returnValue,
+        paging: {},
+      },
+    });
+
+    getMessages({ subChannelId }, callback);
+    await pause();
+
+    // await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    // fire new message creation event
+    client.emitter.emit('message.created', {
+      messages: [rawNewMessage],
+      messageFeeds: [],
+      users: [],
+      files: [],
+      reactions: [],
+    });
+
+    await pause();
+
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        error: undefined,
+        loading: false,
+      }),
+    );
+    expect(callback.mock.calls[2][0].data[0]).toMatchObject(newMessage);
+    expect(callback.mock.calls[2][0].data[1]).toMatchObject(message);
+  });
+
+  test('it should add new message to collection onUpdate', async () => {
+    // mock response of queryMessages and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        messages: returnValue,
+        paging: {},
+      },
+    });
+
+    getMessages({ subChannelId }, callback);
+    await pause();
+
+    // await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    // fire new message creation event
+    client.emitter.emit('message.updated', {
+      messages: [rawMessage],
+      messageFeeds: [],
+      users: [],
+      files: [],
+      reactions: [],
+    });
+
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        data: [message],
+        error: undefined,
+        loading: false,
+      }),
+    );
+  });
+
+  test('it should add new message to collection onDelete', async () => {
+    // mock response of queryMessages and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        messages: returnValue,
+        paging: {},
+      },
+    });
+
+    getMessages({ subChannelId, includeDeleted: true }, callback);
+    await pause();
+
+    // await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    // fire new message deletion event
+    client.emitter.emit('message.deleted', {
+      messages: [{ ...rawMessage, isDeleted: true }],
+      messageFeeds: [],
+      users: [],
+      files: [],
+      reactions: [],
+    });
+
+    await pause();
+
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: [{ ...message, isDeleted: true }],
+        error: undefined,
+        loading: false,
+      }),
+    );
+  });
+
+  describe('when querying the message collection with specific sort and filter options, the result should be sorted correctly', () => {
+    describe('sorting', () => {
+      test('default', async () => {
+        const { subChannelId } = messages;
+        const returnValue: Amity.RawMessage[] = [
+          generateRawMessage({ messageId: messages.page3[2], segment: 9 }),
+          generateRawMessage({ messageId: messages.page3[1], segment: 8 }),
+          generateRawMessage({ messageId: messages.page3[0], segment: 7 }),
+        ];
+
+        const callback = jest.fn();
+        const spyGet = jest.spyOn(client.http, 'get').mockResolvedValue({
+          data: {
+            messages: returnValue,
+            paging: {},
+          },
+        });
+
+        getMessages({ subChannelId }, callback);
+
+        expect(spyGet).toHaveBeenCalledWith('/api/v5/messages', {
+          params: {
+            isDeleted: false,
+            messageFeedId: 'message-feed-id',
+            // first time call will not have token, message set limit to COLLECTION_DEFAULT_PAGINATION_LIMIT by default
+            options: { limit: 5 },
+          },
+        });
+
+        expect(callback).toHaveBeenCalledTimes(1);
+        expect(callback).toHaveBeenCalledWith(
+          expect.objectContaining({
+            data: [],
+            error: undefined,
+            loading: true,
+          }),
+        );
+
+        await pause(100);
+
+        expect(callback.mock.calls.length).toBeGreaterThan(1);
+        expect(callback).lastCalledWith(
+          expect.objectContaining({
+            data: returnValue.map(convertRawMessage),
+            error: undefined,
+            loading: false,
+          }),
+        );
+      });
+
+      test('segmentDesc', async () => {
+        const { subChannelId } = messages;
+        const returnValue: Amity.RawMessage[] = [
+          generateRawMessage({ messageId: messages.page3[2], segment: 9 }),
+          generateRawMessage({ messageId: messages.page3[1], segment: 8 }),
+          generateRawMessage({ messageId: messages.page3[0], segment: 7 }),
+        ];
+
+        const callback = jest.fn();
+        const spyGet = jest.spyOn(client.http, 'get').mockResolvedValue({
+          data: {
+            messages: returnValue,
+            paging: {},
+          },
+        });
+
+        getMessages({ subChannelId, sortBy: 'segmentDesc' }, callback);
+
+        expect(spyGet).toHaveBeenCalledWith('/api/v5/messages', {
+          params: {
+            isDeleted: false,
+            messageFeedId: 'message-feed-id',
+            options: {
+              sortBy: 'segmentDesc',
+              // first time call will not have token, message set limit to COLLECTION_DEFAULT_PAGINATION_LIMIT by default
+              limit: 5,
+            },
+          },
+        });
+
+        expect(callback).toHaveBeenCalledTimes(1);
+        expect(callback).toHaveBeenCalledWith(
+          expect.objectContaining({
+            data: [],
+            error: undefined,
+            loading: true,
+          }),
+        );
+
+        await pause(100);
+
+        expect(callback.mock.calls.length).toBeGreaterThan(1);
+        expect(callback).lastCalledWith(
+          expect.objectContaining({
+            data: returnValue.map(convertRawMessage),
+            error: undefined,
+            loading: false,
+          }),
+        );
+      });
+
+      test('segmentDesc + wrong ordering from server', async () => {
+        const { subChannelId } = messages;
+        const returnValue: Amity.RawMessage[] = [
+          generateRawMessage({ messageId: messages.page3[0], segment: 7 }),
+          generateRawMessage({ messageId: messages.page3[1], segment: 8 }),
+          generateRawMessage({ messageId: messages.page3[2], segment: 9 }),
+        ];
+
+        const callback = jest.fn();
+        const spyGet = jest.spyOn(client.http, 'get').mockResolvedValue({
+          data: {
+            messages: returnValue,
+            paging: {},
+          },
+        });
+
+        getMessages({ subChannelId, sortBy: 'segmentDesc' }, callback);
+
+        expect(spyGet).toHaveBeenCalledWith('/api/v5/messages', {
+          params: {
+            isDeleted: false,
+            messageFeedId: 'message-feed-id',
+            options: {
+              sortBy: 'segmentDesc',
+              // first time call will not have token, message set limit to COLLECTION_DEFAULT_PAGINATION_LIMIT by default
+              limit: 5,
+            },
+          },
+        });
+
+        expect(callback).toHaveBeenCalledTimes(1);
+        expect(callback).toHaveBeenCalledWith(
+          expect.objectContaining({
+            data: [],
+            error: undefined,
+            loading: true,
+          }),
+        );
+
+        await pause(100);
+
+        expect(callback.mock.calls.length).toBeGreaterThan(1);
+        expect(callback).lastCalledWith(
+          expect.objectContaining({
+            data: [
+              convertRawMessage(returnValue[2]),
+              convertRawMessage(returnValue[1]),
+              convertRawMessage(returnValue[0]),
+            ],
+            error: undefined,
+            loading: false,
+          }),
+        );
+      });
+
+      test('segmentAsc', async () => {
+        const { subChannelId } = messages;
+        const returnValue: Amity.RawMessage[] = [
+          generateRawMessage({ messageId: messages.page1[0], segment: 1 }),
+          generateRawMessage({ messageId: messages.page1[1], segment: 2 }),
+          generateRawMessage({ messageId: messages.page1[2], segment: 3 }),
+        ];
+
+        const callback = jest.fn();
+        const spyGet = jest.spyOn(client.http, 'get').mockResolvedValue({
+          data: {
+            messages: returnValue,
+            paging: {},
+          },
+        });
+
+        getMessages({ subChannelId, sortBy: 'segmentAsc' }, callback);
+
+        expect(spyGet).toHaveBeenCalledWith('/api/v5/messages', {
+          params: {
+            isDeleted: false,
+            messageFeedId: 'message-feed-id',
+            options: {
+              sortBy: 'segmentAsc',
+              // first time call will not have token, message set limit to COLLECTION_DEFAULT_PAGINATION_LIMIT by default
+              limit: 5,
+            },
+          },
+        });
+
+        expect(callback).toHaveBeenCalledTimes(1);
+        expect(callback).toHaveBeenCalledWith(
+          expect.objectContaining({
+            data: [],
+            error: undefined,
+            loading: true,
+          }),
+        );
+
+        await pause(100);
+
+        expect(callback.mock.calls.length).toBeGreaterThan(1);
+        expect(callback).lastCalledWith(
+          expect.objectContaining({
+            data: returnValue.map(convertRawMessage),
+            error: undefined,
+            loading: false,
+          }),
+        );
+      });
+
+      test('segmentAsc + wrong ordering from server', async () => {
+        const { subChannelId } = messages;
+        const returnValue: Amity.RawMessage[] = [
+          generateRawMessage({ messageId: messages.page1[2], segment: 3 }),
+          generateRawMessage({ messageId: messages.page1[1], segment: 2 }),
+          generateRawMessage({ messageId: messages.page1[0], segment: 1 }),
+        ];
+
+        const callback = jest.fn();
+        const spyGet = jest.spyOn(client.http, 'get').mockResolvedValue({
+          data: {
+            messages: returnValue,
+            paging: {},
+          },
+        });
+
+        getMessages({ subChannelId, sortBy: 'segmentAsc' }, callback);
+
+        expect(spyGet).toHaveBeenCalledWith('/api/v5/messages', {
+          params: {
+            isDeleted: false,
+            messageFeedId: 'message-feed-id',
+            options: {
+              sortBy: 'segmentAsc',
+              // first time call will not have token, message set limit to COLLECTION_DEFAULT_PAGINATION_LIMIT by default
+              limit: 5,
+            },
+          },
+        });
+
+        expect(callback).toHaveBeenCalledTimes(1);
+        expect(callback).toHaveBeenCalledWith(
+          expect.objectContaining({
+            data: [],
+            error: undefined,
+            loading: true,
+          }),
+        );
+
+        await pause(100);
+
+        expect(callback.mock.calls.length).toBeGreaterThan(1);
+        expect(callback).lastCalledWith(
+          expect.objectContaining({
+            data: [
+              convertRawMessage(returnValue[2]),
+              convertRawMessage(returnValue[1]),
+              convertRawMessage(returnValue[0]),
+            ],
+            error: undefined,
+            loading: false,
+          }),
+        );
+      });
+    });
+
+    /**
+     * TODO: check filtering test cases again
+     * The filtering should be on server side when query message from API
+     * But on SDK side, we should filter the message after we get the message RTE event from server
+     */
+
+    describe('filtering', () => {
+      test('tags', async () => {
+        const { subChannelId } = messages;
+        const returnValue: Amity.RawMessage[] = [
+          generateRawMessage({ messageId: messages.page3[2], tags: ['tag1'] }),
+          generateRawMessage({ messageId: messages.page3[1], tags: ['tag2'] }),
+          generateRawMessage({ messageId: messages.page3[0], tags: ['tag3'] }),
+        ];
+
+        const callback = jest.fn();
+        const spyGet = jest.spyOn(client.http, 'get').mockResolvedValue({
+          data: {
+            messages: returnValue,
+            paging: {},
+          },
+        });
+
+        getMessages({ subChannelId, tags: ['tag1', 'tag2'] }, callback);
+
+        expect(spyGet).toHaveBeenCalledWith('/api/v5/messages', {
+          params: {
+            isDeleted: false,
+            messageFeedId: 'message-feed-id',
+            includeTags: ['tag1', 'tag2'],
+            options: { limit: 5 },
+          },
+        });
+
+        expect(callback).toHaveBeenCalledTimes(1);
+        expect(callback).toHaveBeenCalledWith(
+          expect.objectContaining({
+            data: [],
+            error: undefined,
+            loading: true,
+          }),
+        );
+
+        await pause(100);
+
+        expect(callback.mock.calls.length).toBeGreaterThan(1);
+        expect(callback).lastCalledWith(
+          expect.objectContaining({
+            data: [convertRawMessage(returnValue[0]), convertRawMessage(returnValue[1])],
+            error: undefined,
+            loading: false,
+          }),
+        );
+      });
+
+      test('excludeTags', async () => {
+        const { subChannelId } = messages;
+        const returnValue: Amity.RawMessage[] = [
+          generateRawMessage({ messageId: messages.page3[2], tags: ['tag1'] }),
+          generateRawMessage({ messageId: messages.page3[1], tags: ['tag2'] }),
+          generateRawMessage({ messageId: messages.page3[0], tags: ['tag3'] }),
+        ];
+
+        const callback = jest.fn();
+        const spyGet = jest.spyOn(client.http, 'get').mockResolvedValue({
+          data: {
+            messages: returnValue,
+            paging: {},
+          },
+        });
+
+        // filtering out doesn't work when put more than 1 tag in excludeTags
+        getMessages({ subChannelId, excludeTags: ['tag1'] }, callback);
+
+        expect(spyGet).toHaveBeenCalledWith('/api/v5/messages', {
+          params: {
+            isDeleted: false,
+            messageFeedId: 'message-feed-id',
+            excludeTags: ['tag1'],
+            options: { limit: 5 },
+          },
+        });
+
+        expect(callback).toHaveBeenCalledTimes(1);
+        expect(callback).toHaveBeenCalledWith(
+          expect.objectContaining({
+            data: [],
+            error: undefined,
+            loading: true,
+          }),
+        );
+
+        await pause(100);
+
+        expect(callback.mock.calls.length).toBeGreaterThan(1);
+        expect(callback).lastCalledWith(
+          expect.objectContaining({
+            data: [convertRawMessage(returnValue[1]), convertRawMessage(returnValue[2])],
+            error: undefined,
+            loading: false,
+          }),
+        );
+      });
+
+      test('dataType', async () => {
+        const { subChannelId } = messages;
+        const returnValue: Amity.RawMessage[] = [
+          generateRawMessage({ messageId: messages.page3[2], dataType: 'text' }),
+          generateRawMessage({ messageId: messages.page3[1], dataType: 'image' }),
+          generateRawMessage({ messageId: messages.page3[0], dataType: 'video' }),
+        ];
+
+        const callback = jest.fn();
+        // dataType filtering by server, so query messages api v5 response from server will return only image dataType
+        const spyGet = jest.spyOn(client.http, 'get').mockResolvedValue({
+          data: {
+            messages: [returnValue[1]],
+            paging: {},
+          },
+        });
+
+        getMessages({ subChannelId, dataType: 'image' }, callback);
+
+        expect(spyGet).toHaveBeenCalledWith('/api/v5/messages', {
+          params: {
+            isDeleted: false,
+            messageFeedId: 'message-feed-id',
+            dataType: 'image',
+            options: { limit: 5 },
+          },
+        });
+
+        expect(callback).toHaveBeenCalledTimes(1);
+        expect(callback).toHaveBeenCalledWith(
+          expect.objectContaining({
+            data: [],
+            error: undefined,
+            loading: true,
+          }),
+        );
+
+        await pause(100);
+
+        expect(callback.mock.calls.length).toBeGreaterThan(1);
+        expect(callback).lastCalledWith(
+          expect.objectContaining({
+            data: [convertRawMessage(returnValue[1])],
+            error: undefined,
+            loading: false,
+          }),
+        );
+      });
+
+      test('parentId', async () => {
+        const { subChannelId } = messages;
+        const parentId = 'parent-id';
+        const returnValue: Amity.RawMessage[] = [
+          generateRawMessage({ messageId: messages.page3[2], parentId }),
+          generateRawMessage({ messageId: messages.page3[1], parentId }),
+          generateRawMessage({ messageId: messages.page3[0], parentId: 'parent-id-2' }),
+        ];
+
+        // parentId filtering by server,
+        // query messages api v5 from server will return only that parentId
+
+        const callback = jest.fn();
+        const spyGet = jest.spyOn(client.http, 'get').mockResolvedValue({
+          data: {
+            messages: [returnValue[0], returnValue[1]],
+            paging: {},
+          },
+        });
+
+        getMessages({ subChannelId, parentId }, callback);
+
+        expect(spyGet).toHaveBeenCalledWith('/api/v5/messages', {
+          params: {
+            isDeleted: false,
+            messageFeedId: 'message-feed-id',
+            parentId,
+            options: { limit: 5 },
+          },
+        });
+
+        expect(callback).toHaveBeenCalledTimes(1);
+        expect(callback).toHaveBeenCalledWith(
+          expect.objectContaining({
+            data: [],
+            error: undefined,
+            loading: true,
+          }),
+        );
+
+        await pause(100);
+
+        expect(callback.mock.calls.length).toBeGreaterThan(1);
+        expect(callback).lastCalledWith(
+          expect.objectContaining({
+            data: [convertRawMessage(returnValue[0]), convertRawMessage(returnValue[1])],
+            error: undefined,
+            loading: false,
+          }),
+        );
+      });
+    });
+
+    describe('combine sorting + filtering', () => {
+      test('segmentAsc + tags', async () => {
+        const { subChannelId } = messages;
+        const returnValue: Amity.RawMessage[] = [
+          generateRawMessage({ messageId: messages.page3[2], tags: ['tag1'], segment: 9 }),
+          generateRawMessage({ messageId: messages.page3[1], tags: ['tag3'], segment: 8 }),
+          generateRawMessage({ messageId: messages.page3[0], tags: ['tag2'], segment: 7 }),
+          generateRawMessage({ messageId: messages.page2[2], tags: ['tag3'], segment: 6 }),
+          generateRawMessage({ messageId: messages.page2[1], tags: ['tag3'], segment: 5 }),
+        ];
+
+        const callback = jest.fn();
+        const spyGet = jest.spyOn(client.http, 'get').mockResolvedValue({
+          data: {
+            messages: returnValue,
+            paging: {},
+          },
+        });
+
+        getMessages({ subChannelId, tags: ['tag3'], sortBy: 'segmentAsc' }, callback);
+
+        expect(spyGet).toHaveBeenCalledWith('/api/v5/messages', {
+          params: {
+            isDeleted: false,
+            messageFeedId: 'message-feed-id',
+            includeTags: ['tag3'],
+            options: { sortBy: 'segmentAsc', limit: 5 },
+          },
+        });
+
+        expect(callback).toHaveBeenCalledTimes(1);
+        expect(callback).toHaveBeenCalledWith(
+          expect.objectContaining({
+            data: [],
+            error: undefined,
+            loading: true,
+          }),
+        );
+
+        await pause(100);
+
+        expect(callback.mock.calls.length).toBeGreaterThan(1);
+        expect(callback).lastCalledWith(
+          expect.objectContaining({
+            data: [
+              convertRawMessage(returnValue[4]),
+              convertRawMessage(returnValue[3]),
+              convertRawMessage(returnValue[1]),
+            ],
+            error: undefined,
+            loading: false,
+          }),
+        );
+      });
+    });
+  });
+
+  test('when querying two message collections with the same subchannelId but different params, results do not mix with each other.', async () => {
+    const callback = jest.fn();
+    const callback2 = jest.fn();
+
+    const { subChannelId } = messages;
+    const returnValue: Amity.RawMessage[] = [
+      generateRawMessage({ messageId: messages.page3[2], segment: 9 }),
+      generateRawMessage({ messageId: messages.page3[1], segment: 8 }),
+      generateRawMessage({ messageId: messages.page3[0], segment: 7 }),
+    ];
+
+    const returnValue2: Amity.RawMessage[] = [
+      generateRawMessage({ messageId: messages.page1[0], segment: 1 }),
+      generateRawMessage({ messageId: messages.page1[1], segment: 2 }),
+      generateRawMessage({ messageId: messages.page1[2], segment: 3 }),
+    ];
+
+    const spyGet = jest.spyOn(client.http, 'get').mockImplementation((url: string, params) => {
+      if (params?.params?.options?.sortBy === 'segmentDesc') {
+        return Promise.resolve({
+          data: {
+            messages: returnValue,
+            paging: {},
+          },
+        });
+      }
+      return Promise.resolve({
+        data: {
+          messages: returnValue2,
+          paging: {},
+        },
+      });
+    });
+
+    getMessages({ subChannelId, sortBy: 'segmentDesc' }, callback);
+    getMessages({ subChannelId, sortBy: 'segmentAsc' }, callback2);
+
+    expect(spyGet).toHaveBeenCalledWith('/api/v5/messages', {
+      params: {
+        isDeleted: false,
+        messageFeedId: 'message-feed-id',
+        options: { sortBy: 'segmentDesc', limit: 5 },
+      },
+    });
+
+    expect(spyGet).toHaveBeenCalledWith('/api/v5/messages', {
+      params: {
+        isDeleted: false,
+        messageFeedId: 'message-feed-id',
+        options: { sortBy: 'segmentAsc', limit: 5 },
+      },
+    });
+
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: [],
+        error: undefined,
+        loading: true,
+      }),
+    );
+
+    await pause(100);
+
+    expect(callback.mock.calls.length).toBeGreaterThan(1);
+    expect(callback).lastCalledWith(
+      expect.objectContaining({
+        data: returnValue.map(convertRawMessage),
+        error: undefined,
+        loading: false,
+      }),
+    );
+
+    expect(callback2.mock.calls.length).toBeGreaterThan(1);
+    expect(callback2).lastCalledWith(
+      expect.objectContaining({
+        data: returnValue2.map(convertRawMessage),
+        error: undefined,
+        loading: false,
+      }),
+    );
+  });
+
+  test('when querying two message collections with the same subchannelId but different params, pagination works correctly for each.', async () => {
+    const callback = jest.fn();
+    const callback2 = jest.fn();
+
+    const { subChannelId } = messages;
+    // Value1 is for segmentDesc sorting
+    const returnValue1Page1: Amity.RawMessage[] = [
+      generateRawMessage({ messageId: messagesDesc.page1[0], segment: 100 }),
+      generateRawMessage({ messageId: messagesDesc.page1[1], segment: 99 }),
+      generateRawMessage({ messageId: messagesDesc.page1[2], segment: 98 }),
+    ];
+
+    const returnValue1Page2: Amity.RawMessage[] = [
+      generateRawMessage({ messageId: messagesDesc.page2[0], segment: 97 }),
+      generateRawMessage({ messageId: messagesDesc.page2[1], segment: 96 }),
+      generateRawMessage({ messageId: messagesDesc.page2[2], segment: 95 }),
+    ];
+
+    // Value2 is for segmentAsc sorting
+    const returnValue2Page1: Amity.RawMessage[] = [
+      generateRawMessage({ messageId: messages.page1[0], segment: 1 }),
+      generateRawMessage({ messageId: messages.page1[1], segment: 2 }),
+      generateRawMessage({ messageId: messages.page1[2], segment: 3 }),
+    ];
+
+    const returnValue2Page2: Amity.RawMessage[] = [
+      generateRawMessage({ messageId: messages.page2[0], segment: 4 }),
+      generateRawMessage({ messageId: messages.page2[1], segment: 5 }),
+      generateRawMessage({ messageId: messages.page2[2], segment: 6 }),
+    ];
+
+    const returnValue2Page3: Amity.RawMessage[] = [
+      generateRawMessage({ messageId: messages.page3[0], segment: 7 }),
+      generateRawMessage({ messageId: messages.page3[1], segment: 8 }),
+      generateRawMessage({ messageId: messages.page3[2], segment: 9 }),
+    ];
+
+    const spyGet = jest.spyOn(client.http, 'get').mockImplementation((url: string, params) => {
+      if (url !== '/api/v5/messages') return Promise.resolve();
+
+      // segmentDesc page#1
+      if (params?.params?.options?.sortBy === 'segmentDesc') {
+        return Promise.resolve({
+          data: {
+            messages: returnValue1Page1,
+            paging: {
+              previous: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDM5MTExMTAwMDAwMH0',
+              next: 'eyJsaW1pdCI6MywiYmVmb3JlIjoibWVzc2FnZUlkMTAxIn0=',
+            },
+          },
+        });
+      }
+
+      // segmentDesc page#2, option contains only token
+      if (params?.params?.options?.token === 'eyJsaW1pdCI6MywiYmVmb3JlIjoibWVzc2FnZUlkMTAxIn0=') {
+        return Promise.resolve({
+          data: {
+            messages: returnValue1Page2,
+            paging: {
+              previous: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDM5MTExMTAwMDAwMH0',
+            },
+          },
+        });
+      }
+
+      // segmentAsc page#2
+      if (
+        params?.params?.options?.token ===
+        'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDM5MTExMTAwMDAwMH0='
+      ) {
+        return Promise.resolve({
+          data: {
+            messages: returnValue2Page2,
+            paging: {
+              previous: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDM5MTExMTAwMDAwMH0',
+              next: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDQ5MTExMTAwMDAwMH0=',
+            },
+          },
+        });
+      }
+
+      // segmentAsc page#3
+      if (
+        params?.params?.options?.token ===
+        'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDQ5MTExMTAwMDAwMH0='
+      ) {
+        return Promise.resolve({
+          data: {
+            messages: returnValue2Page3,
+            paging: {
+              previous: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDM5MTExMTAwMDAwMH0',
+            },
+          },
+        });
+      }
+
+      // segmentAsc page#1
+      return Promise.resolve({
+        data: {
+          messages: returnValue2Page1,
+          paging: {
+            previous: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDM5MTExMTAwMDAwMH0',
+            next: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDM5MTExMTAwMDAwMH0=',
+          },
+        },
+      });
+    });
+
+    getMessages({ subChannelId, sortBy: 'segmentDesc', limit: 3 }, callback);
+    getMessages({ subChannelId, sortBy: 'segmentAsc', limit: 3 }, callback2);
+
+    expect(spyGet).toHaveBeenCalledWith('/api/v5/messages', {
+      params: {
+        isDeleted: false,
+        messageFeedId: 'message-feed-id',
+        options: { sortBy: 'segmentDesc', limit: 3 },
+      },
+    });
+
+    expect(spyGet).toHaveBeenCalledWith('/api/v5/messages', {
+      params: {
+        isDeleted: false,
+        messageFeedId: 'message-feed-id',
+        options: { sortBy: 'segmentAsc', limit: 3 },
+      },
+    });
+
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: [],
+        error: undefined,
+        loading: true,
+      }),
+    );
+
+    await pause(100);
+
+    expect(callback.mock.calls.length).toBeGreaterThan(1);
+    expect(callback).lastCalledWith(
+      expect.objectContaining({
+        data: returnValue1Page1.map(convertRawMessage),
+        error: undefined,
+        loading: false,
+      }),
+    );
+
+    // ge more page for live collection #2
+    callback2.mock.lastCall[0].onNextPage();
+
+    await pause(100);
+
+    callback2.mock.lastCall[0].onNextPage();
+
+    await pause(100);
+
+    /**
+     * collection #1
+     * should contains 1 pages
+     * should call the callback function 2 times
+     */
+
+    expect(callback.mock.calls.length).toBeGreaterThan(1);
+    expect(callback).lastCalledWith(
+      expect.objectContaining({
+        data: returnValue1Page1.map(convertRawMessage),
+        error: undefined,
+        loading: false,
+      }),
+    );
+
+    /**
+     * collection #2
+     * should contains 3 pages, because of 2 times calling onNextPage()
+     * should call the callback function 6 times
+     */
+
+    expect(callback2.mock.calls.length).toBeGreaterThan(5);
+    expect(callback2).lastCalledWith(
+      expect.objectContaining({
+        data: [...returnValue2Page1, ...returnValue2Page2, ...returnValue2Page3].map(
+          convertRawMessage,
+        ),
+        error: undefined,
+        loading: false,
+      }),
+    );
+
+    // get more page for live collection #1
+    callback.mock.lastCall[0].onNextPage();
+
+    await pause(100);
+
+    expect(callback).lastCalledWith(
+      expect.objectContaining({
+        data: [...returnValue1Page1, ...returnValue1Page2].map(convertRawMessage),
+        error: undefined,
+        loading: false,
+      }),
+    );
+  });
+});