@amityco/ts-sdk 0.0.1-beta.39 → 0.0.1-beta.40

package/src/core/tests/subscription.test.ts

@@ -1,6 +1,9 @@
-import { getChannelTopic, getMessageTopic } from '../subscription';
+import { ASCUnknownError } from '~/core/errors';
+import { connectClient, disconnectClient, client } from '~/utils/tests';
 
-describe('Subscription', () => {
+import { getChannelTopic, getMessageTopic, subscribeTopic } from '../subscription';
+
+describe('getTopic', () => {
   test('should generate channel topic', () => {
     const channel = { path: 'channel-path' };
 
@@ -13,3 +16,78 @@ describe('Subscription', () => {
     expect(getMessageTopic(message)).toEqual('message-path');
   });
 });
+
+describe('subscription', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  const channel = { path: 'channel-path' };
+
+  // integration_test_id: cb1b5450-b131-4a00-9c47-aad26f415b20
+  test('it should return succesfull result for valid topic', () => {
+    client.mqtt.subscribe = jest.fn().mockImplementation(() => () => null);
+
+    const recieved = subscribeTopic(getChannelTopic(channel), () => null);
+
+    expect(recieved).toBeTruthy();
+  });
+
+  // integration_test_id: 09db1790-08e1-43d2-a674-866c5dd3c75c
+  test('it should return 800000 for subscribing to invalid topid', () => {
+    const expected = new ASCUnknownError(Amity.ClientError.UNKNOWN_ERROR, Amity.ErrorLevel.ERROR);
+    client.mqtt.subscribe = jest.fn().mockImplementation(() => () => {
+      throw expected;
+    });
+
+    try {
+      subscribeTopic('invalid topic', () => null);
+    } catch (error) {
+      expect(error).toEqual(expected);
+    }
+  });
+
+  test('it should call mqtt connect if accesstoken does not match', () => {
+    const callback = jest.fn();
+
+    client.token = { accessToken: '', issuedAt: '', expiresAt: '' };
+    client.mqtt.connect = callback;
+
+    subscribeTopic(getChannelTopic(channel), () => null);
+
+    expect(callback).toHaveBeenCalled();
+  });
+});
+
+describe('unsubsribe', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  const channel = { path: 'channel-path' };
+
+  // integration_test_id: 87978499-5f4e-4a36-a092-56dde566329a
+  test('it should succesfully call unsubsribe', () => {
+    client.mqtt.unsubscribe = jest.fn().mockImplementation(() => true);
+    client.mqtt.subscribe = jest.fn().mockImplementation(() => client.mqtt.unsubscribe);
+
+    const recieved = subscribeTopic(getChannelTopic(channel), () => null);
+
+    expect(recieved()).toEqual(true);
+  });
+
+  // integration_test_id: 8d444682-453d-44f8-b8c1-8c282e7db4bc
+  test('it should throw error', () => {
+    const expected = new ASCUnknownError(Amity.ClientError.UNKNOWN_ERROR, Amity.ErrorLevel.ERROR);
+    client.mqtt.unsubscribe = jest.fn().mockImplementation(() => {
+      throw expected;
+    });
+    client.mqtt.subscribe = jest.fn().mockImplementation(() => client.mqtt.unsubscribe);
+
+    try {
+      const recieved = subscribeTopic('invalid topic', () => null);
+
+      recieved();
+    } catch (error) {
+      expect(error).toEqual(expected);
+    }
+  });
+});

package/src/external/api/tests/createUserToken.test.ts

@@ -0,0 +1,29 @@
+import { getFutureDate } from '~/core/model';
+import { createHttpTransport } from '~/core/transports';
+import { createUserToken } from '../createUserToken';
+
+jest.mock('~/core/transports', () => ({
+  __esModule: true,
+  ...jest.requireActual('~/core/transports'),
+  createHttpTransport: jest.fn(),
+}));
+
+describe('createUserToken', () => {
+  // integration_test_id: 4771d3b9-1a05-4942-85e1-d2abea936c2f
+  it('should return a valid token', async () => {
+    const payload = {
+      accessToken: 'accessToken',
+      refreshToken: 'refreshToken',
+      issuedAt: new Date().toISOString(),
+      expiresAt: getFutureDate(),
+    };
+    (createHttpTransport as jest.Mock).mockReturnValue({ post: () => ({ data: payload }) });
+
+    const { accessToken } = await createUserToken('apiKey', 'sg', {
+      userId: 'userId',
+      displayName: 'displayName',
+    });
+
+    expect(accessToken).toStrictEqual('accessToken');
+  });
+});

package/src/feed/api/queryGlobalFeed.ts

@@ -4,6 +4,7 @@ import { toPage, toToken } from '~/core/query';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { pullFromCache, pushToCache } from '~/cache/api';
 import { getResolver } from '~/core/model';
+import { prepareMembershipPayload } from '~/group/utils';
 
 /**
  * ```js
@@ -29,7 +30,7 @@ export const queryGlobalFeed = async (query?: {
 
   const { useCustomRanking, page, ...params } = query ?? {};
 
-  const { data } = await client.http.get<Amity.PostPayload & Amity.Pagination>(
+  const { data: queryPayload } = await client.http.get<Amity.PostPayload & Amity.Pagination>(
     useCustomRanking ? `/api/v5/me/global-feeds` : `/api/v4/me/global-feeds`,
     {
       params: {
@@ -41,13 +42,16 @@ export const queryGlobalFeed = async (query?: {
     },
   );
 
-  const { paging, ...payload } = data;
-  const { posts } = payload;
+  const { paging, ...payload } = queryPayload;
+
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+
+  const { posts } = data;
 
   const cachedAt = client.cache && Date.now();
 
   if (client.cache) {
-    ingestInCache(payload as Amity.PostPayload);
+    ingestInCache(data);
 
     const cacheKey = [
       'globalFeed',

package/src/group/utils/test/withUsers.test.ts

@@ -5,15 +5,15 @@ import { baseMembership, user11, user12 } from '~/utils/tests';
 
 const users = [user11, user12];
 
-const member1: Amity.MembershipRaw<Amity.GroupType> = { ...baseMembership, userId: user11.userId };
+const member1: Amity.RawMembership<Amity.GroupType> = { ...baseMembership, userId: user11.userId };
 const mappedMember1: Amity.Membership<Amity.GroupType> = { ...member1, user: user11 };
 const unmapableMember1: Amity.Membership<Amity.GroupType> = { ...member1, user: undefined };
 
-const member2: Amity.MembershipRaw<Amity.GroupType> = { ...baseMembership, userId: user12.userId };
+const member2: Amity.RawMembership<Amity.GroupType> = { ...baseMembership, userId: user12.userId };
 const mappedMember2: Amity.Membership<Amity.GroupType> = { ...member2, user: user12 };
 const unmapableMember2: Amity.Membership<Amity.GroupType> = { ...member2, user: undefined };
 
-const members1: Amity.MembershipRaw<Amity.GroupType>[] = [member1, member2];
+const members1: Amity.RawMembership<Amity.GroupType>[] = [member1, member2];
 const mappedMembers1: Amity.Membership<Amity.GroupType>[] = [mappedMember1, mappedMember2];
 const unmapableMembers1: Amity.Membership<Amity.GroupType>[] = [unmapableMember1, unmapableMember2];
 
@@ -49,7 +49,7 @@ describe('withUser', () => {
   test('`.user` should return undefined when user not exist', () => {
     enableCache();
     ingestInCache({ users });
-    const member: Amity.MembershipRaw<Amity.GroupType> = {
+    const member: Amity.RawMembership<Amity.GroupType> = {
       ...member1,
       userId: 'not-exist-user-id',
     };
@@ -83,7 +83,7 @@ describe('withUsers', () => {
   test('`.user` should return undefined when some user not exist', () => {
     enableCache();
     ingestInCache({ users });
-    const members: Amity.MembershipRaw<Amity.GroupType>[] = [
+    const members: Amity.RawMembership<Amity.GroupType>[] = [
       ...members1,
       { ...member1, userId: 'not-exist-user-id' },
     ];

package/src/group/utils/withUser.ts

@@ -23,22 +23,27 @@ export const withUser = <
   member: M,
   userIdProp: I = <I>'userId',
   userProp: U = <U>'user',
-): Record<U, Amity.User | undefined> & M => ({
-  get [userProp]() {
-    const client = getActiveClient();
+): Record<U, Amity.User | undefined> & M => {
+  // If the user prop already exists, do not overwrite.
+  if (member[userProp]) return member;
 
-    if (!client.cache) return undefined;
+  return {
+    get [userProp]() {
+      const client = getActiveClient();
 
-    const userCache = pullFromCache<Amity.User>(['user', 'get', member[userIdProp]])?.data;
+      if (!client.cache) return undefined;
 
-    if (!userCache) {
-      return undefined;
-    }
+      const userCache = pullFromCache<Amity.User>(['user', 'get', member[userIdProp]])?.data;
 
-    return userCache;
-  },
-  ...member,
-});
+      if (!userCache) {
+        return undefined;
+      }
+
+      return userCache;
+    },
+    ...member,
+  };
+};
 
 /**
  * Mapping membership model with user object
@@ -58,8 +63,9 @@ export const withUsers = <
   members: M,
   userIdProp: I = <I>'userId',
   userProp: U = <U>'user',
-): (Record<U, Amity.User | undefined> & M[number])[] =>
-  members.map(member => withUser(member, userIdProp, userProp));
+): (Record<U, Amity.User | undefined> & M[number])[] => {
+  return members?.map(member => withUser(member, userIdProp, userProp)) ?? members;
+};
 
 /**
  * Transform members prop in any payload with attached users members

package/src/message/api/createMessage.ts

@@ -4,7 +4,8 @@ import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
 import { upsertInCache, pullFromCache, pushToCache, dropFromCache } from '~/cache/api';
-import { convertParams, convertResponseFromRaw } from '../utils';
+
+import { convertParams, prepareMessagePayload } from '../utils';
 
 // FIXME: temp solution
 let uniqueId: string | undefined;
@@ -45,12 +46,14 @@ export const createMessage = async <T extends Amity.MessageContentType>(
 
   const referenceId = uniqueId;
   uniqueId = undefined;
-  const { data } = await client.http
-    .post<Amity.RawMessagePayload>('/api/v5/messages', {
-      ...convertParams(bundle),
-      referenceId,
-    })
-    .then(convertResponseFromRaw);
+
+  const { data: payload } = await client.http.post<Amity.MessagePayload>('/api/v5/messages', {
+    ...convertParams(bundle),
+    referenceId,
+  });
+
+  const data = prepareMessagePayload(payload);
+  const { messages } = data;
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) {
@@ -58,8 +61,6 @@ export const createMessage = async <T extends Amity.MessageContentType>(
     ingestInCache(data, { cachedAt });
   }
 
-  const { messages } = data;
-
   fireEvent('local.message.created', { messages });
 
   return {

package/src/message/api/getMessage.ts

@@ -38,12 +38,12 @@ export const getMessage = async (
 
   isInTombstone('message', messageId);
 
-  let data: Amity.MessagePayload;
+  let data: Amity.ProcessedMessagePayload;
 
   try {
     // API-FIX: endpoint should not be /list, parameters should be querystring.
     const response = await client.http
-      .get<Amity.RawMessagePayload>(`/api/v5/messages/${encodeURIComponent(messageId)}`)
+      .get<Amity.MessagePayload>(`/api/v5/messages/${encodeURIComponent(messageId)}`)
       .then(convertResponseFromRaw);
 
     data = response.data;

package/src/message/api/getMessages.ts

@@ -26,7 +26,7 @@ export const getMessages = async (
   client.log('message/getMessages', messageIds);
 
   const { data } = await client.http
-    .get<Amity.RawMessagePayload>(`/api/v5/messages/list`, {
+    .get<Amity.MessagePayload>(`/api/v5/messages/list`, {
       params: { messageIds: messageIds.map(encodeURIComponent) },
     })
     .then(convertResponseFromRaw);

package/src/message/api/queryMessages.ts

@@ -34,7 +34,7 @@ export const queryMessages = async (
   // API-FIX: pagination should not be indexed on channelSegment (3)
   // const { data } = await client.http.get<Amity.Response<Amity.Paged<Amity.MessagePayload>>>(
   const response = await client.http
-    .get<Amity.RawMessagePayload & Amity.Pagination>(`/api/v5/messages`, { params })
+    .get<Amity.MessagePayload & Amity.Pagination>(`/api/v5/messages`, { params })
     .then(convertResponseFromRaw);
 
   // API-FIX: backend should answer Amity.Response (2)
@@ -45,7 +45,7 @@ export const queryMessages = async (
   const cachedAt = client.cache && Date.now();
 
   if (client.cache) {
-    ingestInCache(data as Amity.MessagePayload, { cachedAt });
+    ingestInCache(data as Amity.ProcessedMessagePayload, { cachedAt });
 
     const cacheKey = ['message', 'query', params as Amity.Serializable];
     pushToCache(cacheKey, { messages: messages.map(getResolver('message')), paging });

package/src/message/api/tests/createMessage.test.ts

@@ -178,7 +178,11 @@ describe('uniqueId / referenceId', () => {
     const callback = jest.fn();
 
     onMessageCreated(callback);
-    client.emitter.emit('message.created', { messages: [rawNewMessage] });
+    client.emitter.emit('message.created', {
+      messages: [rawNewMessage],
+      files: [],
+      users: [],
+    });
     await pause();
 
     expect(callback).toHaveBeenCalledWith(

package/src/message/api/updateMessage.ts

@@ -30,7 +30,7 @@ export const updateMessage = async (
   client.log('message/updateMessage', patch);
 
   const { data } = await client.http
-    .put<Amity.RawMessagePayload>(
+    .put<Amity.MessagePayload>(
       `/api/v5/messages/${encodeURIComponent(messageId)}`,
       convertParams(patch),
     )

package/src/message/events/onMessageCreated.ts

@@ -24,7 +24,7 @@ import { prepareMessagePayload } from '../utils';
 export const onMessageCreated = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
   const client = getActiveClient();
 
-  const filter = (rawPayload: Amity.RawMessagePayload) => {
+  const filter = (rawPayload: Amity.MessagePayload) => {
     const payload = prepareMessagePayload(rawPayload);
     const message = payload.messages[0];
     const cached = pullFromCache<Amity.Channel>(['channel', 'get', message.channelId]);

package/src/message/events/onMessageDeleted.ts

@@ -22,7 +22,7 @@ import { prepareMessagePayload } from '../utils';
 export const onMessageDeleted = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
   const client = getActiveClient();
 
-  const filter = (rawPayload: Amity.RawMessagePayload) => {
+  const filter = (rawPayload: Amity.MessagePayload) => {
     const payload = prepareMessagePayload(rawPayload);
 
     ingestInCache(payload);

package/src/message/events/onMessageFetched.ts

@@ -21,7 +21,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 export const onMessageFetched = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.MessagePayload) => {
+  const filter = (payload: Amity.Events['local.message.fetched']) => {
     ingestInCache(payload);
     callback(payload.messages[0]);
   };

package/src/message/events/onMessageFlagCleared.ts

@@ -23,7 +23,7 @@ export const onMessageFlagCleared = (
 ): Amity.Unsubscriber => {
   const client = getActiveClient();
 
-  const filter = (rawPayload: Amity.RawMessagePayload) => {
+  const filter = (rawPayload: Amity.MessagePayload) => {
     const payload = prepareMessagePayload(rawPayload);
 
     ingestInCache(payload);

package/src/message/events/onMessageFlagged.ts

@@ -22,7 +22,7 @@ import { prepareMessagePayload } from '../utils';
 export const onMessageFlagged = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
   const client = getActiveClient();
 
-  const filter = (rawPayload: Amity.RawMessagePayload) => {
+  const filter = (rawPayload: Amity.MessagePayload) => {
     const payload = prepareMessagePayload(rawPayload);
 
     ingestInCache(payload);

package/src/message/events/onMessageReactionAdded.ts

@@ -24,7 +24,7 @@ export const onMessageReactionAdded = (
 ): Amity.Unsubscriber => {
   const client = getActiveClient();
 
-  const filter = (rawPayload: Amity.RawMessagePayload) => {
+  const filter = (rawPayload: Amity.MessagePayload) => {
     const payload = prepareMessagePayload(rawPayload);
 
     ingestInCache(payload);

package/src/message/events/onMessageReactionRemoved.ts

@@ -24,7 +24,7 @@ export const onMessageReactionRemoved = (
 ): Amity.Unsubscriber => {
   const client = getActiveClient();
 
-  const filter = (rawPayload: Amity.RawMessagePayload) => {
+  const filter = (rawPayload: Amity.MessagePayload) => {
     const payload = prepareMessagePayload(rawPayload);
 
     ingestInCache(payload);

package/src/message/events/onMessageUnflagged.ts

@@ -21,7 +21,7 @@ import { prepareMessagePayload } from '../utils';
 export const onMessageUnflagged = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
   const client = getActiveClient();
 
-  const filter = (rawPayload: Amity.RawMessagePayload) => {
+  const filter = (rawPayload: Amity.MessagePayload) => {
     const payload = prepareMessagePayload(rawPayload);
 
     ingestInCache(payload);

package/src/message/events/onMessageUpdated.ts

@@ -22,7 +22,7 @@ import { prepareMessagePayload } from '../utils';
 export const onMessageUpdated = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
   const client = getActiveClient();
 
-  const filter = (rawPayload: Amity.RawMessagePayload) => {
+  const filter = (rawPayload: Amity.MessagePayload) => {
     const payload = prepareMessagePayload(rawPayload);
 
     ingestInCache(payload);

package/src/message/tests/events.test.ts

@@ -32,7 +32,11 @@ describe('Message Events', () => {
     test(`should call '${onEvent.name}' callback if '${event}' event is dispatched`, () => {
       const callback = jest.fn();
       const unsubscribe = onEvent(callback);
-      client.emitter.emit(event, { messages: [rawMessage] });
+      client.emitter.emit(event, {
+        messages: [rawMessage],
+        files: [],
+        users: [],
+      });
 
       unsubscribe();
 
@@ -45,7 +49,11 @@ describe('Message Events', () => {
       const unsubscribe = onEvent(callback);
 
       unsubscribe();
-      client.emitter.emit(event, { messages: [rawMessage] });
+      client.emitter.emit(event, {
+        files: [],
+        users: [],
+        messages: [rawMessage],
+      });
 
       expect(callback).not.toHaveBeenCalled();
     });

package/src/message/tests/observers/liveMessage.test.ts

@@ -3,6 +3,7 @@ import { disableCache, enableCache } from '~/cache/api';
 import { UNSYNCED_OBJECT_CACHED_AT_MESSAGE } from '~/utils/constants';
 import { pause, client, connectClient, disconnectClient, generateRawMessage } from '~/utils/tests';
 import { getFutureDate } from '~/core/model';
+
 import { convertFromRaw } from '../../utils';
 import { liveMessage } from '../../observers/liveMessage';
 import { createMessage } from '../../api';
@@ -67,7 +68,11 @@ describe('liveMessage', () => {
     if (event === 'local.message.fetched') {
       client.emitter.emit('local.message.fetched', { messages: [updatedMessage] });
     } else {
-      client.emitter.emit(event, { messages: [rawUpdatedMessage] });
+      client.emitter.emit(event, {
+        messages: [rawUpdatedMessage],
+        users: [],
+        files: [],
+      });
     }
     await pause();
 

package/src/message/tests/observers/liveMessages.test.ts

@@ -8,6 +8,7 @@ import {
   messages,
   generateRawMessage,
 } from '~/utils/tests';
+
 import { convertFromRaw } from '../../utils';
 import { queryMessages } from '../../api';
 import { liveMessages } from '../../observers';
@@ -276,7 +277,11 @@ describe('liveMessages', () => {
     expect(callback).toHaveBeenCalledTimes(2);
 
     // fire new message creation event
-    client.emitter.emit('message.created', { messages: [rawNewMessage] });
+    client.emitter.emit('message.created', {
+      messages: [rawNewMessage],
+      users: [],
+      files: [],
+    });
 
     expect(callback).toHaveBeenNthCalledWith(
       3,
@@ -305,7 +310,11 @@ describe('liveMessages', () => {
     expect(callback).toHaveBeenCalledTimes(2);
 
     // fire new message creation event
-    client.emitter.emit('message.updated', { messages: [rawMessage] });
+    client.emitter.emit('message.updated', {
+      messages: [rawMessage],
+      users: [],
+      files: [],
+    });
 
     expect(callback).toHaveBeenNthCalledWith(
       3,
@@ -333,7 +342,11 @@ describe('liveMessages', () => {
     expect(callback).toHaveBeenCalledTimes(2);
 
     // fire new message creation event
-    client.emitter.emit('message.deleted', { messages: [rawMessage] });
+    client.emitter.emit('message.deleted', {
+      messages: [rawMessage],
+      users: [],
+      files: [],
+    });
 
     expect(callback).toHaveBeenNthCalledWith(
       3,

package/src/message/utils/index.ts

@@ -68,16 +68,18 @@ export function convertFromRaw({
   return out;
 }
 
-export const prepareMessagePayload = (payload: Amity.RawMessagePayload): Amity.MessagePayload => {
+export const prepareMessagePayload = (
+  payload: Amity.MessagePayload,
+): Amity.ProcessedMessagePayload => {
   return {
     ...payload,
     messages: payload.messages.map(convertFromRaw),
   };
 };
 
-export const convertResponseFromRaw = <T extends Amity.RawMessagePayload>(
+export const convertResponseFromRaw = <T extends Amity.MessagePayload>(
   response: AxiosResponse<T>,
-): AxiosResponse<Omit<T, 'messages'> & { messages: Amity.MessagePayload['messages'] }> => {
+): AxiosResponse<Omit<T, 'messages'> & { messages: Amity.ProcessedMessagePayload['messages'] }> => {
   return {
     ...response,
     data: {

package/src/poll/api/tests/closePoll.test.ts

@@ -0,0 +1,50 @@
+import { client, pause, poll11 } from '~/utils/tests';
+import { ASCError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
+import { onPollUpdated } from '~/poll/events';
+import { closePoll } from '../closePoll';
+import { getPoll } from '../getPoll';
+
+describe('closePoll', () => {
+  beforeAll(enableCache);
+  afterAll(disableCache);
+
+  // integration_test_id: b679db23-6a49-4858-ba53-2b64ced2f587
+  it('should close the poll', async () => {
+    client.http.put = jest
+      .fn()
+      .mockResolvedValueOnce({ data: { polls: [{ ...poll11, status: 'closed' }] } });
+    const callback = jest.fn();
+    onPollUpdated(callback);
+
+    const { data: poll } = await closePoll(poll11.pollId);
+    const { data: cachedPoll } = getPoll.locally(poll.pollId)!;
+    await pause();
+
+    expect(poll.status).toEqual('closed');
+    expect(cachedPoll).toMatchObject(poll);
+    expect(callback).toHaveBeenCalledWith(poll);
+  });
+
+  // integration_test_id: ec12e345-0e93-435b-9750-e81408fcb791
+  it('should fail to close if the poll does not exist', async () => {
+    client.http.put = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCError('error message', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.FATAL),
+      );
+
+    await expect(() => closePoll('non-existent-poll-id')).rejects.toThrow();
+  });
+
+  // integration_test_id: ed6ea62d-199c-4446-a3c3-554812707b42
+  it('should fail to close if user does not have permissions', async () => {
+    client.http.put = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCError('error message', Amity.ServerError.FORBIDDEN, Amity.ErrorLevel.FATAL),
+      );
+
+    await expect(() => closePoll('no-permissions-poll-id')).rejects.toThrow();
+  });
+});