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

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

@@ -0,0 +1,313 @@
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+
+import { liveMessages } from '../liveMessages';
+import { queryMessages } from '~/message/api';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  messages,
+  message as defaultMessage,
+} from '~/utils/tests';
+
+describe('liveMessages', () => {
+  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
+     * 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 liveMessages check if mocked console get's called with the correct
+    // message
+    client.use();
+    liveMessages({ channelId }, 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: {},
+      },
+    });
+
+    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 })).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: returnValue,
+        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);
+
+    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 = [
+      { 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: {},
+      },
+    });
+
+    liveMessages({ channelId, isDeleted: false }, 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 })).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: [returnValue[1]],
+        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: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+            next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+          },
+        },
+      })
+      .mockResolvedValueOnce({
+        data: {
+          messages: returnValue2,
+          paging: {
+            previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+            next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+          },
+        },
+      });
+
+    liveMessages({ channelId }, callback);
+
+    expect(callback).toHaveBeenCalled();
+
+    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 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 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 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/post/observers/livePosts.ts

@@ -14,6 +14,7 @@ import {
 import {
   COLLECTION_DEFAULT_CACHING_POLICY,
   COLLECTION_DEFAULT_PAGINATION_LIMIT,
+  ENABLE_CACHE_MESSAGE,
 } from '~/utils/constants';
 
 import {
@@ -57,7 +58,7 @@ export const livePosts = (
   const { log, cache } = getActiveClient();
 
   if (!cache) {
-    console.log('For using Live Collection feature you need to enable Cache!');
+    console.log(ENABLE_CACHE_MESSAGE);
   }
 
   const timestamp = Date.now();

package/src/post/tests/api/getPost.test.ts

@@ -1,12 +1,12 @@
 import { ASCApiError } from '~/core/errors';
-import { client, userPosts } from '~/utils/tests';
+import { client, posts } from '~/utils/tests';
 import { pushToCache, enableCache, disableCache } from '~/cache/api';
 
 import { getPost } from '~/post/api';
 
 describe('post/api', () => {
-  const post = { postId: userPosts.page1[0] };
-  const post2 = { postId: userPosts.page1[1] };
+  const post = { postId: posts.page1[0] };
+  const post2 = { postId: posts.page1[1] };
 
   describe('getPost.locally', () => {
     test('should return undefined if cache is turned off', () => {

package/src/post/tests/api/queryPosts.test.ts

@@ -1,9 +1,9 @@
 import { queryPosts } from '~/post/api';
-import { client, userPosts } from '~/utils/tests';
+import { client, posts } from '~/utils/tests';
 
 describe('post/api', () => {
   test('should return a post query', async () => {
-    const returnValue = [{ postId: userPosts.page1[0] }];
+    const returnValue = [{ postId: posts.page1[0] }];
 
     client.http.get = jest.fn().mockResolvedValue({
       data: {
@@ -13,8 +13,8 @@ describe('post/api', () => {
     });
 
     const data = await queryPosts({
-      targetId: userPosts.targetId,
-      targetType: userPosts.targetType,
+      targetId: posts.targetId,
+      targetType: posts.targetType,
     });
 
     expect(data).toBeDefined();

package/src/utils/constants.ts

@@ -1,2 +1,3 @@
 export const COLLECTION_DEFAULT_PAGINATION_LIMIT = 5;
 export const COLLECTION_DEFAULT_CACHING_POLICY: Amity.QueryPolicy = 'cache_then_server';
+export const ENABLE_CACHE_MESSAGE = 'For using Live Collection feature you need to enable Cache!';

package/src/utils/tests/client.ts

@@ -1,5 +1,33 @@
-import { createClient } from '~/client/api';
+import {
+  createClient,
+  connectClient as sdkConnectClient,
+  disconnectClient as sdkDisconnectClient,
+} from '~/client/api';
 
-const client = createClient('key', 'sg');
+import { user11 } from './dummy';
 
-export default client;
+export const client = createClient('key', 'sg');
+
+export const connectClient = async () => {
+  client.mqtt.connect = jest.fn();
+  client.mqtt.subscribe = jest.fn();
+  client.http.post = jest.fn().mockReturnValueOnce({
+    data: {
+      accessToken: 'accessToken',
+      refreshToken: 'refreshToken',
+      users: [user11],
+    },
+  });
+
+  setTimeout(() => {
+    client.ws.emit('connect');
+  }, 500);
+
+  await sdkConnectClient({ userId: 'test' });
+};
+
+export const disconnectClient = async () => {
+  sdkDisconnectClient().then(() => client.ws.emit('disconnect'));
+};
+
+export default {};

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

@@ -0,0 +1,96 @@
+import { date, rolesAndPermissions, user11 } from '.';
+
+export const channelRaw1: Amity.ChannelRaw = {
+  messageCount: 1,
+  createdAt: date,
+  type: 'community',
+  channelId: 'channelId11',
+};
+
+export const channelRaw2: Amity.ChannelRaw = {
+  messageCount: 3,
+  createdAt: date,
+  type: 'community',
+  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: 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'> = {
+  isMuted: false,
+  createdAt: date,
+  muteTimeout: '',
+  isBanned: false,
+  readToSegment: 1,
+  lastActivity: date,
+  membership: 'member',
+  userId: user11.userId,
+  ...rolesAndPermissions,
+  lastMentionedSegment: 0,
+  channelId: channel11.channelId,
+};
+
+export const channelUser2: Amity.Membership<'channel'> = {
+  ...channelUser1,
+  readToSegment: 1,
+  lastMentionedSegment: 2,
+  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

@@ -0,0 +1,8 @@
+export const date = new Date().toISOString();
+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/message.ts

@@ -0,0 +1,21 @@
+import { date, channel11, user11 } from '.';
+
+export const message: Amity.Message = {
+  reactions: {},
+  editedAt: date,
+  createdAt: date,
+  reactionsCount: 0,
+  channelSegment: 1,
+  childrenNumber: 0,
+  userId: user11.userId,
+  messageId: 'message11',
+  channelId: channel11.channelId,
+  data: { text: 'message1' },
+};
+
+export const messages = {
+  channelId: 'channelId',
+  page1: ['messageId11', 'messageId12', 'messageId13'],
+  page2: ['messageId21', 'messageId22', 'messageId23'],
+  page3: ['messageId31', 'messageId32', 'messageId33'],
+};

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

@@ -0,0 +1,31 @@
+import { user11, date } from '.';
+
+export const post1: Amity.Post = {
+  path: '',
+  feedId: '',
+  children: [],
+  comments: [],
+  flagCount: 0,
+  reactions: {},
+  hashFlag: null,
+  editedAt: date,
+  createdAt: date,
+  commentsCount: 0,
+  reactionsCount: 0,
+  postId: 'postId11',
+  targetType: 'user',
+  parentId: 'postId12',
+  data: { text: 'post1' },
+  targetId: user11.userId,
+  hasFlaggedComment: false,
+  hasFlaggedChildren: false,
+  postedUserId: user11.userId,
+};
+
+export const posts = {
+  targetId: user11.userId,
+  targetType: 'user' as Amity.PostTargetType,
+  page1: [post1.postId, 'postId12', 'postId13'],
+  page2: ['postId21', 'postId22', 'postId23'],
+  page3: ['postId31', 'postId32', 'postId33'],
+};

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

@@ -0,0 +1,26 @@
+import { date, rolesAndPermissions } from '.';
+
+export const user11: Amity.User = {
+  _id: '',
+  path: '',
+  flagCount: 0,
+  userId: 'test',
+  hashFlag: null,
+  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 { userPosts } from './dummy';
-export { default as client } from './client';
+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));

package/dist/utils/tests/dummy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dummy.d.ts","sourceRoot":"","sources":["../../../src/utils/tests/dummy.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS;;;;;;CAMrB,CAAC"}

package/src/utils/tests/dummy.ts

@@ -1,7 +0,0 @@
-export const userPosts = {
-  targetId: 'userId',
-  targetType: 'user' as Amity.PostTargetType,
-  page1: ['postId11', 'postId12', 'postId13'],
-  page2: ['postId21', 'postId22', 'postId23'],
-  page3: ['postId31', 'postId32', 'postId33'],
-};