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

package/src/community/api/test/leaveCommunity.test.ts

@@ -0,0 +1,78 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { getResolver } from '~/core/model';
+import { client, community11, communityUser11, user11 } from '~/utils/tests';
+
+import { leaveCommunity } from '../leaveCommunity';
+import { onCommunityLeft } from '../../events';
+
+const communityToLeave = community11;
+const toLeaveUser = { ...communityUser11, communityMembership: 'member' };
+const leavedUser = { ...communityUser11, communityMembership: 'none' };
+
+const resolvedDeleteValue = {
+  data: {
+    communities: [communityToLeave],
+    communityUsers: [leavedUser],
+    files: [],
+    users: [user11],
+    categories: [],
+    feeds: [],
+  },
+};
+
+describe('leaveCommunity', () => {
+  test('should return true value', async () => {
+    client.http.delete = jest.fn().mockResolvedValueOnce(resolvedDeleteValue);
+
+    await expect(leaveCommunity(communityToLeave.communityId)).resolves.toBe(true);
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.delete = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(leaveCommunity(communityToLeave.communityId)).rejects.toThrow('error');
+  });
+
+  test('should update cache after leaved community', async () => {
+    enableCache();
+    client.http.delete = jest.fn().mockResolvedValueOnce(resolvedDeleteValue);
+    pushToCache(
+      [
+        'communityUsers',
+        'get',
+        getResolver('communityUsers')({
+          communityId: communityToLeave.communityId,
+          userId: toLeaveUser.userId,
+        }),
+      ],
+      toLeaveUser,
+    );
+
+    await leaveCommunity(communityToLeave.communityId);
+    const recieved = pullFromCache([
+      'communityUsers',
+      'get',
+      getResolver('communityUsers')({
+        communityId: communityToLeave.communityId,
+        userId: toLeaveUser.userId,
+      }),
+    ])?.data;
+
+    expect(recieved).toEqual(expect.objectContaining(leavedUser));
+
+    disableCache();
+  });
+
+  test('should fire event `onCommunityLeft`', async () => {
+    let dispose;
+    client.http.delete = jest.fn().mockResolvedValueOnce(resolvedDeleteValue);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onCommunityLeft(resolve);
+    }).finally(dispose);
+
+    await leaveCommunity(toLeaveUser.userId);
+
+    await expect(callbackPromise).resolves.toEqual(expect.objectContaining(communityToLeave));
+  });
+});

package/src/community/api/test/queryCommunity.test.ts

@@ -0,0 +1,108 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+
+import { client, community11, community21, communityUser11 } from '~/utils/tests';
+
+import { queryCommunities } from '../queryCommunities';
+
+const communities = [community11, community21];
+
+const pagingToken = {
+  previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+  next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+};
+
+const communitiesToQuery = [community11];
+const communityIdsToQuery = communitiesToQuery.map(community => community.communityId);
+const communityUsersToQuery = [communityUser11];
+const queryCriteriaWithoutPage = { displayName: communities[0].displayName };
+const pagingCriteria = { limit: 10 };
+const queryCriteria = { ...queryCriteriaWithoutPage, page: pagingCriteria };
+
+const resolvedGetValue = {
+  data: {
+    communities: communitiesToQuery,
+    communityUsers: communityUsersToQuery,
+    files: [],
+    users: [],
+    categories: [],
+    feeds: [],
+    paging: pagingToken,
+  },
+};
+
+describe('queryCommunities', () => {
+  test('should return fetched communities with correct paging', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedGetValue);
+
+    await expect(queryCommunities(queryCriteria)).resolves.toEqual(
+      expect.objectContaining({
+        data: communitiesToQuery,
+        prevPage: { before: 55, limit: 10 },
+        nextPage: { before: 55, limit: 10 },
+      }),
+    );
+  });
+
+  test('should update cache after fetching communities', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    await queryCommunities(queryCriteria);
+
+    const recieved = pullFromCache([
+      'community',
+      'query',
+      { ...queryCriteriaWithoutPage, options: pagingCriteria },
+    ])?.data;
+
+    expect(recieved).toEqual({
+      communities: communityIdsToQuery,
+      paging: pagingToken,
+    });
+
+    disableCache();
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(queryCommunities(queryCriteria)).rejects.toThrow('error');
+  });
+});
+
+describe.skip('queryCommunities.locally', () => {
+  beforeEach(() => enableCache());
+  afterEach(() => disableCache());
+
+  test('should return cached communities', () => {
+    communities.forEach(community =>
+      pushToCache(['community', 'get', community.communityId], community),
+    );
+
+    pushToCache(['community', 'query', { ...queryCriteriaWithoutPage, options: pagingCriteria }], {
+      communities: communitiesToQuery,
+      paging: pagingToken,
+    });
+
+    expect(queryCommunities.locally(queryCriteria)).toEqual(
+      expect.objectContaining({
+        data: communitiesToQuery,
+        prevPage: { before: 55, limit: 10 },
+        nextPage: { before: 55, limit: 10 },
+      }),
+    );
+  });
+
+  test(`shouldn't return if individual communities cache not exist`, () => {
+    pushToCache(['community', 'query', { ...queryCriteriaWithoutPage, options: pagingCriteria }], {
+      communities: communitiesToQuery,
+      paging: pagingToken,
+    });
+
+    expect(queryCommunities.locally(queryCriteria)).toBeUndefined();
+  });
+
+  test('it should return undefined if communities not in cache', () => {
+    expect(queryCommunities.locally({ displayName: 'non-existent' })).toBeUndefined();
+  });
+});

package/src/community/api/test/queryCommunityMembers.test.ts

@@ -0,0 +1,122 @@
+import { getResolver } from '~/core/model';
+
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMembershipPayload } from '~/group/utils';
+
+import { client, communityUserModel, communityUserQueryResponse } from '~/utils/tests';
+
+import { queryCommunityMembers } from '../queryCommunityMembers';
+
+describe('queryCommunityMembers', () => {
+  const { communityId } = communityUserQueryResponse.data.communities[0];
+
+  test('it should return community members', async () => {
+    const expected = communityUserQueryResponse.data.communityUsers;
+    client.http.get = jest.fn().mockResolvedValue(communityUserQueryResponse);
+
+    const { data: received } = await queryCommunityMembers({ communityId });
+
+    expect(received).toEqual(expected);
+  });
+
+  test('it should return community members and attach the user', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(communityUserQueryResponse);
+
+    const { data: received } = await queryCommunityMembers({ communityId });
+
+    expect(received).toEqual(communityUserModel);
+
+    disableCache();
+  });
+
+  test('it should throw error', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(queryCommunityMembers({ communityId })).rejects.toThrow('error');
+  });
+
+  test('it should update cache upon fetching data from server', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(communityUserQueryResponse);
+
+    const { data: received } = await queryCommunityMembers({ communityId });
+    const cache = queryCommunityMembers.locally({ communityId })?.data;
+
+    expect(cache).toBeDefined();
+    expect(received).toEqual(cache);
+
+    disableCache();
+  });
+});
+
+describe('queryCommunityMembers.locally', () => {
+  const { communityId } = communityUserQueryResponse.data.communities[0];
+  const cacheKey = ['communityUsers', 'query', { communityId, options: {} }];
+
+  test('it should fetch query locally if present in cache', () => {
+    enableCache();
+
+    const { paging, ...payload } = communityUserQueryResponse.data;
+    const preparedPayload = prepareMembershipPayload(payload, 'communityUsers');
+    const { communityUsers } = preparedPayload;
+
+    ingestInCache(preparedPayload);
+
+    pushToCache(cacheKey, {
+      communityUsers: communityUsers.map(({ communityId, userId }) =>
+        getResolver('communityUsers')({ communityId, userId }),
+      ),
+      paging,
+    });
+
+    const received = queryCommunityMembers.locally({ communityId })?.data;
+
+    expect(received).toBeDefined();
+    expect(received).toEqual(communityUserModel);
+
+    disableCache();
+  });
+
+  test('it should return undefined if only partial data in cache', () => {
+    enableCache();
+
+    const { paging, ...payload } = communityUserQueryResponse.data;
+    const preparedPayload = prepareMembershipPayload(payload, 'communityUsers');
+    const { communityUsers } = preparedPayload;
+
+    // ingest incomplete data
+    ingestInCache({
+      ...preparedPayload,
+      communityUsers: [payload.communityUsers[0]],
+    } as Amity.CommunityMembershipPayload);
+
+    pushToCache(cacheKey, {
+      communityUsers: communityUsers.map(({ communityId, userId }) =>
+        getResolver('communityUsers')({ communityId, userId }),
+      ),
+      paging,
+    });
+
+    const received = queryCommunityMembers.locally({ communityId })!;
+
+    expect(received).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if data not in cache', () => {
+    enableCache();
+
+    const received = queryCommunityMembers.locally({ communityId });
+
+    expect(received).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if cache disabled', () => {
+    expect(queryCommunityMembers.locally({ communityId })).toBeUndefined();
+  });
+});

package/src/community/api/test/removeCommunityMemberRole.test.ts

@@ -0,0 +1,67 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { getResolver } from '~/core/model';
+
+import { client, community11, communityUser11, user11 } from '~/utils/tests';
+
+import { removeCommunityMembersRoles } from '../removeCommunityMembersRoles';
+
+const community = community11;
+const roleToRemove = 'some-exist-role';
+const userToRemoveRole = { ...communityUser11, roles: [...communityUser11.roles, roleToRemove] };
+const removedRoleUser = { ...communityUser11 };
+
+const resolvedDeleteValue = {
+  data: {
+    communities: [community],
+    communityUsers: [removedRoleUser],
+    files: [],
+    users: [user11],
+    categories: [],
+    feeds: [],
+  },
+};
+
+describe('removeCommunityMembersRoles', () => {
+  test('should return true', async () => {
+    client.http.delete = jest.fn().mockResolvedValue(resolvedDeleteValue);
+
+    const recieved = removeCommunityMembersRoles(
+      community.communityId,
+      [roleToRemove],
+      [userToRemoveRole.userId],
+    );
+
+    await expect(recieved).resolves.toBe(true);
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.delete = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(
+      removeCommunityMembersRoles(community.communityId, [roleToRemove], [userToRemoveRole.userId]),
+    ).rejects.toThrow('error');
+  });
+
+  test('should create cache after added user', async () => {
+    enableCache();
+    client.http.delete = jest.fn().mockResolvedValue(resolvedDeleteValue);
+
+    await removeCommunityMembersRoles(
+      community.communityId,
+      [roleToRemove],
+      [userToRemoveRole.userId],
+    );
+    const recieved = pullFromCache([
+      'communityUsers',
+      'get',
+      getResolver('communityUsers')({
+        communityId: community.communityId,
+        userId: userToRemoveRole.userId,
+      }),
+    ])?.data;
+
+    expect(recieved).toEqual(expect.objectContaining(removedRoleUser));
+
+    disableCache();
+  });
+});

package/src/community/api/test/removeCommunityMembers.test.ts

@@ -0,0 +1,75 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { getResolver } from '~/core/model';
+
+import { client, community11, communityUser11, user11 } from '~/utils/tests';
+
+import { onCommunityUserRemoved } from '../../events';
+import { removeCommunityMembers } from '../removeCommunityMembers';
+
+const communityToRemoveUser = community11;
+const userToRemove = communityUser11;
+const removedUser = { ...communityUser11, communityMembership: 'none' };
+
+const resolvedDeleteValue = {
+  data: {
+    communities: [communityToRemoveUser],
+    communityUsers: [removedUser],
+    files: [],
+    users: [user11],
+    categories: [],
+    feeds: [],
+  },
+};
+
+describe('removeCommunityMembers', () => {
+  test('should return true value', async () => {
+    client.http.delete = jest.fn().mockResolvedValue(resolvedDeleteValue);
+
+    const recieved = removeCommunityMembers(communityToRemoveUser.communityId, [
+      userToRemove.userId,
+    ]);
+
+    await expect(recieved).resolves.toBe(true);
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.delete = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(
+      removeCommunityMembers(communityToRemoveUser.communityId, [userToRemove.userId]),
+    ).rejects.toThrow('error');
+  });
+
+  test('should create cache after removed user', async () => {
+    enableCache();
+    client.http.delete = jest.fn().mockResolvedValue(resolvedDeleteValue);
+
+    await removeCommunityMembers(communityToRemoveUser.communityId, [userToRemove.userId]);
+
+    const recieved = pullFromCache([
+      'communityUsers',
+      'get',
+      getResolver('communityUsers')({
+        communityId: communityToRemoveUser.communityId,
+        userId: userToRemove.userId,
+      }),
+    ])?.data;
+
+    expect(recieved).toEqual(expect.objectContaining(removedUser));
+
+    disableCache();
+  });
+
+  test('should fire event `onCommunityUserRemoved`', async () => {
+    let dispose;
+    client.http.delete = jest.fn().mockResolvedValueOnce(resolvedDeleteValue);
+
+    const callback = new Promise(resolve => {
+      dispose = onCommunityUserRemoved(resolve);
+    }).finally(dispose);
+
+    await removeCommunityMembers(communityToRemoveUser.communityId, [userToRemove.userId]);
+
+    await expect(callback).resolves.toEqual(expect.objectContaining(communityToRemoveUser));
+  });
+});

package/src/community/api/test/updateCommunity.test.ts

@@ -0,0 +1,65 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { client, community11, communityUser11, user11 } from '~/utils/tests';
+
+import { updateCommunity } from '../updateCommunity';
+import { onCommunityUpdated } from '../../events';
+
+const communityToUpdate = community11;
+const patch = { displayName: 'new-display-name' };
+const updatedCommunity = { ...communityToUpdate, ...patch };
+
+const resolvedPutValue = {
+  data: {
+    communities: [updatedCommunity],
+    communityUsers: [communityUser11],
+    files: [],
+    users: [user11],
+    categories: [],
+    feeds: [],
+  },
+};
+
+describe('updateCommunity', () => {
+  test('should return updated community', async () => {
+    client.http.put = jest.fn().mockResolvedValueOnce(resolvedPutValue);
+
+    const recieved = updateCommunity(communityToUpdate.communityId, patch);
+
+    await expect(recieved).resolves.toEqual(expect.objectContaining({ data: updatedCommunity }));
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.put = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(updateCommunity(communityToUpdate.communityId, patch)).rejects.toThrow('error');
+  });
+
+  test('should update cache after updated community', async () => {
+    enableCache();
+    client.http.put = jest.fn().mockResolvedValueOnce(resolvedPutValue);
+
+    await updateCommunity(communityToUpdate.communityId, patch);
+    const recieved = pullFromCache<Amity.Community>([
+      'community',
+      'get',
+      communityToUpdate.communityId,
+    ])?.data;
+
+    expect(recieved).toEqual(expect.objectContaining(updatedCommunity));
+
+    disableCache();
+  });
+
+  test('should fire event `onCommunityUpdated`', async () => {
+    let dispose;
+    client.http.put = jest.fn().mockResolvedValueOnce(resolvedPutValue);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onCommunityUpdated(resolve);
+    }).finally(dispose);
+
+    await updateCommunity(updatedCommunity.communityId, patch);
+
+    await expect(callbackPromise).resolves.toEqual(expect.objectContaining(updatedCommunity));
+  });
+});

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

@@ -0,0 +1,46 @@
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  community11,
+  communityUser11,
+} from '~/utils/tests';
+
+import { onCommunityCreated } from '../onCommunityCreated';
+
+const communityToCreate = community11;
+
+const eventPayload: Amity.CommunityPayload = {
+  communities: [communityToCreate],
+  communityUsers: [communityUser11],
+  files: [],
+  users: [],
+  categories: [],
+  feeds: [],
+};
+
+describe('onCommunityCreated', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('it should got event after community created', () => {
+    const callback = jest.fn();
+    const unsub = onCommunityCreated(callback);
+    client.emitter.emit('community.created', eventPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(communityToCreate);
+  });
+
+  test('it should got nothing if we did unsubscribe before got event', () => {
+    const callback = jest.fn();
+    const unsub = onCommunityCreated(callback);
+
+    unsub();
+
+    client.emitter.emit('community.created', eventPayload);
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,35 @@
+import { client, connectClient, disconnectClient, community11 } from '~/utils/tests';
+
+import { onCommunityDeleted } from '../onCommunityDeleted';
+
+const deletedCommunity = { ...community11, isDeleted: true };
+
+const eventPayload: Amity.CommunityPayload = {
+  communities: [deletedCommunity],
+};
+
+describe('onCommunityDeleted', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('it should got event after community deleted', () => {
+    const callback = jest.fn();
+    const unsub = onCommunityDeleted(callback);
+    client.emitter.emit('community.deleted', eventPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(deletedCommunity);
+  });
+
+  test('it should got nothing if we did unsubscribe before got event', () => {
+    const callback = jest.fn();
+    const unsub = onCommunityDeleted(callback);
+
+    unsub();
+
+    client.emitter.emit('community.deleted', eventPayload);
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,50 @@
+import { withUser } from '~/group/utils';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  community11,
+  communityUser11,
+  user11,
+} from '~/utils/tests';
+
+import { onCommunityJoined } from '../onCommunityJoined';
+
+const communityToJoin = community11;
+const joinedUserRaw = communityUser11;
+const joinedUser = withUser(joinedUserRaw);
+
+const eventPayload: Amity.CommunityMembershipPayload = {
+  communities: [communityToJoin],
+  communityUsers: [joinedUserRaw],
+  files: [],
+  users: [user11],
+  categories: [],
+  feeds: [],
+};
+
+describe('onCommunityJoined', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('it should got event after join community', () => {
+    const callback = jest.fn();
+    const unsub = onCommunityJoined(callback);
+    client.emitter.emit('community.joined', eventPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(communityToJoin, joinedUser);
+  });
+
+  test('it should got nothing if we did unsubscribe before got event', () => {
+    const callback = jest.fn();
+    const unsub = onCommunityJoined(callback);
+
+    unsub();
+
+    client.emitter.emit('community.joined', eventPayload);
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,50 @@
+import { withUser } from '~/group/utils';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  community11,
+  communityUser11,
+  user11,
+} from '~/utils/tests';
+
+import { onCommunityLeft } from '../onCommunityLeft';
+
+const communityToLeave = community11;
+const leavedUserRaw = { ...communityUser11, communityMembership: 'none' as const };
+const leavedUser = withUser(leavedUserRaw);
+
+const eventPayload: Amity.CommunityMembershipPayload = {
+  communities: [communityToLeave],
+  communityUsers: [leavedUserRaw],
+  files: [],
+  users: [user11],
+  categories: [],
+  feeds: [],
+};
+
+describe('onCommunityLeft', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('it should got event after left community', () => {
+    const callback = jest.fn();
+    const unsub = onCommunityLeft(callback);
+    client.emitter.emit('community.left', eventPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(communityToLeave, leavedUser);
+  });
+
+  test('it should got nothing if we did unsubscribe before got event', () => {
+    const callback = jest.fn();
+    const unsub = onCommunityLeft(callback);
+
+    unsub();
+
+    client.emitter.emit('community.left', eventPayload);
+    expect(callback).not.toHaveBeenCalled();
+  });
+});