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

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

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

package/src/community/api/test/addCommunityMemberRole.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 { addCommunityMembersRoles } from '../addCommunityMembersRoles';
+
+const roleToAdd = 'some-new-sole';
+const userCommunity = community11;
+const userToAddRole = communityUser11;
+
+const addedRoleUser = {
+  ...userToAddRole,
+  roles: [...userToAddRole.roles, roleToAdd],
+};
+
+const resolvedPostValue = {
+  data: {
+    communities: [userCommunity],
+    communityUsers: [addedRoleUser],
+    files: [],
+    users: [user11],
+    categories: [],
+    feeds: [],
+  },
+};
+
+describe('addCommunityMembersRoles', () => {
+  test('should return true', async () => {
+    client.http.post = jest.fn().mockResolvedValue(resolvedPostValue);
+
+    const recieved = addCommunityMembersRoles(
+      userCommunity.communityId,
+      [roleToAdd],
+      [userToAddRole.userId],
+    );
+
+    await expect(recieved).resolves.toBe(true);
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(
+      addCommunityMembersRoles(userCommunity.communityId, [roleToAdd], [userToAddRole.userId]),
+    ).rejects.toThrow('error');
+  });
+
+  test('should create cache after added user', async () => {
+    enableCache();
+    client.http.post = jest.fn().mockResolvedValue(resolvedPostValue);
+
+    await addCommunityMembersRoles(userCommunity.communityId, [roleToAdd], [userToAddRole.userId]);
+    const recieved = pullFromCache([
+      'communityUsers',
+      'get',
+      getResolver('communityUsers')({
+        communityId: userCommunity.communityId,
+        userId: userToAddRole.userId,
+      }),
+    ])?.data;
+
+    expect(recieved).toEqual(expect.objectContaining(addedRoleUser));
+
+    disableCache();
+  });
+});

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

@@ -0,0 +1,61 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+
+import { client, community11, communityUser11 } from '~/utils/tests';
+
+import { onCommunityCreated } from '../../events';
+import { createCommunity } from '../createCommunity';
+
+const communityToCreate = community11;
+const { communityId: createId, ...payload } = communityToCreate;
+
+const resolvedPostValue = {
+  data: {
+    communities: [communityToCreate],
+    communityUsers: [communityUser11],
+    files: [],
+    users: [],
+    categories: [],
+    feeds: [],
+  },
+};
+
+describe('createCommunity', () => {
+  test('should return created community', async () => {
+    client.http.post = jest.fn().mockResolvedValue(resolvedPostValue);
+
+    const recieved = createCommunity(payload);
+
+    await expect(recieved).resolves.toEqual(expect.objectContaining({ data: communityToCreate }));
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(createCommunity(payload)).rejects.toThrow('error');
+  });
+
+  test('should create cache after created community', async () => {
+    enableCache();
+    client.http.post = jest.fn().mockResolvedValue(resolvedPostValue);
+
+    await createCommunity(payload);
+    const recieved = pullFromCache(['community', 'get', createId])?.data;
+
+    expect(recieved).toEqual(expect.objectContaining(communityToCreate));
+
+    disableCache();
+  });
+
+  test('should fire event `onCommunityCreated`', async () => {
+    let dispose;
+    client.http.post = jest.fn().mockResolvedValueOnce(resolvedPostValue);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onCommunityCreated(resolve);
+    }).finally(dispose);
+
+    await createCommunity(payload);
+
+    await expect(callbackPromise).resolves.toEqual(expect.objectContaining(communityToCreate));
+  });
+});

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

@@ -0,0 +1,74 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { client, community11, communityUser11, user11 } from '~/utils/tests';
+
+import { deleteCommunity } from '../deleteCommunity';
+import { onCommunityDeleted } from '../../events';
+
+const communityToDelete = community11;
+const { communityId: deleteId } = communityToDelete;
+const deletedCommunity = { ...communityToDelete, isDeleted: true };
+const { updatedAt, ...deletedCommunityWithoutTS } = deletedCommunity;
+
+const resolvedDeleteValue = {
+  data: {
+    success: true,
+  },
+};
+
+const resolvedGetValue = {
+  data: {
+    communities: [deletedCommunity],
+    communityUsers: [communityUser11],
+    files: [],
+    users: [user11],
+    categories: [],
+    feeds: [],
+  },
+};
+
+describe('deleteCommunity', () => {
+  test('should return deleted community', async () => {
+    client.http.delete = jest.fn().mockResolvedValueOnce(resolvedDeleteValue);
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedGetValue);
+
+    await expect(deleteCommunity(deleteId)).resolves.toEqual(
+      expect.objectContaining(deletedCommunityWithoutTS),
+    );
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.delete = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(deleteCommunity(deleteId)).rejects.toThrow('error');
+  });
+
+  test('should update cache after deleted community', async () => {
+    enableCache();
+    client.http.delete = jest.fn().mockResolvedValueOnce(resolvedDeleteValue);
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedGetValue);
+    pushToCache(['community', 'get', deleteId], communityToDelete);
+
+    await deleteCommunity(deleteId);
+    const recieved = pullFromCache(['community', 'get', deleteId])?.data;
+
+    expect(recieved).toEqual(expect.objectContaining(deletedCommunityWithoutTS));
+
+    disableCache();
+  });
+
+  test('should fire event `onCommunityDeleted`', async () => {
+    let dispose;
+    client.http.delete = jest.fn().mockResolvedValueOnce(resolvedDeleteValue);
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedGetValue);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onCommunityDeleted(resolve);
+    }).finally(dispose);
+
+    await deleteCommunity(deleteId);
+
+    await expect(callbackPromise).resolves.toEqual(
+      expect.objectContaining(deletedCommunityWithoutTS),
+    );
+  });
+});

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

@@ -0,0 +1,73 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { client, community11, community21 } from '~/utils/tests';
+
+import { getCommunities } from '../getCommunities';
+
+const communitiesToGet = [community11, community21];
+const getIds = communitiesToGet.map(({ communityId }) => communityId);
+
+const resolvedGetValue = {
+  data: {
+    communities: communitiesToGet,
+    communityUsers: [community11, community21],
+    files: [],
+    users: [],
+    categories: [],
+    feeds: [],
+  },
+};
+
+describe('getCommunities', () => {
+  test('should return fetched communities', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedGetValue);
+
+    await expect(getCommunities(getIds)).resolves.toEqual(
+      expect.objectContaining({ data: communitiesToGet }),
+    );
+  });
+
+  test('should update cache after fetching communities', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    await getCommunities(getIds);
+
+    const recieved = getIds.map(id => pullFromCache(['community', 'get', id])?.data);
+
+    expect(recieved).toEqual(communitiesToGet);
+
+    disableCache();
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(getCommunities(getIds)).rejects.toThrow('error');
+  });
+});
+
+describe('getCommunities.locally', () => {
+  beforeEach(() => enableCache());
+  afterEach(() => disableCache());
+
+  test('should return cached communities', () => {
+    communitiesToGet.forEach(community =>
+      pushToCache(['community', 'get', community.communityId], community),
+    );
+
+    expect(getCommunities.locally(getIds)?.data).toEqual(communitiesToGet);
+  });
+
+  test('it should return undefined if communities not in cache', () => {
+    expect(getCommunities.locally(['non-existent-communities'])).toBeUndefined();
+  });
+
+  test('should return undefined if cache not enabled', () => {
+    disableCache();
+    communitiesToGet.forEach(community =>
+      pushToCache(['community', 'get', community.communityId], community),
+    );
+
+    expect(getCommunities.locally(getIds)).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,69 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { client, community11 } from '~/utils/tests';
+
+import { getCommunity } from '../getCommunity';
+
+const communityToGet = community11;
+const getId = community11.communityId;
+
+const resolvedGetValue = {
+  data: {
+    communities: [communityToGet],
+    communityUsers: [community11],
+    files: [],
+    users: [],
+    categories: [],
+    feeds: [],
+  },
+};
+
+describe('getCommunity', () => {
+  test('should return fetched community', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedGetValue);
+
+    await expect(getCommunity(getId)).resolves.toEqual(
+      expect.objectContaining({ data: communityToGet }),
+    );
+  });
+
+  test('should update cache after fetching community', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    await getCommunity(getId);
+
+    const recieved = pullFromCache(['community', 'get', getId])?.data;
+
+    expect(recieved).toEqual(communityToGet);
+
+    disableCache();
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(getCommunity(getId)).rejects.toThrow('error');
+  });
+});
+
+describe('getCommunity.locally', () => {
+  beforeEach(() => enableCache());
+  afterEach(() => disableCache());
+
+  test('should return cached community', () => {
+    pushToCache(['community', 'get', getId], communityToGet);
+
+    expect(getCommunity.locally(getId)?.data).toEqual(communityToGet);
+  });
+
+  test('it should return undefined if community not in cache', () => {
+    expect(getCommunity.locally('non-existent-community')).toBeUndefined();
+  });
+
+  test('should return undefined if cache not enabled', () => {
+    disableCache();
+    pushToCache(['community', 'get', getId], communityToGet);
+
+    expect(getCommunity.locally(getId)).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,102 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { client, community11, community21 } from '~/utils/tests';
+
+import { getRecommendedCommunities } from '../getRecommendedCommunities';
+
+const recommendedCommunities = [community11, community21];
+const recommendedIds = recommendedCommunities.map(({ communityId }) => communityId);
+
+const pagingToken = {
+  previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+  next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+};
+
+const pagingCriteria = { limit: 10 };
+
+const resolvedGetValue = {
+  data: {
+    communities: recommendedCommunities,
+    communityUsers: [community11, community21],
+    files: [],
+    users: [],
+    categories: [],
+    feeds: [],
+    paging: pagingToken,
+  },
+};
+
+describe('getRecommendedCommunities', () => {
+  test('should return fetched recommended communities with correct paging', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedGetValue);
+
+    await expect(getRecommendedCommunities(pagingCriteria)).resolves.toEqual(
+      expect.objectContaining({ data: recommendedCommunities }),
+    );
+  });
+
+  test('should update cache after fetching recommended communities', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    await getRecommendedCommunities(pagingCriteria);
+
+    const recieved = pullFromCache([
+      'community',
+      'recommended',
+      { params: { options: pagingCriteria } },
+    ])?.data;
+
+    expect(recieved).toEqual({ communities: recommendedIds });
+
+    disableCache();
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(getRecommendedCommunities(pagingCriteria)).rejects.toThrow('error');
+  });
+});
+
+describe('getRecommendedCommunities.locally', () => {
+  beforeEach(() => enableCache());
+  afterEach(() => disableCache());
+
+  test('should return cached recommended communities', () => {
+    recommendedCommunities.forEach(community =>
+      pushToCache(['community', 'get', community.communityId], community),
+    );
+
+    pushToCache(['community', 'recommended', { params: { options: pagingCriteria } }], {
+      communities: recommendedIds,
+    });
+
+    expect(getRecommendedCommunities.locally(pagingCriteria)?.data).toEqual(recommendedCommunities);
+  });
+
+  test('it should return undefined if recommended communities not in cache', () => {
+    recommendedCommunities.forEach(community =>
+      pushToCache(['community', 'get', community.communityId], community),
+    );
+
+    pushToCache(['community', 'recommended', { params: { options: pagingCriteria } }], {
+      communities: recommendedIds,
+    });
+
+    expect(getRecommendedCommunities.locally({ limit: -1 })).toBeUndefined();
+  });
+
+  test('should return undefined if cache not enabled', () => {
+    disableCache();
+
+    recommendedCommunities.forEach(community =>
+      pushToCache(['community', 'get', community.communityId], community),
+    );
+
+    pushToCache(['community', 'recommended', { params: { options: pagingCriteria } }], {
+      communities: recommendedIds,
+    });
+
+    expect(getRecommendedCommunities.locally(pagingCriteria)).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,102 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { client, community11, community21 } from '~/utils/tests';
+
+import { getTopTrendingCommunities } from '../getTopTrendingCommunities';
+
+const topTrendCommunities = [community11, community21];
+const topTrendIds = topTrendCommunities.map(({ communityId }) => communityId);
+
+const pagingToken = {
+  previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+  next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+};
+
+const pagingCriteria = { limit: 10 };
+
+const resolvedGetValue = {
+  data: {
+    communities: topTrendCommunities,
+    communityUsers: [community11, community21],
+    files: [],
+    users: [],
+    categories: [],
+    feeds: [],
+    paging: pagingToken,
+  },
+};
+
+describe('getTopTrendingCommunities', () => {
+  test('should return fetched top trend communities with correct paging', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedGetValue);
+
+    await expect(getTopTrendingCommunities(pagingCriteria)).resolves.toEqual(
+      expect.objectContaining({ data: topTrendCommunities }),
+    );
+  });
+
+  test('should update cache after fetching top trend communities', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    await getTopTrendingCommunities(pagingCriteria);
+
+    const recieved = pullFromCache([
+      'community',
+      'top-trending',
+      { params: { options: pagingCriteria } },
+    ])?.data;
+
+    expect(recieved).toEqual({ communities: topTrendIds });
+
+    disableCache();
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(getTopTrendingCommunities(pagingCriteria)).rejects.toThrow('error');
+  });
+});
+
+describe('getTopTrendingCommunities.locally', () => {
+  beforeEach(() => enableCache());
+  afterEach(() => disableCache());
+
+  test('should return cached top trend communities', () => {
+    topTrendCommunities.forEach(community =>
+      pushToCache(['community', 'get', community.communityId], community),
+    );
+
+    pushToCache(['community', 'top-trending', { params: { options: pagingCriteria } }], {
+      communities: topTrendIds,
+    });
+
+    expect(getTopTrendingCommunities.locally(pagingCriteria)?.data).toEqual(topTrendCommunities);
+  });
+
+  test('it should return undefined if top trend communities not in cache', () => {
+    topTrendCommunities.forEach(community =>
+      pushToCache(['community', 'get', community.communityId], community),
+    );
+
+    pushToCache(['community', 'top-trending', { params: { options: pagingCriteria } }], {
+      communities: topTrendIds,
+    });
+
+    expect(getTopTrendingCommunities.locally({ limit: -1 })).toBeUndefined();
+  });
+
+  test('should return undefined if cache not enabled', () => {
+    disableCache();
+
+    topTrendCommunities.forEach(community =>
+      pushToCache(['community', 'get', community.communityId], community),
+    );
+
+    pushToCache(['community', 'top-trending', { params: { options: pagingCriteria } }], {
+      communities: topTrendIds,
+    });
+
+    expect(getTopTrendingCommunities.locally(pagingCriteria)).toBeUndefined();
+  });
+});

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

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