@amityco/ts-sdk 0.0.1-beta.30 → 0.0.1-beta.32

package/src/user/tests/observers/liveUser.test.ts

@@ -0,0 +1,224 @@
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
+import { LIVE_OBJECT_ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+
+import { liveUser } from '../../observers/liveUser';
+
+import {
+  pause,
+  client,
+  connectClient,
+  disconnectClient,
+  userQueryResponse,
+  user11 as defaultUser,
+} from '~/utils/tests';
+
+const getSnapshot = () => {
+  return {
+    loading: true,
+    error: undefined as any,
+    data: undefined as undefined | Amity.User,
+  };
+};
+
+describe('liveUser', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(async () => {
+    enableCache();
+  });
+
+  afterEach(disableCache);
+
+  test('it should show user 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 liveUser check if mocked console get's called with the correct
+    // user
+    client.use();
+    liveUser(defaultUser.userId, callback);
+
+    expect(console.log).toBeCalledWith(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
+  });
+
+  test('it should return user live object', async () => {
+    const snapshot = getSnapshot();
+
+    // mock response of queryUsers and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(userQueryResponse);
+
+    liveUser(defaultUser.userId, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    snapshot.loading = false;
+    snapshot.data = defaultUser;
+
+    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,
+    );
+
+    // mock response of queryUsers and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockRejectedValue(error);
+
+    liveUser(defaultUser.userId, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    snapshot.error = error;
+    snapshot.loading = false;
+    expect(callback).toHaveBeenLastCalledWith(expect.objectContaining(snapshot));
+  });
+
+  test('it should terminate updates on api failure', async () => {
+    const snapshot = getSnapshot();
+    const error = new ASCApiError(
+      'server error!',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    // mock response of queryUsers and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockRejectedValue(error);
+
+    liveUser(defaultUser.userId, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    snapshot.error = error;
+    snapshot.loading = false;
+    expect(callback).toHaveBeenLastCalledWith(expect.objectContaining(snapshot));
+
+    const updatedAt = new Date(defaultUser?.updatedAt ?? new Date());
+    updatedAt.setDate(updatedAt.getDate() + 7);
+
+    const updatedUser = {
+      ...defaultUser,
+      updatedAt: updatedAt.toISOString(),
+    };
+    client.emitter.emit('user.updated', { users: [updatedUser], files: [] });
+
+    delete snapshot.error;
+    snapshot.loading = false;
+    snapshot.data = updatedUser;
+    expect(callback).not.toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+
+  test('it should not return updates on obtain once!', async () => {
+    const snapshot = getSnapshot();
+
+    // mock response of queryUsers and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(userQueryResponse);
+
+    const unsub = liveUser(defaultUser.userId, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    unsub();
+
+    const updatedAt = new Date(defaultUser?.updatedAt ?? new Date());
+    updatedAt.setDate(updatedAt.getDate() + 7);
+
+    const updatedUser = {
+      ...defaultUser,
+      updatedAt: updatedAt.toISOString(),
+    };
+    client.emitter.emit('user.updated', { users: [updatedUser], files: [] });
+
+    delete snapshot.error;
+    snapshot.loading = false;
+    snapshot.data = updatedUser;
+    expect(callback).not.toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+
+  const events: [string, keyof Amity.Events][] = [
+    ['it should return updated user on onFetch', 'user.fetched'],
+    ['it should return updated user on onUpdate', 'user.updated'],
+    ['it should return updated user on onDelete', 'user.deleted'],
+    ['it should return updated user on onFlagged', 'user.flagged'],
+    ['it should return updated user on onUnflagged', 'user.unflagged'],
+    ['it should return updated user on onFlagCleared', 'user.flagCleared'],
+  ];
+
+  test.each(events)('%s', async (test, event) => {
+    const snapshot = getSnapshot();
+
+    // mock response of queryUsers and validate
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(userQueryResponse);
+
+    liveUser(defaultUser.userId, callback);
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    const updatedAt = new Date(defaultUser?.updatedAt ?? new Date());
+    updatedAt.setDate(updatedAt.getDate() + 7);
+
+    const updatedUser = {
+      ...defaultUser,
+      updatedAt: updatedAt.toISOString(),
+    };
+    client.emitter.emit(event, { users: [updatedUser], files: [] });
+
+    delete snapshot.error;
+    snapshot.loading = false;
+    snapshot.data = updatedUser;
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+});

package/src/utils/constants.ts

@@ -1,3 +1,8 @@
 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!';
+export const LIVE_OBJECT_ENABLE_CACHE_MESSAGE =
+  'For using Live Object feature you need to enable Cache!';
+export const UNSYNCED_OBJECT_CACHED_AT_MESSAGE =
+  'Observing unsynced object is not supported by Live Object.';
+export const UNSYNCED_OBJECT_CACHED_AT_VALUE = -5;

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

@@ -95,6 +95,39 @@ export const channelUser4: Amity.Membership<'channel'> = {
   userId: user13.userId,
 };
 
+export const channelUser5: Amity.Membership<'channel'> = {
+  isMuted: false,
+  createdAt: date,
+  muteTimeout: '',
+  isBanned: true,
+  readToSegment: 1,
+  lastActivity: date,
+  userId: user13.userId,
+  ...rolesAndPermissions,
+  membership: 'banned',
+  lastMentionedSegment: 0,
+  channelId: channel11.channelId,
+};
+
+export const channelUser6: Amity.Membership<'channel'> = {
+  isMuted: true,
+  createdAt: date,
+  muteTimeout: '',
+  isBanned: true,
+  readToSegment: 1,
+  lastActivity: date,
+  userId: 'test',
+  ...rolesAndPermissions,
+  membership: 'banned',
+  lastMentionedSegment: 0,
+  channelId: channel11.channelId,
+};
+
+export const channelUser7: Amity.Membership<'channel'> = {
+  ...channelUser3,
+  membership: 'member',
+};
+
 export const channelQueryResponse = {
   data: {
     channels: [channel11, channel12],
@@ -134,3 +167,13 @@ export const channelUserQueryResponsePage2 = {
     ...mockPage,
   },
 };
+
+export const channelUserQueryResponsePage3 = {
+  data: {
+    channels: [channel11],
+    channelUsers: [channelUser7, channelUser6],
+    users: [],
+    files: [],
+    ...mockPage,
+  },
+};

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

@@ -1,6 +1,8 @@
 import { date, channel11, user11 } from '.';
 
-export const message: Amity.Message = {
+export const message11: Amity.Message = {
+  fileId: null,
+  type: 'text',
   reactions: {},
   editedAt: date,
   createdAt: date,
@@ -15,7 +17,19 @@ export const message: Amity.Message = {
 
 export const messages = {
   channelId: 'channelId',
-  page1: ['messageId11', 'messageId12', 'messageId13'],
+  page1: [message11.messageId, 'messageId12', 'messageId13'],
   page2: ['messageId21', 'messageId22', 'messageId23'],
   page3: ['messageId31', 'messageId32', 'messageId33'],
 };
+
+export const messageQueryResponse = {
+  data: {
+    messages: [message11],
+    files: [],
+    users: [],
+    paging: {
+      previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+      next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+    },
+  },
+};

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

@@ -1,6 +1,7 @@
+import { encodeJson } from '..';
 import { user11, date } from '.';
 
-export const post1: Amity.Post = {
+export const post11: Amity.Post = {
   path: '',
   feedId: '',
   children: [],
@@ -15,17 +16,39 @@ export const post1: Amity.Post = {
   postId: 'postId11',
   targetType: 'user',
   parentId: 'postId12',
-  data: { text: 'post1' },
+  data: { text: 'post11' },
   targetId: user11.userId,
   hasFlaggedComment: false,
   hasFlaggedChildren: false,
   postedUserId: user11.userId,
 };
 
+export const post12: Amity.Post = {
+  ...post11,
+  postId: 'post12',
+};
+
+export const post13: Amity.Post = {
+  ...post11,
+  postId: 'post13',
+};
+
 export const posts = {
   targetId: user11.userId,
   targetType: 'user' as Amity.PostTargetType,
-  page1: [post1.postId, 'postId12', 'postId13'],
+  page1: [post11.postId, post12.postId, post13.postId],
   page2: ['postId21', 'postId22', 'postId23'],
   page3: ['postId31', 'postId32', 'postId33'],
 };
+
+const nextPage = encodeJson({ before: post13.postId, limit: 10 });
+
+export const postQueryResponse = {
+  data: {
+    posts: [post11, post12, post13],
+    files: [],
+    paging: {
+      next: nextPage,
+    },
+  },
+};

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

@@ -24,3 +24,14 @@ export const user14: Amity.User = {
   ...user11,
   userId: 'user4',
 };
+
+export const userQueryResponse = {
+  data: {
+    users: [user11, user12],
+    files: [],
+    paging: {
+      previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+      next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+    },
+  },
+};

package/dist/channel/tests/utils/prepareChannelPayload.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prepareChannelPayload.test.d.ts","sourceRoot":"","sources":["../../../../src/channel/tests/utils/prepareChannelPayload.test.ts"],"names":[],"mappings":""}

package/dist/message/observers/tests/liveMessages.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"liveMessages.test.d.ts","sourceRoot":"","sources":["../../../../src/message/observers/tests/liveMessages.test.ts"],"names":[],"mappings":""}