@amityco/ts-sdk 7.10.1-9fe9d33d.0 → 7.10.1-ec1ce4a3.0

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

@@ -1,1193 +0,0 @@
-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,
-      }),
-    );
-  });
-});