@amityco/ts-sdk 0.0.1-beta.42.2 → 0.0.1-beta.43

package/src/channel/api/tests/createChannel.test.ts

@@ -2,45 +2,62 @@ import { disableCache, enableCache, pullFromCache } from '~/cache/api';
 import {
   channelPayload,
   client,
+  connectClient,
   conversationChannelPayload,
+  convertRawChannelPayload,
+  disconnectClient,
   liveChannelPayload,
   rawChannelPayload,
 } from '~/utils/tests';
-import { prepareChannelPayload } from '~/channel/utils';
 
 import { createChannel } from '../createChannel';
 
 const resPayload = { data: rawChannelPayload };
 
 describe('createChannel', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
   // integration_test_id: 9d80fd54-9e6d-454d-8344-6f9436b8e495
   test('it should create a channel for community', async () => {
     client.http.post = jest.fn().mockResolvedValueOnce(resPayload);
 
+    const {
+      channels: [expected],
+    } = convertRawChannelPayload(rawChannelPayload);
+
     const res = await createChannel({ type: 'community' });
 
     expect(res).toBeDefined();
-    expect(res.data).toStrictEqual(prepareChannelPayload(rawChannelPayload).channels[0]);
+    expect(res.data).toStrictEqual(expected);
   });
 
   // integration_test_id: cef520ab-027d-4c5b-836c-a7f63ddc5146
   test('it should create a channel for live', async () => {
     client.http.post = jest.fn().mockResolvedValueOnce({ data: liveChannelPayload });
 
+    const {
+      channels: [expected],
+    } = convertRawChannelPayload(liveChannelPayload);
+
     const res = await createChannel({ type: 'live' });
 
     expect(res).toBeDefined();
-    expect(res.data).toStrictEqual(prepareChannelPayload(liveChannelPayload).channels[0]);
+    expect(res.data).toStrictEqual(expected);
   });
 
   // integration_test_id: 11a43612-ff6f-4262-874c-4419d342cff1
   test('it should create a channel for conversation', async () => {
     client.http.post = jest.fn().mockResolvedValueOnce({ data: conversationChannelPayload });
 
+    const {
+      channels: [expected],
+    } = convertRawChannelPayload(conversationChannelPayload);
+
     const res = await createChannel({ type: 'conversation' });
 
     expect(res).toBeDefined();
-    expect(res.data).toStrictEqual(prepareChannelPayload(conversationChannelPayload).channels[0]);
+    expect(res.data).toStrictEqual(expected);
   });
 
   test('it should add channel to cache', async () => {
@@ -49,11 +66,15 @@ describe('createChannel', () => {
     client.http.post = jest.fn().mockResolvedValueOnce(resPayload);
     const { channelId } = channelPayload.channels[0];
 
+    const {
+      channels: [expected],
+    } = convertRawChannelPayload(rawChannelPayload);
+
     await createChannel({ type: 'community' });
     const data = pullFromCache(['channel', 'get', channelId]);
 
     expect(data).toBeDefined();
-    expect(data?.data).toStrictEqual(prepareChannelPayload(rawChannelPayload).channels[0]);
+    expect(data?.data).toStrictEqual(expected);
 
     disableCache();
   });
@@ -65,10 +86,10 @@ describe('createChannel', () => {
     const expectedPayload = { type: 'conversation', isDistinct: true };
 
     await createChannel({ type: 'conversation' });
-    const [recieved, recievedPayload] = mockFn.mock.lastCall;
+    const [received, receivedPayload] = mockFn.mock.lastCall;
 
-    expect(recieved).toBe(expected);
-    expect(recievedPayload).toStrictEqual(expectedPayload);
+    expect(received).toBe(expected);
+    expect(receivedPayload).toStrictEqual(expectedPayload);
   });
 
   test('it should return an error', async () => {

package/src/channel/api/tests/getChannel.test.ts

@@ -1,18 +1,25 @@
 import { ASCApiError } from '~/core/errors';
 import { disableCache, enableCache, pushToCache } from '~/cache/api';
-import { client, channelQueryResponse } from '~/utils/tests';
+import {
+  client,
+  channelQueryResponse,
+  convertRawChannelPayload,
+  connectClient,
+  disconnectClient,
+} from '~/utils/tests';
 
 import { pushToTombstone } from '~/cache/api/pushToTombstone';
 import { isInTombstone } from '~/cache/api/isInTombstone';
 
-import { prepareChannelPayload } from '~/channel/utils';
-
 import { getChannel } from '../getChannel';
 
 const { channelId } = channelQueryResponse.data.channels[0];
-const channel = prepareChannelPayload(channelQueryResponse.data).channels[0];
+const channel = convertRawChannelPayload(channelQueryResponse.data).channels[0];
 
 describe('getChannel', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
   // integration_test_id: b331e01c-20db-4f17-979b-b280d8818792
   test('it should return a valid channel', async () => {
     client.http.get = jest.fn().mockResolvedValueOnce(channelQueryResponse);

package/src/channel/api/tests/getChannels.test.ts

@@ -1,23 +1,31 @@
-import { disableCache, enableCache, pushToCache, pullFromCache } from '~/cache/api';
-import { client, getChannelsResponse } from '~/utils/tests';
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import {
+  client,
+  connectClient,
+  convertRawChannelPayload,
+  disconnectClient,
+  getChannelsResponse,
+} from '~/utils/tests';
+import { ASCApiError } from '~/core/errors';
 
 import { getChannels } from '../getChannels';
-import { prepareChannelPayload } from '~/channel/utils';
-import { ASCApiError } from '~/core/errors';
 
 const channelIds = [
   getChannelsResponse.data.channels[0].channelId,
   getChannelsResponse.data.channels[1].channelId,
   getChannelsResponse.data.channels[2].channelId,
 ];
-const channel = prepareChannelPayload(getChannelsResponse.data).channels;
+const { channels } = convertRawChannelPayload(getChannelsResponse.data);
 
 describe('getChannels', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
   // integration_test_id: ced0cd3b-1714-499d-862e-0284da1c8bb1
   test('it should return a valid channels', async () => {
     client.http.get = jest.fn().mockResolvedValueOnce(getChannelsResponse);
 
-    const expected = channel;
+    const expected = channels;
     const { data: received } = await getChannels(channelIds);
 
     expect(received).toStrictEqual(expected);
@@ -31,7 +39,7 @@ describe('getChannels', () => {
     const data = getChannels.locally(channelIds);
 
     expect(data).toBeDefined();
-    expect(data?.data).toEqual(channel);
+    expect(data?.data).toEqual(channels);
 
     disableCache();
   });
@@ -56,14 +64,14 @@ describe('getChannels locally', () => {
 
     const cachedAt = Date.now();
 
-    pushToCache(['channel', 'get', channelIds[0]], channel[0], { cachedAt });
-    pushToCache(['channel', 'get', channelIds[1]], channel[1], { cachedAt });
-    pushToCache(['channel', 'get', channelIds[2]], channel[2], { cachedAt });
+    pushToCache(['channel', 'get', channelIds[0]], channels[0], { cachedAt });
+    pushToCache(['channel', 'get', channelIds[1]], channels[1], { cachedAt });
+    pushToCache(['channel', 'get', channelIds[2]], channels[2], { cachedAt });
 
     const data = getChannels.locally(channelIds);
 
     expect(data).toBeDefined();
-    expect(data?.data).toEqual(channel);
+    expect(data?.data).toEqual(channels);
     expect(data?.cachedAt).toEqual(cachedAt);
 
     disableCache();
@@ -84,9 +92,9 @@ describe('getChannels locally', () => {
 
     const cachedAt = Date.now();
 
-    pushToCache(['channel', 'get', channelIds[0]], channel[0], { cachedAt });
-    pushToCache(['channel', 'get', channelIds[1]], channel[1], { cachedAt: cachedAt + 1 });
-    pushToCache(['channel', 'get', channelIds[2]], channel[2], { cachedAt: cachedAt + 2 });
+    pushToCache(['channel', 'get', channelIds[0]], channels[0], { cachedAt });
+    pushToCache(['channel', 'get', channelIds[1]], channels[1], { cachedAt: cachedAt + 1 });
+    pushToCache(['channel', 'get', channelIds[2]], channels[2], { cachedAt: cachedAt + 2 });
 
     const data = getChannels.locally(channelIds);
 

package/src/channel/api/tests/queryChannelMembers.test.ts

@@ -3,12 +3,21 @@ import { getResolver } from '~/core/model';
 import { disableCache, enableCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
-import { prepareChannelPayload } from '~/channel/utils';
-import { client, channelUserQueryResponse, channelUserModel } from '~/utils/tests';
+import {
+  client,
+  channelUserQueryResponse,
+  channelUserModel,
+  convertRawChannelPayload,
+  connectClient,
+  disconnectClient,
+} from '~/utils/tests';
 
 import { queryChannelMembers } from '../queryChannelMembers';
 
 describe('queryChannelMembers', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
   const { channelId } = channelUserQueryResponse.data.channels[0];
 
   // integration_test_id: 1e5a4b11-a7f3-496e-a594-22b10ed28a20
@@ -63,7 +72,7 @@ describe('queryChannelMembers.locally', () => {
     enableCache();
 
     const { paging, ...payload } = channelUserQueryResponse.data;
-    const preparedPayload = prepareChannelPayload(payload);
+    const preparedPayload = convertRawChannelPayload(payload);
     const { channelUsers } = preparedPayload;
 
     ingestInCache(preparedPayload);
@@ -90,7 +99,7 @@ describe('queryChannelMembers.locally', () => {
     enableCache();
 
     const { paging, ...payload } = channelUserQueryResponse.data;
-    const preparedPayload = prepareChannelPayload(payload);
+    const preparedPayload = convertRawChannelPayload(payload);
     const { channelUsers } = preparedPayload;
 
     // ingest incomplete data

package/src/channel/api/tests/queryChannels.test.ts

@@ -3,20 +3,25 @@ import { getResolver } from '~/core/model';
 import { disableCache, enableCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
-import { prepareChannelPayload } from '~/channel/utils';
 import {
   client,
   channelQueryResponse,
   channelTagQueryResponse,
   channelExcludeTagQueryResponse,
+  convertRawChannelPayload,
+  connectClient,
+  disconnectClient,
 } from '~/utils/tests';
 
 import { queryChannels } from '../queryChannels';
 
 describe('queryChannels', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
   // integration_test_id: 06c14dab-4799-4f26-9e52-be7c12b3bdb3
   test('it should return channels', async () => {
-    const expected = prepareChannelPayload(channelQueryResponse.data).channels;
+    const { channels: expected } = convertRawChannelPayload(channelQueryResponse.data);
     client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
 
     const { data } = await queryChannels();
@@ -28,25 +33,30 @@ describe('queryChannels', () => {
   test('it should return channels match with membership type', async () => {
     // Actually there is no any flag to tell about this list is relate to membership type
     // But need to implement this case to match with our test list
-    const expected = prepareChannelPayload(channelQueryResponse.data).channels;
+    const { channels: expected } = convertRawChannelPayload(channelQueryResponse.data);
     client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
+
     const { data } = await queryChannels({ membership: 'member' });
+
     expect(data).toEqual(expected);
   });
 
   // integration_test_id: 92329d41-9403-44e7-979f-ed227e6ab120
   test('it should return channels match with tags query type', async () => {
-    const expected = prepareChannelPayload(channelTagQueryResponse.data).channels;
+    const { channels: expected } = convertRawChannelPayload(channelTagQueryResponse.data);
     client.http.get = jest.fn().mockResolvedValue(channelTagQueryResponse);
+
     const { data } = await queryChannels({ tags: ['tag1'] });
+
     expect(data).toEqual(expected);
     expect(data[0].tags).toContain('tag1');
   });
 
   // integration_test_id: 5249778c-6d99-4e2f-9b80-2f4ea6ae1833
   test('it should return channels without tags which defined in exclude options', async () => {
-    const expected = prepareChannelPayload(channelExcludeTagQueryResponse.data).channels;
+    const { channels: expected } = convertRawChannelPayload(channelExcludeTagQueryResponse.data);
     client.http.get = jest.fn().mockResolvedValue(channelExcludeTagQueryResponse);
+
     const { data } = await queryChannels({ excludeTags: ['tag1'] });
     expect(data).toEqual(expected);
 
@@ -82,7 +92,7 @@ describe('queryChannels.locally', () => {
     enableCache();
 
     const { paging, ...payload } = channelQueryResponse.data;
-    const data = prepareChannelPayload(payload);
+    const data = convertRawChannelPayload(payload);
     const { channels } = data;
 
     ingestInCache(data);
@@ -101,7 +111,7 @@ describe('queryChannels.locally', () => {
     enableCache();
 
     const { paging, ...payload } = channelQueryResponse.data;
-    const data = prepareChannelPayload(payload);
+    const data = convertRawChannelPayload(payload);
     const { channels } = data;
 
     // ingest incomplete data
@@ -127,9 +137,9 @@ describe('queryChannels.locally', () => {
 
     const { data } = channelQueryResponse;
     const { paging, ...payload } = data;
-    const { channels: expected } = prepareChannelPayload(payload);
+    const { channels: expected } = convertRawChannelPayload(payload);
 
-    ingestInCache(prepareChannelPayload(data));
+    ingestInCache(convertRawChannelPayload(data));
 
     pushToCache(cacheKey, { channels: payload.channels.map(getResolver('channel')), paging });
 

package/src/channel/api/unbanChannelMembers.ts

@@ -35,7 +35,7 @@ export const unbanChannelMembers = async (
     },
   );
 
-  const preparedPayload = prepareChannelPayload(payload);
+  const preparedPayload = await prepareChannelPayload(payload);
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(preparedPayload, { cachedAt });

package/src/channel/api/updateChannel.ts

@@ -34,7 +34,7 @@ export const updateChannel = async (
     patch,
   );
 
-  const data = prepareChannelPayload(payload);
+  const data = await prepareChannelPayload(payload);
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });

package/src/channel/events/onChannelCreated.ts

@@ -23,8 +23,8 @@ import { prepareChannelPayload } from '../utils';
 export const onChannelCreated = (callback: Amity.Listener<Amity.Channel>) => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.ChannelPayload) => {
-    const data = prepareChannelPayload(payload);
+  const filter = async (payload: Amity.ChannelPayload) => {
+    const data = await prepareChannelPayload(payload);
 
     ingestInCache(data);
     callback(data.channels[0]);

package/src/channel/events/onChannelDeleted.ts

@@ -1,9 +1,9 @@
-import { getActiveClient } from '~/client/api';
 import { createEventSubscriber } from '~/core/events';
 
+import { getActiveClient } from '~/client/api/activeClient';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
-import { prepareChannelPayload } from '../utils';
+import { prepareChannelPayload } from '../utils/prepareChannelPayload';
 
 /**
  * ```js
@@ -23,8 +23,8 @@ import { prepareChannelPayload } from '../utils';
 export const onChannelDeleted = (callback: Amity.Listener<Amity.Channel>) => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.ChannelPayload) => {
-    const data = prepareChannelPayload(payload);
+  const filter = async (payload: Amity.ChannelPayload) => {
+    const data = await prepareChannelPayload(payload);
 
     ingestInCache(data);
     callback(data.channels[0]);

package/src/channel/events/onChannelJoined.ts

@@ -25,8 +25,8 @@ export const onChannelJoined = (
 ) => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.ChannelMembershipPayload) => {
-    const preparedPayload = prepareChannelPayload(payload);
+  const filter = async (payload: Amity.ChannelMembershipPayload) => {
+    const preparedPayload = await prepareChannelPayload(payload);
     const { channels, channelUsers } = preparedPayload;
 
     ingestInCache(preparedPayload);

package/src/channel/events/onChannelLeft.ts

@@ -25,8 +25,8 @@ export const onChannelLeft = (
 ) => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.ChannelMembershipPayload) => {
-    const preparedPayload = prepareChannelPayload(payload);
+  const filter = async (payload: Amity.ChannelMembershipPayload) => {
+    const preparedPayload = await prepareChannelPayload(payload);
     const { channels, channelUsers } = preparedPayload;
 
     ingestInCache(preparedPayload);

package/src/channel/events/onChannelMemberAdded.ts

@@ -24,8 +24,8 @@ export const onChannelMemberAdded = (
 ): Amity.Unsubscriber => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.ChannelMembershipPayload) => {
-    const preparedPayload = prepareChannelPayload(payload);
+  const filter = async (payload: Amity.ChannelMembershipPayload) => {
+    const preparedPayload = await prepareChannelPayload(payload);
     const { channels, channelUsers } = preparedPayload;
 
     ingestInCache(preparedPayload);

package/src/channel/events/onChannelMemberBanned.ts

@@ -1,6 +1,6 @@
-import { getActiveClient } from '~/client/api';
 import { createEventSubscriber } from '~/core/events';
 
+import { getActiveClient } from '~/client/api/activeClient';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
 import { prepareChannelPayload } from '../utils';
@@ -25,8 +25,8 @@ export const onChannelMemberBanned = (
 ) => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.ChannelMembershipPayload) => {
-    const preparedPayload = prepareChannelPayload(payload);
+  const filter = async (payload: Amity.ChannelMembershipPayload) => {
+    const preparedPayload = await prepareChannelPayload(payload);
     const { channels, channelUsers } = preparedPayload;
 
     ingestInCache(preparedPayload);

package/src/channel/events/onChannelMemberRemoved.ts

@@ -25,8 +25,8 @@ export const onChannelMemberRemoved = (
 ) => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.ChannelMembershipPayload) => {
-    const preparedPayload = prepareChannelPayload(payload);
+  const filter = async (payload: Amity.ChannelMembershipPayload) => {
+    const preparedPayload = await prepareChannelPayload(payload);
     const { channels, channelUsers } = preparedPayload;
 
     ingestInCache(preparedPayload);

package/src/channel/events/onChannelMemberUnbanned.ts

@@ -25,8 +25,8 @@ export const onChannelMemberUnbanned = (
 ) => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.ChannelMembershipPayload) => {
-    const preparedPayload = prepareChannelPayload(payload);
+  const filter = async (payload: Amity.ChannelMembershipPayload) => {
+    const preparedPayload = await prepareChannelPayload(payload);
     const { channels, channelUsers } = preparedPayload;
 
     ingestInCache(preparedPayload);

package/src/channel/events/onChannelMuted.ts

@@ -23,8 +23,8 @@ import { prepareChannelPayload } from '../utils';
 export const onChannelMuted = (callback: Amity.Listener<Amity.Channel>) => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.ChannelPayload) => {
-    const data = prepareChannelPayload(payload);
+  const filter = async (payload: Amity.ChannelPayload) => {
+    const data = await prepareChannelPayload(payload);
 
     ingestInCache(data);
     callback(data.channels[0]);

package/src/channel/events/onChannelUpdated.ts

@@ -1,9 +1,10 @@
+import { pullFromCache, upsertInCache } from '~/cache/api';
 import { getActiveClient } from '~/client/api';
 import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
-import { prepareChannelPayload } from '../utils';
+import { prepareChannelPayload, updateChannelMarker } from '../utils';
 
 /**
  * ```js
@@ -23,18 +24,38 @@ import { prepareChannelPayload } from '../utils';
 export const onChannelUpdated = (callback: Amity.Listener<Amity.Channel>) => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.ChannelPayload) => {
-    const data = prepareChannelPayload(payload);
+  const filter = async (payload: Amity.ChannelPayload) => {
+    const data = await prepareChannelPayload(payload);
 
     ingestInCache(data);
     callback(data.channels[0]);
   };
 
+  const channelMarkerChangeHandler = async (
+    rawPayload: MakeRequired<Amity.ChannelMarkerPayload, 'userEntityMarkers'>,
+  ) => {
+    const marker = rawPayload.userEntityMarkers[0];
+    const cacheKey = ['channel', 'get', marker.entityId];
+    const channel = pullFromCache<Amity.Channel>(cacheKey)?.data;
+
+    if (!channel) return;
+
+    const updated = updateChannelMarker(channel, marker);
+    upsertInCache(cacheKey, updated);
+    callback(updated);
+  };
+
   const disposers = [
     createEventSubscriber(client, 'onChannelUpdated', 'channel.updated', filter),
-    createEventSubscriber(client, 'local.channel.updated', 'local.channel.updated', payload =>
+    createEventSubscriber(client, 'onChannelUpdated', 'local.channel.updated', payload =>
       callback(payload.channels[0]),
     ),
+    createEventSubscriber(
+      client,
+      'onChannelUpdated',
+      'local.channelMarker.fetched',
+      channelMarkerChangeHandler,
+    ),
   ];
 
   return () => {

package/src/channel/events/tests/onChannelCreated.test.ts

@@ -5,6 +5,7 @@ import {
   client,
   connectClient,
   disconnectClient,
+  pause,
   rawChannelUser,
   user11,
 } from '~/utils/tests';
@@ -30,12 +31,14 @@ describe('onChannelCreated event', () => {
     users: [user11],
   };
 
-  test('it should call callback when channel have created', () => {
+  test('it should call callback when channel have created', async () => {
     const callback = jest.fn();
 
     const unsub = onChannelCreated(callback);
     client.emitter.emit('channel.created', channelPayload);
 
+    await pause();
+
     unsub();
 
     expect(callback).toHaveBeenCalled();

package/src/channel/events/tests/onChannelJoined.test.ts

@@ -6,9 +6,11 @@ import {
   client,
   connectClient,
   disconnectClient,
+  pause,
   rawChannelUser,
   user11,
 } from '~/utils/tests';
+
 import { onChannelJoined } from '../onChannelJoined';
 
 describe('onChannelJoined event', () => {
@@ -31,12 +33,14 @@ describe('onChannelJoined event', () => {
     users: [user11],
   };
 
-  test('it should call callback when have someone joined channel', () => {
+  test('it should call callback when have someone joined channel', async () => {
     const callback = jest.fn();
 
     const unsub = onChannelJoined(callback);
     client.emitter.emit('channel.joined', channelPayload);
 
+    await pause();
+
     unsub();
 
     expect(callback).toHaveBeenCalled();

package/src/channel/events/tests/onChannelMemberAdded.test.ts

@@ -8,7 +8,9 @@ import {
   rawChannelUser,
   channelRaw1,
   channelUser,
+  pause,
 } from '~/utils/tests';
+
 import { onChannelMemberAdded } from '../onChannelMemberAdded';
 
 describe('onChannelMemberAdded event', () => {
@@ -31,12 +33,14 @@ describe('onChannelMemberAdded event', () => {
     users: [user11],
   };
 
-  test('it should call callback when have someone add member to channel', () => {
+  test('it should call callback when have someone add member to channel', async () => {
     const callback = jest.fn();
 
     const unsub = onChannelMemberAdded(callback);
     client.emitter.emit('channel.membersAdded', channelPayload);
 
+    await pause();
+
     unsub();
 
     expect(callback).toHaveBeenCalled();

package/src/channel/events/tests/onChannelMemberBanned.test.ts

@@ -10,6 +10,7 @@ import {
   user11,
   user13,
   channelRaw1,
+  pause,
 } from '~/utils/tests';
 
 import { onChannelMemberBanned } from '../onChannelMemberBanned';
@@ -34,12 +35,14 @@ describe('onChannelMemberBanned event', () => {
     users: [user11, user13],
   };
 
-  test('it should call callback with channel and banned member', () => {
+  test('it should call callback with channel and banned member', async () => {
     const callback = jest.fn();
 
     const unsub = onChannelMemberBanned(callback);
     client.emitter.emit('channel.banned', channelPayload);
 
+    await pause();
+
     unsub();
 
     expect(callback).toHaveBeenCalled();