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

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));
+  });
+});

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();
+  });
+});