@amityco/ts-sdk 0.0.1-ce7eebc.0 → 0.0.1-ce96c83.0

package/src/community/events/test/utils.test.ts

@@ -0,0 +1,158 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { getResolver } from '~/core/model';
+import { withUser } from '~/group/utils';
+import {
+  client,
+  community11,
+  communityUser11,
+  connectClient,
+  disconnectClient,
+  user11,
+} from '~/utils/tests';
+
+import { createCommunityEventSubscriber, createCommunityMemberEventSubscriber } from '../utils';
+
+const event = 'community.created';
+const communityToCreate = community11;
+
+const eventPayload: Amity.CommunityPayload = {
+  communities: [communityToCreate],
+  communityUsers: [communityUser11],
+  files: [],
+  users: [],
+  categories: [],
+  feeds: [],
+};
+
+describe('createCommunityEventSubscriber', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('it should return event subscriber', () => {
+    const callback = jest.fn();
+    const received = createCommunityEventSubscriber(event, callback);
+
+    expect(received).toBeDefined();
+  });
+
+  test('it should trigger callback with correctly params when cache is disabled', () => {
+    disableCache();
+
+    const callback = jest.fn();
+    const unsub = createCommunityEventSubscriber(event, callback);
+    client.emitter.emit(event, eventPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(communityToCreate);
+  });
+
+  test('it should trigger callback with correctly params when cache is enabled', () => {
+    enableCache();
+
+    const callback = jest.fn();
+    const unsub = createCommunityEventSubscriber(event, callback);
+    client.emitter.emit(event, eventPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(communityToCreate);
+
+    disableCache();
+  });
+
+  test('it should ingest cache', () => {
+    enableCache();
+
+    const callback = jest.fn();
+    const unsub = createCommunityEventSubscriber(event, callback);
+    client.emitter.emit(event, eventPayload);
+
+    unsub();
+
+    const recieved = pullFromCache(['community', 'get', communityToCreate.communityId])?.data;
+
+    expect(recieved).toEqual(communityToCreate);
+
+    disableCache();
+  });
+});
+
+const event2 = 'community.userAdded';
+const communityToAddUser = community11;
+const addedUserRaw = communityUser11;
+const addedUser = withUser(addedUserRaw);
+
+const eventPayload2: Amity.CommunityMembershipPayload = {
+  communities: [communityToAddUser],
+  communityUsers: [addedUserRaw],
+  files: [],
+  users: [user11],
+  categories: [],
+  feeds: [],
+};
+
+describe('createCommunityMemberEventSubscriber', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('it should return event subscriber', () => {
+    const callback = jest.fn();
+    const received = createCommunityMemberEventSubscriber(event2, callback);
+
+    expect(received).toBeDefined();
+  });
+
+  test('it should trigger callback with correctly params when cache is disabled', () => {
+    disableCache();
+
+    const callback = jest.fn();
+    const unsub = createCommunityMemberEventSubscriber(event2, callback);
+    client.emitter.emit(event2, eventPayload2);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(communityToAddUser, addedUser);
+  });
+
+  test('it should trigger callback with correctly params when cache is enabled', () => {
+    enableCache();
+
+    const callback = jest.fn();
+    const unsub = createCommunityMemberEventSubscriber(event2, callback);
+    client.emitter.emit(event2, eventPayload2);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(communityToAddUser, addedUser);
+
+    disableCache();
+  });
+
+  test('it should ingest cache', () => {
+    enableCache();
+
+    const callback = jest.fn();
+    const unsub = createCommunityMemberEventSubscriber(event2, callback);
+    client.emitter.emit(event2, eventPayload2);
+
+    unsub();
+
+    const recieved = pullFromCache([
+      'communityUsers',
+      'get',
+      getResolver('communityUsers')({
+        communityId: communityToAddUser.communityId,
+        userId: addedUser.userId,
+      }),
+    ])?.data;
+
+    expect(recieved).toEqual(addedUser);
+
+    disableCache();
+  });
+});

package/src/post/events/tests/onPostFlagged.test.ts

@@ -0,0 +1,33 @@
+import { onPostFlagged } from '../onPostFlagged';
+import { client, connectClient, disconnectClient, postPayload, post11 } from '~/utils/tests';
+
+describe('onPostFlagged', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  test('it should got event after post flagged', () => {
+    const callback = jest.fn();
+    const unsub = onPostFlagged(callback);
+    client.emitter.emit('post.flagged', postPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(post11);
+  });
+
+  test('it should got nothing if we did unsubscribe before got event', () => {
+    const callback = jest.fn();
+    const unsub = onPostFlagged(callback);
+
+    unsub();
+
+    client.emitter.emit('post.flagged', postPayload);
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/post/events/tests/onPostReactionAdded.test.ts

@@ -0,0 +1,40 @@
+import { onPostReactionAdded } from '../onPostReactionAdded';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  postPayload,
+  post11,
+  reaction11,
+} from '~/utils/tests';
+
+describe('onPostReactionAdded', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  test('it should got event after add reaction to post', () => {
+    const callback = jest.fn();
+    const unsub = onPostReactionAdded(callback);
+    client.emitter.emit('post.addReaction', { ...postPayload, reactor: reaction11 });
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(post11);
+  });
+
+  test('it should got nothing if we did unsubscribe before got event', () => {
+    const callback = jest.fn();
+    const unsub = onPostReactionAdded(callback);
+
+    unsub();
+
+    client.emitter.emit('post.addReaction', { ...postPayload, reactor: reaction11 });
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/post/events/tests/onPostReactionRemoved.test.ts

@@ -0,0 +1,40 @@
+import { onPostReactionRemoved } from '../onPostReactionRemoved';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  postPayload,
+  post11,
+  reaction11,
+} from '~/utils/tests';
+
+describe('onPostReactionRemoved', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  test('it should got event after reaction got removed from post', () => {
+    const callback = jest.fn();
+    const unsub = onPostReactionRemoved(callback);
+    client.emitter.emit('post.removeReaction', { ...postPayload, reactor: reaction11 });
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(post11);
+  });
+
+  test('it should got nothing if we did unsubscribe before got event', () => {
+    const callback = jest.fn();
+    const unsub = onPostReactionRemoved(callback);
+
+    unsub();
+
+    client.emitter.emit('post.removeReaction', { ...postPayload, reactor: reaction11 });
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/post/events/tests/onPostUnflagged.test.ts

@@ -0,0 +1,33 @@
+import { onPostUnflagged } from '../onPostUnflagged';
+import { client, connectClient, disconnectClient, postPayload, post11 } from '~/utils/tests';
+
+describe('onPostUnflagged', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  test('it should got event after post unflagged', () => {
+    const callback = jest.fn();
+    const unsub = onPostUnflagged(callback);
+    client.emitter.emit('post.unflagged', postPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(post11);
+  });
+
+  test('it should got nothing if we did unsubscribe before got event', () => {
+    const callback = jest.fn();
+    const unsub = onPostUnflagged(callback);
+
+    unsub();
+
+    client.emitter.emit('post.unflagged', postPayload);
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/post/events/tests/onPostUpdated.test.ts

@@ -0,0 +1,33 @@
+import { onPostUpdated } from '../onPostUpdated';
+import { client, connectClient, disconnectClient, postPayload, post11 } from '~/utils/tests';
+
+describe('onPostUpdated', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  test('it should got event after post updated', () => {
+    const callback = jest.fn();
+    const unsub = onPostUpdated(callback);
+    client.emitter.emit('post.updated', postPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(post11);
+  });
+
+  test('it should got nothing if we did unsubscribe before got event', () => {
+    const callback = jest.fn();
+    const unsub = onPostUpdated(callback);
+
+    unsub();
+
+    client.emitter.emit('post.updated', postPayload);
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/post/observers/livePosts.ts

@@ -120,6 +120,9 @@ export const livePosts = (
       if (params.isDeleted) collection.data.unshift(post.postId);
     }
 
+    if (params.feedType === 'reviewing' && action === 'onApproved')
+      collection.data = collection.data.filter(p => p !== post.postId);
+
     pushToCache(cacheKey, collection);
 
     responder(collection);

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

@@ -270,4 +270,28 @@ describe('livePosts', () => {
     snapshot.data = [deletedPost, ...payload];
     expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
   });
+
+  test('it should remove approved post when feedtype reviewing', async () => {
+    const approvedPost = post11;
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(postQueryResponsePage2);
+
+    livePosts({ ...params, feedType: 'reviewing' }, callback);
+
+    await pause();
+    const payload = postQueryResponsePage2.data.posts;
+    const snapshot = getSnapshot();
+
+    snapshot.data = payload;
+    snapshot.loading = false;
+
+    expect(callback).toHaveBeenNthCalledWith(2, expect.objectContaining(snapshot));
+
+    client.emitter.emit('post.approved', {
+      posts: [approvedPost],
+    });
+
+    snapshot.data = payload.filter(({ postId }) => postId !== approvedPost.postId);
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
 });

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

@@ -1,4 +1,6 @@
-import { baseMembership, date, user11, user12, file11 } from '.';
+import { DefaultCommunityPostSetting } from '~/@types';
+
+import { baseMembership, date, user11, user12, file11, user13 } from '.';
 
 const mockPage: Amity.Pagination = {
   paging: {
@@ -19,6 +21,7 @@ export const baseCommunity: Amity.Community = {
   path: '',
   postsCount: 0,
   userId: '',
+  postSetting: DefaultCommunityPostSetting,
 };
 
 export const community11: Amity.Community = {
@@ -43,6 +46,12 @@ export const community11: Amity.Community = {
   categoryIds: [],
 };
 
+export const community21: Amity.Community = {
+  ...baseCommunity,
+  communityId: 'community21',
+  displayName: 'Community21',
+};
+
 export const communityUser11: Amity.MembershipRaw<'community'> = {
   ...baseMembership,
   communityMembership: 'member',
@@ -67,6 +76,13 @@ export const communityUser12: Amity.MembershipRaw<'community'> = {
   communityMembership: 'member',
 };
 
+export const communityUser21: Amity.MembershipRaw<'community'> = {
+  ...baseMembership,
+  userId: user13.userId,
+  communityId: community21.communityId,
+  communityMembership: 'member',
+};
+
 export const communityPayload: Amity.CommunityPayload = {
   communities: [community11],
   communityUsers: [communityUser11],