@amityco/ts-sdk 0.0.1-cb052d5.0 → 0.0.1-cb5cdb1.0

package/src/channel/api/tests/getChannel.test.ts

@@ -0,0 +1,112 @@
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { client, channelQueryResponse } from '~/utils/tests';
+
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+import { isInTombstone } from '~/cache/api/isInTombstone';
+
+import { prepareChannelPayload } from '~/channel/utils';
+
+import { getChannel } from '../getChannel';
+
+const { channelId } = channelQueryResponse.data.channels[0];
+const channel = prepareChannelPayload(channelQueryResponse.data).channels[0];
+
+describe('getChannel', () => {
+  // integration_test_id: b331e01c-20db-4f17-979b-b280d8818792
+  test('it should return a valid channel', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(channelQueryResponse);
+
+    const expected = channel;
+    const { data: received } = await getChannel(channelId);
+
+    expect(received).toStrictEqual(expected);
+  });
+
+  test('it should update cache after fetch from server', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
+    await getChannel(channelId);
+
+    expect(getChannel.locally(channelId)).toBeDefined();
+
+    disableCache();
+  });
+
+  // integration_test_id: da9dc3e8-01fd-4e76-a26b-ac8333a69b23
+  test('it should return an error', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(getChannel(channelId)).rejects.toThrow('error');
+  });
+
+  test('it should return an error if channel in cache but api throws not found', async () => {
+    enableCache();
+    pushToCache(['channel', 'get', channelId], channel, { cachedAt: Date.now() });
+
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(getChannel(channelId)).rejects.toThrow();
+    expect(getChannel.locally(channelId)).toBeUndefined();
+
+    disableCache();
+  });
+});
+
+describe('getChannel locally', () => {
+  test('it should return data from cache', () => {
+    enableCache();
+
+    const cachedAt = Date.now();
+
+    pushToCache(['channel', 'get', channelId], channel, { cachedAt });
+
+    const data = getChannel.locally(channelId);
+
+    expect(data).toBeDefined();
+    expect(data?.data).toEqual(channel);
+    expect(data?.cachedAt).toEqual(cachedAt);
+
+    disableCache();
+  });
+
+  test('should return undefined if channel not in cache', () => {
+    expect(getChannel.locally('non-existent-channel')).toBeUndefined();
+  });
+
+  test('should return undefined if cache not enabled', () => {
+    expect(getChannel.locally(channelId)).toBeUndefined();
+  });
+});
+
+describe('getChannel tombostone', () => {
+  test('it should add channel to tombostone if 404', async () => {
+    enableCache();
+
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(getChannel(channelId)).rejects.toThrow();
+    expect(() => {
+      isInTombstone('channel', channelId);
+    }).toThrow();
+
+    disableCache();
+  });
+
+  test('it should throw error if channel not found in tombostone', async () => {
+    enableCache();
+
+    pushToTombstone('channel', channelId);
+    await expect(getChannel(channelId)).rejects.toThrow();
+
+    disableCache();
+  });
+});

package/src/channel/api/tests/getChannels.test.ts

@@ -0,0 +1,97 @@
+import { disableCache, enableCache, pushToCache, pullFromCache } from '~/cache/api';
+import { client, getChannelsResponse } from '~/utils/tests';
+
+import { getChannels } from '../getChannels';
+import { prepareChannelPayload } from '~/channel/utils';
+import { ASCApiError } from '~/core/errors';
+
+const channelIds = [
+  getChannelsResponse.data.channels[0].channelId,
+  getChannelsResponse.data.channels[1].channelId,
+  getChannelsResponse.data.channels[2].channelId,
+];
+const channel = prepareChannelPayload(getChannelsResponse.data).channels;
+
+describe('getChannels', () => {
+  // integration_test_id: ced0cd3b-1714-499d-862e-0284da1c8bb1
+  test('it should return a valid channels', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(getChannelsResponse);
+
+    const expected = channel;
+    const { data: received } = await getChannels(channelIds);
+
+    expect(received).toStrictEqual(expected);
+  });
+
+  test('it should update cache after fetch from server', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(getChannelsResponse);
+    await getChannels(channelIds);
+
+    const data = getChannels.locally(channelIds);
+
+    expect(data).toBeDefined();
+    expect(data?.data).toEqual(channel);
+
+    disableCache();
+  });
+
+  // integration_test_id: 344a8f3d-0e54-4eb9-850f-80283e638352
+  test('it should return an error 400400 when try to get channels by invalid channel id', async () => {
+    const error = new ASCApiError(
+      'Some channel not found',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.get = jest.fn().mockRejectedValueOnce(error);
+
+    await expect(getChannels(channelIds)).rejects.toThrow(error);
+  });
+});
+
+describe('getChannels locally', () => {
+  test('it should return data from cache', () => {
+    enableCache();
+
+    const cachedAt = Date.now();
+
+    pushToCache(['channel', 'get', channelIds[0]], channel[0], { cachedAt });
+    pushToCache(['channel', 'get', channelIds[1]], channel[1], { cachedAt });
+    pushToCache(['channel', 'get', channelIds[2]], channel[2], { cachedAt });
+
+    const data = getChannels.locally(channelIds);
+
+    expect(data).toBeDefined();
+    expect(data?.data).toEqual(channel);
+    expect(data?.cachedAt).toEqual(cachedAt);
+
+    disableCache();
+  });
+
+  test('should return undefined if channel not in cache', () => {
+    expect(
+      getChannels.locally(['non-existent-channel-1', 'non-existent-channel-2']),
+    ).toBeUndefined();
+  });
+
+  test('should return undefined if cache not enabled', () => {
+    expect(getChannels.locally(channelIds)).toBeUndefined();
+  });
+
+  test('it should return cachedAt same date with oldest record', () => {
+    enableCache();
+
+    const cachedAt = Date.now();
+
+    pushToCache(['channel', 'get', channelIds[0]], channel[0], { cachedAt });
+    pushToCache(['channel', 'get', channelIds[1]], channel[1], { cachedAt: cachedAt + 1 });
+    pushToCache(['channel', 'get', channelIds[2]], channel[2], { cachedAt: cachedAt + 2 });
+
+    const data = getChannels.locally(channelIds);
+
+    expect(data?.cachedAt).toEqual(cachedAt);
+
+    disableCache();
+  });
+});

package/src/channel/api/tests/joinChannel.test.ts

@@ -0,0 +1,111 @@
+import { pullFromCache, enableCache, disableCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
+import { getResolver } from '~/core/model';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  channel1,
+  user11,
+  channelUserQueryResponse,
+  channelUser,
+} from '~/utils/tests';
+
+import { joinChannel } from '../joinChannel';
+
+describe('joinChannel', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  const { channelId } = channel1;
+
+  // integration_test_id: efef33a8-bf09-4dfe-8ed9-e7c3615ad74d
+  test('it should return channelUser', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const recieved = await joinChannel(channelId);
+
+    expect(recieved).toBe(true);
+  });
+
+  test('it should update cache', async () => {
+    enableCache();
+
+    const expected = channelUser;
+    client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const didJoinChannel = await joinChannel(channelId);
+
+    const resolverId = getResolver('channelUsers')({ channelId, userId: user11.userId });
+    const recieved = pullFromCache(['channelUsers', 'get', resolverId]);
+
+    expect(didJoinChannel).toBe(true);
+    expect(recieved?.data).toStrictEqual(expected);
+
+    disableCache();
+  });
+
+  // integration_test_id: 402a8cd8-6522-42d0-8f40-ccccae0093a1
+  test('it should throw error 400400 when user joins channel which does not exist', async () => {
+    const apiError = new ASCApiError(
+      'ChannelId Not Found',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.post = jest.fn().mockRejectedValueOnce({
+      status: 403,
+      data: apiError,
+    });
+
+    try {
+      await joinChannel(channelId);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(403);
+      expect(data).toEqual(apiError);
+    }
+  });
+
+  // integration_test_id: dcad7f35-586c-400f-8eca-2334d6d7b3e0
+  test("it should throw error 400300 when user tries to join channel in which he doesn't have permission", async () => {
+    const apiError = new ASCApiError(
+      "Can't join the conversation channel",
+      Amity.ServerError.FORBIDDEN,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.post = jest.fn().mockRejectedValueOnce({
+      status: 403,
+      data: apiError,
+    });
+
+    try {
+      await joinChannel(channelId);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(403);
+      expect(data).toEqual(apiError);
+    }
+  });
+
+  // integration_test_id: 8ccb81b7-a89c-486a-81ed-7371b3ef1c4f
+  test('it should throw error 400304 when user tries to join channel in which he is banned', async () => {
+    const apiError = new ASCApiError(
+      'User is banned from this channel',
+      Amity.ServerError.CHANNEL_BAN,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.post = jest.fn().mockRejectedValueOnce({
+      status: 403,
+      data: apiError,
+    });
+
+    try {
+      await joinChannel(channelId);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(403);
+      expect(data).toEqual(apiError);
+    }
+  });
+});

package/src/channel/api/tests/leaveChannel.test.ts

@@ -0,0 +1,90 @@
+import { pullFromCache, enableCache, disableCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
+import { getResolver } from '~/core/model';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  channel1,
+  user11,
+  channelUserQueryResponse,
+  channelUser,
+} from '~/utils/tests';
+
+import { leaveChannel } from '../leaveChannel';
+
+describe('leaveChannel', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  const { channelId } = channel1;
+
+  // integration_test_id: 3b4408dd-0f45-4270-9384-73d9ddac4511
+  test('it should return channelUser', async () => {
+    client.http.delete = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const recieved = await leaveChannel(channelId);
+
+    expect(recieved).toBe(true);
+  });
+
+  test('it should update cache', async () => {
+    enableCache();
+
+    const expected = channelUser;
+    client.http.delete = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const didleaveChannel = await leaveChannel(channelId);
+
+    const resolverId = getResolver('channelUsers')({ channelId, userId: user11.userId });
+    const recieved = pullFromCache(['channelUsers', 'get', resolverId]);
+
+    expect(didleaveChannel).toBe(true);
+    expect(recieved?.data).toStrictEqual(expected);
+
+    disableCache();
+  });
+
+  // integration_test_id: 4f56790e-5fa0-4d04-8c20-ab0c39d0776f
+  test('it should throw error 400301 when user try to leave a channel which user is not a member', async () => {
+    const apiError = new ASCApiError(
+      'User is not member of channel',
+      Amity.ServerError.PERMISSION_DENIED,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.delete = jest.fn().mockRejectedValueOnce({
+      status: 403,
+      data: apiError,
+    });
+
+    try {
+      await leaveChannel(channelId);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(403);
+      expect(data).toEqual(apiError);
+    }
+  });
+
+  // integration_test_id: 818d2317-e138-4d66-bdc0-bcc858580df5
+  test('it should throw error 400304 when user try to leave channel which he got banned', async () => {
+    const apiError = new ASCApiError(
+      'User is banned from this channel',
+      Amity.ServerError.CHANNEL_BAN,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.delete = jest.fn().mockRejectedValueOnce({
+      status: 403,
+      data: apiError,
+    });
+
+    try {
+      await leaveChannel(channelId);
+    } catch ({ status = null, data = null }) {
+      expect(status).toEqual(403);
+      expect(data).toEqual(apiError);
+    }
+  });
+});

package/src/channel/api/tests/queryChannelMembers.test.ts

@@ -0,0 +1,128 @@
+import { getResolver } from '~/core/model';
+
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '~/channel/utils';
+import { client, channelUserQueryResponse, channelUserModel } from '~/utils/tests';
+
+import { queryChannelMembers } from '../queryChannelMembers';
+
+describe('queryChannelMembers', () => {
+  const { channelId } = channelUserQueryResponse.data.channels[0];
+
+  test('it should return channel members', async () => {
+    const expected = channelUserQueryResponse.data.channelUsers;
+    client.http.get = jest.fn().mockResolvedValue(channelUserQueryResponse);
+
+    const { data } = await queryChannelMembers({ channelId });
+    expect(data).toEqual(expected);
+  });
+
+  test('it should return channel members by attaching a user', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(channelUserQueryResponse);
+
+    const { data } = await queryChannelMembers({ channelId });
+
+    expect(data).toEqual(channelUserModel);
+
+    disableCache();
+  });
+
+  test('it should throw error', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(queryChannelMembers({ channelId })).rejects.toThrow('error');
+  });
+
+  test('it should update cache upon fetching data from server', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(channelUserQueryResponse);
+
+    const { data: got } = await queryChannelMembers({ channelId });
+    const { data } = queryChannelMembers.locally({ channelId })!;
+
+    expect(data).toBeDefined();
+    expect(got).toEqual(data);
+
+    disableCache();
+  });
+});
+
+describe('queryChannelMembers.locally', () => {
+  const { channelId } = channelUserQueryResponse.data.channels[0];
+  const cacheKey = [
+    'channelUsers',
+    'query',
+    { channelId, options: { limit: 10, after: undefined } },
+  ];
+
+  test('it should fetch query locally if present in cache', () => {
+    enableCache();
+
+    const { paging, ...payload } = channelUserQueryResponse.data;
+    const preparedPayload = prepareChannelPayload(payload);
+    const { channelUsers } = preparedPayload;
+
+    ingestInCache(preparedPayload);
+
+    pushToCache(cacheKey, {
+      channelUsers: channelUsers.map(({ channelId, userId }) =>
+        getResolver('channelUsers')({ channelId, userId }),
+      ),
+      paging,
+    });
+
+    const got = queryChannelMembers.locally({
+      channelId,
+      page: { limit: 10, after: undefined },
+    })?.data;
+
+    expect(got).toBeDefined();
+    expect(got).toEqual(channelUsers);
+
+    disableCache();
+  });
+
+  test('it should return undefined if only partial data in cache', () => {
+    enableCache();
+
+    const { paging, ...payload } = channelUserQueryResponse.data;
+    const preparedPayload = prepareChannelPayload(payload);
+    const { channelUsers } = preparedPayload;
+
+    // ingest incomplete data
+    ingestInCache({
+      ...preparedPayload,
+      channelUsers: [preparedPayload.channelUsers[0]],
+    });
+
+    pushToCache(cacheKey, {
+      channelUsers: channelUsers.map(({ channelId, userId }) =>
+        getResolver('channelUsers')({ channelId, userId }),
+      ),
+      paging,
+    });
+
+    const got = queryChannelMembers.locally({ channelId })!;
+
+    expect(got).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if data not in cache', () => {
+    enableCache();
+
+    const got = queryChannelMembers.locally({ channelId });
+
+    expect(got).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if cache disabled', () => {
+    expect(queryChannelMembers.locally({ channelId })).toBeUndefined();
+  });
+});

package/src/channel/api/tests/queryChannels.test.ts

@@ -0,0 +1,159 @@
+import { getResolver } from '~/core/model';
+
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '~/channel/utils';
+import {
+  client,
+  channelQueryResponse,
+  channelTagQueryResponse,
+  channelExcludeTagQueryResponse,
+} from '~/utils/tests';
+
+import { queryChannels } from '../queryChannels';
+
+describe('queryChannels', () => {
+  // integration_test_id: 06c14dab-4799-4f26-9e52-be7c12b3bdb3
+  test('it should return channels', async () => {
+    const expected = prepareChannelPayload(channelQueryResponse.data).channels;
+    client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
+
+    const { data } = await queryChannels();
+
+    expect(data).toEqual(expected);
+  });
+
+  // integration_test_id: 253fb0ac-f868-4570-9b1e-98b08861aa53
+  test('it should return channels match with membership type', async () => {
+    // Actually there is no any flag to tell about this list is relate to membership type
+    // But need to implement this case to match with our test list
+    const expected = prepareChannelPayload(channelQueryResponse.data).channels;
+    client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
+    const { data } = await queryChannels({ membership: 'member' });
+    expect(data).toEqual(expected);
+  });
+
+  // integration_test_id: 92329d41-9403-44e7-979f-ed227e6ab120
+  test('it should return channels match with tags query type', async () => {
+    const expected = prepareChannelPayload(channelTagQueryResponse.data).channels;
+    client.http.get = jest.fn().mockResolvedValue(channelTagQueryResponse);
+    const { data } = await queryChannels({ tags: ['tag1'] });
+    expect(data).toEqual(expected);
+    expect(data[0].tags).toContain('tag1');
+  });
+
+  // integration_test_id: 5249778c-6d99-4e2f-9b80-2f4ea6ae1833
+  test('it should return channels without tags which defined in exclude options', async () => {
+    const expected = prepareChannelPayload(channelExcludeTagQueryResponse.data).channels;
+    client.http.get = jest.fn().mockResolvedValue(channelExcludeTagQueryResponse);
+    const { data } = await queryChannels({ excludeTags: ['tag1'] });
+    expect(data).toEqual(expected);
+
+    data.forEach(item => {
+      expect(item.tags).not.toContain('tag1');
+    });
+  });
+
+  test('it should throw error', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(queryChannels()).rejects.toThrow('error');
+  });
+
+  test('it should update cache upon fetching data from server', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
+
+    const { data: got } = await queryChannels();
+    const { data } = queryChannels.locally()!;
+
+    expect(data).toBeDefined();
+    expect(got).toEqual(data);
+
+    disableCache();
+  });
+});
+
+describe('queryChannels.locally', () => {
+  const cacheKey = ['channel', 'query', { options: { limit: 10, after: undefined } }];
+
+  test('it should fetch query locally if present in cache', () => {
+    enableCache();
+
+    const { paging, ...payload } = channelQueryResponse.data;
+    const data = prepareChannelPayload(payload);
+    const { channels } = data;
+
+    ingestInCache(data);
+
+    pushToCache(cacheKey, { channels: channels.map(getResolver('channel')), paging });
+
+    const { data: got } = queryChannels.locally()!;
+
+    expect(got).toBeDefined();
+    expect(got).toEqual(channels);
+
+    disableCache();
+  });
+
+  test('it should return undefined if only partial data in cache', () => {
+    enableCache();
+
+    const { paging, ...payload } = channelQueryResponse.data;
+    const data = prepareChannelPayload(payload);
+    const { channels } = data;
+
+    // ingest incomplete data
+    ingestInCache({
+      ...data,
+      channels: [data.channels[0]],
+    });
+
+    pushToCache(cacheKey, {
+      channels: channels.map(getResolver('channel')),
+      paging,
+    });
+
+    const got = queryChannels.locally()!;
+
+    expect(got).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if params do not match', () => {
+    enableCache();
+
+    const { data } = channelQueryResponse;
+    const { paging, ...payload } = data;
+    const { channels: expected } = prepareChannelPayload(payload);
+
+    ingestInCache(prepareChannelPayload(data));
+
+    pushToCache(cacheKey, { channels: payload.channels.map(getResolver('channel')), paging });
+
+    const { data: received } = queryChannels.locally()!;
+    const received2 = queryChannels.locally({ displayName: 'test' })!;
+
+    expect(received).toBeDefined();
+    expect(received).toEqual(expected);
+    expect(received2).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if data not in cache', () => {
+    enableCache();
+
+    const got = queryChannels.locally();
+
+    expect(got).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if cache disabled', () => {
+    expect(queryChannels.locally()).toBeUndefined();
+  });
+});