828 lines
36 KiB
TypeScript
828 lines
36 KiB
TypeScript
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
|
|
// See LICENSE.txt for license information.
|
|
|
|
/* eslint-disable max-lines */
|
|
|
|
import {createIntl} from 'react-intl';
|
|
import {DeviceEventEmitter} from 'react-native';
|
|
|
|
import {ActionType, DeepLink, Events} from '@constants';
|
|
import {SYSTEM_IDENTIFIERS} from '@constants/database';
|
|
import DatabaseManager from '@database/manager';
|
|
import NetworkManager from '@managers/network_manager';
|
|
import TestHelper from '@test/test_helper';
|
|
|
|
import {
|
|
removeMemberFromChannel,
|
|
fetchChannelMembersByIds,
|
|
updateChannelMemberSchemeRoles,
|
|
fetchMemberInChannel,
|
|
fetchChannelMemberships,
|
|
addMembersToChannel,
|
|
fetchChannelByName,
|
|
createChannel,
|
|
patchChannel,
|
|
leaveChannel,
|
|
fetchChannelCreator,
|
|
fetchMyChannelsForTeam,
|
|
fetchMyChannel,
|
|
joinChannel,
|
|
joinChannelIfNeeded,
|
|
markChannelAsRead,
|
|
unsetActiveChannelOnServer,
|
|
joinIfNeededAndSwitchToChannel,
|
|
goToNPSChannel,
|
|
fetchMissingDirectChannelsInfo,
|
|
fetchDirectChannelsInfo,
|
|
createDirectChannel,
|
|
fetchChannels,
|
|
makeDirectChannel,
|
|
fetchArchivedChannels,
|
|
createGroupChannel,
|
|
fetchSharedChannels,
|
|
makeGroupChannel,
|
|
getChannelMemberCountsByGroup,
|
|
getChannelTimezones,
|
|
switchToChannelById,
|
|
switchToPenultimateChannel,
|
|
switchToLastChannel,
|
|
searchChannels,
|
|
fetchChannelById,
|
|
searchAllChannels,
|
|
updateChannelNotifyProps,
|
|
toggleMuteChannel,
|
|
archiveChannel,
|
|
unarchiveChannel,
|
|
convertChannelToPrivate,
|
|
handleKickFromChannel,
|
|
fetchGroupMessageMembersCommonTeams,
|
|
convertGroupMessageToPrivateChannel,
|
|
setChannelAutotranslation,
|
|
setMyChannelAutotranslation,
|
|
} from './channel';
|
|
|
|
import type ServerDataOperator from '@database/operator/server_data_operator';
|
|
import type ChannelModel from '@typings/database/models/servers/channel';
|
|
|
|
const serverUrl = 'baseHandler.test.com';
|
|
let operator: ServerDataOperator;
|
|
|
|
const user: UserProfile = {
|
|
id: 'userid',
|
|
username: 'username',
|
|
roles: '',
|
|
} as UserProfile;
|
|
|
|
let mockIsTablet: jest.Mock;
|
|
jest.mock('@utils/helpers', () => {
|
|
const original = jest.requireActual('@utils/helpers');
|
|
mockIsTablet = jest.fn(() => false);
|
|
return {
|
|
...original,
|
|
isTablet: mockIsTablet,
|
|
};
|
|
});
|
|
|
|
let mockGetActiveServer: jest.Mock;
|
|
jest.mock('@queries/app/servers', () => {
|
|
const original = jest.requireActual('@queries/app/servers');
|
|
mockGetActiveServer = jest.fn(() => false);
|
|
return {
|
|
...original,
|
|
getActiveServer: mockGetActiveServer,
|
|
};
|
|
});
|
|
|
|
const mockClient = {
|
|
removeFromChannel: jest.fn(),
|
|
getChannelMembersByIds: jest.fn((channelId: string, userIds: string[]) => userIds.map((uid) => ({user_id: uid, channel_id: channelId, roles: ''}))),
|
|
updateChannelMemberSchemeRoles: jest.fn(),
|
|
getMemberInChannel: jest.fn((channelId: string, userId: string) => ({id: userId + '-' + channelId, user_id: userId, channel_id: channelId, roles: ''})),
|
|
getChannel: jest.fn((channelId: string) => ({id: channelId, name: 'channel1', creatorId: user.id})),
|
|
getProfilesInChannel: jest.fn(() => ([user])),
|
|
addToChannel: jest.fn((channelId: string, userId: string) => ({id: userId + '-' + channelId, user_id: userId, channel_id: channelId, roles: ''})),
|
|
getProfilesByIds: jest.fn((userIds: string[]) => userIds.map((uid) => ({id: uid, username: 'u' + uid, roles: ''}))),
|
|
getChannelByName: jest.fn((teamId: string, channelName: string) => ({id: channelId, name: channelName, team_id: teamId})),
|
|
createChannel: jest.fn((channel: Channel) => ({...channel, id: channelId})),
|
|
getChannelMember: jest.fn((channelId: string, userId: string) => ({id: userId + '-' + channelId, user_id: userId, channel_id: channelId, roles: ''})),
|
|
patchChannel: jest.fn((channelId: string, channel: ChannelPatch) => ({...channel, id: channelId})),
|
|
getUser: jest.fn((userId: string) => ({...user, id: userId})),
|
|
getMyChannels: jest.fn((teamId: string) => ([{id: channelId, name: 'channel1', creatorId: user.id, team_id: teamId}])),
|
|
getMyChannelMembers: jest.fn(() => ([{id: user.id + '-' + channelId, user_id: user.id, channel_id: channelId, roles: ''}])),
|
|
getCategories: jest.fn((userId: string, teamId: string) => ({categories: [{id: 'categoryid', channel_ids: [channelId], team_id: teamId}], order: ['categoryid']})),
|
|
viewMyChannel: jest.fn(),
|
|
getTeamByName: jest.fn((teamName: string) => ({id: teamId, name: teamName})),
|
|
getTeam: jest.fn((id: string) => ({id, name: 'teamname'})),
|
|
addToTeam: jest.fn((teamId: string, userId: string) => ({id: userId + '-' + teamId, user_id: userId, team_id: teamId, roles: ''})),
|
|
getUserByUsername: jest.fn((username: string) => ({...user, id: 'userid2', username})),
|
|
createDirectChannel: jest.fn((userIds: string[]) => ({id: userIds[0] + '__' + userIds[1], team_id: '', type: 'D', display_name: 'displayname'})),
|
|
getChannels: jest.fn((teamId: string) => ([{id: channelId, name: 'channel1', creatorId: user.id, team_id: teamId}])),
|
|
getArchivedChannels: jest.fn((teamId: string) => ([{id: channelId + 'old', name: 'channel1old', creatorId: user.id, team_id: teamId, delete_at: 1}])),
|
|
createGroupChannel: jest.fn(() => ({id: 'groupid', team_id: '', type: 'G', display_name: 'displayname'})),
|
|
getProfilesInGroupChannels: jest.fn(() => ({groupid: [user, {...user, id: 'userid2'}]})),
|
|
savePreferences: jest.fn(),
|
|
getRolesByNames: jest.fn((roles: string[]) => roles.map((r) => ({id: r, name: r} as Role))),
|
|
getSharedChannels: jest.fn((teamId: string) => ([{id: channelId + 'shared', name: 'channel1shared', creatorId: user.id, team_id: teamId, shared: true}])),
|
|
getChannelMemberCountsByGroup: jest.fn((channelId: string) => ({group_id: channelId, channel_member_count: 3, channel_member_timezones_count: 2})),
|
|
getChannelTimezones: jest.fn(() => ['est']),
|
|
autocompleteChannels: jest.fn((teamId: string) => ([{id: channelId, name: 'channel1', creatorId: user.id, team_id: teamId}])),
|
|
searchAllChannels: jest.fn(() => ([{id: channelId, name: 'channel1', creatorId: user.id, team_id: teamId}])),
|
|
updateChannelNotifyProps: jest.fn(),
|
|
deleteChannel: jest.fn(),
|
|
unarchiveChannel: jest.fn(),
|
|
convertChannelToPrivate: jest.fn(),
|
|
getGroupMessageMembersCommonTeams: jest.fn(() => ({id: teamId, name: 'teamname'})),
|
|
convertGroupMessageToPrivateChannel: jest.fn((channelId: string) => ({id: channelId, name: 'channel1', creatorId: user.id, type: 'P'})),
|
|
getPosts: jest.fn(() => ({
|
|
order: [],
|
|
posts: [],
|
|
previousPostId: '',
|
|
})),
|
|
setChannelAutotranslation: jest.fn(),
|
|
setMyChannelAutotranslation: jest.fn(),
|
|
};
|
|
|
|
const teamId = 'teamid1';
|
|
const channelId = 'channelid1';
|
|
|
|
const intl = createIntl({
|
|
locale: 'en',
|
|
messages: {},
|
|
});
|
|
|
|
beforeAll(() => {
|
|
// @ts-ignore
|
|
NetworkManager.getClient = () => mockClient;
|
|
});
|
|
|
|
beforeEach(async () => {
|
|
await DatabaseManager.init([serverUrl]);
|
|
operator = DatabaseManager.serverDatabases[serverUrl]!.operator;
|
|
});
|
|
|
|
afterEach(async () => {
|
|
await DatabaseManager.destroyServerDatabase(serverUrl);
|
|
});
|
|
|
|
describe('channelMember', () => {
|
|
it('removeMemberFromChannel - handle not found database', async () => {
|
|
const result = await removeMemberFromChannel('foo', '', '') as {error: unknown};
|
|
expect(result?.error).toBeDefined();
|
|
});
|
|
|
|
it('removeMemberFromChannel - base case', async () => {
|
|
const result = await removeMemberFromChannel(serverUrl, channelId, user.id);
|
|
expect(result).toBeDefined();
|
|
});
|
|
|
|
it('fetchChannelMembersByIds - handle not found database', async () => {
|
|
const {members, error} = await fetchChannelMembersByIds('foo', '', []);
|
|
expect(members).toBeUndefined();
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('fetchChannelMembersByIds - base case', async () => {
|
|
const {members, error} = await fetchChannelMembersByIds(serverUrl, channelId, [user.id]);
|
|
expect(error).toBeUndefined();
|
|
expect(members).toBeDefined();
|
|
expect(members?.length).toBe(1);
|
|
});
|
|
|
|
it('updateChannelMemberSchemeRoles - base case', async () => {
|
|
const result = await updateChannelMemberSchemeRoles(serverUrl, channelId, user.id, true, true);
|
|
expect(result).toBeDefined();
|
|
});
|
|
|
|
it('fetchMemberInChannel - handle not found database', async () => {
|
|
const {member, error} = await fetchMemberInChannel('foo', '', '');
|
|
expect(member).toBeUndefined();
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('fetchMemberInChannel - base case', async () => {
|
|
await operator.handleSystem({systems: [{id: SYSTEM_IDENTIFIERS.CURRENT_USER_ID, value: user.id}], prepareRecordsOnly: false});
|
|
const {member, error} = await fetchMemberInChannel(serverUrl, channelId, user.id);
|
|
expect(error).toBeUndefined();
|
|
expect(member).toBeDefined();
|
|
});
|
|
|
|
it('fetchChannelMemberships - base case', async () => {
|
|
const {members, users} = await fetchChannelMemberships(serverUrl, channelId, {});
|
|
expect(users).toBeDefined();
|
|
expect(users.length).toBe(1);
|
|
expect(members).toBeDefined();
|
|
expect(members.length).toBe(1);
|
|
});
|
|
|
|
it('addMembersToChannel - handle not found database', async () => {
|
|
const {channelMemberships, error} = await addMembersToChannel('foo', '', []);
|
|
expect(channelMemberships).toBeUndefined();
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('addMembersToChannel - base case', async () => {
|
|
const {channelMemberships, error} = await addMembersToChannel(serverUrl, channelId, [user.id]);
|
|
expect(error).toBeUndefined();
|
|
expect(channelMemberships).toBeDefined();
|
|
expect(channelMemberships?.length).toBe(1);
|
|
});
|
|
|
|
it('getChannelMemberCountsByGroup - base case', async () => {
|
|
const {channelMemberCountsByGroup, error} = await getChannelMemberCountsByGroup(serverUrl, channelId, true);
|
|
expect(error).toBeUndefined();
|
|
expect(channelMemberCountsByGroup).toBeDefined();
|
|
});
|
|
|
|
it('updateChannelNotifyProps - handle not found database', async () => {
|
|
const {notifyProps, error} = await updateChannelNotifyProps('foo', '', {});
|
|
expect(notifyProps).toBeUndefined();
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('updateChannelNotifyProps - base case', async () => {
|
|
const {notifyProps, error} = await updateChannelNotifyProps(serverUrl, channelId, {});
|
|
expect(error).toBeUndefined();
|
|
expect(notifyProps).toBeDefined();
|
|
});
|
|
|
|
it('toggleMuteChannel - handle not found database', async () => {
|
|
const {notifyProps, error} = await toggleMuteChannel('foo', '');
|
|
expect(notifyProps).toBeUndefined();
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('toggleMuteChannel - base case', async () => {
|
|
await operator.handleMyChannelSettings({
|
|
settings: [{id: channelId, user_id: user.id, channel_id: channelId, roles: '', last_viewed_at: 1, last_update_at: 1, msg_count: 10, mention_count: 0, notify_props: {}}],
|
|
prepareRecordsOnly: false,
|
|
});
|
|
|
|
const {notifyProps, error} = await toggleMuteChannel(serverUrl, channelId, true);
|
|
expect(error).toBeUndefined();
|
|
expect(notifyProps).toBeDefined();
|
|
});
|
|
});
|
|
|
|
describe('channel', () => {
|
|
it('fetchChannelByName - handle not found database', async () => {
|
|
const {channel, error} = await fetchChannelByName('foo', '', '');
|
|
expect(channel).toBeUndefined();
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('fetchChannelByName - base case', async () => {
|
|
const {channel, error} = await fetchChannelByName(serverUrl, channelId, 'channelname');
|
|
expect(error).toBeUndefined();
|
|
expect(channel).toBeDefined();
|
|
});
|
|
|
|
it('createChannel - handle not found database', async () => {
|
|
const {channel, error} = await createChannel('foo', '', '', '', 'O');
|
|
expect(channel).toBeUndefined();
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('createChannel - base case', async () => {
|
|
await operator.handleSystem({systems: [{id: SYSTEM_IDENTIFIERS.CURRENT_USER_ID, value: user.id}, {id: SYSTEM_IDENTIFIERS.CURRENT_TEAM_ID, value: teamId}], prepareRecordsOnly: false});
|
|
const {channel, error} = await createChannel(serverUrl, 'channeldisplayname', 'purpose', 'header', 'O');
|
|
expect(error).toBeUndefined();
|
|
expect(channel).toBeDefined();
|
|
});
|
|
|
|
it('patchChannel - handle not found database', async () => {
|
|
const {channel, error} = await patchChannel('foo', '', {});
|
|
expect(channel).toBeUndefined();
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('patchChannel - base case', async () => {
|
|
await operator.handleChannel({channels: [{
|
|
id: channelId,
|
|
purpose: 'oldpurpose',
|
|
team_id: teamId,
|
|
total_msg_count: 0,
|
|
} as Channel],
|
|
prepareRecordsOnly: false});
|
|
|
|
const {channel, error} = await patchChannel(serverUrl, channelId, {name: 'channelname', display_name: 'Channel Name', purpose: 'purpose', header: 'header'});
|
|
expect(error).toBeUndefined();
|
|
expect(channel).toBeDefined();
|
|
});
|
|
|
|
it('leaveChannel - handle not found database', async () => {
|
|
const {error} = await leaveChannel('foo', '');
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('leaveChannel - no user', async () => {
|
|
const {error} = await leaveChannel(serverUrl, channelId);
|
|
expect(error).toBeDefined();
|
|
expect(error).toBe('current user not found');
|
|
});
|
|
|
|
it('leaveChannel - base case', async () => {
|
|
await operator.handleSystem({systems: [{id: SYSTEM_IDENTIFIERS.CURRENT_USER_ID, value: user.id}, {id: SYSTEM_IDENTIFIERS.CURRENT_TEAM_ID, value: teamId}], prepareRecordsOnly: false});
|
|
await operator.handleUsers({users: [user], prepareRecordsOnly: false});
|
|
|
|
const result = await leaveChannel(serverUrl, channelId);
|
|
expect(result.error).toBeUndefined();
|
|
expect(result).toBeDefined();
|
|
});
|
|
|
|
it('fetchChannelCreator - handle not found database', async () => {
|
|
const {user: fetchedUser, error} = await fetchChannelCreator('foo', '');
|
|
expect(fetchedUser).toBeUndefined();
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('fetchChannelCreator - base case', async () => {
|
|
await operator.handleSystem({systems: [{id: SYSTEM_IDENTIFIERS.CURRENT_USER_ID, value: user.id}, {id: SYSTEM_IDENTIFIERS.CURRENT_TEAM_ID, value: teamId}], prepareRecordsOnly: false});
|
|
await operator.handleChannel({channels: [{
|
|
id: channelId,
|
|
team_id: teamId,
|
|
total_msg_count: 0,
|
|
creator_id: user.id,
|
|
} as Channel],
|
|
prepareRecordsOnly: false});
|
|
|
|
const {user: fetchedUser, error} = await fetchChannelCreator(serverUrl, channelId);
|
|
expect(error).toBeUndefined();
|
|
expect(fetchedUser).toBeDefined();
|
|
});
|
|
|
|
it('fetchMyChannelsForTeam - handle not found database', async () => {
|
|
const {error} = await fetchMyChannelsForTeam('foo', '');
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('fetchMyChannelsForTeam - base case', async () => {
|
|
await operator.handleSystem({systems: [{id: SYSTEM_IDENTIFIERS.CURRENT_USER_ID, value: user.id}, {id: SYSTEM_IDENTIFIERS.CURRENT_TEAM_ID, value: teamId}], prepareRecordsOnly: false});
|
|
const {channels, memberships, categories, error} = await fetchMyChannelsForTeam(serverUrl, teamId, true, 0, false, true);
|
|
expect(error).toBeUndefined();
|
|
expect(channels).toBeDefined();
|
|
expect(memberships).toBeDefined();
|
|
expect(categories).toBeDefined();
|
|
});
|
|
|
|
it('fetchMyChannel - base case', async () => {
|
|
await operator.handleSystem({systems: [{id: SYSTEM_IDENTIFIERS.CURRENT_USER_ID, value: user.id}, {id: SYSTEM_IDENTIFIERS.CURRENT_TEAM_ID, value: teamId}], prepareRecordsOnly: false});
|
|
const {channels, memberships, error} = await fetchMyChannel(serverUrl, teamId, channelId);
|
|
expect(error).toBeUndefined();
|
|
expect(channels).toBeDefined();
|
|
expect(memberships).toBeDefined();
|
|
});
|
|
|
|
it('joinChannel - handle not found database', async () => {
|
|
const {error} = await joinChannel('foo', '');
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('joinChannel - by id', async () => {
|
|
await operator.handleSystem({systems: [{id: SYSTEM_IDENTIFIERS.CURRENT_USER_ID, value: user.id}, {id: SYSTEM_IDENTIFIERS.CURRENT_TEAM_ID, value: teamId}], prepareRecordsOnly: false});
|
|
const {channel, member, error} = await joinChannel(serverUrl, teamId, channelId);
|
|
expect(error).toBeUndefined();
|
|
expect(channel).toBeDefined();
|
|
expect(member).toBeDefined();
|
|
});
|
|
|
|
it('joinChannel - by name', async () => {
|
|
await operator.handleSystem({systems: [{id: SYSTEM_IDENTIFIERS.CURRENT_USER_ID, value: user.id}, {id: SYSTEM_IDENTIFIERS.CURRENT_TEAM_ID, value: teamId}], prepareRecordsOnly: false});
|
|
const {channel, member, error} = await joinChannel(serverUrl, teamId, undefined, 'channelname');
|
|
expect(error).toBeUndefined();
|
|
expect(channel).toBeDefined();
|
|
expect(member).toBeDefined();
|
|
});
|
|
|
|
it('joinChannelIfNeeded - handle not found database', async () => {
|
|
const {error} = await joinChannelIfNeeded('foo', '') as {error: unknown};
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('joinChannelIfNeeded - base case', async () => {
|
|
await operator.handleSystem({systems: [{id: SYSTEM_IDENTIFIERS.CURRENT_USER_ID, value: user.id}, {id: SYSTEM_IDENTIFIERS.CURRENT_TEAM_ID, value: teamId}], prepareRecordsOnly: false});
|
|
const {channel, member} = await joinChannelIfNeeded(serverUrl, channelId) as {channel: Channel; member: ChannelMember};
|
|
expect(channel).toBeDefined();
|
|
expect(member).toBeDefined();
|
|
});
|
|
|
|
it('joinChannelIfNeeded - not needed', async () => {
|
|
await operator.handleMyChannel({channels: [{
|
|
id: channelId,
|
|
team_id: teamId,
|
|
total_msg_count: 0,
|
|
creator_id: user.id,
|
|
} as Channel],
|
|
myChannels: [{
|
|
id: 'id',
|
|
channel_id: channelId,
|
|
user_id: user.id,
|
|
msg_count: 0,
|
|
} as ChannelMembership],
|
|
prepareRecordsOnly: false});
|
|
|
|
const result = await joinChannelIfNeeded(serverUrl, channelId) as {};
|
|
expect(result).toBeDefined();
|
|
expect(result).not.toHaveProperty('channel');
|
|
expect(result).not.toHaveProperty('error');
|
|
});
|
|
|
|
it('markChannelAsRead - base case', async () => {
|
|
const result = await markChannelAsRead(serverUrl, channelId, true);
|
|
expect(result).toBeDefined();
|
|
expect(result).not.toHaveProperty('error');
|
|
});
|
|
|
|
it('unsetActiveChannelOnServer - base case', async () => {
|
|
const result = await unsetActiveChannelOnServer(serverUrl);
|
|
expect(result).toBeDefined();
|
|
expect(result).not.toHaveProperty('error');
|
|
});
|
|
|
|
it('switchToChannelByName - handle not found database', async () => {
|
|
const {error} = await joinIfNeededAndSwitchToChannel('foo', {}, {}, () => {}, intl);
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('switchToChannelByName - base case', async () => {
|
|
await operator.handleSystem({systems: [{id: SYSTEM_IDENTIFIERS.CURRENT_USER_ID, value: user.id}, {id: SYSTEM_IDENTIFIERS.CURRENT_TEAM_ID, value: teamId}], prepareRecordsOnly: false});
|
|
|
|
const result = await joinIfNeededAndSwitchToChannel(serverUrl, {name: 'channelname'}, {name: 'teamname'}, () => {}, intl);
|
|
expect(result).toBeDefined();
|
|
expect(result).not.toHaveProperty('error');
|
|
});
|
|
|
|
it('switchToChannelByName - team redirect', async () => {
|
|
await operator.handleSystem({systems: [{id: SYSTEM_IDENTIFIERS.CURRENT_USER_ID, value: user.id}, {id: SYSTEM_IDENTIFIERS.CURRENT_TEAM_ID, value: teamId}], prepareRecordsOnly: false});
|
|
|
|
const result = await joinIfNeededAndSwitchToChannel(serverUrl, {name: 'channelname'}, {name: DeepLink.Redirect}, () => {}, intl);
|
|
expect(result).toBeDefined();
|
|
expect(result).not.toHaveProperty('error');
|
|
});
|
|
|
|
it('goToNPSChannel - handle not found database', async () => {
|
|
const {error} = await goToNPSChannel('foo');
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('goToNPSChannel - base case', async () => {
|
|
await operator.handleSystem({systems: [{id: SYSTEM_IDENTIFIERS.CURRENT_USER_ID, value: user.id}, {id: SYSTEM_IDENTIFIERS.CURRENT_TEAM_ID, value: teamId}], prepareRecordsOnly: false});
|
|
await operator.handleUsers({users: [user], prepareRecordsOnly: false});
|
|
|
|
const result = await goToNPSChannel(serverUrl);
|
|
expect(result).toBeDefined();
|
|
expect(result).not.toHaveProperty('error');
|
|
});
|
|
|
|
it('fetchChannels - base case', async () => {
|
|
const {channels, error} = await fetchChannels(serverUrl, teamId);
|
|
expect(error).toBeUndefined();
|
|
expect(channels).toBeDefined();
|
|
});
|
|
|
|
it('fetchArchivedChannels - base case', async () => {
|
|
const {channels, error} = await fetchArchivedChannels(serverUrl, teamId);
|
|
expect(error).toBeUndefined();
|
|
expect(channels).toBeDefined();
|
|
});
|
|
|
|
it('fetchSharedChannels - base case', async () => {
|
|
const {channels, error} = await fetchSharedChannels(serverUrl, teamId);
|
|
expect(error).toBeUndefined();
|
|
expect(channels).toBeDefined();
|
|
});
|
|
|
|
it('getChannelTimezones - base case', async () => {
|
|
const {channelTimezones, error} = await getChannelTimezones(serverUrl, channelId);
|
|
expect(error).toBeUndefined();
|
|
expect(channelTimezones).toBeDefined();
|
|
});
|
|
|
|
it('switchToChannelById - handle not found database', async () => {
|
|
const {error} = await switchToChannelById('foo', '') as {error: unknown};
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('switchToChannelById - base case', async () => {
|
|
await operator.handleSystem({systems: [{id: SYSTEM_IDENTIFIERS.CURRENT_USER_ID, value: user.id}, {id: SYSTEM_IDENTIFIERS.CURRENT_TEAM_ID, value: teamId}], prepareRecordsOnly: false});
|
|
|
|
const result = await switchToChannelById(serverUrl, channelId);
|
|
expect(result).toBeDefined();
|
|
expect(result).not.toHaveProperty('error');
|
|
});
|
|
|
|
it('switchToPenultimateChannel - handle not found database', async () => {
|
|
const {error} = await switchToPenultimateChannel('foo') as {error: unknown};
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('switchToPenultimateChannel - base case', async () => {
|
|
await operator.handleSystem({systems: [{id: SYSTEM_IDENTIFIERS.CURRENT_USER_ID, value: user.id}, {id: SYSTEM_IDENTIFIERS.CURRENT_TEAM_ID, value: teamId}], prepareRecordsOnly: false});
|
|
|
|
const result = await switchToPenultimateChannel(serverUrl);
|
|
expect(result).toBeDefined();
|
|
expect(result).not.toHaveProperty('error');
|
|
});
|
|
|
|
it('switchToLastChannel - handle not found database', async () => {
|
|
const {error} = await switchToLastChannel('foo') as {error: unknown};
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('switchToLastChannel - base case', async () => {
|
|
await operator.handleSystem({systems: [{id: SYSTEM_IDENTIFIERS.CURRENT_USER_ID, value: user.id}, {id: SYSTEM_IDENTIFIERS.CURRENT_TEAM_ID, value: teamId}], prepareRecordsOnly: false});
|
|
|
|
const result = await switchToLastChannel(serverUrl);
|
|
expect(result).toBeDefined();
|
|
expect(result).not.toHaveProperty('error');
|
|
});
|
|
|
|
it('searchChannels - handle error', async () => {
|
|
const {error} = await searchChannels('foo', '', teamId, true) as {error: unknown};
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('searchChannels - base case', async () => {
|
|
const result = await searchChannels(serverUrl, 'searchterm', teamId, false);
|
|
expect(result).toBeDefined();
|
|
expect(result).not.toHaveProperty('error');
|
|
expect(result).toHaveProperty('channels');
|
|
});
|
|
|
|
it('fetchChannelById - base case', async () => {
|
|
const result = await fetchChannelById(serverUrl, channelId);
|
|
expect(result).toBeDefined();
|
|
expect(result).not.toHaveProperty('error');
|
|
});
|
|
|
|
it('searchAllChannels - handle not found database', async () => {
|
|
const {error} = await searchAllChannels('foo', '') as {error: unknown};
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('searchAllChannels - base case', async () => {
|
|
const result = await searchAllChannels(serverUrl, 'searchterm');
|
|
expect(result).toBeDefined();
|
|
expect(result).not.toHaveProperty('error');
|
|
expect(result).toHaveProperty('channels');
|
|
});
|
|
|
|
it('archiveChannel - handle not found database', async () => {
|
|
const {error} = await archiveChannel('foo', '') as {error: unknown};
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('archiveChannel - base case', async () => {
|
|
const result = await archiveChannel(serverUrl, channelId);
|
|
expect(result).toBeDefined();
|
|
expect(result).not.toHaveProperty('error');
|
|
});
|
|
|
|
it('unarchiveChannel - base case', async () => {
|
|
const result = await unarchiveChannel(serverUrl, channelId);
|
|
expect(result).toBeDefined();
|
|
expect(result).not.toHaveProperty('error');
|
|
});
|
|
|
|
it('convertChannelToPrivate - handle not found database', async () => {
|
|
const {error} = await convertChannelToPrivate('foo', '') as {error: unknown};
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('convertChannelToPrivate - base case', async () => {
|
|
await operator.handleChannel({channels: [{
|
|
id: channelId,
|
|
team_id: teamId,
|
|
total_msg_count: 0,
|
|
type: 'O',
|
|
} as Channel],
|
|
prepareRecordsOnly: false});
|
|
|
|
const result = await convertChannelToPrivate(serverUrl, channelId);
|
|
expect(result).toBeDefined();
|
|
expect(result).not.toHaveProperty('error');
|
|
});
|
|
|
|
it('handleKickFromChannel - handle not found database', async () => {
|
|
const {error} = await handleKickFromChannel('foo', '');
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('handleKickFromChannel - not current channel', async () => {
|
|
const result = await handleKickFromChannel(serverUrl, channelId);
|
|
expect(result).toBeDefined();
|
|
expect(result).not.toHaveProperty('error');
|
|
});
|
|
|
|
it('handleKickFromChannel - base case', async () => {
|
|
mockIsTablet.mockImplementationOnce(() => true);
|
|
mockGetActiveServer.mockImplementationOnce(() => ({url: serverUrl}));
|
|
await operator.handleSystem({systems: [{id: SYSTEM_IDENTIFIERS.CURRENT_CHANNEL_ID, value: channelId}, {id: SYSTEM_IDENTIFIERS.CURRENT_TEAM_ID, value: teamId}], prepareRecordsOnly: false});
|
|
|
|
const result = await handleKickFromChannel(serverUrl, channelId);
|
|
expect(result).toBeDefined();
|
|
expect(result).not.toHaveProperty('error');
|
|
});
|
|
});
|
|
|
|
describe('direct and group', () => {
|
|
it('fetchMissingDirectChannelsInfo - handle not found database', async () => {
|
|
const {directChannels, error} = await fetchMissingDirectChannelsInfo('foo', []);
|
|
expect(directChannels).toBeUndefined();
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('fetchMissingDirectChannelsInfo - base case', async () => {
|
|
const {directChannels, error} = await fetchMissingDirectChannelsInfo(serverUrl, [{id: 'id', name: 'name', type: 'D'} as Channel], 'channelname');
|
|
expect(error).toBeUndefined();
|
|
expect(directChannels).toBeDefined();
|
|
});
|
|
|
|
it('fetchDirectChannelsInfo - handle not found database', async () => {
|
|
const {directChannels, error} = await fetchDirectChannelsInfo('foo', []);
|
|
expect(directChannels).toBeUndefined();
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('fetchDirectChannelsInfo - base case', async () => {
|
|
const channel = {id: 'id', name: 'name', type: 'D'} as Channel;
|
|
const {directChannels, error} = await fetchDirectChannelsInfo(serverUrl, [{...channel, toApi: () => channel} as unknown as ChannelModel]);
|
|
expect(error).toBeUndefined();
|
|
expect(directChannels).toBeDefined();
|
|
});
|
|
|
|
it('createDirectChannel - handle not found database', async () => {
|
|
const {data, error} = await createDirectChannel('foo', '');
|
|
expect(data).toBeUndefined();
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('createDirectChannel - no user', async () => {
|
|
await operator.handleSystem({systems: [{id: SYSTEM_IDENTIFIERS.CURRENT_USER_ID, value: user.id}], prepareRecordsOnly: false});
|
|
const {data, error} = await createDirectChannel(serverUrl, 'userid2');
|
|
expect(data).toBeUndefined();
|
|
expect(error).toBeDefined();
|
|
expect(error).toBe('Cannot get the current user');
|
|
});
|
|
|
|
it('createDirectChannel - base case', async () => {
|
|
await operator.handleSystem({systems: [{id: SYSTEM_IDENTIFIERS.CURRENT_USER_ID, value: user.id}], prepareRecordsOnly: false});
|
|
await operator.handleUsers({users: [user], prepareRecordsOnly: false});
|
|
|
|
const {data, error} = await createDirectChannel(serverUrl, 'userid2');
|
|
expect(error).toBeUndefined();
|
|
expect(data).toBeDefined();
|
|
});
|
|
|
|
it('createDirectChannel - with display name', async () => {
|
|
await operator.handleSystem({systems: [{id: SYSTEM_IDENTIFIERS.CURRENT_USER_ID, value: user.id}], prepareRecordsOnly: false});
|
|
await operator.handleUsers({users: [user], prepareRecordsOnly: false});
|
|
|
|
const {data, error} = await createDirectChannel(serverUrl, 'userid2', 'displayname');
|
|
expect(error).toBeUndefined();
|
|
expect(data).toBeDefined();
|
|
});
|
|
|
|
it('makeDirectChannel - handle not found database', async () => {
|
|
const {data, error} = await makeDirectChannel('foo', '');
|
|
expect(data).toBeUndefined();
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('makeDirectChannel - base case', async () => {
|
|
await operator.handleSystem({systems: [{id: SYSTEM_IDENTIFIERS.CURRENT_USER_ID, value: user.id}], prepareRecordsOnly: false});
|
|
await operator.handleUsers({users: [user], prepareRecordsOnly: false});
|
|
|
|
const {data, error} = await makeDirectChannel(serverUrl, 'userid2');
|
|
expect(error).toBeUndefined();
|
|
expect(data).toBeDefined();
|
|
});
|
|
|
|
it('makeDirectChannel - with display name', async () => {
|
|
await operator.handleSystem({systems: [{id: SYSTEM_IDENTIFIERS.CURRENT_USER_ID, value: user.id}], prepareRecordsOnly: false});
|
|
await operator.handleUsers({users: [user], prepareRecordsOnly: false});
|
|
|
|
const {data, error} = await makeDirectChannel(serverUrl, 'userid2', 'displayname');
|
|
expect(error).toBeUndefined();
|
|
expect(data).toBeDefined();
|
|
});
|
|
|
|
it('createGroupChannel - handle not found database', async () => {
|
|
const {data, error} = await createGroupChannel('foo', []);
|
|
expect(data).toBeUndefined();
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('createGroupChannel - no user', async () => {
|
|
await operator.handleSystem({systems: [{id: SYSTEM_IDENTIFIERS.CURRENT_USER_ID, value: user.id}], prepareRecordsOnly: false});
|
|
const {data, error} = await createGroupChannel(serverUrl, ['userid2']);
|
|
expect(data).toBeUndefined();
|
|
expect(error).toBeDefined();
|
|
expect(error).toBe('Cannot get the current user');
|
|
});
|
|
|
|
it('createGroupChannel - base case', async () => {
|
|
await operator.handleSystem({systems: [{id: SYSTEM_IDENTIFIERS.CURRENT_USER_ID, value: user.id}], prepareRecordsOnly: false});
|
|
await operator.handleUsers({users: [user], prepareRecordsOnly: false});
|
|
|
|
const {data, error} = await createGroupChannel(serverUrl, ['userid2']);
|
|
expect(error).toBeUndefined();
|
|
expect(data).toBeDefined();
|
|
});
|
|
|
|
it('makeGroupChannel - handle not found database', async () => {
|
|
const {data, error} = await makeGroupChannel('foo', []);
|
|
expect(data).toBeUndefined();
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('makeGroupChannel - base case', async () => {
|
|
await operator.handleSystem({systems: [{id: SYSTEM_IDENTIFIERS.CURRENT_USER_ID, value: user.id}], prepareRecordsOnly: false});
|
|
await operator.handleUsers({users: [user], prepareRecordsOnly: false});
|
|
|
|
const {data, error} = await makeGroupChannel(serverUrl, ['userid2']);
|
|
expect(error).toBeUndefined();
|
|
expect(data).toBeDefined();
|
|
});
|
|
|
|
it('fetchGroupMessageMembersCommonTeams - base case', async () => {
|
|
const {teams, error} = await fetchGroupMessageMembersCommonTeams(serverUrl, channelId);
|
|
expect(error).toBeUndefined();
|
|
expect(teams).toBeDefined();
|
|
});
|
|
|
|
it('convertGroupMessageToPrivateChannel - handle not found database', async () => {
|
|
const {updatedChannel, error} = await convertGroupMessageToPrivateChannel('foo', '', '', '');
|
|
expect(updatedChannel).toBeUndefined();
|
|
expect(error).toBeDefined();
|
|
});
|
|
|
|
it('convertGroupMessageToPrivateChannel - base case', async () => {
|
|
await operator.handleChannel({channels: [{
|
|
id: channelId,
|
|
team_id: teamId,
|
|
total_msg_count: 0,
|
|
type: 'G',
|
|
} as Channel],
|
|
prepareRecordsOnly: false});
|
|
|
|
const {updatedChannel, error} = await convertGroupMessageToPrivateChannel(serverUrl, channelId, teamId, 'newprivatechannel');
|
|
expect(error).toBeUndefined();
|
|
expect(updatedChannel).toBeDefined();
|
|
});
|
|
});
|
|
|
|
describe('setChannelAutotranslation', () => {
|
|
it('should update channel and call deletePostsForChannel when disabling autotranslation', async () => {
|
|
const post = TestHelper.fakePost({id: 'postid1', channel_id: channelId, root_id: ''});
|
|
const channelWithAutotranslation = TestHelper.fakeChannel({id: channelId, team_id: teamId, autotranslation: true});
|
|
await operator.handleChannel({channels: [channelWithAutotranslation], prepareRecordsOnly: false});
|
|
await operator.handlePosts({actionType: ActionType.POSTS.RECEIVED_IN_CHANNEL, order: [post.id], posts: [post], prepareRecordsOnly: false});
|
|
jest.mocked(mockClient.setChannelAutotranslation).mockResolvedValue({id: channelId, autotranslation: false} as Channel);
|
|
|
|
const result = await setChannelAutotranslation(serverUrl, channelId, false);
|
|
|
|
expect(result.error).toBeUndefined();
|
|
expect(result.channel).toBeDefined();
|
|
expect(result.channel!.autotranslation).toBe(false);
|
|
expect(mockClient.setChannelAutotranslation).toHaveBeenCalledWith(channelId, false);
|
|
|
|
expect(DeviceEventEmitter.emit).toHaveBeenCalledWith(Events.POST_DELETED_FOR_CHANNEL, {serverUrl, channelId, teamId});
|
|
});
|
|
|
|
it('should handle client error', async () => {
|
|
jest.mocked(mockClient.setChannelAutotranslation).mockRejectedValueOnce(new Error('API error'));
|
|
|
|
const result = await setChannelAutotranslation(serverUrl, channelId, true);
|
|
|
|
expect(result.error).toBeDefined();
|
|
expect(DeviceEventEmitter.emit).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe('setMyChannelAutotranslation', () => {
|
|
it('should update myChannel and call deletePostsForChannel when autotranslation changes', async () => {
|
|
const post = TestHelper.fakePost({id: 'postid1', channel_id: channelId, root_id: ''});
|
|
const channel = TestHelper.fakeChannel({id: channelId, team_id: teamId});
|
|
const myChannelMember = TestHelper.fakeChannelMember({channel_id: channelId, autotranslation_disabled: false});
|
|
await operator.handleChannel({channels: [channel], prepareRecordsOnly: false});
|
|
await operator.handleMyChannel({channels: [channel], myChannels: [myChannelMember], prepareRecordsOnly: false});
|
|
await operator.handlePosts({actionType: ActionType.POSTS.RECEIVED_IN_CHANNEL, order: [post.id], posts: [post], prepareRecordsOnly: false});
|
|
jest.mocked(mockClient.setMyChannelAutotranslation).mockResolvedValue({} as ChannelMembership);
|
|
|
|
const result = await setMyChannelAutotranslation(serverUrl, channelId, false);
|
|
|
|
expect(result.error).toBeUndefined();
|
|
expect(result.data).toBe(true);
|
|
expect(mockClient.setMyChannelAutotranslation).toHaveBeenCalledWith(channelId, false);
|
|
expect(DeviceEventEmitter.emit).toHaveBeenCalledWith(Events.POST_DELETED_FOR_CHANNEL, {serverUrl, channelId, teamId});
|
|
});
|
|
|
|
it('should handle client error', async () => {
|
|
jest.mocked(mockClient.setMyChannelAutotranslation).mockRejectedValueOnce(new Error('API error'));
|
|
|
|
const result = await setMyChannelAutotranslation(serverUrl, channelId, true);
|
|
|
|
expect(result.error).toBeDefined();
|
|
expect(DeviceEventEmitter.emit).not.toHaveBeenCalled();
|
|
});
|
|
});
|