@amityco/ts-sdk 0.0.1-beta.28 → 0.0.1-beta.29

package/src/follow/tests/observers/liveFollowings.test.ts

@@ -0,0 +1,239 @@
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+
+import { queryFollowings } from '../../api/queryFollowings';
+import { liveFollowings } from '../../observers/liveFollowings';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  follows,
+  encodeJson,
+  follow11,
+} from '~/utils/tests';
+
+const getSnapshot = () => {
+  return {
+    loading: true,
+    error: undefined as any,
+    data: [] as Amity.FollowStatus[],
+  };
+};
+
+describe('liveFollowings', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  const { userId } = follows;
+  const args: Amity.FollowingLiveCollection = { userId };
+
+  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 liveFollowings check if mocked console get's called with the correct
+    // message
+    client.use();
+    liveFollowings(args, callback);
+
+    expect(console.log).toBeCalledWith(ENABLE_CACHE_MESSAGE);
+  });
+
+  test('it should return following collection', async () => {
+    const snapshot = getSnapshot();
+    const response = { data: { paging: {}, follows: follows.page1 } };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    liveFollowings(args, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await expect(queryFollowings(args)).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    snapshot.loading = false;
+    snapshot.data = response.data.follows;
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+  });
+
+  test('it should return error on api failure', async () => {
+    const snapshot = getSnapshot();
+    const error = new ASCApiError(
+      'server error!',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockRejectedValue(error);
+
+    liveFollowings(args, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await expect(queryFollowings(args)).rejects.toThrow();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    snapshot.error = error;
+    snapshot.loading = false;
+    expect(callback).toHaveBeenLastCalledWith(expect.objectContaining(snapshot));
+  });
+
+  const statusFilters: [string, Amity.FollowingLiveCollection][] = [
+    ['all', { ...args, status: 'all', limit: 10 }],
+    ['accepted', { ...args, status: 'accepted', limit: 10 }],
+    ['pending', { ...args, status: 'pending', limit: 10 }],
+  ];
+
+  test.each(statusFilters)('it should filter %s follows based on param', async (filter, params) => {
+    const snapshot = getSnapshot();
+    const response = { data: { paging: {}, follows: follows.page1 } };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    liveFollowings(params, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    // TODO : why ts gives no shit about args here ? wrong type :D
+    const query = queryFollowings(params);
+
+    await expect(query).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    snapshot.loading = false;
+    snapshot.data =
+      filter === 'all'
+        ? response.data.follows
+        : response.data.follows.filter(fl => fl.status === filter);
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+  });
+
+  test('it should return method to fetch next page', async () => {
+    const snapshot = getSnapshot();
+    const args: Amity.FollowingLiveCollection = { userId, limit: 3 };
+    const next = encodeJson({
+      limit: 3,
+      before: follows.page1[2].from,
+      updatedAt: follows.page1[2].updatedAt,
+    });
+
+    const response = { data: { follows: follows.page2, paging: {} } };
+    const responseWithNextPage = { data: { follows: follows.page1, paging: { next } } };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(responseWithNextPage);
+
+    liveFollowings(args, callback);
+
+    expect(callback).toHaveBeenCalled();
+
+    await expect(queryFollowings(args)).resolves.toBeTruthy();
+
+    expect(callback.mock.lastCall).toHaveLength(1);
+
+    const { onNextPage, hasNextPage } = callback.mock.lastCall[0];
+
+    expect(hasNextPage).toBe(true);
+    expect(onNextPage).toBeTruthy();
+
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    onNextPage();
+
+    await expect(queryFollowings(args)).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(4);
+
+    snapshot.loading = false;
+    snapshot.data = [...responseWithNextPage.data.follows, ...response.data.follows];
+    expect(callback).toHaveBeenNthCalledWith(4, expect.objectContaining(snapshot));
+  });
+
+  const createEvents: [keyof Amity.Events][] = [
+    ['follow.created'],
+    ['follow.requested'],
+    ['follow.accepted'],
+  ];
+
+  test.each(createEvents)('it should add new follow to collection on %s', async event => {
+    const snapshot = getSnapshot();
+    const newFollowing: Amity.FollowStatus = {
+      ...follow11,
+      to: 'some-user',
+    };
+    const response = { data: { follows: follows.page1, paging: {} } };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    liveFollowings(args, callback);
+
+    await expect(queryFollowings(args)).resolves.toBeTruthy();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    client.emitter.emit(event, { follows: [newFollowing] });
+
+    snapshot.loading = false;
+    snapshot.data = [newFollowing, ...response.data.follows];
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+
+  const removeEvents: [keyof Amity.Events][] = [
+    ['follow.requestDeclined'],
+    ['follow.requestCanceled'],
+    ['follow.unfollowed'],
+    ['follow.followerDeleted'],
+  ];
+
+  test.each(removeEvents)('it should remove a follow to collection on %s', async event => {
+    const snapshot = getSnapshot();
+    const response = { data: { follows: follows.page1, paging: {} } };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    liveFollowings(args, callback);
+
+    await expect(queryFollowings(args)).resolves.toBeTruthy();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    client.emitter.emit(event, { follows: [response.data.follows[0]] });
+
+    const [first, ...data] = response.data.follows;
+
+    snapshot.data = data;
+    snapshot.loading = false;
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+});

package/src/message/observers/tests/liveMessages.test.ts

@@ -1,15 +1,37 @@
-import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
 import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
 
 import { liveMessages } from '../liveMessages';
-
-import { client, messages } from '~/utils/tests';
 import { queryMessages } from '~/message/api';
 
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  messages,
+  message as defaultMessage,
+} from '~/utils/tests';
+
 describe('liveMessages', () => {
-  beforeEach(enableCache);
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(async () => {
+    enableCache();
+  });
+
   afterEach(disableCache);
 
+  const { channelId } = messages;
+  const returnValue = [{ messageId: messages.page1[0] }];
+  const message = { ...defaultMessage, messageId: returnValue[0].messageId, channelId };
+
   test('it should show message if cache not enabled', () => {
     /*
      * NOTE: at the time of writing this test cache is diabled by default, but
@@ -25,14 +47,12 @@ describe('liveMessages', () => {
     // call liveMessages check if mocked console get's called with the correct
     // message
     client.use();
-    liveMessages({ channelId: messages.channelId }, callback);
+    liveMessages({ channelId }, callback);
 
     expect(console.log).toBeCalledWith(ENABLE_CACHE_MESSAGE);
   });
 
   test('it should return message collection', async () => {
-    const returnValue = [{ messageId: messages.page1[0] }];
-
     // mock response of queryMessages and validate
     const callback = jest.fn();
     client.http.get = jest.fn().mockResolvedValue({
@@ -42,7 +62,7 @@ describe('liveMessages', () => {
       },
     });
 
-    liveMessages({ channelId: messages.channelId }, callback);
+    liveMessages({ channelId }, callback);
 
     expect(callback).toHaveBeenCalledTimes(1);
 
@@ -55,7 +75,7 @@ describe('liveMessages', () => {
       }),
     );
 
-    await expect(queryMessages({ channelId: messages.channelId })).resolves.toBeTruthy();
+    await expect(queryMessages({ channelId })).resolves.toBeTruthy();
 
     expect(callback).toHaveBeenCalledTimes(2);
 
@@ -68,6 +88,43 @@ describe('liveMessages', () => {
     );
   });
 
+  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);
+
+    liveMessages({ channelId }, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: [],
+        error: undefined,
+        loading: true,
+      }),
+    );
+
+    await expect(queryMessages({ channelId })).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 = [
@@ -84,7 +141,7 @@ describe('liveMessages', () => {
       },
     });
 
-    liveMessages({ channelId: messages.channelId, isDeleted: false }, callback);
+    liveMessages({ channelId, isDeleted: false }, callback);
 
     expect(callback).toHaveBeenCalledTimes(1);
 
@@ -97,7 +154,7 @@ describe('liveMessages', () => {
       }),
     );
 
-    await expect(queryMessages({ channelId: messages.channelId })).resolves.toBeTruthy();
+    await expect(queryMessages({ channelId })).resolves.toBeTruthy();
 
     expect(callback).toHaveBeenCalledTimes(2);
 
@@ -111,23 +168,146 @@ describe('liveMessages', () => {
   });
 
   test('it should return method to fetch next page', async () => {
-    // mock nextPage()
-  });
+    const returnValue2 = [{ messageId: messages.page2[0] }];
+
+    const callback = jest.fn();
+    client.http.get = jest
+      .fn()
+      .mockResolvedValue({
+        data: {
+          messages: returnValue,
+          paging: {
+            previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+            next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+          },
+        },
+      })
+      .mockResolvedValueOnce({
+        data: {
+          messages: returnValue2,
+          paging: {
+            previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+            next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+          },
+        },
+      });
+
+    liveMessages({ channelId }, callback);
+
+    expect(callback).toHaveBeenCalled();
 
-  test('it should add new message to collection onCreate', () => {
-    // new message should be added to top of collection
+    await expect(queryMessages({ channelId })).resolves.toBeTruthy();
+
+    expect(callback.mock.lastCall).toHaveLength(1);
+
+    const { onNextPage, hasNextPage } = callback.mock.lastCall[0];
+
+    expect(hasNextPage).toBe(true);
+    expect(onNextPage).toBeTruthy();
+
+    onNextPage();
+
+    await expect(queryMessages({ channelId })).resolves.toBeTruthy();
+
+    // 4 -> becuase 1 local & server call each per call (2)
+    expect(callback).toHaveBeenCalledTimes(4);
+
+    expect(callback).toHaveBeenNthCalledWith(
+      4,
+      expect.objectContaining({
+        data: [...returnValue2, ...returnValue],
+        error: undefined,
+        loading: false,
+      }),
+    );
   });
 
-  test('it should update message in collection onUpdate', () => {
-    // updated message should be reflected in collection
+  test('it should add new message to collection onCreate', async () => {
+    const newMessage = {
+      ...message,
+      messageId: 'new-messageId',
+    };
+
+    // mock response of queryMessages and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        messages: returnValue,
+        paging: {},
+      },
+    });
+
+    liveMessages({ channelId }, callback);
+
+    await expect(queryMessages({ channelId })).resolves.toBeTruthy();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    // fire new message creation event
+    client.emitter.emit('v3.message.didCreate', { messages: [newMessage] });
+
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: [newMessage, ...returnValue],
+        error: undefined,
+        loading: false,
+      }),
+    );
   });
 
-  test('it should delete message from collection onDelete', () => {
-    // should remove message from collection on delete
+  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: {},
+      },
+    });
+
+    liveMessages({ channelId }, callback);
+
+    await expect(queryMessages({ channelId })).resolves.toBeTruthy();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    // fire new message creation event
+    client.emitter.emit('v3.message.didUpdate', { messages: [message] });
+
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: [message],
+        error: undefined,
+        loading: false,
+      }),
+    );
   });
 
-  test('it should get messages from cache if present', () => {
-    // push message with Id in collection response to cache
-    // get request to get that messageId should not be called
+  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: {},
+      },
+    });
+
+    liveMessages({ channelId }, callback);
+
+    await expect(queryMessages({ channelId })).resolves.toBeTruthy();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    // fire new message creation event
+    client.emitter.emit('v3.message.didDelete', { messages: [message] });
+
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: [],
+        error: undefined,
+        loading: false,
+      }),
+    );
   });
 });

package/src/utils/tests/dummy/channel.ts

@@ -14,16 +14,38 @@ export const channelRaw2: Amity.ChannelRaw = {
   channelId: 'channelId12',
 };
 
+export const channelRaw3: Amity.ChannelRaw = {
+  messageCount: 3,
+  createdAt: date,
+  type: 'community',
+  channelId: 'channelId21',
+};
+
 export const channel11: Amity.Channel = {
   ...channelRaw1,
   hasMention: false,
   unreadCount: 0,
+  type: 'community',
+  isDeleted: false,
+  tags: ['tag2'],
 };
 
 export const channel12: Amity.Channel = {
   ...channelRaw2,
-  hasMention: true,
-  unreadCount: 2,
+  hasMention: false,
+  unreadCount: 0,
+  type: 'conversation',
+  isDeleted: true,
+  tags: ['tag1'],
+};
+
+export const channel21: Amity.Channel = {
+  ...channelRaw3,
+  hasMention: false,
+  unreadCount: 0,
+  type: 'conversation',
+  isDeleted: true,
+  tags: ['tag1'],
 };
 
 export const channelUser1: Amity.Membership<'channel'> = {
@@ -47,6 +69,28 @@ export const channelUser2: Amity.Membership<'channel'> = {
   channelId: channel12.channelId,
 };
 
-export const channels = {
-  page1: [channel11.channelId, channel12.channelId],
+export const channelQueryResponse = {
+  data: {
+    channels: [channel11, channel12],
+    channelUsers: [],
+    files: [],
+    users: [],
+    paging: {
+      previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+      next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+    },
+  },
+};
+
+export const channelQueryResponsePage2 = {
+  data: {
+    channels: [channel21],
+    channelUsers: [],
+    files: [],
+    users: [],
+    paging: {
+      previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+      next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+    },
+  },
 };

package/src/utils/tests/dummy/follow.ts

@@ -0,0 +1,60 @@
+import { date, user11, user12, user13, user14 } from '.';
+
+const timeStamps: Amity.Timestamps = {
+  createdAt: date,
+  updatedAt: date,
+};
+
+// user11 follows user12
+export const follow11: Amity.FollowStatus = {
+  ...timeStamps,
+  to: user12.userId,
+  status: 'accepted',
+  from: user11.userId,
+};
+
+// user11 pineding user13
+export const follow12: Amity.FollowStatus = {
+  ...timeStamps,
+  status: 'pending',
+  to: user13.userId,
+  from: user11.userId,
+};
+
+// user14 declined user11
+export const follow13: Amity.FollowStatus = {
+  ...timeStamps,
+  status: 'none',
+  to: user14.userId,
+  from: user11.userId,
+};
+
+// user12 follows user11
+export const follow21: Amity.FollowStatus = {
+  ...timeStamps,
+  status: 'accepted',
+  to: user11.userId,
+  from: user12.userId,
+};
+
+// user13 pineding user11
+export const follow22: Amity.FollowStatus = {
+  ...timeStamps,
+  status: 'pending',
+  to: user11.userId,
+  from: user13.userId,
+};
+
+// user11 declined user14
+export const follow23: Amity.FollowStatus = {
+  ...timeStamps,
+  status: 'none',
+  to: user11.userId,
+  from: user14.userId,
+};
+
+export const follows = {
+  userId: user11.userId,
+  page1: [follow11, follow12, follow13],
+  page2: [follow21, follow22, follow23],
+};

package/src/utils/tests/dummy/index.ts

@@ -3,5 +3,6 @@ export const rolesAndPermissions = { roles: [], permissions: [] };
 
 export * from './user';
 export * from './post';
+export * from './follow';
 export * from './channel';
 export * from './message';

package/src/utils/tests/dummy/user.ts

@@ -9,3 +9,18 @@ export const user11: Amity.User = {
   createdAt: date,
   ...rolesAndPermissions,
 };
+
+export const user12: Amity.User = {
+  ...user11,
+  userId: 'user2',
+};
+
+export const user13: Amity.User = {
+  ...user11,
+  userId: 'user3',
+};
+
+export const user14: Amity.User = {
+  ...user11,
+  userId: 'user4',
+};

package/src/utils/tests/index.ts

@@ -1,2 +1,3 @@
+export * from './utils';
 export * from './dummy';
 export * from './client';

package/src/utils/tests/utils.ts

@@ -0,0 +1,3 @@
+import { encode } from 'js-base64';
+
+export const encodeJson = (value: Record<string, any>) => encode(JSON.stringify(value));