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

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

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

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

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

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

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

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

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

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

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

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