mattermost-redux
Version:
Common code (API client, Redux stores, logic, utility functions) for building a Mattermost client
1,239 lines (1,035 loc) • 104 kB
JavaScript
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
// See LICENSE.txt for license information.
import assert from 'assert';
import nock from 'nock';
import * as Actions from 'actions/channels';
import {addUserToTeam} from 'actions/teams';
import {getProfilesByIds, login} from 'actions/users';
import {createIncomingHook, createOutgoingHook} from 'actions/integrations';
import {Client4} from 'client';
import {General, RequestStatus, Preferences, Permissions} from '../constants';
import {CategoryTypes} from '../constants/channel_categories';
import {MarkUnread} from '../constants/channels';
import TestHelper from 'test/test_helper';
import configureStore from 'test/test_store';
import {getPreferenceKey} from 'utils/preference_utils';
const OK_RESPONSE = {status: 'OK'};
describe('Actions.Channels', () => {
let store;
beforeAll(async () => {
await TestHelper.initBasic(Client4);
});
beforeEach(async () => {
store = await configureStore();
});
afterAll(async () => {
await TestHelper.tearDown();
});
it('selectChannel', async () => {
const channelId = TestHelper.generateId();
await store.dispatch(Actions.selectChannel(channelId));
await TestHelper.wait(100);
const state = store.getState();
assert.equal(state.entities.channels.currentChannelId, channelId);
});
it('createChannel', async () => {
nock(Client4.getBaseRoute()).
post('/channels').
reply(201, TestHelper.fakeChannelWithId(TestHelper.basicTeam.id));
await store.dispatch(Actions.createChannel(TestHelper.fakeChannel(TestHelper.basicTeam.id), TestHelper.basicUser.id));
const createRequest = store.getState().requests.channels.createChannel;
if (createRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(createRequest.error));
}
const {channels, myMembers} = store.getState().entities.channels;
const channelsCount = Object.keys(channels).length;
const membersCount = Object.keys(myMembers).length;
assert.ok(channels);
assert.ok(myMembers);
assert.ok(channels[Object.keys(myMembers)[0]]);
assert.ok(myMembers[Object.keys(channels)[0]]);
assert.equal(myMembers[Object.keys(channels)[0]].user_id, TestHelper.basicUser.id);
assert.equal(channelsCount, membersCount);
assert.equal(channelsCount, 1);
assert.equal(membersCount, 1);
});
it('createDirectChannel', async () => {
nock(Client4.getBaseRoute()).
post('/users').
query(true).
reply(201, TestHelper.fakeUserWithId());
const user = await TestHelper.basicClient4.createUser(
TestHelper.fakeUser(),
null,
null,
TestHelper.basicTeam.invite_id,
);
nock(Client4.getBaseRoute()).
post('/users/ids').
reply(200, [user]);
await store.dispatch(getProfilesByIds([user.id]));
nock(Client4.getBaseRoute()).
post('/channels/direct').
reply(201, {...TestHelper.fakeChannelWithId(), type: 'D'});
const {data: created} = await store.dispatch(Actions.createDirectChannel(TestHelper.basicUser.id, user.id));
const createRequest = store.getState().requests.channels.createChannel;
if (createRequest.status === RequestStatus.FAILURE) {
throw new Error(createRequest.error);
}
const state = store.getState();
const {channels, myMembers} = state.entities.channels;
const {profiles, profilesInChannel} = state.entities.users;
const preferences = state.entities.preferences.myPreferences;
const channelsCount = Object.keys(channels).length;
const membersCount = Object.keys(myMembers).length;
assert.ok(channels, 'channels is empty');
assert.ok(myMembers, 'members is empty');
assert.ok(profiles[user.id], 'profiles does not have userId');
assert.ok(Object.keys(preferences).length, 'preferences is empty');
assert.ok(channels[Object.keys(myMembers)[0]], 'channels should have the member');
assert.ok(myMembers[Object.keys(channels)[0]], 'members should belong to channel');
assert.equal(myMembers[Object.keys(channels)[0]].user_id, TestHelper.basicUser.id);
assert.equal(channelsCount, membersCount);
assert.equal(channels[Object.keys(channels)[0]].type, 'D');
assert.equal(channelsCount, 1);
assert.equal(membersCount, 1);
assert.ok(profilesInChannel, 'profiles in channel is empty');
assert.ok(profilesInChannel[created.id], 'profiles in channel is empty for channel');
assert.equal(profilesInChannel[created.id].size, 2, 'incorrect number of profiles in channel');
assert.ok(profilesInChannel[created.id].has(TestHelper.basicUser.id), 'creator is not in channel');
assert.ok(profilesInChannel[created.id].has(user.id), 'user is not in channel');
});
it('createGroupChannel', async () => {
nock(Client4.getBaseRoute()).
post('/users').
query(true).
reply(201, TestHelper.fakeUserWithId());
const user = await TestHelper.basicClient4.createUser(
TestHelper.fakeUser(),
null,
null,
TestHelper.basicTeam.invite_id,
);
nock(Client4.getBaseRoute()).
post('/users').
query(true).
reply(201, TestHelper.fakeUserWithId());
const user2 = await TestHelper.basicClient4.createUser(
TestHelper.fakeUser(),
null,
null,
TestHelper.basicTeam.invite_id,
);
TestHelper.mockLogin();
await store.dispatch(login(TestHelper.basicUser.email, TestHelper.basicUser.password));
nock(Client4.getBaseRoute()).
post('/users/ids').
reply(200, [user, user2]);
await store.dispatch(getProfilesByIds([user.id, user2.id]));
nock(Client4.getBaseRoute()).
post('/channels/group').
reply(201, {...TestHelper.fakeChannelWithId(), type: 'G'});
const result = await store.dispatch(Actions.createGroupChannel([TestHelper.basicUser.id, user.id, user2.id]));
const created = result.data;
assert.ok(!result.error, 'error was returned');
assert.ok(created, 'channel was not returned');
const createRequest = store.getState().requests.channels.createChannel;
if (createRequest.status === RequestStatus.FAILURE) {
throw new Error(createRequest.error);
}
const state = store.getState();
const {channels, myMembers} = state.entities.channels;
const preferences = state.entities.preferences.myPreferences;
const {profilesInChannel} = state.entities.users;
assert.ok(channels, 'channels is empty');
assert.ok(channels[created.id], 'channel does not exist');
assert.ok(myMembers, 'members is empty');
assert.ok(myMembers[created.id], 'member does not exist');
assert.ok(Object.keys(preferences).length, 'preferences is empty');
assert.ok(profilesInChannel, 'profiles in channel is empty');
assert.ok(profilesInChannel[created.id], 'profiles in channel is empty for channel');
assert.equal(profilesInChannel[created.id].size, 3, 'incorrect number of profiles in channel');
assert.ok(profilesInChannel[created.id].has(TestHelper.basicUser.id), 'creator is not in channel');
assert.ok(profilesInChannel[created.id].has(user.id), 'user is not in channel');
assert.ok(profilesInChannel[created.id].has(user2.id), 'user2 is not in channel');
});
it('updateChannel', async () => {
const channel = {
...TestHelper.basicChannel,
purpose: 'This is to test redux',
header: 'MM with Redux',
};
nock(Client4.getBaseRoute()).
put(`/channels/${channel.id}`).
reply(200, channel);
await store.dispatch(Actions.updateChannel(channel));
const updateRequest = store.getState().requests.channels.updateChannel;
if (updateRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(updateRequest.error));
}
const {channels} = store.getState().entities.channels;
const channelId = Object.keys(channels)[0];
assert.ok(channelId);
assert.ok(channels[channelId]);
assert.strictEqual(channels[channelId].header, 'MM with Redux');
});
it('patchChannel', async () => {
const channel = {
header: 'MM with Redux2',
};
nock(Client4.getBaseRoute()).
put(`/channels/${TestHelper.basicChannel.id}/patch`).
reply(200, {...TestHelper.basicChannel, ...channel});
await store.dispatch(Actions.patchChannel(TestHelper.basicChannel.id, channel));
const updateRequest = store.getState().requests.channels.updateChannel;
if (updateRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(updateRequest.error));
}
const {channels} = store.getState().entities.channels;
const channelId = Object.keys(channels)[0];
assert.ok(channelId);
assert.ok(channels[channelId]);
assert.strictEqual(channels[channelId].header, 'MM with Redux2');
});
it('updateChannelPrivacy', async () => {
const publicChannel = TestHelper.basicChannel;
nock(Client4.getChannelRoute(publicChannel.id)).
put('/privacy').
reply(200, {...publicChannel, type: General.PRIVATE_CHANNEL});
assert.equal(publicChannel.type, General.OPEN_CHANNEL);
await store.dispatch(Actions.updateChannelPrivacy(publicChannel.id, General.PRIVATE_CHANNEL));
const updateRequest = store.getState().requests.channels.updateChannel;
if (updateRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(updateRequest.error));
}
const {channels} = store.getState().entities.channels;
const channelId = Object.keys(channels)[0];
assert.ok(channelId);
assert.ok(channels[channelId]);
assert.equal(channels[channelId].type, General.PRIVATE_CHANNEL);
});
it('convertChannelToPrivate', async () => {
const publicChannel = TestHelper.basicChannel;
nock(Client4.getChannelRoute(publicChannel.id)).
post('/convert').
reply(200, {...TestHelper.basicChannel, type: General.PRIVATE_CHANNEL});
assert.equal(TestHelper.basicChannel.type, General.OPEN_CHANNEL);
await store.dispatch(Actions.convertChannelToPrivate(TestHelper.basicChannel.id));
const updateRequest = store.getState().requests.channels.updateChannel;
if (updateRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(updateRequest.error));
}
const {channels} = store.getState().entities.channels;
const channelId = Object.keys(channels)[0];
assert.ok(channelId);
assert.ok(channels[channelId]);
assert.equal(channels[channelId].type, General.PRIVATE_CHANNEL);
});
it('getChannel', async () => {
nock(Client4.getBaseRoute()).
get(`/channels/${TestHelper.basicChannel.id}`).
reply(200, TestHelper.basicChannel);
await store.dispatch(Actions.getChannel(TestHelper.basicChannel.id));
const {channels} = store.getState().entities.channels;
assert.ok(channels[TestHelper.basicChannel.id]);
});
it('getChannelByNameAndTeamName', async () => {
nock(Client4.getTeamsRoute()).
get(`/name/${TestHelper.basicTeam.name}/channels/name/${TestHelper.basicChannel.name}?include_deleted=false`).
reply(200, TestHelper.basicChannel);
await store.dispatch(Actions.getChannelByNameAndTeamName(TestHelper.basicTeam.name, TestHelper.basicChannel.name));
const {channels} = store.getState().entities.channels;
assert.ok(channels[TestHelper.basicChannel.id]);
});
it('getChannelAndMyMember', async () => {
nock(Client4.getBaseRoute()).
get(`/channels/${TestHelper.basicChannel.id}`).
reply(200, TestHelper.basicChannel);
nock(Client4.getBaseRoute()).
get(`/channels/${TestHelper.basicChannel.id}/members/me`).
reply(200, TestHelper.basicChannelMember);
await store.dispatch(Actions.getChannelAndMyMember(TestHelper.basicChannel.id));
const {channels, myMembers} = store.getState().entities.channels;
assert.ok(channels[TestHelper.basicChannel.id]);
assert.ok(myMembers[TestHelper.basicChannel.id]);
});
it('fetchMyChannelsAndMembers', async () => {
nock(Client4.getBaseRoute()).
post('/users').
query(true).
reply(201, TestHelper.fakeUserWithId());
const user = await TestHelper.basicClient4.createUser(
TestHelper.fakeUser(),
null,
null,
TestHelper.basicTeam.invite_id,
);
nock(Client4.getBaseRoute()).
post('/channels/direct').
reply(201, {...TestHelper.fakeChannelWithId(), team_id: '', type: 'D'});
const {data: directChannel} = await store.dispatch(Actions.createDirectChannel(TestHelper.basicUser.id, user.id));
nock(Client4.getBaseRoute()).
get(`/users/me/teams/${TestHelper.basicTeam.id}/channels`).
query(true).
reply(200, [directChannel, TestHelper.basicChannel]);
nock(Client4.getBaseRoute()).
get(`/users/me/teams/${TestHelper.basicTeam.id}/channels/members`).
reply(200, [{user_id: TestHelper.basicUser.id, roles: 'channel_user', channel_id: directChannel.id}, TestHelper.basicChannelMember]);
await store.dispatch(Actions.fetchMyChannelsAndMembers(TestHelper.basicTeam.id));
const {channels, channelsInTeam, myMembers} = store.getState().entities.channels;
assert.ok(channels);
assert.ok(myMembers);
assert.ok(channels[Object.keys(myMembers)[0]]);
assert.ok(myMembers[Object.keys(channels)[0]]);
assert.ok(channelsInTeam[''].has(directChannel.id));
assert.equal(Object.keys(channels).length, Object.keys(myMembers).length);
});
it('updateChannelNotifyProps', async () => {
const notifyProps = {
mark_unread: MarkUnread.MENTION,
desktop: 'none',
};
nock(Client4.getBaseRoute()).
get(`/users/me/teams/${TestHelper.basicTeam.id}/channels`).
query(true).
reply(200, [TestHelper.basicChannel]);
nock(Client4.getBaseRoute()).
get(`/users/me/teams/${TestHelper.basicTeam.id}/channels/members`).
reply(200, [TestHelper.basicChannelMember]);
await store.dispatch(Actions.fetchMyChannelsAndMembers(TestHelper.basicTeam.id));
nock(Client4.getBaseRoute()).
put(`/channels/${TestHelper.basicChannel.id}/members/${TestHelper.basicUser.id}/notify_props`).
reply(200, OK_RESPONSE);
await store.dispatch(Actions.updateChannelNotifyProps(
TestHelper.basicUser.id,
TestHelper.basicChannel.id,
notifyProps));
const members = store.getState().entities.channels.myMembers;
const member = members[TestHelper.basicChannel.id];
assert.ok(member);
assert.equal(member.notify_props.mark_unread, MarkUnread.MENTION);
assert.equal(member.notify_props.desktop, 'none');
});
it('deleteChannel', async () => {
const secondClient = TestHelper.createClient4();
nock(Client4.getBaseRoute()).
post('/users').
query(true).
reply(201, TestHelper.fakeUserWithId());
const user = await TestHelper.basicClient4.createUser(
TestHelper.fakeUser(),
null,
null,
TestHelper.basicTeam.invite_id,
);
nock(Client4.getBaseRoute()).
post('/users/login').
reply(200, user);
await secondClient.login(user.email, 'password1');
nock(Client4.getBaseRoute()).
post('/channels').
reply(201, TestHelper.fakeChannelWithId(TestHelper.basicTeam.id));
const secondChannel = await secondClient.createChannel(
TestHelper.fakeChannel(TestHelper.basicTeam.id));
nock(Client4.getBaseRoute()).
post(`/channels/${secondChannel.id}/members`).
reply(201, {user_id: TestHelper.basicUser.id, roles: 'channel_user', channel_id: secondChannel.id});
await store.dispatch(Actions.joinChannel(
TestHelper.basicUser.id,
TestHelper.basicTeam.id,
secondChannel.id,
));
nock(Client4.getBaseRoute()).
get(`/users/me/teams/${TestHelper.basicTeam.id}/channels`).
query(true).
reply(200, [secondChannel, TestHelper.basicChannel]);
nock(Client4.getBaseRoute()).
get(`/users/me/teams/${TestHelper.basicTeam.id}/channels/members`).
reply(200, [{user_id: TestHelper.basicUser.id, roles: 'channel_user', channel_id: secondChannel.id}, TestHelper.basicChannelMember]);
await store.dispatch(Actions.fetchMyChannelsAndMembers(TestHelper.basicTeam.id));
nock(Client4.getBaseRoute()).
post('/hooks/incoming').
reply(201, {
id: TestHelper.generateId(),
create_at: 1507840900004,
update_at: 1507840900004,
delete_at: 0,
user_id: TestHelper.basicUser.id,
channel_id: secondChannel.id,
team_id: TestHelper.basicTeam.id,
display_name: 'TestIncomingHook',
description: 'Some description.',
});
const incomingHook = await store.dispatch(createIncomingHook({channel_id: secondChannel.id, display_name: 'test', description: 'test'}));
nock(Client4.getBaseRoute()).
post('/hooks/outgoing').
reply(201, {
id: TestHelper.generateId(),
token: TestHelper.generateId(),
create_at: 1507841118796,
update_at: 1507841118796,
delete_at: 0,
creator_id: TestHelper.basicUser.id,
channel_id: secondChannel.id,
team_id: TestHelper.basicTeam.id,
trigger_words: ['testword'],
trigger_when: 0,
callback_urls: ['http://notarealurl'],
display_name: 'TestOutgoingHook',
description: '',
content_type: 'application/x-www-form-urlencoded',
});
const outgoingHook = await store.dispatch(createOutgoingHook({
channel_id: secondChannel.id,
team_id: TestHelper.basicTeam.id,
display_name: 'TestOutgoingHook',
trigger_words: [TestHelper.generateId()],
callback_urls: ['http://notarealurl']},
));
nock(Client4.getBaseRoute()).
delete(`/channels/${secondChannel.id}`).
reply(200, OK_RESPONSE);
await store.dispatch(Actions.deleteChannel(secondChannel.id));
const {incomingHooks, outgoingHooks} = store.getState().entities.integrations;
assert.ifError(incomingHooks[incomingHook.id]);
assert.ifError(outgoingHooks[outgoingHook.id]);
});
it('unarchiveChannel', async () => {
const secondClient = TestHelper.createClient4();
nock(Client4.getBaseRoute()).
post('/users').
query(true).
reply(201, TestHelper.fakeUserWithId());
const user = await TestHelper.basicClient4.createUser(
TestHelper.fakeUser(),
null,
null,
TestHelper.basicTeam.invite_id,
);
nock(Client4.getBaseRoute()).
post('/users/login').
reply(200, user);
await secondClient.login(user.email, 'password1');
nock(Client4.getBaseRoute()).
post('/channels').
reply(201, TestHelper.fakeChannelWithId(TestHelper.basicTeam.id));
const secondChannel = await secondClient.createChannel(
TestHelper.fakeChannel(TestHelper.basicTeam.id));
nock(Client4.getBaseRoute()).
post(`/channels/${secondChannel.id}/members`).
reply(201, {user_id: TestHelper.basicUser.id, roles: 'channel_user', channel_id: secondChannel.id});
await store.dispatch(Actions.joinChannel(
TestHelper.basicUser.id,
TestHelper.basicTeam.id,
secondChannel.id,
));
nock(Client4.getBaseRoute()).
get(`/users/me/teams/${TestHelper.basicTeam.id}/channels`).
query(true).
reply(200, [secondChannel, TestHelper.basicChannel]);
nock(Client4.getBaseRoute()).
get(`/users/me/teams/${TestHelper.basicTeam.id}/channels/members`).
reply(200, [{user_id: TestHelper.basicUser.id, roles: 'channel_user', channel_id: secondChannel.id}, TestHelper.basicChannelMember]);
await store.dispatch(Actions.fetchMyChannelsAndMembers(TestHelper.basicTeam.id));
nock(Client4.getBaseRoute()).
post('/hooks/incoming').
reply(201, {
id: TestHelper.generateId(),
create_at: 1507840900004,
update_at: 1507840900004,
delete_at: 1609090954545,
user_id: TestHelper.basicUser.id,
channel_id: secondChannel.id,
team_id: TestHelper.basicTeam.id,
display_name: 'TestIncomingHook',
description: 'Some description.',
});
const incomingHook = await store.dispatch(createIncomingHook({channel_id: secondChannel.id, display_name: 'test', description: 'test'}));
nock(Client4.getBaseRoute()).
post('/hooks/outgoing').
reply(201, {
id: TestHelper.generateId(),
token: TestHelper.generateId(),
create_at: 1507841118796,
update_at: 1507841118796,
delete_at: 1609090954545,
creator_id: TestHelper.basicUser.id,
channel_id: secondChannel.id,
team_id: TestHelper.basicTeam.id,
trigger_words: ['testword'],
trigger_when: 0,
callback_urls: ['http://notarealurl'],
display_name: 'TestOutgoingHook',
description: '',
content_type: 'application/x-www-form-urlencoded',
});
const outgoingHook = await store.dispatch(createOutgoingHook({
channel_id: secondChannel.id,
team_id: TestHelper.basicTeam.id,
display_name: 'TestOutgoingHook',
trigger_words: [TestHelper.generateId()],
callback_urls: ['http://notarealurl']},
));
nock(Client4.getBaseRoute()).
delete(`/channels/${secondChannel.id}`).
reply(200, OK_RESPONSE);
await store.dispatch(Actions.unarchiveChannel(secondChannel.id));
const {incomingHooks, outgoingHooks} = store.getState().entities.integrations;
assert.ifError(incomingHooks[incomingHook.id]);
assert.ifError(outgoingHooks[outgoingHook.id]);
});
describe('viewChannel', () => {
test('should contact server and update last_viewed_at of both channels', async () => {
const channelId = TestHelper.generateId();
const prevChannelId = TestHelper.generateId();
const currentUserId = TestHelper.generateId();
store = await configureStore({
entities: {
channels: {
myMembers: {
[channelId]: {
channel_id: channelId,
last_viewed_at: 1000,
roles: '',
},
[prevChannelId]: {
channel_id: prevChannelId,
last_viewed_at: 1000,
roles: '',
},
},
},
users: {
currentUserId,
},
},
});
nock(Client4.getBaseRoute()).
post('/channels/members/me/view', {channel_id: channelId, prev_channel_id: prevChannelId}).
reply(200, OK_RESPONSE);
const now = Date.now();
const result = await store.dispatch(Actions.viewChannel(channelId, prevChannelId));
expect(result).toEqual({data: true});
const state = store.getState();
expect(state.entities.channels.myMembers[channelId].last_viewed_at).toBeGreaterThan(now);
expect(state.entities.channels.myMembers[prevChannelId].last_viewed_at).toBeGreaterThan(now);
});
test('should clear manually unread state from current channel', async () => {
const channelId = TestHelper.generateId();
const currentUserId = TestHelper.generateId();
store = await configureStore({
entities: {
channels: {
manuallyUnread: {
[channelId]: true,
},
myMembers: {
[channelId]: {
channel_id: channelId,
last_viewed_at: 1000,
roles: '',
},
},
},
users: {
currentUserId,
},
},
});
nock(Client4.getBaseRoute()).
post('/channels/members/me/view', {channel_id: channelId, prev_channel_id: ''}).
reply(200, OK_RESPONSE);
const result = await store.dispatch(Actions.viewChannel(channelId));
expect(result).toEqual({data: true});
const state = store.getState();
expect(state.entities.channels.manuallyUnread[channelId]).not.toBe(true);
});
test('should not update last_viewed_at of previous channel if it is manually marked as unread', async () => {
const channelId = TestHelper.generateId();
const prevChannelId = TestHelper.generateId();
const currentUserId = TestHelper.generateId();
store = await configureStore({
entities: {
channels: {
manuallyUnread: {
[prevChannelId]: true,
},
myMembers: {
[channelId]: {
channel_id: channelId,
last_viewed_at: 1000,
roles: '',
},
[prevChannelId]: {
channel_id: prevChannelId,
last_viewed_at: 1000,
roles: '',
},
},
},
users: {
currentUserId,
},
},
});
nock(Client4.getBaseRoute()).
post('/channels/members/me/view', {channel_id: channelId, prev_channel_id: ''}).
reply(200, OK_RESPONSE);
const now = Date.now();
const result = await store.dispatch(Actions.viewChannel(channelId, prevChannelId));
expect(result).toEqual({data: true});
const state = store.getState();
expect(state.entities.channels.myMembers[channelId].last_viewed_at).toBeGreaterThan(now);
expect(state.entities.channels.myMembers[prevChannelId].last_viewed_at).toBe(1000);
});
});
it('markChannelAsViewed', async () => {
nock(Client4.getBaseRoute()).
post('/channels').
reply(201, TestHelper.fakeChannelWithId(TestHelper.basicTeam.id));
const userChannel = await Client4.createChannel(
TestHelper.fakeChannel(TestHelper.basicTeam.id),
);
nock(Client4.getBaseRoute()).
get(`/users/me/teams/${TestHelper.basicTeam.id}/channels`).
query(true).
reply(200, [userChannel, TestHelper.basicChannel]);
nock(Client4.getBaseRoute()).
get(`/users/me/teams/${TestHelper.basicTeam.id}/channels/members`).
reply(200, [{user_id: TestHelper.basicUser.id, roles: 'channel_user', channel_id: userChannel.id}, TestHelper.basicChannelMember]);
await store.dispatch(Actions.fetchMyChannelsAndMembers(TestHelper.basicTeam.id));
const timestamp = Date.now();
let members = store.getState().entities.channels.myMembers;
let member = members[TestHelper.basicChannel.id];
const otherMember = members[userChannel.id];
assert.ok(member);
assert.ok(otherMember);
await TestHelper.wait(50);
await store.dispatch(Actions.markChannelAsViewed(TestHelper.basicChannel.id));
members = store.getState().entities.channels.myMembers;
member = members[TestHelper.basicChannel.id];
assert.ok(member.last_viewed_at > timestamp);
});
describe('markChannelAsUnread', () => {
it('plain message', async () => {
const teamId = TestHelper.generateId();
const channelId = TestHelper.generateId();
const userId = TestHelper.generateId();
store = await configureStore({
entities: {
channels: {
channels: {
[channelId]: {team_id: teamId, total_msg_count: 10},
},
myMembers: {
[channelId]: {msg_count: 10, mention_count: 0},
},
},
teams: {
myMembers: {
[teamId]: {msg_count: 0, mention_count: 0},
},
},
users: {
currentUserId: userId,
},
},
});
store.dispatch(Actions.markChannelAsUnread(teamId, channelId, [TestHelper.generateId()], false));
const state = store.getState();
assert.equal(state.entities.channels.channels[channelId].total_msg_count, 11);
assert.equal(state.entities.channels.myMembers[channelId].msg_count, 10);
assert.equal(state.entities.channels.myMembers[channelId].mention_count, 0);
assert.equal(state.entities.teams.myMembers[teamId].msg_count, 1);
assert.equal(state.entities.teams.myMembers[teamId].mention_count, 0);
});
it('message mentioning current user', async () => {
const teamId = TestHelper.generateId();
const channelId = TestHelper.generateId();
const userId = TestHelper.generateId();
store = await configureStore({
entities: {
channels: {
channels: {
[channelId]: {team_id: teamId, total_msg_count: 10},
},
myMembers: {
[channelId]: {msg_count: 10, mention_count: 0},
},
},
teams: {
myMembers: {
[teamId]: {msg_count: 0, mention_count: 0},
},
},
users: {
currentUserId: userId,
},
},
});
store.dispatch(Actions.markChannelAsUnread(teamId, channelId, [userId], false));
const state = store.getState();
assert.equal(state.entities.channels.channels[channelId].total_msg_count, 11);
assert.equal(state.entities.channels.myMembers[channelId].msg_count, 10);
assert.equal(state.entities.channels.myMembers[channelId].mention_count, 1);
assert.equal(state.entities.teams.myMembers[teamId].msg_count, 1);
assert.equal(state.entities.teams.myMembers[teamId].mention_count, 1);
});
it('plain message with mark_unread="mention"', async () => {
const teamId = TestHelper.generateId();
const channelId = TestHelper.generateId();
const userId = TestHelper.generateId();
store = await configureStore({
entities: {
channels: {
channels: {
[channelId]: {team_id: teamId, total_msg_count: 10},
},
myMembers: {
[channelId]: {msg_count: 10, mention_count: 0, notify_props: {mark_unread: MarkUnread.MENTION}},
},
},
teams: {
myMembers: {
[teamId]: {msg_count: 0, mention_count: 0},
},
},
users: {
currentUserId: userId,
},
},
});
store.dispatch(Actions.markChannelAsUnread(teamId, channelId, [TestHelper.generateId()], false));
const state = store.getState();
assert.equal(state.entities.channels.channels[channelId].total_msg_count, 11);
assert.equal(state.entities.channels.myMembers[channelId].msg_count, 11);
assert.equal(state.entities.channels.myMembers[channelId].mention_count, 0);
assert.equal(state.entities.teams.myMembers[teamId].msg_count, 0);
assert.equal(state.entities.teams.myMembers[teamId].mention_count, 0);
});
it('message mentioning current user with mark_unread="mention"', async () => {
const teamId = TestHelper.generateId();
const channelId = TestHelper.generateId();
const userId = TestHelper.generateId();
store = await configureStore({
entities: {
channels: {
channels: {
[channelId]: {team_id: teamId, total_msg_count: 10},
},
myMembers: {
[channelId]: {msg_count: 10, mention_count: 0, notify_props: {mark_unread: MarkUnread.MENTION}},
},
},
teams: {
myMembers: {
[teamId]: {msg_count: 0, mention_count: 0},
},
},
users: {
currentUserId: userId,
},
},
});
store.dispatch(Actions.markChannelAsUnread(teamId, channelId, [userId], false));
const state = store.getState();
assert.equal(state.entities.channels.channels[channelId].total_msg_count, 11);
assert.equal(state.entities.channels.myMembers[channelId].msg_count, 11);
assert.equal(state.entities.channels.myMembers[channelId].mention_count, 1);
assert.equal(state.entities.teams.myMembers[teamId].msg_count, 0);
assert.equal(state.entities.teams.myMembers[teamId].mention_count, 1);
});
it('channel member should not be updated if it has already been fetched', async () => {
const teamId = TestHelper.generateId();
const channelId = TestHelper.generateId();
const userId = TestHelper.generateId();
store = await configureStore({
entities: {
channels: {
channels: {
[channelId]: {team_id: teamId, total_msg_count: 8},
},
myMembers: {
[channelId]: {msg_count: 5, mention_count: 2},
},
},
teams: {
myMembers: {
[teamId]: {msg_count: 2, mention_count: 1},
},
},
users: {
currentUserId: userId,
},
},
});
store.dispatch(Actions.markChannelAsUnread(teamId, channelId, [userId], true));
const state = store.getState();
assert.equal(state.entities.channels.channels[channelId].total_msg_count, 8);
assert.equal(state.entities.channels.myMembers[channelId].msg_count, 5);
assert.equal(state.entities.channels.myMembers[channelId].mention_count, 2);
assert.equal(state.entities.teams.myMembers[teamId].msg_count, 3);
assert.equal(state.entities.teams.myMembers[teamId].mention_count, 2);
});
});
describe('markChannelAsRead', () => {
it('one read channel', async () => {
const channelId = TestHelper.generateId();
const teamId = TestHelper.generateId();
store = await configureStore({
entities: {
channels: {
channels: {
[channelId]: {
id: channelId,
team_id: teamId,
total_msg_count: 10,
},
},
myMembers: {
[channelId]: {
channel_id: channelId,
mention_count: 0,
msg_count: 10,
},
},
},
teams: {
myMembers: {
[teamId]: {
id: teamId,
mention_count: 0,
msg_count: 0,
},
},
},
},
});
await store.dispatch(Actions.markChannelAsRead(channelId));
const state = store.getState();
assert.equal(state.entities.channels.myMembers[channelId].mention_count, 0);
assert.equal(state.entities.channels.myMembers[channelId].msg_count, state.entities.channels.channels[channelId].total_msg_count);
assert.equal(state.entities.teams.myMembers[teamId].mention_count, 0);
assert.equal(state.entities.teams.myMembers[teamId].msg_count, 0);
});
it('one unread channel', async () => {
const channelId = TestHelper.generateId();
const teamId = TestHelper.generateId();
store = await configureStore({
entities: {
channels: {
channels: {
[channelId]: {
id: channelId,
team_id: teamId,
total_msg_count: 10,
},
},
myMembers: {
[channelId]: {
channel_id: channelId,
mention_count: 2,
msg_count: 5,
},
},
},
teams: {
myMembers: {
[teamId]: {
id: teamId,
mention_count: 2,
msg_count: 5,
},
},
},
},
});
await store.dispatch(Actions.markChannelAsRead(channelId));
const state = store.getState();
assert.equal(state.entities.channels.myMembers[channelId].mention_count, 0);
assert.equal(state.entities.channels.myMembers[channelId].msg_count, state.entities.channels.channels[channelId].total_msg_count);
assert.equal(state.entities.teams.myMembers[teamId].mention_count, 0);
assert.equal(state.entities.teams.myMembers[teamId].msg_count, 0);
});
it('one unread DM channel', async () => {
const channelId = TestHelper.generateId();
store = await configureStore({
entities: {
channels: {
channels: {
[channelId]: {
id: channelId,
team_id: '',
total_msg_count: 10,
},
},
myMembers: {
[channelId]: {
channel_id: channelId,
mention_count: 2,
msg_count: 5,
},
},
},
teams: {
myMembers: {
},
},
},
});
await store.dispatch(Actions.markChannelAsRead(channelId));
const state = store.getState();
assert.equal(state.entities.channels.myMembers[channelId].mention_count, 0);
assert.equal(state.entities.channels.myMembers[channelId].msg_count, state.entities.channels.channels[channelId].total_msg_count);
});
it('two unread channels, same team, reading one', async () => {
const channelId1 = TestHelper.generateId();
const channelId2 = TestHelper.generateId();
const teamId = TestHelper.generateId();
store = await configureStore({
entities: {
channels: {
channels: {
[channelId1]: {
id: channelId1,
team_id: teamId,
total_msg_count: 10,
},
[channelId2]: {
id: channelId2,
team_id: teamId,
total_msg_count: 12,
},
},
myMembers: {
[channelId1]: {
channel_id: channelId1,
mention_count: 2,
msg_count: 5,
},
[channelId2]: {
channel_id: channelId2,
mention_count: 4,
msg_count: 9,
},
},
},
teams: {
myMembers: {
[teamId]: {
id: teamId,
mention_count: 6,
msg_count: 8,
},
},
},
},
});
await store.dispatch(Actions.markChannelAsRead(channelId1));
const state = store.getState();
assert.equal(state.entities.channels.myMembers[channelId1].mention_count, 0);
assert.equal(state.entities.channels.myMembers[channelId1].msg_count, state.entities.channels.channels[channelId1].total_msg_count);
assert.equal(state.entities.channels.myMembers[channelId2].mention_count, 4);
assert.equal(state.entities.channels.myMembers[channelId2].msg_count, 9);
assert.equal(state.entities.teams.myMembers[teamId].mention_count, 4);
assert.equal(state.entities.teams.myMembers[teamId].msg_count, 3);
});
it('two unread channels, same team, reading both', async () => {
const channelId1 = TestHelper.generateId();
const channelId2 = TestHelper.generateId();
const teamId = TestHelper.generateId();
store = await configureStore({
entities: {
channels: {
channels: {
[channelId1]: {
id: channelId1,
team_id: teamId,
total_msg_count: 10,
},
[channelId2]: {
id: channelId2,
team_id: teamId,
total_msg_count: 12,
},
},
myMembers: {
[channelId1]: {
channel_id: channelId1,
mention_count: 2,
msg_count: 5,
},
[channelId2]: {
channel_id: channelId2,
mention_count: 4,
msg_count: 9,
},
},
},
teams: {
myMembers: {
[teamId]: {
id: teamId,
mention_count: 6,
msg_count: 8,
},
},
},
},
});
await store.dispatch(Actions.markChannelAsRead(channelId1, channelId2));
const state = store.getState();
assert.equal(state.entities.channels.myMembers[channelId1].mention_count, 0);
assert.equal(state.entities.channels.myMembers[channelId1].msg_count, state.entities.channels.channels[channelId1].total_msg_count);
assert.equal(state.entities.channels.myMembers[channelId2].mention_count, 0);
assert.equal(state.entities.channels.myMembers[channelId2].msg_count, state.entities.channels.channels[channelId2].total_msg_count);
assert.equal(state.entities.teams.myMembers[teamId].mention_count, 0);
assert.equal(state.entities.teams.myMembers[teamId].msg_count, 0);
});
it('two unread channels, same team, reading both (opposite order)', async () => {
const channelId1 = TestHelper.generateId();
const channelId2 = TestHelper.generateId();
const teamId = TestHelper.generateId();
store = await configureStore({
entities: {
channels: {
channels: {
[channelId1]: {
id: channelId1,
team_id: teamId,
total_msg_count: 10,
},
[channelId2]: {
id: channelId2,
team_id: teamId,
total_msg_count: 12,
},
},
myMembers: {
[channelId1]: {
channel_id: channelId1,
mention_count: 2,
msg_count: 5,
},
[channelId2]: {
channel_id: channelId2,
mention_count: 4,
msg_count: 9,
},
},
},
teams: {
myMembers: {
[teamId]: {
id: teamId,
mention_count: 6,
msg_count: 8,
},
},
},
},
});
await store.dispatch(Actions.markChannelAsRead(channelId2, channelId1));
const state = store.getState();
assert.equal(state.entities.channels.myMembers[channelId1].mention_count, 0);
assert.equal(state.entities.channels.myMembers[channelId1].msg_count, state.entities.