@amityco/ts-sdk 0.0.1-beta-34 → 0.0.1-beta-35

package/src/post/observers/tests/livePosts.test.ts

@@ -0,0 +1,273 @@
+import { disableCache, enableCache } from '~/cache/api';
+
+import {
+  client,
+  pause,
+  connectClient,
+  disconnectClient,
+  post11,
+  postQueryResponse,
+  postQueryResponsePage2,
+} from '~/utils/tests';
+
+import { livePosts } from '../livePosts';
+
+const getSnapshot = () => {
+  return {
+    data: [] as Amity.Post[],
+    loading: true,
+    error: undefined as any,
+  };
+};
+
+const { targetId, targetType } = post11;
+const params = { targetId, targetType };
+
+describe('livePosts', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  test('it should return post collection', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(postQueryResponse);
+
+    livePosts(params, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    const snapshot = getSnapshot();
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    // cause we apply prepareChannelPayload on post raw data from server
+    const payload = postQueryResponse.data;
+
+    snapshot.data = payload.posts;
+    snapshot.loading = false;
+
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+  });
+
+  const filters: [string, Amity.PostLiveCollection, number?][] = [
+    ['not deleted', { ...params, isDeleted: false }],
+    ['deleted', { ...params, isDeleted: true }, 1],
+    ['tags', { ...params, tags: ['test_tag'] }, 1],
+  ];
+
+  test.each(filters)(
+    'it should filter by %s posts',
+    async (filter, params, expectedPostIdx = 0) => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue(postQueryResponsePage2);
+
+      const payload = postQueryResponsePage2.data;
+      const snapshotData = [payload.posts[expectedPostIdx]];
+
+      livePosts(params, callback);
+
+      expect(callback).toHaveBeenCalledTimes(1);
+
+      const snapshot = getSnapshot();
+      // 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 = snapshotData;
+
+      expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+    },
+  );
+
+  test('it should return method to fetch next page', async () => {
+    const callback = jest.fn();
+    client.http.get = jest
+      .fn()
+      .mockResolvedValue(postQueryResponse)
+      .mockResolvedValueOnce(postQueryResponsePage2);
+
+    livePosts(params, callback);
+
+    expect(callback).toHaveBeenCalled();
+
+    await pause();
+
+    expect(callback.mock.lastCall).toHaveLength(1);
+
+    const { onNextPage, hasNextPage } = callback.mock.lastCall[0];
+
+    expect(hasNextPage).toBe(true);
+    expect(onNextPage).toBeTruthy();
+
+    onNextPage();
+
+    await pause();
+
+    // 4 -> becuase 1 local & server call each per call (2)
+    expect(callback).toHaveBeenCalledTimes(4);
+
+    const payload = postQueryResponse.data;
+    const payload2 = postQueryResponsePage2.data;
+
+    const snapshot = getSnapshot();
+    snapshot.loading = false;
+    snapshot.data = [...payload2.posts, ...payload.posts];
+
+    expect(callback).toHaveBeenNthCalledWith(4, expect.objectContaining(snapshot));
+  });
+
+  const events: [string, keyof Amity.Events, Amity.Post][] = [
+    [
+      'it should add new post to collection onCreate',
+      'post.created',
+      { ...post11, postId: 'new-post-id' },
+    ],
+    ['it should edit post in collection onUpdate', 'post.updated', post11],
+    ['it should update post in collection onApproved', 'post.approved', post11],
+    ['it should remove post in collection onDelete', 'post.deleted', post11],
+    ['it should remove post in collection onDeclined', 'post.declined', post11],
+  ];
+
+  test.each(events)('%s', async (test, event, post) => {
+    const snapshot = getSnapshot();
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(postQueryResponse);
+
+    livePosts(params, callback);
+
+    await pause();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    client.emitter.emit(event, {
+      posts: [post],
+    });
+
+    const payload = postQueryResponse.data;
+    const deletePayload = payload.posts.filter(post => post.postId !== post11.postId);
+
+    snapshot.loading = false;
+    // get data based on event
+    switch (event) {
+      case 'post.created':
+        snapshot.data = [post, ...payload.posts];
+        break;
+
+      case 'post.deleted':
+      case 'post.declined':
+        snapshot.data = deletePayload;
+        break;
+
+      case 'post.addReaction':
+        payload.posts[0] = post;
+        snapshot.data = payload.posts;
+        break;
+
+      default:
+        snapshot.data = payload.posts;
+    }
+
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+
+  const reactionEvents: [
+    string,
+    keyof Amity.Events,
+    Amity.PostPayload & { reactor: Amity.Reaction },
+  ][] = [
+    [
+      'it should update post in collection onReactionAdded',
+      'post.addReaction',
+      {
+        posts: [{ ...post11, reactionsCount: 1 }],
+        reactor: {
+          referenceId: post11.postId,
+          referenceType: 'post',
+          reactionId: 'test-reaction-id',
+          reactionName: 'like',
+          userId: 'test',
+          createdAt: '',
+        },
+      },
+    ],
+    [
+      'it should update post in collection onReactionRemoved',
+      'post.removeReaction',
+      {
+        posts: [{ ...post11, reactionsCount: 0 }],
+        reactor: {
+          referenceId: post11.postId,
+          referenceType: 'post',
+          reactionId: 'test-reaction-id',
+          reactionName: 'like',
+          userId: 'test',
+          createdAt: '',
+        },
+      },
+    ],
+  ];
+
+  test.each(reactionEvents)('%s', async (test, event, reactionPayload) => {
+    const expectedReactionCount = reactionPayload.posts[0].reactionsCount;
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(postQueryResponse);
+
+    livePosts(params, callback);
+
+    await pause();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    client.emitter.emit(event, reactionPayload);
+
+    const { reactionsCount } = callback.mock.lastCall[0].data[0];
+    expect(reactionsCount).toBe(expectedReactionCount);
+  });
+
+  /*
+   * This test was added as when isDeleted posts were queried, the livePosts api
+   * would try to delete the post when 'post.deleted' event occured, where instead
+   * it should be adding it to the collection. As livePosts is called with a
+   * param to reutrun deleted posts only
+   */
+  test('it should update posts to include deleted post', async () => {
+    const deletedPost = { ...post11, isDeleted: true };
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(postQueryResponsePage2);
+
+    livePosts({ ...params, isDeleted: true }, callback);
+
+    await pause();
+    const payload = postQueryResponsePage2.data.posts.filter(p => p.isDeleted);
+    const snapshot = getSnapshot();
+
+    snapshot.data = payload;
+    snapshot.loading = false;
+
+    expect(callback).toHaveBeenNthCalledWith(2, expect.objectContaining(snapshot));
+
+    client.emitter.emit('post.deleted', {
+      posts: [deletedPost],
+    });
+
+    snapshot.data = [deletedPost, ...payload];
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+});

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

@@ -58,6 +58,29 @@ export const post13: Amity.Post = {
   postId: 'post13',
 };
 
+export const post14: Amity.Post = {
+  ...post11,
+  postId: 'post14',
+  targetType: 'community',
+  isDeleted: false,
+  children: [],
+};
+
+export const post15: Amity.Post = {
+  ...post11,
+  postId: 'post15',
+  isDeleted: true,
+  children: [post11.postId],
+  targetType: 'community',
+  tags: ['test_tag'],
+};
+
+export const post16: Amity.Post = {
+  ...post11,
+  postId: 'post16',
+  targetType: 'user',
+};
+
 export const posts = {
   targetId: user11.userId,
   targetType: 'user' as Amity.PostTargetType,
@@ -85,6 +108,17 @@ export const postQueryResponse = {
   data: {
     posts: [post11, post12, post13],
     files: [],
+    reactor: { userId: 'test' },
+    paging: {
+      next: nextPage,
+    },
+  },
+};
+
+export const postQueryResponsePage2 = {
+  data: {
+    posts: [post14, post15, post16],
+    files: [],
     paging: {
       next: nextPage,
     },