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

package/src/channelRepository/observers/tests/getChannels.test.ts

@@ -1,1074 +0,0 @@
-import { disableCache, enableCache } from '~/cache/api';
-import {
-  channel1,
-  channel2,
-  channelQueryResponse,
-  channelQueryResponsePage2,
-  channelRaw1,
-  channelRaw2,
-  client,
-  connectClient,
-  convertRawChannelPayload,
-  convertChannelFromRaw,
-  disconnectClient,
-  generateRawChannel,
-  generateRawMessage,
-  mockPage,
-  pause,
-  rawChannelUser,
-  rawChannelUser2,
-  user11,
-  channelDisplayName3,
-  channelDisplayName2,
-  channelDisplayName1,
-  channelCreatedAt3,
-  channelCreatedAt2,
-  channelCreatedAt1,
-  channelLastActivity1,
-  channelLastActivity2,
-  channelLastActivity3,
-  channelDisplayName4,
-  channelQueryResponseWithoutPaging,
-} from '~/utils/tests';
-
-import { getChannels } from '../getChannels';
-import * as getChannelMarkers from '../../../marker/api/getChannelMarkers';
-import { getChannelMessagePreviewWithUser } from '~/messagePreview/utils';
-
-const getSnapshot = (params?: Record<string, any>) => {
-  return {
-    data: [] as Amity.Channel[],
-    loading: true,
-    error: undefined as any,
-    ...params,
-  };
-};
-
-const getMarker = () => {
-  return {
-    unreadCount: 0,
-    isDeleted: false,
-  } as Amity.ChannelMarker;
-};
-
-describe('getChannels', () => {
-  jest.spyOn(getChannelMarkers, 'getChannelMarkers').mockResolvedValue({
-    data: [],
-    cachedAt: undefined,
-  });
-
-  beforeAll(connectClient);
-  afterAll(disconnectClient);
-  beforeEach(enableCache);
-  afterEach(disableCache);
-
-  test('it should return channel collection', async () => {
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
-
-    getChannels({}, callback);
-    await pause();
-
-    expect(callback).toHaveBeenCalledTimes(2);
-    expect(callback).toHaveBeenNthCalledWith(1, expect.objectContaining(getSnapshot()));
-    expect(callback).toHaveBeenNthCalledWith(
-      2,
-      expect.objectContaining(
-        getSnapshot({
-          data: convertRawChannelPayload(channelQueryResponse.data).channels.map(channel => {
-            return { ...channel, messagePreview: null };
-          }),
-          loading: false,
-        }),
-      ),
-    );
-  });
-
-  test('it should return data from cache first when call with the same query', async () => {
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
-
-    getChannels({}, () => undefined);
-    await pause();
-    getChannels({}, callback);
-    await pause();
-
-    expect(callback).toHaveBeenCalledTimes(2);
-    expect(callback).toHaveBeenNthCalledWith(
-      1,
-      expect.objectContaining(
-        getSnapshot({
-          data: convertRawChannelPayload(channelQueryResponse.data).channels.map(
-            getChannelMessagePreviewWithUser,
-          ),
-          loading: true,
-        }),
-      ),
-    );
-    expect(callback).toHaveBeenNthCalledWith(
-      2,
-      expect.objectContaining(
-        getSnapshot({
-          data: convertRawChannelPayload(channelQueryResponse.data).channels.map(
-            getChannelMessagePreviewWithUser,
-          ),
-          loading: false,
-        }),
-      ),
-    );
-  });
-
-  describe('when querying the channel collection with specific sort and filter options, the result is sorted and filtered correctly.', () => {
-    const rawDeletedChannel = generateRawChannel({
-      channelId: 'deleted-channel-id',
-      isDeleted: true,
-      type: 'conversation',
-    });
-    const deletedChannel = convertChannelFromRaw(rawDeletedChannel);
-    const rawTaggedChannel = generateRawChannel({
-      channelId: 'tagged-channel-id',
-      tags: ['tag1', 'tag2'],
-      type: 'conversation',
-    });
-    const taggedChannel = convertChannelFromRaw(rawTaggedChannel);
-    const rawTaggedChannel2 = generateRawChannel({
-      channelId: 'tagged-channel-id-2',
-      tags: ['tag2'],
-      type: 'conversation',
-    });
-    const taggedChannel2 = convertChannelFromRaw(rawTaggedChannel2);
-
-    const filterCases: [string, Amity.ChannelLiveCollection, Amity.Channel[]][] = [
-      [
-        'deleted',
-        { isDeleted: false },
-        [
-          channel1,
-          { ...taggedChannel, messagePreview: null },
-          { ...taggedChannel2, messagePreview: null },
-        ],
-      ],
-      [
-        'tagged',
-        { tags: ['tag2'] },
-        [
-          { ...taggedChannel, messagePreview: null },
-          { ...taggedChannel2, messagePreview: null },
-        ],
-      ],
-      [
-        'out excluded tags',
-        { excludeTags: ['tag1'] },
-        [
-          channel1,
-          { ...deletedChannel, messagePreview: null },
-          { ...taggedChannel2, messagePreview: null },
-        ],
-      ],
-      ['member', { membership: 'member' }, [channel1]],
-      [
-        'not member',
-        { membership: 'notMember' },
-        [
-          { ...deletedChannel, messagePreview: null },
-          { ...taggedChannel, messagePreview: null },
-          { ...taggedChannel2, messagePreview: null },
-        ],
-      ],
-      [
-        'all membership',
-        { membership: 'all' },
-        [
-          channel1,
-          { ...deletedChannel, messagePreview: null },
-          { ...taggedChannel, messagePreview: null },
-          { ...taggedChannel2, messagePreview: null },
-        ],
-      ],
-    ];
-
-    const sortingCases: [
-      string,
-      Amity.ChannelLiveCollection,
-      Amity.RawChannel[],
-      Amity.RawChannel[],
-    ][] = [
-      [
-        'displayName',
-        { sortBy: 'displayName' },
-        [channelDisplayName1, channelDisplayName2, channelDisplayName3],
-        [channelDisplayName1, channelDisplayName2, channelDisplayName3],
-      ],
-      [
-        'displayName + wrong order',
-        { sortBy: 'displayName' },
-        [channelDisplayName3, channelDisplayName2, channelDisplayName1],
-        [channelDisplayName1, channelDisplayName2, channelDisplayName3],
-      ],
-      [
-        'firstCreated',
-        { sortBy: 'firstCreated' },
-        [channelCreatedAt1, channelCreatedAt2, channelCreatedAt3],
-        [channelCreatedAt1, channelCreatedAt2, channelCreatedAt3],
-      ],
-      [
-        'firstCreated + wrong order',
-        { sortBy: 'firstCreated' },
-        [channelCreatedAt3, channelCreatedAt2, channelCreatedAt1],
-        [channelCreatedAt1, channelCreatedAt2, channelCreatedAt3],
-      ],
-      [
-        'lastCreated',
-        { sortBy: 'lastCreated' },
-        [channelCreatedAt3, channelCreatedAt2, channelCreatedAt1],
-        [channelCreatedAt3, channelCreatedAt2, channelCreatedAt1],
-      ],
-      [
-        'lastCreated + wrong order',
-        { sortBy: 'lastCreated' },
-        [channelCreatedAt1, channelCreatedAt2, channelCreatedAt3],
-        [channelCreatedAt3, channelCreatedAt2, channelCreatedAt1],
-      ],
-      [
-        'lastActivity',
-        { sortBy: 'lastActivity' },
-        [channelLastActivity3, channelLastActivity2, channelLastActivity1],
-        [channelLastActivity3, channelLastActivity2, channelLastActivity1],
-      ],
-      [
-        'lastActivity + wrong order',
-        { sortBy: 'lastActivity' },
-        [channelLastActivity1, channelLastActivity2, channelLastActivity3],
-        [channelLastActivity3, channelLastActivity2, channelLastActivity1],
-      ],
-    ];
-
-    const filterAndSortingCases: [
-      string,
-      Amity.ChannelLiveCollection,
-      Amity.RawChannel[],
-      Amity.RawChannel[],
-    ][] = [
-      [
-        'types + displayName',
-        { types: ['community', 'live'], sortBy: 'displayName' },
-        [channelDisplayName2, channelDisplayName1, channelDisplayName3, channelDisplayName4],
-        [channelDisplayName1, channelDisplayName2, channelDisplayName3],
-      ],
-    ];
-
-    test.each(filterCases)('it should filter by %s channels', async (_filter, params, expected) => {
-      const callback = jest.fn();
-      client.http.get = jest.fn().mockResolvedValue({
-        data: {
-          channels: [channelRaw1, rawDeletedChannel, rawTaggedChannel, rawTaggedChannel2],
-          channelUsers: [rawChannelUser],
-          files: [],
-          users: [user11],
-          ...mockPage,
-        },
-      });
-
-      getChannels(params, callback);
-
-      expect(callback).toHaveBeenCalledTimes(1);
-      // check if cache data returned (should be empty)
-      expect(callback).toHaveBeenCalledWith(expect.objectContaining(getSnapshot()));
-
-      await pause();
-
-      expect(callback).toHaveBeenCalledTimes(2);
-      expect(callback).toHaveBeenCalledWith(
-        expect.objectContaining(
-          getSnapshot({
-            loading: false,
-            data: expected,
-          }),
-        ),
-      );
-    });
-
-    test.each(sortingCases)('it should sort by %s', async (_filter, params, returned, expected) => {
-      const callback = jest.fn();
-      client.http.get = jest.fn().mockResolvedValue({
-        data: {
-          channels: returned,
-          channelUsers: [rawChannelUser],
-          files: [],
-          users: [user11],
-          ...mockPage,
-        },
-      });
-
-      getChannels(params, callback);
-
-      expect(callback).toHaveBeenCalledTimes(1);
-
-      await pause();
-
-      expect(callback).toHaveBeenCalledTimes(2);
-      expect(callback).toHaveBeenCalledWith(
-        expect.objectContaining(
-          getSnapshot({
-            loading: false,
-            data: expected.map(convertChannelFromRaw).map(getChannelMessagePreviewWithUser),
-          }),
-        ),
-      );
-    });
-
-    test.each(filterAndSortingCases)(
-      'it should filter and sort by %s',
-      async (_filter, params, returned, expected) => {
-        const callback = jest.fn();
-        client.http.get = jest.fn().mockResolvedValue({
-          data: {
-            channels: returned,
-            channelUsers: [rawChannelUser],
-            files: [],
-            users: [user11],
-            ...mockPage,
-          },
-        });
-
-        getChannels(params, callback);
-
-        expect(callback).toHaveBeenCalledTimes(1);
-
-        await pause();
-
-        expect(callback).toHaveBeenCalledTimes(2);
-        expect(callback).toHaveBeenCalledWith(
-          expect.objectContaining(
-            getSnapshot({
-              loading: false,
-              data: expected.map(convertChannelFromRaw).map(getChannelMessagePreviewWithUser),
-            }),
-          ),
-        );
-      },
-    );
-  });
-
-  test('when querying two channel collections using different parameters, the results from each collection remain distinct and do not overlap', async () => {
-    const callback = jest.fn();
-    const callback2 = jest.fn();
-    const callback1Response = [channelDisplayName2, channelDisplayName1, channelDisplayName3];
-    const callback1Expected = [channelDisplayName1, channelDisplayName2, channelDisplayName3];
-    const callback2Response = [channelCreatedAt3, channelCreatedAt2, channelCreatedAt1];
-
-    client.http.get = jest.fn().mockImplementation((_url: string, params) => {
-      if (!params.params.sortBy) {
-        return {
-          data: {
-            channels: callback2Response,
-            channelUsers: [rawChannelUser],
-            files: [],
-            users: [user11],
-            ...mockPage,
-          },
-        };
-      }
-      return {
-        data: {
-          channels: callback1Response,
-          channelUsers: [rawChannelUser],
-          files: [],
-          users: [user11],
-          ...mockPage,
-        },
-      };
-    });
-
-    getChannels({ types: ['community', 'live'], sortBy: 'displayName' }, callback);
-    getChannels({}, callback2);
-
-    expect(callback).toHaveBeenCalledTimes(1);
-
-    await pause(100);
-
-    expect(callback).toHaveBeenCalledTimes(2);
-    expect(callback).lastCalledWith(
-      expect.objectContaining(
-        getSnapshot({
-          loading: false,
-          data: callback1Expected.map(convertChannelFromRaw).map(getChannelMessagePreviewWithUser),
-        }),
-      ),
-    );
-
-    expect(callback2).lastCalledWith(
-      expect.objectContaining(
-        getSnapshot({
-          loading: false,
-          data: callback2Response.map(convertChannelFromRaw).map(getChannelMessagePreviewWithUser),
-        }),
-      ),
-    );
-
-    callback.mock.lastCall[0].onNextPage();
-
-    await pause(100);
-
-    expect(callback).lastCalledWith(
-      expect.objectContaining(
-        getSnapshot({
-          loading: false,
-          data: callback1Expected.map(convertChannelFromRaw).map(getChannelMessagePreviewWithUser),
-        }),
-      ),
-    );
-
-    expect(callback2).lastCalledWith(
-      expect.objectContaining(
-        getSnapshot({
-          loading: false,
-          data: callback2Response.map(convertChannelFromRaw).map(getChannelMessagePreviewWithUser),
-        }),
-      ),
-    );
-
-    callback2.mock.lastCall[0].onNextPage();
-
-    await pause(100);
-
-    expect(callback).lastCalledWith(
-      expect.objectContaining(
-        getSnapshot({
-          loading: false,
-          data: callback1Expected.map(convertChannelFromRaw).map(getChannelMessagePreviewWithUser),
-        }),
-      ),
-    );
-
-    expect(callback2).lastCalledWith(
-      expect.objectContaining(
-        getSnapshot({
-          loading: false,
-          data: callback2Response.map(convertChannelFromRaw).map(getChannelMessagePreviewWithUser),
-        }),
-      ),
-    );
-  });
-
-  test('when querying two channel collections using different parameters, pagination for each collection operates correctly and does not overlap or mix results', async () => {
-    const callback = jest.fn();
-    const callback2 = jest.fn();
-
-    const returnValue1Page1: Amity.RawChannel[] = [
-      generateRawChannel({ channelId: 'channelId1', isDeleted: false, type: 'community' }),
-      generateRawChannel({ channelId: 'channelId2', isDeleted: false, type: 'live' }),
-      generateRawChannel({ channelId: 'channelId3', isDeleted: false, type: 'broadcast' }),
-    ];
-
-    const returnValue1Page2: Amity.RawChannel[] = [
-      generateRawChannel({ channelId: 'channelId4', isDeleted: false }),
-      generateRawChannel({ channelId: 'channelId5', isDeleted: false }),
-    ];
-
-    const returnValue2Page1: Amity.RawChannel[] = [
-      generateRawChannel({ channelId: 'channelId36', tags: ['test'], displayName: '' }),
-      generateRawChannel({ channelId: 'channelId35', tags: ['test'], displayName: '' }),
-    ];
-
-    const returnValue2Page2: Amity.RawChannel[] = [
-      generateRawChannel({ channelId: 'channelId34', tags: ['test'], displayName: '' }),
-      generateRawChannel({ channelId: 'channelId33', tags: ['test'], displayName: '' }),
-    ];
-
-    const returnValue2Page3: Amity.RawChannel[] = [
-      generateRawChannel({ channelId: 'channelId32', tags: ['test'], displayName: '' }),
-      generateRawChannel({ channelId: 'channelId31', tags: ['test'], displayName: '' }),
-    ];
-
-    const spyGet = jest.spyOn(client.http, 'get').mockImplementation((url: string, params) => {
-      if (!params?.params.tags) {
-        if (params?.params?.options.token === 'eyJza2lwIjowLCJsaW1pdCI6MTB9') {
-          return Promise.resolve({
-            data: {
-              channels: returnValue1Page2,
-              channelUsers: [rawChannelUser],
-              files: [],
-              users: [user11],
-              ...mockPage,
-            },
-          });
-        }
-        return Promise.resolve({
-          data: {
-            channels: returnValue1Page1,
-            channelUsers: [rawChannelUser],
-            files: [],
-            users: [user11],
-            paging: {
-              next: 'eyJza2lwIjowLCJsaW1pdCI6MTB9',
-            },
-          },
-        });
-      }
-      if (params?.params?.options?.token === 'eyJza2lwIjowLCJsaW1pdCI6MTB9') {
-        return Promise.resolve({
-          data: {
-            channels: returnValue2Page2,
-            channelUsers: [rawChannelUser],
-            files: [],
-            users: [user11],
-            paging: {
-              previous: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDM5MTExMTAwMDAwMH0',
-              next: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDQ5MTExMTAwMDAwMH0=',
-            },
-          },
-        });
-      }
-      if (
-        params?.params?.options?.token ===
-        'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDQ5MTExMTAwMDAwMH0='
-      ) {
-        return Promise.resolve({
-          data: {
-            channels: returnValue2Page3,
-            channelUsers: [rawChannelUser],
-            files: [],
-            users: [user11],
-            paging: {
-              previous: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDM5MTExMTAwMDAwMH0',
-            },
-          },
-        });
-      }
-
-      return Promise.resolve({
-        data: {
-          channels: returnValue2Page1,
-          channelUsers: [rawChannelUser],
-          files: [],
-          users: [user11],
-          paging: {
-            next: 'eyJza2lwIjowLCJsaW1pdCI6MTB9',
-          },
-        },
-      });
-    });
-
-    getChannels({}, callback);
-    getChannels({ types: ['community', 'live'], tags: ['test'], sortBy: 'displayName' }, callback2);
-
-    expect(spyGet).toHaveBeenCalledWith('/api/v3/channels', {
-      params: {
-        options: { limit: 5 }, // default limit in SDK
-      },
-    });
-
-    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(convertChannelFromRaw).map(getChannelMessagePreviewWithUser),
-        error: undefined,
-        loading: false,
-      }),
-    );
-
-    expect(callback2).lastCalledWith(
-      expect.objectContaining({
-        data: returnValue2Page1.map(convertChannelFromRaw).map(getChannelMessagePreviewWithUser),
-        error: undefined,
-        loading: false,
-      }),
-    );
-
-    // get page 2 for live collection #2
-    callback2.mock.lastCall[0].onNextPage();
-
-    await pause(100);
-
-    // get page 3 for live collection #2
-    callback2.mock.lastCall[0].onNextPage();
-
-    await pause(100);
-
-    expect(callback.mock.calls.length).toBeGreaterThan(1);
-    expect(callback).lastCalledWith(
-      expect.objectContaining({
-        data: returnValue1Page1.map(convertChannelFromRaw).map(getChannelMessagePreviewWithUser),
-        error: undefined,
-        loading: false,
-      }),
-    );
-
-    expect(callback2.mock.calls.length).toBe(6);
-    expect(callback2).lastCalledWith(
-      expect.objectContaining({
-        data: [...returnValue2Page1, ...returnValue2Page2, ...returnValue2Page3]
-          .map(convertChannelFromRaw)
-          .map(getChannelMessagePreviewWithUser),
-        error: undefined,
-        loading: false,
-      }),
-    );
-
-    // get page 2 for live collection #1
-
-    callback.mock.lastCall[0].onNextPage();
-
-    await pause(100);
-
-    expect(callback).lastCalledWith(
-      expect.objectContaining({
-        data: [...returnValue1Page1, ...returnValue1Page2]
-          .map(convertChannelFromRaw)
-          .map(getChannelMessagePreviewWithUser),
-        error: undefined,
-        loading: false,
-      }),
-    );
-  });
-
-  test('it should return method to fetch next page', async () => {
-    const callback = jest.fn();
-    client.http.get = jest
-      .fn()
-      .mockResolvedValue(channelQueryResponse)
-      .mockResolvedValueOnce(channelQueryResponsePage2);
-
-    getChannels({}, callback);
-    await pause();
-
-    expect(callback).toHaveBeenCalled();
-    expect(callback.mock.lastCall).toHaveLength(1);
-
-    const { onNextPage, hasNextPage } = callback.mock.lastCall[0];
-
-    expect(hasNextPage).toBe(true);
-    expect(onNextPage).toBeTruthy();
-
-    onNextPage();
-    await pause();
-
-    // 4 -> because 1 local & server call each per call (2)
-    expect(callback).toHaveBeenCalledTimes(4);
-    expect(callback).toHaveBeenNthCalledWith(
-      4,
-      expect.objectContaining(
-        getSnapshot({
-          loading: false,
-          data: [
-            ...convertRawChannelPayload(channelQueryResponsePage2.data).channels.map(channel => {
-              return { ...channel, messagePreview: null };
-            }),
-            ...convertRawChannelPayload(channelQueryResponse.data).channels.map(channel => {
-              return { ...channel, messagePreview: null };
-            }),
-          ],
-        }),
-      ),
-    );
-  });
-
-  describe('events', () => {
-    const rawNewChannel = generateRawChannel({ channelId: 'new-channel-id' });
-
-    const rawUpdatedChannel = { ...channelRaw1, updatedAt: new Date().toISOString() };
-
-    const cases: [string, keyof Amity.Events, Amity.RawChannel, Amity.Channel[]][] = [
-      [
-        'it should add new channel to collection onCreate',
-        'channel.created',
-        rawNewChannel,
-        [{ ...convertChannelFromRaw(rawNewChannel), messagePreview: null }, channel1, channel2],
-      ],
-      [
-        'it should add new channel to collection onJoin',
-        'channel.joined',
-        rawNewChannel,
-        [{ ...convertChannelFromRaw(rawNewChannel), messagePreview: null }, channel1, channel2],
-      ],
-      [
-        'it should update channel in collection onUpdate',
-        'channel.updated',
-        rawUpdatedChannel,
-        [{ ...channel1, updatedAt: rawUpdatedChannel.updatedAt }, channel2],
-      ],
-      [
-        'it should update channel in collection onMuted',
-        'channel.setMuted',
-        { ...channelRaw1, isMuted: true },
-        [{ ...channel1, isMuted: true }, channel2],
-      ],
-      [
-        'it should remove channel from collection onDelete',
-        'channel.deleted',
-        { ...channelRaw1, isDeleted: true },
-        [channel2],
-      ],
-      [
-        'it should remove channel from collection onLeft',
-        'channel.left',
-        { ...channelRaw1, isDeleted: true },
-        [channel2],
-      ],
-    ];
-
-    test.each(cases)('%s', async (test, event, rawChannel, expected) => {
-      const callback = jest.fn();
-      client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
-
-      getChannels({ isDeleted: false }, callback);
-      await pause();
-      client.emitter.emit(event, {
-        channels: [rawChannel],
-        channelUsers: [rawChannelUser],
-        users: [],
-        files: [],
-      });
-      await pause();
-
-      expect(callback).toHaveBeenNthCalledWith(
-        3,
-        expect.objectContaining(
-          getSnapshot({
-            data: expected,
-            loading: false,
-          }),
-        ),
-      );
-    });
-
-    it('should add the channel to collection if user is added to the channel and member filter is applied', async () => {
-      const callback = jest.fn();
-      client.http.get = jest.fn().mockResolvedValue({
-        data: {
-          channels: [channelRaw2],
-          channelUsers: [rawChannelUser2],
-          files: [],
-          users: [user11],
-          ...mockPage,
-        },
-      });
-
-      getChannels({ membership: 'member' }, callback);
-      await pause();
-      client.emitter.emit('channel.membersAdded', {
-        channels: [channelRaw1],
-        channelUsers: [rawChannelUser],
-        users: [user11],
-        files: [],
-        messagePreviews: [],
-      });
-      await pause();
-
-      expect(callback).toHaveBeenNthCalledWith(
-        3,
-        expect.objectContaining(getSnapshot({ data: [channel1, channel2], loading: false })),
-      );
-    });
-
-    it('should add the channel to collection if user is removed from the channel and nonMember filter is applied', async () => {
-      const callback = jest.fn();
-      client.http.get = jest.fn().mockResolvedValue({
-        data: {
-          channels: [channelRaw2],
-          channelUsers: [],
-          files: [],
-          users: [user11],
-          ...mockPage,
-        },
-      });
-
-      getChannels({ membership: 'notMember' }, callback);
-      await pause();
-      client.emitter.emit('channel.membersRemoved', {
-        channels: [channelRaw1],
-        channelUsers: [{ ...rawChannelUser, membership: 'none' }],
-        users: [user11],
-        files: [],
-        messagePreviews: [],
-      });
-      await pause();
-
-      expect(callback).toHaveBeenNthCalledWith(
-        3,
-        expect.objectContaining(getSnapshot({ data: [channel1, channel2], loading: false })),
-      );
-    });
-
-    it('should add the channel to collection if tag is added to the channel and tags is applied', async () => {
-      const callback = jest.fn();
-      client.http.get = jest.fn().mockResolvedValue({
-        data: {
-          channels: [channelRaw2],
-          channelUsers: [rawChannelUser2],
-          files: [],
-          users: [user11],
-          ...mockPage,
-        },
-      });
-
-      getChannels({ tags: ['tag1'] }, callback);
-      await pause();
-      client.emitter.emit('channel.updated', {
-        channels: [{ ...channelRaw1, tags: ['tag1'] }],
-        channelUsers: [rawChannelUser],
-        users: [user11],
-        files: [],
-        messagePreviews: [],
-      });
-      await pause();
-
-      expect(callback).toHaveBeenNthCalledWith(
-        3,
-        expect.objectContaining(
-          getSnapshot({ data: [{ ...channel1, tags: ['tag1'] }, channel2], loading: false }),
-        ),
-      );
-    });
-
-    /**
-     * TODO: check if this test is valid, by checking event payload from the event that trigger this case
-     * check event payload community channel if it is the same as other channel
-     */
-
-    test.each([
-      [
-        'should remove the channel from the collection if user is removed from the channel and member filter is applied',
-        'channel.membersRemoved',
-      ],
-      [
-        'should remove the channel from the collection if user is left from the channel and member filter is applied',
-        'channel.left',
-      ],
-    ] as [string, keyof Amity.Events][])('%s', async (test, event) => {
-      const callback = jest.fn();
-      client.http.get = jest.fn().mockResolvedValue({
-        data: {
-          channels: [channelRaw1, channelRaw2],
-          channelUsers: [rawChannelUser, rawChannelUser2],
-          files: [],
-          users: [user11],
-          ...mockPage,
-        },
-      });
-
-      getChannels({ membership: 'member' }, callback);
-      await pause();
-      client.emitter.emit(event, {
-        channels: [channelRaw1],
-        channelUsers: [{ ...rawChannelUser, membership: 'none' }],
-        users: [user11],
-        files: [],
-      });
-      await pause();
-
-      expect(callback).toHaveBeenNthCalledWith(
-        3,
-        expect.objectContaining(getSnapshot({ data: [channel2], loading: false })),
-      );
-    });
-
-    /**
-     * TODO: check if this test is valid, by checking event payload from the event that trigger this case
-     * check event payload community channel if it is the same as other channel
-     */
-
-    test.each([
-      [
-        'should remove the channel from the collection if user is added to the channel and notMember filter is applied',
-        'channel.membersAdded',
-      ],
-      [
-        'should remove the channel from the collection if user is joined to the channel and notMember filter is applied',
-        'channel.joined',
-      ],
-    ] as [string, keyof Amity.Events][])('%s', async (test, event) => {
-      const callback = jest.fn();
-      client.http.get = jest.fn().mockResolvedValue({
-        data: {
-          channels: [channelRaw1, channelRaw2],
-          channelUsers: [],
-          files: [],
-          users: [user11],
-          ...mockPage,
-        },
-      });
-
-      getChannels({ membership: 'notMember' }, callback);
-      await pause();
-      client.emitter.emit('channel.membersAdded', {
-        channels: [channelRaw1],
-        channelUsers: [rawChannelUser],
-        users: [user11],
-        files: [],
-        messagePreviews: [],
-      });
-      await pause();
-
-      expect(callback).toHaveBeenNthCalledWith(
-        3,
-        expect.objectContaining(getSnapshot({ data: [channel2], loading: false })),
-      );
-    });
-  });
-
-  // TODO: re-enable this after implement marker-sync service
-  xit('should increase the unread count once message is created', async () => {
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue({
-      data: {
-        channels: [channelRaw1],
-        channelUsers: [rawChannelUser],
-        files: [],
-        users: [user11],
-        ...mockPage,
-      },
-    });
-
-    getChannels({}, callback);
-    await pause();
-    client.emitter.emit('message.created', {
-      messages: [
-        generateRawMessage({
-          channelPublicId: channelRaw1.channelId,
-          messageFeedId: channelRaw1._id,
-          segment: channelRaw1.messageCount + 1,
-        }),
-      ],
-      messageFeeds: [],
-      files: [],
-      users: [],
-      reactions: [],
-    });
-    await pause(500);
-
-    expect(callback).toHaveBeenNthCalledWith(
-      3,
-      expect.objectContaining(
-        getSnapshot({
-          data: [
-            {
-              ...channel1,
-              lastActivity: expect.anything(),
-              messageCount: channel1.messageCount + 1,
-              updatedAt: expect.anything(),
-            },
-          ],
-          loading: false,
-        }),
-      ),
-    );
-  });
-});
-
-describe('getChannels by channelIds', () => {
-  jest.spyOn(getChannelMarkers, 'getChannelMarkers').mockResolvedValue({
-    data: [],
-    cachedAt: undefined,
-  });
-
-  beforeAll(connectClient);
-  afterAll(disconnectClient);
-  beforeEach(enableCache);
-  afterEach(disableCache);
-
-  test('it should return channel collection when query by channelIds', async () => {
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue(channelQueryResponseWithoutPaging);
-
-    getChannels({}, callback);
-    await pause();
-
-    expect(callback).toHaveBeenCalledTimes(2);
-    expect(callback).toHaveBeenNthCalledWith(1, expect.objectContaining(getSnapshot()));
-    expect(callback).toHaveBeenNthCalledWith(
-      2,
-      expect.objectContaining(
-        getSnapshot({
-          data: convertRawChannelPayload(channelQueryResponse.data).channels.map(channel => {
-            return { ...channel, messagePreview: null };
-          }),
-          loading: false,
-        }),
-      ),
-    );
-  });
-
-  describe('events', () => {
-    const rawNewChannel = generateRawChannel({ channelId: 'new-channel-id' });
-
-    const rawUpdatedChannel = { ...channelRaw1, updatedAt: new Date().toISOString() };
-
-    const cases: [string, keyof Amity.Events, Amity.RawChannel, Amity.Channel[]][] = [
-      [
-        'it should not add new channel to collection onCreate',
-        'channel.created',
-        rawNewChannel,
-        [channel1, channel2],
-      ],
-      [
-        'it should not add new channel to collection onJoin',
-        'channel.joined',
-        rawNewChannel,
-        [channel1, channel2],
-      ],
-      [
-        'it should update channel in collection onUpdate',
-        'channel.updated',
-        rawUpdatedChannel,
-        [{ ...channel1, updatedAt: rawUpdatedChannel.updatedAt }, channel2],
-      ],
-      [
-        'it should update channel in collection onMuted',
-        'channel.setMuted',
-        { ...channelRaw1, isMuted: true },
-        [{ ...channel1, isMuted: true }, channel2],
-      ],
-      [
-        'it should not remove channel from collection onDelete',
-        'channel.deleted',
-        { ...channelRaw1, isDeleted: true },
-        [channel1, channel2],
-      ],
-      [
-        'it should not remove channel from collection onLeft',
-        'channel.left',
-        { ...channelRaw1, isDeleted: true },
-        [channel1, channel2],
-      ],
-    ];
-
-    test.each(cases)('%s', async (test, event, rawChannel, expected) => {
-      const callback = jest.fn();
-      client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
-
-      getChannels({ channelIds: [channelRaw1._id, channelRaw2._id] }, callback);
-      await pause();
-      client.emitter.emit(event, {
-        channels: [rawChannel],
-        channelUsers: [rawChannelUser],
-        users: [],
-        files: [],
-      });
-      await pause();
-
-      expect(callback).toHaveBeenNthCalledWith(
-        event === 'channel.updated' || event === 'channel.setMuted' ? 3 : 2,
-        expect.objectContaining(
-          getSnapshot({
-            data: expected,
-            loading: false,
-          }),
-        ),
-      );
-    });
-  });
-});