toki/mattermost-mobile
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

Improved unit tests (#151)

Browse source
This commit is contained in:
enahum 2016-12-22 13:07:23 -03:00 committed by GitHub
parent f32de304aa
commit 8243eda444
10 changed files with 1274 additions and 1706 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
service/actions/users.js
View file

@ -10,7 +10,7 @@ export function login(loginId, password, mfaToken = '') {
return async (dispatch, getState) => {
dispatch({type: UsersTypes.LOGIN_REQUEST}, getState);
Client.login(loginId, password, mfaToken).
return Client.login(loginId, password, mfaToken).
then(async (data) => {
let teamMembers;
let preferences;

31
test/app/actions/login.test.js
View file

@ -7,27 +7,20 @@ import * as Actions from 'app/actions/views/login';
import configureStore from 'app/store';
describe('Actions.Views.Login', () => {
it('handleLoginIdChanged', (done) => {
const store = configureStore();
store.subscribe(() => {
const loginId = store.getState().views.login.loginId;
assert.equal('email@example.com', loginId);
done();
});
Actions.handleLoginIdChanged('email@example.com')(store.dispatch, store.getState);
let store;
beforeEach(() => {
store = configureStore();
});
it('handlePasswordChanged', (done) => {
const store = configureStore();
it('handleLoginIdChanged', async () => {
await Actions.handleLoginIdChanged('email@example.com')(store.dispatch, store.getState);
const loginId = store.getState().views.login.loginId;
assert.equal('email@example.com', loginId);
});
store.subscribe(() => {
const password = store.getState().views.login.password;
assert.equal('password', password);
done();
});
Actions.handlePasswordChanged('password')(store.dispatch, store.getState);
it('handlePasswordChanged', async () => {
await Actions.handlePasswordChanged('password')(store.dispatch, store.getState);
const password = store.getState().views.login.password;
assert.equal('password', password);
});
});

12
test/app/actions/select_server.test.js
View file

@ -7,15 +7,11 @@ import * as Actions from 'app/actions/views/select_server';
import configureStore from 'app/store';
describe('Actions.Views.SelectServer', () => {
it('handleServerUrlChanged', (done) => {
it('handleServerUrlChanged', async () => {
const store = configureStore();
store.subscribe(() => {
const serverUrl = store.getState().views.selectServer.serverUrl;
assert.equal('https://mattermost.example.com', serverUrl);
done();
});
Actions.handleServerUrlChanged('https://mattermost.example.com')(store.dispatch, store.getState);
await Actions.handleServerUrlChanged('https://mattermost.example.com')(store.dispatch, store.getState);
const serverUrl = store.getState().views.selectServer.serverUrl;
assert.equal('https://mattermost.example.com', serverUrl);
});
});

787
test/service/actions/channels.test.js
View file

@ -4,508 +4,375 @@
import assert from 'assert';
import * as Actions from 'service/actions/channels';
import {getProfilesByIds} from 'service/actions/users';
import Client from 'service/client';
import configureStore from 'app/store';
import {RequestStatus} from 'service/constants';
import TestHelper from 'test/test_helper';
describe('Actions.Channels', () => {
it('createChannel', (done) => {
TestHelper.initBasic(Client).then(() => {
const store = configureStore();
store.subscribe(() => {
const channels = store.getState().entities.channels.channels;
const members = store.getState().entities.channels.myMembers;
const createRequest = store.getState().requests.channels.createChannel;
const membersRequest = store.getState().requests.channels.myMembers;
if (createRequest.status === RequestStatus.SUCCESS && membersRequest.status === RequestStatus.SUCCESS) {
const channelsCount = Object.keys(channels).length;
const membersCount = Object.keys(members).length;
assert.ok(channels);
assert.ok(members);
assert.ok(channels[Object.keys(members)[0]]);
assert.ok(members[Object.keys(channels)[0]]);
assert.equal(members[Object.keys(channels)[0]].user_id, TestHelper.basicUser.id);
assert.equal(channelsCount, membersCount);
assert.equal(channelsCount, 1);
assert.equal(membersCount, 1);
done();
} else if (createRequest.status === RequestStatus.FAILURE && membersRequest.status === RequestStatus.FAILURE) {
done(new Error(JSON.stringify(createRequest.error)));
}
});
const channel = {
team_id: TestHelper.basicTeam.id,
name: 'redux-test',
display_name: 'Redux Test',
purpose: 'This is to test redux',
header: 'MM with Redux',
type: 'O'
};
Actions.createChannel(channel, TestHelper.basicUser.id)(store.dispatch, store.getState);
});
let store;
let secondChannel;
before(async () => {
await TestHelper.initBasic(Client);
});
it('createDirectChannel', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
const user = await TestHelper.basicClient.createUserWithInvite(
TestHelper.fakeUser(),
null,
null,
TestHelper.basicTeam.invite_id
);
store.subscribe(() => {
const state = store.getState();
const channels = state.entities.channels.channels;
const members = state.entities.channels.myMembers;
const preferences = state.entities.preferences.myPreferences;
const createRequest = state.requests.channels.createChannel;
if (createRequest.status === RequestStatus.SUCCESS || createRequest.status === RequestStatus.FAILURE) {
if (createRequest.error) {
done(new Error(JSON.stringify(createRequest.error)));
}
const channelsCount = Object.keys(channels).length;
const membersCount = Object.keys(members).length;
assert.ok(channels, 'channels is empty');
assert.ok(members, 'members is empty');
assert.ok(Object.keys(preferences).length, 'preferences is empty');
assert.ok(channels[Object.keys(members)[0]], 'channels should have the member');
assert.ok(members[Object.keys(channels)[0]], 'members should belong to channel');
assert.equal(members[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);
done();
}
});
Actions.createDirectChannel(TestHelper.basicTeam.id, TestHelper.basicUser.id, user.id)(store.dispatch, store.getState);
});
}).timeout(3000);
it('updateChannel', (done) => {
TestHelper.initBasic(Client).then(() => {
const store = configureStore();
store.subscribe(() => {
const channels = store.getState().entities.channels.channels;
const updateRequest = store.getState().requests.channels.updateChannel;
if (updateRequest.status === RequestStatus.SUCCESS) {
const channelId = Object.keys(channels)[0];
const channel = channels[channelId];
assert.ok(channelId);
assert.ok(channel);
assert.equal(channel.header, 'MM with Redux');
done();
} else if (updateRequest.status === RequestStatus.FAILURE) {
done(new Error(JSON.stringify(updateRequest.error)));
}
});
const channel = {
...TestHelper.basicChannel,
purpose: 'This is to test redux',
header: 'MM with Redux'
};
Actions.updateChannel(channel)(store.dispatch, store.getState);
});
beforeEach(() => {
store = configureStore();
});
it('getChannel', (done) => {
TestHelper.initBasic(Client).then(() => {
const store = configureStore();
store.subscribe(() => {
const channels = store.getState().entities.channels.channels;
const members = store.getState().entities.channels.myMembers;
const channelRequest = store.getState().requests.channels.getChannel;
if (channelRequest.status === RequestStatus.SUCCESS) {
assert.ok(channels[TestHelper.basicChannel.id]);
assert.ok(members[TestHelper.basicChannel.id]);
done();
} else if (channelRequest.status === RequestStatus.FAILURE) {
done(new Error(JSON.stringify(channelRequest.error)));
}
});
Actions.getChannel(TestHelper.basicTeam.id, TestHelper.basicChannel.id)(store.dispatch, store.getState);
});
after(async () => {
await TestHelper.basicClient.logout();
});
it('fetchMyChannelsAndMembers', (done) => {
TestHelper.initBasic(Client).then(() => {
const store = configureStore();
it('createChannel', async () => {
const channel = {
team_id: TestHelper.basicTeam.id,
name: 'redux-test',
display_name: 'Redux Test',
purpose: 'This is to test redux',
header: 'MM with Redux',
type: 'O'
};
store.subscribe(() => {
const channels = store.getState().entities.channels.channels;
const members = store.getState().entities.channels.myMembers;
const channelsRequest = store.getState().requests.channels.getChannels;
const membersRequest = store.getState().requests.channels.myMembers;
if (channelsRequest.status === RequestStatus.SUCCESS && membersRequest.status === RequestStatus.SUCCESS) {
assert.ok(channels);
assert.ok(members);
assert.ok(channels[Object.keys(members)[0]]);
assert.ok(members[Object.keys(channels)[0]]);
assert.equal(Object.keys(channels).length, Object.keys(members).length);
done();
} else if (channelsRequest.status === RequestStatus.FAILURE && membersRequest.status === RequestStatus.FAILURE) {
done(new Error(JSON.stringify(channelsRequest.error)));
}
});
Actions.fetchMyChannelsAndMembers(TestHelper.basicTeam.id)(store.dispatch, store.getState);
});
}).timeout(3000);
it('updateChannelNotifyProps', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
store.subscribe(() => {
const members = store.getState().entities.channels.myMembers;
const updateRequest = store.getState().requests.channels.updateChannelNotifyProps;
if (updateRequest.status === RequestStatus.SUCCESS) {
const member = members[TestHelper.basicChannel.id];
assert.ok(member);
assert.equal(member.notify_props.mark_unread, 'mention');
assert.equal(member.notify_props.desktop, 'none');
done();
} else if (updateRequest.status === RequestStatus.FAILURE) {
done(new Error(JSON.stringify(updateRequest.error)));
}
});
const notifyProps = {
mark_unread: 'mention',
desktop: 'none'
};
await Actions.fetchMyChannelsAndMembers(TestHelper.basicTeam.id)(store.dispatch, store.getState);
Actions.updateChannelNotifyProps(
TestHelper.basicUser.id,
TestHelper.basicTeam.id,
TestHelper.basicChannel.id,
notifyProps)(store.dispatch, store.getState);
});
await Actions.createChannel(channel, TestHelper.basicUser.id)(store.dispatch, store.getState);
const {createChannel: createRequest, myMembers: membersRequest} = store.getState().requests.channels;
if (createRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(createRequest.error));
} else if (membersRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(membersRequest.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('leaveChannel', (done) => {
TestHelper.initBasic(Client).then(() => {
const store = configureStore();
it('createDirectChannel', async () => {
const user = await TestHelper.basicClient.createUserWithInvite(
TestHelper.fakeUser(),
null,
null,
TestHelper.basicTeam.invite_id
);
store.subscribe(() => {
const channels = store.getState().entities.channels.channels;
const members = store.getState().entities.channels.myMembers;
const leaveRequest = store.getState().requests.channels.leaveChannel;
await getProfilesByIds([user.id])(store.dispatch, store.getState);
await Actions.createDirectChannel(TestHelper.basicTeam.id, TestHelper.basicUser.id, user.id)(store.dispatch, store.getState);
if (leaveRequest.status === RequestStatus.SUCCESS) {
const channel = channels[TestHelper.basicChannel.id];
const member = members[TestHelper.basicChannel.id];
const createRequest = store.getState().requests.channels.createChannel;
if (createRequest.status === RequestStatus.FAILURE) {
throw new Error(createRequest.error);
}
assert.ifError(channel);
assert.ifError(member);
done();
} else if (leaveRequest.status === RequestStatus.FAILURE) {
done(new Error(JSON.stringify(leaveRequest.error)));
}
});
const state = store.getState();
const {channels, myMembers: members} = state.entities.channels;
const profiles = state.entities.users.profiles;
const preferences = state.entities.preferences.myPreferences;
const channelsCount = Object.keys(channels).length;
const membersCount = Object.keys(members).length;
Actions.leaveChannel(
TestHelper.basicTeam.id,
TestHelper.basicChannel.id)(store.dispatch, store.getState);
});
assert.ok(channels, 'channels is empty');
assert.ok(members, '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(members)[0]], 'channels should have the member');
assert.ok(members[Object.keys(channels)[0]], 'members should belong to channel');
assert.equal(members[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);
});
it('joinChannel', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
const secondClient = TestHelper.createClient();
const user = await TestHelper.basicClient.createUserWithInvite(
TestHelper.fakeUser(),
null,
null,
TestHelper.basicTeam.invite_id
);
await secondClient.login(user.email, 'password1');
it('updateChannel', async () => {
const channel = {
...TestHelper.basicChannel,
purpose: 'This is to test redux',
header: 'MM with Redux'
};
const secondChannel = await secondClient.createChannel(
TestHelper.fakeChannel(TestHelper.basicTeam.id));
await Actions.updateChannel(channel)(store.dispatch, store.getState);
store.subscribe(() => {
const channels = store.getState().entities.channels.channels;
const members = store.getState().entities.channels.myMembers;
const joinRequest = store.getState().requests.channels.joinChannel;
const updateRequest = store.getState().requests.channels.updateChannel;
if (updateRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(updateRequest.error));
}
if (joinRequest.status === RequestStatus.SUCCESS) {
const channel = channels[secondChannel.id];
const member = members[secondChannel.id];
assert.ok(channel);
assert.ok(member);
done();
} else if (joinRequest.status === RequestStatus.FAILURE) {
done(new Error(JSON.stringify(joinRequest.error)));
}
});
Actions.joinChannel(
TestHelper.basicUser.id,
TestHelper.basicTeam.id,
secondChannel.id)(store.dispatch, store.getState);
});
}).timeout(3000);
it('joinChannelByName', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
const secondClient = TestHelper.createClient();
const user = await TestHelper.basicClient.createUserWithInvite(
TestHelper.fakeUser(),
null,
null,
TestHelper.basicTeam.invite_id
);
await secondClient.login(user.email, 'password1');
const secondChannel = await secondClient.createChannel(
TestHelper.fakeChannel(TestHelper.basicTeam.id));
store.subscribe(() => {
const channels = store.getState().entities.channels.channels;
const members = store.getState().entities.channels.myMembers;
const joinRequest = store.getState().requests.channels.joinChannel;
if (joinRequest.status === RequestStatus.SUCCESS) {
const channel = channels[secondChannel.id];
const member = members[secondChannel.id];
assert.ok(channel);
assert.ok(member);
done();
} else if (joinRequest.status === RequestStatus.FAILURE) {
done(new Error(JSON.stringify(joinRequest.error)));
}
});
Actions.joinChannel(
TestHelper.basicUser.id,
TestHelper.basicTeam.id,
null,
secondChannel.name)(store.dispatch, store.getState);
});
}).timeout(3000);
it('deleteChannel', (done) => {
TestHelper.initBasic(Client).then(() => {
const store = configureStore();
store.subscribe(() => {
const channels = store.getState().entities.channels.channels;
const members = store.getState().entities.channels.myMembers;
const deleteRequest = store.getState().requests.channels.deleteChannel;
if (deleteRequest.status === RequestStatus.SUCCESS) {
const channel = channels[TestHelper.basicChannel.id];
const member = members[TestHelper.basicChannel.id];
assert.ifError(channel);
assert.ifError(member);
done();
} else if (deleteRequest.status === RequestStatus.FAILURE) {
done(new Error(JSON.stringify(deleteRequest.error)));
}
});
Actions.deleteChannel(
TestHelper.basicTeam.id,
TestHelper.basicChannel.id)(store.dispatch, store.getState);
});
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('updateLastViewedAt', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
let lastViewed;
it('getChannel', async () => {
await Actions.getChannel(TestHelper.basicTeam.id, TestHelper.basicChannel.id)(store.dispatch, store.getState);
store.subscribe(() => {
const members = store.getState().entities.channels.myMembers;
const updateRequest = store.getState().requests.channels.updateLastViewedAt;
let member;
const channelRequest = store.getState().requests.channels.getChannel;
if (channelRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(channelRequest.error));
}
if (updateRequest.status === RequestStatus.STARTED) {
member = members[TestHelper.basicChannel.id];
assert.ok(member);
lastViewed = member.last_viewed_at;
} else if (updateRequest.status === RequestStatus.SUCCESS) {
member = members[TestHelper.basicChannel.id];
assert.ok(member.last_viewed_at > lastViewed);
done();
} else if (updateRequest.status === RequestStatus.FAILURE) {
done(new Error(JSON.stringify(updateRequest.error)));
}
});
await Actions.fetchMyChannelsAndMembers(TestHelper.basicTeam.id)(store.dispatch, store.getState);
Actions.updateLastViewedAt(
TestHelper.basicTeam.id,
TestHelper.basicChannel.id, true)(store.dispatch, store.getState);
});
const {channels, myMembers} = store.getState().entities.channels;
assert.ok(channels[TestHelper.basicChannel.id]);
assert.ok(myMembers[TestHelper.basicChannel.id]);
});
it('getMoreChannels', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
const secondClient = TestHelper.createClient();
const user = await TestHelper.basicClient.createUserWithInvite(
TestHelper.fakeUser(),
null,
null,
TestHelper.basicTeam.invite_id
);
await secondClient.login(user.email, 'password1');
it('fetchMyChannelsAndMembers', async () => {
await Actions.fetchMyChannelsAndMembers(TestHelper.basicTeam.id)(store.dispatch, store.getState);
const secondChannel = await secondClient.createChannel(
TestHelper.fakeChannel(TestHelper.basicTeam.id));
const {getChannels: channelsRequest, myMembers: membersRequest} = store.getState().requests.channels;
if (channelsRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(channelsRequest.error));
} else if (membersRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(membersRequest.error));
}
store.subscribe(() => {
const channels = store.getState().entities.channels.channels;
const members = store.getState().entities.channels.myMembers;
const moreRequest = store.getState().requests.channels.getMoreChannels;
if (moreRequest.status === RequestStatus.SUCCESS) {
const channel = channels[secondChannel.id];
assert.ok(channel);
assert.ifError(members[channel.id]);
done();
} else if (moreRequest.status === RequestStatus.FAILURE) {
done(new Error(JSON.stringify(moreRequest.error)));
}
});
Actions.getMoreChannels(TestHelper.basicTeam.id, 0)(store.dispatch, store.getState);
});
}).timeout(3000);
it('getChannelStats', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
store.subscribe(() => {
const stats = store.getState().entities.channels.stats;
const statsRequest = store.getState().requests.channels.getChannelStats;
if (statsRequest.status === RequestStatus.SUCCESS) {
const stat = stats[TestHelper.basicChannel.id];
assert.ok(stat);
assert.equal(stat.member_count, 1);
done();
} else if (statsRequest.status === RequestStatus.FAILURE) {
done(new Error(JSON.stringify(statsRequest.error)));
}
});
Actions.getChannelStats(
TestHelper.basicTeam.id,
TestHelper.basicChannel.id
)(store.dispatch, store.getState);
});
const {channels, 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.equal(Object.keys(channels).length, Object.keys(myMembers).length);
});
it('addChannelMember', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
const user = await TestHelper.basicClient.createUserWithInvite(
TestHelper.fakeUser(),
null,
null,
TestHelper.basicTeam.invite_id
);
it('updateChannelNotifyProps', async () => {
const notifyProps = {
mark_unread: 'mention',
desktop: 'none'
};
store.subscribe(() => {
const profilesInChannel = store.getState().entities.users.profilesInChannel;
const profilesNotInChannel = store.getState().entities.users.profilesNotInChannel;
const addRequest = store.getState().requests.channels.addChannelMember;
await Actions.fetchMyChannelsAndMembers(TestHelper.basicTeam.id)(store.dispatch, store.getState);
await Actions.updateChannelNotifyProps(
TestHelper.basicUser.id,
TestHelper.basicTeam.id,
TestHelper.basicChannel.id,
notifyProps)(store.dispatch, store.getState);
if (addRequest.status === RequestStatus.SUCCESS) {
const channel = profilesInChannel[TestHelper.basicChannel.id];
const notChannel = profilesNotInChannel[TestHelper.basicChannel.id];
assert.ok(channel);
assert.ok(notChannel);
assert.ok(channel.has(user.id));
assert.ifError(notChannel.has(user.id));
done();
} else if (addRequest.status === RequestStatus.FAILURE) {
done(new Error(JSON.stringify(addRequest.error)));
}
});
const updateRequest = store.getState().requests.channels.updateChannelNotifyProps;
if (updateRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(updateRequest.error));
}
Actions.addChannelMember(
TestHelper.basicTeam.id,
TestHelper.basicChannel.id,
user.id
)(store.dispatch, store.getState);
});
const members = store.getState().entities.channels.myMembers;
const member = members[TestHelper.basicChannel.id];
assert.ok(member);
assert.equal(member.notify_props.mark_unread, 'mention');
assert.equal(member.notify_props.desktop, 'none');
});
it('removeChannelMember', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
const user = await TestHelper.basicClient.createUserWithInvite(
TestHelper.fakeUser(),
null,
null,
TestHelper.basicTeam.invite_id
);
it('leaveChannel', async () => {
await Actions.leaveChannel(
TestHelper.basicTeam.id,
TestHelper.basicChannel.id
)(store.dispatch, store.getState);
store.subscribe(() => {
const profilesInChannel = store.getState().entities.users.profilesInChannel;
const profilesNotInChannel = store.getState().entities.users.profilesNotInChannel;
const removeRequest = store.getState().requests.channels.removeChannelMember;
const leaveRequest = store.getState().requests.channels.leaveChannel;
if (leaveRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(leaveRequest.error));
}
if (removeRequest.status === RequestStatus.SUCCESS) {
const channel = profilesInChannel[TestHelper.basicChannel.id];
const notChannel = profilesNotInChannel[TestHelper.basicChannel.id];
assert.ok(channel);
assert.ok(notChannel);
assert.ok(notChannel.has(user.id));
assert.ifError(channel.has(user.id));
done();
} else if (removeRequest.status === RequestStatus.FAILURE) {
done(new Error(JSON.stringify(removeRequest.error)));
}
});
const {channels, myMembers} = store.getState().entities.channels;
assert.ifError(channels[TestHelper.basicChannel.id]);
assert.ifError(myMembers[TestHelper.basicChannel.id]);
});
await Actions.addChannelMember(
TestHelper.basicTeam.id,
TestHelper.basicChannel.id,
user.id
)(store.dispatch, store.getState);
it('joinChannel', async () => {
await Actions.joinChannel(
TestHelper.basicUser.id,
TestHelper.basicTeam.id,
TestHelper.basicChannel.id
)(store.dispatch, store.getState);
Actions.removeChannelMember(
TestHelper.basicTeam.id,
TestHelper.basicChannel.id,
user.id
)(store.dispatch, store.getState);
});
const joinRequest = store.getState().requests.channels.joinChannel;
if (joinRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(joinRequest.error));
}
const {channels, myMembers} = store.getState().entities.channels;
assert.ok(channels[TestHelper.basicChannel.id]);
assert.ok(myMembers[TestHelper.basicChannel.id]);
});
it('joinChannelByName', async () => {
const secondClient = TestHelper.createClient();
const user = await TestHelper.basicClient.createUserWithInvite(
TestHelper.fakeUser(),
null,
null,
TestHelper.basicTeam.invite_id
);
await secondClient.login(user.email, 'password1');
secondChannel = await secondClient.createChannel(
TestHelper.fakeChannel(TestHelper.basicTeam.id));
await Actions.joinChannel(
TestHelper.basicUser.id,
TestHelper.basicTeam.id,
null,
secondChannel.name
)(store.dispatch, store.getState);
const joinRequest = store.getState().requests.channels.joinChannel;
if (joinRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(joinRequest.error));
}
const {channels, myMembers} = store.getState().entities.channels;
assert.ok(channels[secondChannel.id]);
assert.ok(myMembers[secondChannel.id]);
});
it('deleteChannel', async () => {
await Actions.fetchMyChannelsAndMembers(TestHelper.basicTeam.id)(store.dispatch, store.getState);
await Actions.deleteChannel(
TestHelper.basicTeam.id,
secondChannel.id
)(store.dispatch, store.getState);
const deleteRequest = store.getState().requests.channels.deleteChannel;
if (deleteRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(deleteRequest.error));
}
const {channels, myMembers} = store.getState().entities.channels;
assert.ifError(channels[secondChannel.id]);
assert.ifError(myMembers[secondChannel.id]);
});
it('updateLastViewedAt', async () => {
await Actions.fetchMyChannelsAndMembers(TestHelper.basicTeam.id)(store.dispatch, store.getState);
let members = store.getState().entities.channels.myMembers;
let member = members[TestHelper.basicChannel.id];
assert.ok(member);
const lastViewed = member.last_viewed_at;
await Actions.updateLastViewedAt(
TestHelper.basicTeam.id,
TestHelper.basicChannel.id, true)(store.dispatch, store.getState);
const updateRequest = store.getState().requests.channels.updateLastViewedAt;
if (updateRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(updateRequest.error));
}
members = store.getState().entities.channels.myMembers;
member = members[TestHelper.basicChannel.id];
assert.ok(member.last_viewed_at > lastViewed);
});
it('getMoreChannels', async () => {
const userClient = TestHelper.createClient();
const user = await TestHelper.basicClient.createUserWithInvite(
TestHelper.fakeUser(),
null,
null,
TestHelper.basicTeam.invite_id
);
await userClient.login(user.email, 'password1');
const userChannel = await userClient.createChannel(
TestHelper.fakeChannel(TestHelper.basicTeam.id)
);
await Actions.getMoreChannels(TestHelper.basicTeam.id, 0)(store.dispatch, store.getState);
const moreRequest = store.getState().requests.channels.getMoreChannels;
if (moreRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(moreRequest.error));
}
const {channels, myMembers} = store.getState().entities.channels;
const channel = channels[userChannel.id];
assert.ok(channel);
assert.ifError(myMembers[channel.id]);
});
it('getChannelStats', async () => {
await Actions.getChannelStats(
TestHelper.basicTeam.id,
TestHelper.basicChannel.id
)(store.dispatch, store.getState);
const statsRequest = store.getState().requests.channels.getChannelStats;
if (statsRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(statsRequest.error));
}
const {stats} = store.getState().entities.channels;
const stat = stats[TestHelper.basicChannel.id];
assert.ok(stat);
assert.equal(stat.member_count, 1);
});
it('addChannelMember', async () => {
const user = await TestHelper.basicClient.createUserWithInvite(
TestHelper.fakeUser(),
null,
null,
TestHelper.basicTeam.invite_id
);
await Actions.addChannelMember(
TestHelper.basicTeam.id,
TestHelper.basicChannel.id,
user.id
)(store.dispatch, store.getState);
const addRequest = store.getState().requests.channels.addChannelMember;
if (addRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(addRequest.error));
}
const {profilesInChannel, profilesNotInChannel} = store.getState().entities.users;
const channel = profilesInChannel[TestHelper.basicChannel.id];
const notChannel = profilesNotInChannel[TestHelper.basicChannel.id];
assert.ok(channel);
assert.ok(notChannel);
assert.ok(channel.has(user.id));
assert.ifError(notChannel.has(user.id));
});
it('removeChannelMember', async () => {
const user = await TestHelper.basicClient.createUserWithInvite(
TestHelper.fakeUser(),
null,
null,
TestHelper.basicTeam.invite_id
);
await Actions.addChannelMember(
TestHelper.basicTeam.id,
TestHelper.basicChannel.id,
user.id
)(store.dispatch, store.getState);
await Actions.removeChannelMember(
TestHelper.basicTeam.id,
TestHelper.basicChannel.id,
user.id
)(store.dispatch, store.getState);
const removeRequest = store.getState().requests.channels.removeChannelMember;
if (removeRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(removeRequest.error));
}
const {profilesInChannel, profilesNotInChannel} = store.getState().entities.users;
const channel = profilesInChannel[TestHelper.basicChannel.id];
const notChannel = profilesNotInChannel[TestHelper.basicChannel.id];
assert.ok(channel);
assert.ok(notChannel);
assert.ok(notChannel.has(user.id));
assert.ifError(channel.has(user.id));
});
});

127
test/service/actions/general.test.js
View file

@ -4,93 +4,72 @@
import assert from 'assert';
import * as Actions from 'service/actions/general';
import Config from 'config';
import Client from 'service/client';
import configureStore from 'app/store';
import {RequestStatus} from 'service/constants';
import TestHelper from 'test/test_helper';
describe('Actions.General', () => {
it('getPing', (done) => {
TestHelper.initBasic(Client).then(() => {
const store = configureStore();
store.subscribe(() => {
const ping = store.getState().requests.general.server;
if (ping.error) {
done(new Error(JSON.stringify(ping.error)));
} else if (ping.status !== RequestStatus.STARTED) {
done();
}
});
Actions.getPing()(store.dispatch, store.getState);
});
let store;
before(async () => {
await TestHelper.initBasic(Client);
});
it('getClientConfig', (done) => {
TestHelper.initBasic(Client).then(() => {
const store = configureStore();
store.subscribe(() => {
const clientConfig = store.getState().entities.general.config;
const configRequest = store.getState().requests.general.config;
if (configRequest.status === RequestStatus.SUCCESS || configRequest.status === RequestStatus.FAILURE) {
if (configRequest.error) {
done(new Error(JSON.stringify(configRequest.error)));
} else {
// Check a few basic fields since they may change over time
assert.ok(clientConfig.Version);
assert.ok(clientConfig.BuildNumber);
assert.ok(clientConfig.BuildDate);
assert.ok(clientConfig.BuildHash);
done();
}
}
});
Actions.getClientConfig()(store.dispatch, store.getState);
});
beforeEach(() => {
store = configureStore();
});
it('getLicenseConfig', (done) => {
TestHelper.initBasic(Client).then(() => {
const store = configureStore();
store.subscribe(() => {
const licenseConfig = store.getState().entities.general.license;
const licenseRequest = store.getState().requests.general.license;
if (licenseRequest.status === RequestStatus.SUCCESS || licenseRequest.status === RequestStatus.FAILURE) {
if (licenseRequest.error) {
done(new Error(JSON.stringify(licenseRequest.error)));
} else {
// Check a few basic fields since they may change over time
assert.notStrictEqual(licenseConfig.IsLicensed, undefined);
done();
}
}
});
Actions.getLicenseConfig()(store.dispatch, store.getState);
});
after(async () => {
await TestHelper.basicClient.logout();
});
it('getPing - Invalid URL', (done) => {
TestHelper.initBasic(Client).then(() => {
const store = configureStore();
it('getPing - Invalid URL', async () => {
Client.setUrl('https://google.com/fake/url');
await Actions.getPing()(store.dispatch, store.getState);
store.subscribe(() => {
const ping = store.getState().requests.general.server;
const {server} = store.getState().requests.general;
assert.ok(server.status === RequestStatus.FAILURE && server.error);
});
if (ping.status === RequestStatus.FAILURE && ping.error) {
done();
}
});
it('getPing', async () => {
TestHelper.basicClient.setUrl(Config.DefaultServerUrl);
await Actions.getPing()(store.dispatch, store.getState);
Client.setUrl('https://google.com/fake/url');
Actions.getPing()(store.dispatch, store.getState);
});
}).timeout(5000);
const {server} = store.getState().requests.general;
if (server.status === RequestStatus.FAILED) {
throw new Error(JSON.stringify(server.error));
}
});
it('getClientConfig', async () => {
await Actions.getClientConfig()(store.dispatch, store.getState);
const configRequest = store.getState().requests.general.config;
if (configRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(configRequest.error));
}
const clientConfig = store.getState().entities.general.config;
// Check a few basic fields since they may change over time
assert.ok(clientConfig.Version);
assert.ok(clientConfig.BuildNumber);
assert.ok(clientConfig.BuildDate);
assert.ok(clientConfig.BuildHash);
});
it('getLicenseConfig', async () => {
await Actions.getLicenseConfig()(store.dispatch, store.getState);
const licenseRequest = store.getState().requests.general.license;
if (licenseRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(licenseRequest.error));
}
const licenseConfig = store.getState().entities.general.license;
// Check a few basic fields since they may change over time
assert.notStrictEqual(licenseConfig.IsLicensed, undefined);
});
});

769
test/service/actions/posts.test.js
View file

@ -10,487 +10,396 @@ import {Constants, RequestStatus} from 'service/constants';
import TestHelper from 'test/test_helper';
describe('Actions.Posts', () => {
it('createPost', (done) => {
TestHelper.initBasic(Client).then(() => {
const store = configureStore();
const channelId = TestHelper.basicChannel.id;
const post = TestHelper.fakePost(channelId);
store.subscribe(() => {
const state = store.getState();
const createRequest = state.requests.posts.createPost;
const {posts, postsByChannel} = state.entities.posts;
if (createRequest.status === RequestStatus.SUCCESS) {
assert.ok(posts);
assert.ok(postsByChannel);
assert.ok(postsByChannel[channelId]);
let found = false;
for (const storedPost of Object.values(posts)) {
if (storedPost.message === post.message) {
found = true;
break;
}
}
assert.ok(found, 'failed to find new post in posts');
found = false;
for (const postIdInChannel of postsByChannel[channelId]) {
if (posts[postIdInChannel].message === post.message) {
found = true;
break;
}
}
assert.ok(found, 'failed to find new post in postsByChannel');
done();
} else if (createRequest.status === RequestStatus.FAILURE) {
done(new Error(JSON.stringify(createRequest.error)));
}
});
Actions.createPost(
TestHelper.basicTeam.id,
post
)(store.dispatch, store.getState);
});
let store;
before(async () => {
await TestHelper.initBasic(Client);
});
it('editPost', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
const teamId = TestHelper.basicTeam.id;
const channelId = TestHelper.basicChannel.id;
const post = await Client.createPost(
teamId,
TestHelper.fakePost(channelId)
);
const message = post.message;
store.subscribe(() => {
const state = store.getState();
const editRequest = state.requests.posts.editPost;
const posts = state.entities.posts.posts;
if (editRequest.status === RequestStatus.SUCCESS) {
assert.ok(posts);
assert.ok(posts[post.id]);
assert.strictEqual(
posts[post.id].message,
`${message} (edited)`
);
done();
} else if (editRequest.status === RequestStatus.FAILURE) {
done(new Error(JSON.stringify(editRequest.error)));
}
});
post.message = `${message} (edited)`;
Actions.editPost(
teamId,
post
)(store.dispatch, store.getState);
});
beforeEach(() => {
store = configureStore();
});
it('deletePost', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
const teamId = TestHelper.basicTeam.id;
const channelId = TestHelper.basicChannel.id;
await Actions.createPost(
teamId,
TestHelper.fakePost(channelId)
)(store.dispatch, store.getState);
const initialPosts = store.getState().entities.posts;
const created = initialPosts.posts[initialPosts.postsByChannel[channelId][0]];
store.subscribe(() => {
const state = store.getState();
const deleteRequest = state.requests.posts.deletePost;
const posts = state.entities.posts.posts;
if (deleteRequest.status === RequestStatus.SUCCESS) {
assert.ok(posts);
assert.ok(posts[created.id]);
assert.strictEqual(
posts[created.id].state,
Constants.POST_DELETED
);
done();
} else if (deleteRequest.status === RequestStatus.FAILURE) {
done(new Error(JSON.stringify(deleteRequest.error)));
}
});
Actions.deletePost(teamId, created)(store.dispatch, store.getState);
});
after(async () => {
await TestHelper.basicClient.logout();
});
it('removePost', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
it('createPost', async () => {
const channelId = TestHelper.basicChannel.id;
const post = TestHelper.fakePost(channelId);
const teamId = TestHelper.basicTeam.id;
const channelId = TestHelper.basicChannel.id;
const postId = TestHelper.basicPost.id;
await Actions.createPost(
TestHelper.basicTeam.id,
post
)(store.dispatch, store.getState);
const post1a = await Client.createPost(
teamId,
{...TestHelper.fakePost(channelId), root_id: postId}
);
const state = store.getState();
const createRequest = state.requests.posts.createPost;
if (createRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(createRequest.error));
}
await Actions.getPosts(
teamId,
channelId
)(store.dispatch, store.getState);
const {posts, postsByChannel} = state.entities.posts;
assert.ok(posts);
assert.ok(postsByChannel);
assert.ok(postsByChannel[channelId]);
let shouldStop = false;
store.subscribe(() => {
const state = store.getState();
const {posts, postsByChannel} = state.entities.posts;
let found = false;
for (const storedPost of Object.values(posts)) {
if (storedPost.message === post.message) {
found = true;
break;
}
}
assert.ok(found, 'failed to find new post in posts');
if (!shouldStop) {
assert.ok(posts);
assert.ok(postsByChannel);
assert.ok(postsByChannel[channelId]);
assert.equal(postsByChannel[channelId].length, 0);
assert.ok(!posts[postId]);
assert.ok(!posts[post1a.id]);
shouldStop = true;
done();
}
});
Actions.removePost(
TestHelper.basicPost
)(store.dispatch, store.getState);
});
found = false;
for (const postIdInChannel of postsByChannel[channelId]) {
if (posts[postIdInChannel].message === post.message) {
found = true;
break;
}
}
assert.ok(found, 'failed to find new post in postsByChannel');
});
it('getPost', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
it('editPost', async () => {
const teamId = TestHelper.basicTeam.id;
const channelId = TestHelper.basicChannel.id;
const teamId = TestHelper.basicTeam.id;
const channelId = TestHelper.basicChannel.id;
const post = await Client.createPost(
teamId,
TestHelper.fakePost(channelId)
);
const message = post.message;
const post = await Client.createPost(
teamId,
TestHelper.fakePost(channelId)
);
post.message = `${message} (edited)`;
await Actions.editPost(
teamId,
post
)(store.dispatch, store.getState);
let shouldStop = false;
store.subscribe(() => {
const state = store.getState();
const getRequest = state.requests.posts.getPost;
const {posts, postsByChannel} = state.entities.posts;
const state = store.getState();
const editRequest = state.requests.posts.editPost;
const {posts} = state.entities.posts;
if (!shouldStop &&
(getRequest.status === RequestStatus.SUCCESS || getRequest.status === RequestStatus.FAILURE)) {
if (getRequest.error) {
shouldStop = true;
done(new Error(JSON.stringify(getRequest.error)));
} else {
assert.ok(posts);
assert.ok(postsByChannel);
assert.ok(postsByChannel[channelId]);
if (editRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(editRequest.error));
}
assert.ok(posts[post.id]);
assert.ok(posts);
assert.ok(posts[post.id]);
let found = false;
for (const postIdInChannel of postsByChannel[channelId]) {
if (postIdInChannel === post.id) {
found = true;
break;
}
}
assert.ok(found, 'failed to find post in postsByChannel');
shouldStop = true;
done();
}
}
});
Actions.getPost(
teamId,
channelId,
post.id
)(store.dispatch, store.getState);
});
assert.strictEqual(
posts[post.id].message,
`${message} (edited)`
);
});
it('getPosts', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
it('deletePost', async () => {
const teamId = TestHelper.basicTeam.id;
const channelId = TestHelper.basicChannel.id;
const teamId = TestHelper.basicTeam.id;
const channelId = TestHelper.basicChannel.id;
await Actions.createPost(
teamId,
TestHelper.fakePost(channelId)
)(store.dispatch, store.getState);
const post1 = await Client.createPost(
teamId,
TestHelper.fakePost(channelId)
);
const post1a = await Client.createPost(
teamId,
{...TestHelper.fakePost(channelId), root_id: post1.id}
);
const post2 = await Client.createPost(
teamId,
TestHelper.fakePost(channelId)
);
const post3 = await Client.createPost(
teamId,
TestHelper.fakePost(channelId)
);
const post3a = await Client.createPost(
teamId,
{...TestHelper.fakePost(channelId), root_id: post3.id}
);
const initialPosts = store.getState().entities.posts;
const created = initialPosts.posts[initialPosts.postsByChannel[channelId][0]];
let shouldStop = false;
store.subscribe(() => {
const state = store.getState();
const getRequest = state.requests.posts.getPosts;
const {posts, postsByChannel} = state.entities.posts;
await Actions.deletePost(teamId, created)(store.dispatch, store.getState);
if (!shouldStop &&
(getRequest.status === RequestStatus.SUCCESS || getRequest.status === RequestStatus.FAILURE)) {
if (getRequest.error) {
shouldStop = true;
done(new Error(JSON.stringify(getRequest.error)));
} else {
assert.ok(posts);
assert.ok(postsByChannel);
const state = store.getState();
const deleteRequest = state.requests.posts.deletePost;
const {posts} = state.entities.posts;
const postsInChannel = postsByChannel[channelId];
assert.ok(postsInChannel);
assert.equal(postsInChannel[0], post3a.id, 'wrong order for post3a');
assert.equal(postsInChannel[1], post3.id, 'wrong order for post3');
assert.equal(postsInChannel[3], post1a.id, 'wrong order for post1a');
if (deleteRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(deleteRequest.error));
}
assert.ok(posts[post1.id]);
assert.ok(posts[post1a.id]);
assert.ok(posts[post2.id]);
assert.ok(posts[post3.id]);
assert.ok(posts[post3a.id]);
assert.ok(posts);
assert.ok(posts[created.id]);
shouldStop = true;
done();
}
}
});
assert.strictEqual(
posts[created.id].state,
Constants.POST_DELETED
);
});
Actions.getPosts(
teamId,
channelId
)(store.dispatch, store.getState);
});
}).timeout(3000);
it('removePost', async () => {
const teamId = TestHelper.basicTeam.id;
const channelId = TestHelper.basicChannel.id;
const postId = TestHelper.basicPost.id;
it('getPostsSince', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
const post1a = await Client.createPost(
teamId,
{...TestHelper.fakePost(channelId), root_id: postId}
);
const teamId = TestHelper.basicTeam.id;
const channelId = TestHelper.basicChannel.id;
await Actions.getPosts(
teamId,
channelId
)(store.dispatch, store.getState);
const post1 = await Client.createPost(
teamId,
TestHelper.fakePost(channelId)
);
await Client.createPost(
teamId,
{...TestHelper.fakePost(channelId), root_id: post1.id}
);
const post2 = await Client.createPost(
teamId,
TestHelper.fakePost(channelId)
);
const post3 = await Client.createPost(
teamId,
TestHelper.fakePost(channelId)
);
const post3a = await Client.createPost(
teamId,
{...TestHelper.fakePost(channelId), root_id: post3.id}
);
const postsCount = store.getState().entities.posts.postsByChannel[channelId].length;
let shouldStop = false;
store.subscribe(() => {
const state = store.getState();
const getRequest = state.requests.posts.getPostsSince;
const {posts, postsByChannel} = state.entities.posts;
await Actions.removePost(
TestHelper.basicPost
)(store.dispatch, store.getState);
if (!shouldStop &&
(getRequest.status === RequestStatus.SUCCESS || getRequest.status === RequestStatus.FAILURE)) {
if (getRequest.error) {
shouldStop = true;
done(new Error(JSON.stringify(getRequest.error)));
} else {
assert.ok(posts);
assert.ok(postsByChannel);
const {posts, postsByChannel} = store.getState().entities.posts;
const postsInChannel = postsByChannel[channelId];
assert.ok(postsInChannel);
assert.equal(postsInChannel[0], post3a.id, 'wrong order for post3a');
assert.equal(postsInChannel[1], post3.id, 'wrong order for post3');
assert.equal(postsInChannel.length, 2, 'wrong size');
assert.ok(posts);
assert.ok(postsByChannel);
assert.ok(postsByChannel[channelId]);
shouldStop = true;
done();
}
}
});
// this should count that the basic post and post1a were removed
assert.equal(postsByChannel[channelId].length, postsCount - 2);
assert.ok(!posts[postId]);
assert.ok(!posts[post1a.id]);
});
Actions.getPostsSince(
teamId,
channelId,
post2.create_at
)(store.dispatch, store.getState);
});
}).timeout(3000);
it('getPost', async () => {
const teamId = TestHelper.basicTeam.id;
const channelId = TestHelper.basicChannel.id;
it('getPostsBefore', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
const post = await Client.createPost(
teamId,
TestHelper.fakePost(channelId)
);
const teamId = TestHelper.basicTeam.id;
const channelId = TestHelper.basicChannel.id;
await Actions.getPost(
teamId,
channelId,
post.id
)(store.dispatch, store.getState);
const post1 = await Client.createPost(
teamId,
TestHelper.fakePost(channelId)
);
const post1a = await Client.createPost(
teamId,
{...TestHelper.fakePost(channelId), root_id: post1.id}
);
const post2 = await Client.createPost(
teamId,
TestHelper.fakePost(channelId)
);
const post3 = await Client.createPost(
teamId,
TestHelper.fakePost(channelId)
);
await Client.createPost(
teamId,
{...TestHelper.fakePost(channelId), root_id: post3.id}
);
const state = store.getState();
const getRequest = state.requests.posts.getPost;
const {posts, postsByChannel} = state.entities.posts;
let shouldStop = false;
store.subscribe(() => {
const state = store.getState();
const getRequest = state.requests.posts.getPostsBefore;
const {posts, postsByChannel} = state.entities.posts;
if (getRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(getRequest.error));
}
if (!shouldStop &&
(getRequest.status === RequestStatus.SUCCESS || getRequest.status === RequestStatus.FAILURE)) {
if (getRequest.error) {
shouldStop = true;
done(new Error(JSON.stringify(getRequest.error)));
} else {
assert.ok(posts);
assert.ok(postsByChannel);
assert.ok(posts);
assert.ok(postsByChannel);
assert.ok(postsByChannel[channelId]);
const postsInChannel = postsByChannel[channelId];
assert.ok(postsInChannel);
assert.equal(postsInChannel[0], post1a.id, 'wrong order for post1a');
assert.equal(postsInChannel[1], post1.id, 'wrong order for post1');
assert.equal(postsInChannel.length, 3, 'wrong size');
assert.ok(posts[post.id]);
shouldStop = true;
done();
}
}
});
let found = false;
for (const postIdInChannel of postsByChannel[channelId]) {
if (postIdInChannel === post.id) {
found = true;
break;
}
}
assert.ok(found, 'failed to find post in postsByChannel');
});
Actions.getPostsBefore(
teamId,
channelId,
post2.id,
0,
10
)(store.dispatch, store.getState);
});
}).timeout(3000);
it('getPosts', async () => {
const teamId = TestHelper.basicTeam.id;
const channelId = TestHelper.basicChannel.id;
it('getPostsAfter', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
const post1 = await Client.createPost(
teamId,
TestHelper.fakePost(channelId)
);
const post1a = await Client.createPost(
teamId,
{...TestHelper.fakePost(channelId), root_id: post1.id}
);
const post2 = await Client.createPost(
teamId,
TestHelper.fakePost(channelId)
);
const post3 = await Client.createPost(
teamId,
TestHelper.fakePost(channelId)
);
const post3a = await Client.createPost(
teamId,
{...TestHelper.fakePost(channelId), root_id: post3.id}
);
const teamId = TestHelper.basicTeam.id;
const channelId = TestHelper.basicChannel.id;
await Actions.getPosts(
teamId,
channelId
)(store.dispatch, store.getState);
const post1 = await Client.createPost(
teamId,
TestHelper.fakePost(channelId)
);
await Client.createPost(
teamId,
{...TestHelper.fakePost(channelId), root_id: post1.id}
);
const post2 = await Client.createPost(
teamId,
TestHelper.fakePost(channelId)
);
const post3 = await Client.createPost(
teamId,
TestHelper.fakePost(channelId)
);
const post3a = await Client.createPost(
teamId,
{...TestHelper.fakePost(channelId), root_id: post3.id}
);
const state = store.getState();
const getRequest = state.requests.posts.getPosts;
const {posts, postsByChannel} = state.entities.posts;
let shouldStop = false;
store.subscribe(() => {
const state = store.getState();
const getRequest = state.requests.posts.getPostsAfter;
const {posts, postsByChannel} = state.entities.posts;
if (getRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(getRequest.error));
}
if (!shouldStop &&
(getRequest.status === RequestStatus.SUCCESS || getRequest.status === RequestStatus.FAILURE)) {
if (getRequest.error) {
shouldStop = true;
done(new Error(JSON.stringify(getRequest.error)));
} else {
assert.ok(posts);
assert.ok(postsByChannel);
assert.ok(posts);
assert.ok(postsByChannel);
const postsInChannel = postsByChannel[channelId];
assert.ok(postsInChannel);
assert.equal(postsInChannel[0], post3a.id, 'wrong order for post3a');
assert.equal(postsInChannel[1], post3.id, 'wrong order for post3');
assert.equal(postsInChannel.length, 2, 'wrong size');
const postsInChannel = postsByChannel[channelId];
assert.ok(postsInChannel);
assert.equal(postsInChannel[0], post3a.id, 'wrong order for post3a');
assert.equal(postsInChannel[1], post3.id, 'wrong order for post3');
assert.equal(postsInChannel[3], post1a.id, 'wrong order for post1a');
shouldStop = true;
done();
}
}
});
assert.ok(posts[post1.id]);
assert.ok(posts[post1a.id]);
assert.ok(posts[post2.id]);
assert.ok(posts[post3.id]);
assert.ok(posts[post3a.id]);
});
Actions.getPostsAfter(
teamId,
channelId,
post2.id,
0,
10
)(store.dispatch, store.getState);
});
}).timeout(3000);
it('getPostsSince', async () => {
const teamId = TestHelper.basicTeam.id;
const channelId = TestHelper.basicChannel.id;
const post1 = await Client.createPost(
teamId,
TestHelper.fakePost(channelId)
);
await Client.createPost(
teamId,
{...TestHelper.fakePost(channelId), root_id: post1.id}
);
const post2 = await Client.createPost(
teamId,
TestHelper.fakePost(channelId)
);
const post3 = await Client.createPost(
teamId,
TestHelper.fakePost(channelId)
);
const post3a = await Client.createPost(
teamId,
{...TestHelper.fakePost(channelId), root_id: post3.id}
);
await Actions.getPostsSince(
teamId,
channelId,
post2.create_at
)(store.dispatch, store.getState);
const state = store.getState();
const getRequest = state.requests.posts.getPostsSince;
const {posts, postsByChannel} = state.entities.posts;
if (getRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(getRequest.error));
}
assert.ok(posts);
assert.ok(postsByChannel);
const postsInChannel = postsByChannel[channelId];
assert.ok(postsInChannel);
assert.equal(postsInChannel[0], post3a.id, 'wrong order for post3a');
assert.equal(postsInChannel[1], post3.id, 'wrong order for post3');
assert.equal(postsInChannel.length, 2, 'wrong size');
});
it('getPostsBefore', async () => {
const teamId = TestHelper.basicTeam.id;
const channelId = TestHelper.basicChannel.id;
const post1 = await Client.createPost(
teamId,
TestHelper.fakePost(channelId)
);
const post1a = await Client.createPost(
teamId,
{...TestHelper.fakePost(channelId), root_id: post1.id}
);
const post2 = await Client.createPost(
teamId,
TestHelper.fakePost(channelId)
);
const post3 = await Client.createPost(
teamId,
TestHelper.fakePost(channelId)
);
await Client.createPost(
teamId,
{...TestHelper.fakePost(channelId), root_id: post3.id}
);
await Actions.getPostsBefore(
teamId,
channelId,
post2.id,
0,
10
)(store.dispatch, store.getState);
const state = store.getState();
const getRequest = state.requests.posts.getPostsBefore;
const {posts, postsByChannel} = state.entities.posts;
if (getRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(getRequest.error));
}
assert.ok(posts);
assert.ok(postsByChannel);
const postsInChannel = postsByChannel[channelId];
assert.ok(postsInChannel);
assert.equal(postsInChannel[0], post1a.id, 'wrong order for post1a');
assert.equal(postsInChannel[1], post1.id, 'wrong order for post1');
assert.equal(postsInChannel.length, 10, 'wrong size');
});
it('getPostsAfter', async () => {
const teamId = TestHelper.basicTeam.id;
const channelId = TestHelper.basicChannel.id;
const post1 = await Client.createPost(
teamId,
TestHelper.fakePost(channelId)
);
await Client.createPost(
teamId,
{...TestHelper.fakePost(channelId), root_id: post1.id}
);
const post2 = await Client.createPost(
teamId,
TestHelper.fakePost(channelId)
);
const post3 = await Client.createPost(
teamId,
TestHelper.fakePost(channelId)
);
const post3a = await Client.createPost(
teamId,
{...TestHelper.fakePost(channelId), root_id: post3.id}
);
await Actions.getPostsAfter(
teamId,
channelId,
post2.id,
0,
10
)(store.dispatch, store.getState);
const state = store.getState();
const getRequest = state.requests.posts.getPostsAfter;
const {posts, postsByChannel} = state.entities.posts;
if (getRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(getRequest.error));
}
assert.ok(posts);
assert.ok(postsByChannel);
const postsInChannel = postsByChannel[channelId];
assert.ok(postsInChannel);
assert.equal(postsInChannel[0], post3a.id, 'wrong order for post3a');
assert.equal(postsInChannel[1], post3.id, 'wrong order for post3');
assert.equal(postsInChannel.length, 2, 'wrong size');
});
});

260
test/service/actions/preferences.test.js
View file

@ -10,151 +10,141 @@ import {RequestStatus} from 'service/constants';
import TestHelper from 'test/test_helper';
describe('Actions.Preferences', () => {
it('getMyPreferences', (done) => {
TestHelper.initBasic(Client).then(async ({user}) => {
const store = configureStore();
const existingPreferences = [
{
user_id: user.id,
category: 'test',
name: 'test1',
value: 'test'
},
{
user_id: user.id,
category: 'test',
name: 'test2',
value: 'test'
}
];
await Client.savePreferences(existingPreferences);
store.subscribe(() => {
const state = store.getState();
const request = state.requests.preferences.getMyPreferences;
if (request.status === RequestStatus.SUCCESS) {
const myPreferences = state.entities.preferences.myPreferences;
assert.ok(myPreferences['test--test1'], 'first preference doesn\'t exist');
assert.deepEqual(existingPreferences[0], myPreferences['test--test1']);
assert.ok(myPreferences['test--test2'], 'second preference doesn\'t exist');
assert.deepEqual(existingPreferences[1], myPreferences['test--test2']);
done();
} else if (request.status === RequestStatus.FAILURE) {
done(new Error(JSON.stringify(request.error)));
}
});
Actions.getMyPreferences('1234')(store.dispatch, store.getState);
});
let store;
before(async () => {
await TestHelper.initBasic(Client);
});
it('savePrefrences', (done) => {
TestHelper.initBasic(Client).then(async ({user}) => {
const store = configureStore();
const existingPreferences = [
{
user_id: user.id,
category: 'test',
name: 'test1',
value: 'test'
}
];
await Client.savePreferences(existingPreferences);
Actions.getMyPreferences()(store.dispatch, store.getState);
const preferences = [
{
user_id: user.id,
category: 'test',
name: 'test2',
value: 'test'
},
{
user_id: user.id,
category: 'test',
name: 'test3',
value: 'test'
}
];
store.subscribe(() => {
const state = store.getState();
const request = state.requests.preferences.savePreferences;
if (request.status === RequestStatus.SUCCESS) {
const myPreferences = state.entities.preferences.myPreferences;
assert.ok(myPreferences['test--test1'], 'first preference doesn\'t exist');
assert.deepEqual(existingPreferences[0], myPreferences['test--test1']);
assert.ok(myPreferences['test--test2'], 'second preference doesn\'t exist');
assert.deepEqual(preferences[0], myPreferences['test--test2']);
assert.ok(myPreferences['test--test3'], 'third preference doesn\'t exist');
assert.deepEqual(preferences[1], myPreferences['test--test3']);
done();
} else if (request.status === RequestStatus.FAILURE) {
done(new Error(JSON.stringify(request.error)));
}
});
Actions.savePreferences(preferences)(store.dispatch, store.getState);
});
beforeEach(() => {
store = configureStore();
});
it('deletePreferences', (done) => {
TestHelper.initBasic(Client).then(async ({user}) => {
const store = configureStore();
after(async () => {
await TestHelper.basicClient.logout();
});
const existingPreferences = [
{
user_id: user.id,
category: 'test',
name: 'test1',
value: 'test'
},
{
user_id: user.id,
category: 'test',
name: 'test2',
value: 'test'
},
{
user_id: user.id,
category: 'test',
name: 'test3',
value: 'test'
}
];
it('getMyPreferences', async () => {
const user = TestHelper.basicUser;
const existingPreferences = [
{
user_id: user.id,
category: 'test',
name: 'test1',
value: 'test'
},
{
user_id: user.id,
category: 'test',
name: 'test2',
value: 'test'
}
];
await Client.savePreferences(existingPreferences);
Actions.getMyPreferences()(store.dispatch, store.getState);
await Client.savePreferences(existingPreferences);
await Actions.getMyPreferences('1234')(store.dispatch, store.getState);
store.subscribe(() => {
const state = store.getState();
const request = state.requests.preferences.deletePreferences;
const state = store.getState();
const request = state.requests.preferences.getMyPreferences;
const {myPreferences} = state.entities.preferences;
if (request.status === RequestStatus.SUCCESS) {
const myPreferences = state.entities.preferences.myPreferences;
if (request.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(request.error));
}
assert.ok(!myPreferences['test--test1'], 'deleted preference still exists');
assert.ok(myPreferences['test--test2'], 'second preference doesn\'t exist');
assert.deepEqual(existingPreferences[1], myPreferences['test--test2']);
assert.ok(!myPreferences['test--test3'], 'third preference doesn\'t exist');
assert.ok(myPreferences['test--test1'], 'first preference doesn\'t exist');
assert.deepEqual(existingPreferences[0], myPreferences['test--test1']);
assert.ok(myPreferences['test--test2'], 'second preference doesn\'t exist');
assert.deepEqual(existingPreferences[1], myPreferences['test--test2']);
});
done();
} else if (request.status === RequestStatus.FAILURE) {
done(new Error(JSON.stringify(request.error)));
}
});
it('savePrefrences', async () => {
const user = TestHelper.basicUser;
const existingPreferences = [
{
user_id: user.id,
category: 'test',
name: 'test1',
value: 'test'
}
];
Actions.deletePreferences([existingPreferences[0], existingPreferences[2]])(store.dispatch, store.getState);
});
await Client.savePreferences(existingPreferences);
await Actions.getMyPreferences()(store.dispatch, store.getState);
const preferences = [
{
user_id: user.id,
category: 'test',
name: 'test2',
value: 'test'
},
{
user_id: user.id,
category: 'test',
name: 'test3',
value: 'test'
}
];
await Actions.savePreferences(preferences)(store.dispatch, store.getState);
const state = store.getState();
const request = state.requests.preferences.savePreferences;
const {myPreferences} = state.entities.preferences;
if (request.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(request.error));
}
assert.ok(myPreferences['test--test1'], 'first preference doesn\'t exist');
assert.deepEqual(existingPreferences[0], myPreferences['test--test1']);
assert.ok(myPreferences['test--test2'], 'second preference doesn\'t exist');
assert.deepEqual(preferences[0], myPreferences['test--test2']);
assert.ok(myPreferences['test--test3'], 'third preference doesn\'t exist');
assert.deepEqual(preferences[1], myPreferences['test--test3']);
});
it('deletePreferences', async () => {
const user = TestHelper.basicUser;
const existingPreferences = [
{
user_id: user.id,
category: 'test',
name: 'test1',
value: 'test'
},
{
user_id: user.id,
category: 'test',
name: 'test2',
value: 'test'
},
{
user_id: user.id,
category: 'test',
name: 'test3',
value: 'test'
}
];
await Client.savePreferences(existingPreferences);
await Actions.getMyPreferences()(store.dispatch, store.getState);
await Actions.deletePreferences([
existingPreferences[0],
existingPreferences[2]
])(store.dispatch, store.getState);
const state = store.getState();
const request = state.requests.preferences.deletePreferences;
const {myPreferences} = state.entities.preferences;
if (request.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(request.error));
}
assert.ok(!myPreferences['test--test1'], 'deleted preference still exists');
assert.ok(myPreferences['test--test2'], 'second preference doesn\'t exist');
assert.deepEqual(existingPreferences[1], myPreferences['test--test2']);
assert.ok(!myPreferences['test--test3'], 'third preference doesn\'t exist');
});
});

469
test/service/actions/teams.test.js
View file

@ -10,311 +10,232 @@ import {RequestStatus} from 'service/constants';
import TestHelper from 'test/test_helper';
describe('Actions.Teams', () => {
it('selectTeam', (done) => {
TestHelper.initBasic(Client).then(() => {
const store = configureStore();
store.subscribe(() => {
const currentTeamId = store.getState().entities.teams.currentId;
assert.ok(currentTeamId);
assert.equal(currentTeamId, TestHelper.basicTeam.id);
done();
});
Actions.selectTeam(TestHelper.basicTeam)(store.dispatch, store.getState);
});
let store;
before(async () => {
await TestHelper.initBasic(Client);
});
it('fetchTeams', (done) => {
TestHelper.initBasic(Client).then(() => {
const store = configureStore();
store.subscribe(() => {
const teamsRequest = store.getState().requests.teams.allTeams;
const teams = store.getState().entities.teams.teams;
if (teamsRequest.status === RequestStatus.SUCCESS || teamsRequest.status === RequestStatus.FAILURE) {
if (teamsRequest.error) {
done(new Error(JSON.stringify(teamsRequest.error)));
} else {
assert.ok(teams);
assert.ok(teams[TestHelper.basicTeam.id]);
done();
}
}
});
Actions.fetchTeams()(store.dispatch, store.getState);
});
beforeEach(() => {
store = configureStore();
});
it('getAllTeamListings', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
store.subscribe(() => {
const teamsRequest = store.getState().requests.teams.getAllTeamListings;
const teams = store.getState().entities.teams.teams;
const openIds = store.getState().entities.teams.openTeamIds;
if (teamsRequest.status === RequestStatus.SUCCESS || teamsRequest.status === RequestStatus.FAILURE) {
if (teamsRequest.error) {
done(new Error(JSON.stringify(teamsRequest.error)));
} else {
assert.ok(Object.keys(teams).length > 0);
for (const teamId in teams) {
if (teams.hasOwnProperty(teamId)) {
assert.ok(openIds.has(teamId));
}
}
done();
}
}
});
const team = TestHelper.fakeTeam();
team.allow_open_invite = true;
await Client.createTeam(team);
Actions.getAllTeamListings()(store.dispatch, store.getState);
});
after(async () => {
await TestHelper.basicClient.logout();
});
it('createTeam', (done) => {
TestHelper.initBasic(Client).then(() => {
const store = configureStore();
it('selectTeam', async () => {
await Actions.selectTeam(TestHelper.basicTeam)(store.dispatch, store.getState);
const {currentId} = store.getState().entities.teams;
store.subscribe(() => {
const createRequest = store.getState().requests.teams.createTeam;
const teams = store.getState().entities.teams.teams;
const members = store.getState().entities.teams.myMembers;
const current = store.getState().entities.teams.currentId;
if (createRequest.status === RequestStatus.SUCCESS || createRequest.status === RequestStatus.FAILURE) {
if (createRequest.error) {
done(new Error(JSON.stringify(createRequest.error)));
} else {
const teamId = Object.keys(teams)[0];
assert.strictEqual(Object.keys(teams).length, 1);
assert.strictEqual(current, teamId);
assert.ok(members[teamId]);
done();
}
}
});
Actions.createTeam(
TestHelper.basicUser.id,
TestHelper.fakeTeam()
)(store.dispatch, store.getState);
});
assert.ok(currentId);
assert.equal(currentId, TestHelper.basicTeam.id);
});
it('updateTeam', (done) => {
TestHelper.initBasic(Client).then(() => {
const store = configureStore();
const displayName = 'The Updated Team';
const description = 'This is a team created by unit tests';
it('fetchTeams', async () => {
await Actions.fetchTeams()(store.dispatch, store.getState);
store.subscribe(() => {
const updateRequest = store.getState().requests.teams.updateTeam;
const teams = store.getState().entities.teams.teams;
const teamsRequest = store.getState().requests.teams.allTeams;
const {teams} = store.getState().entities.teams;
if (updateRequest.status === RequestStatus.SUCCESS || updateRequest.status === RequestStatus.FAILURE) {
if (updateRequest.error) {
done(new Error(JSON.stringify(updateRequest.error)));
} else {
const team = teams[TestHelper.basicTeam.id];
assert.ok(team);
assert.strictEqual(team.display_name, displayName);
assert.strictEqual(team.description, description);
done();
}
}
});
if (teamsRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(teamsRequest.error));
}
const team = {
...TestHelper.basicTeam,
display_name: displayName,
description
};
Actions.updateTeam(team)(store.dispatch, store.getState);
});
assert.ok(teams);
assert.ok(teams[TestHelper.basicTeam.id]);
});
it('getMyTeamMembers', (done) => {
TestHelper.initBasic(Client).then(() => {
const store = configureStore();
it('getAllTeamListings', async () => {
const team = {...TestHelper.fakeTeam(), allow_open_invite: true};
store.subscribe(() => {
const membersRequest = store.getState().requests.teams.getMyTeamMembers;
const members = store.getState().entities.teams.myMembers;
await Client.createTeam(team);
await Actions.getAllTeamListings()(store.dispatch, store.getState);
if (membersRequest.status === RequestStatus.SUCCESS || membersRequest.status === RequestStatus.FAILURE) {
if (membersRequest.error) {
done(new Error(JSON.stringify(membersRequest.error)));
} else {
assert.ok(members);
assert.ok(members[TestHelper.basicTeam.id]);
done();
}
}
});
const teamsRequest = store.getState().requests.teams.getAllTeamListings;
const {teams, openTeamIds} = store.getState().entities.teams;
Actions.getMyTeamMembers()(store.dispatch, store.getState);
});
if (teamsRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(teamsRequest.error));
}
assert.ok(Object.keys(teams).length > 0);
for (const teamId in teams) {
if (teams.hasOwnProperty(teamId)) {
assert.ok(openTeamIds.has(teamId));
}
}
});
it('getTeamMember', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
it('createTeam', async () => {
await Actions.createTeam(
TestHelper.basicUser.id,
TestHelper.fakeTeam()
)(store.dispatch, store.getState);
const user = await TestHelper.basicClient.createUserWithInvite(
TestHelper.fakeUser(),
null,
null,
TestHelper.basicTeam.invite_id
);
const createRequest = store.getState().requests.teams.createTeam;
const {teams, myMembers, currentId} = store.getState().entities.teams;
store.subscribe(() => {
const membersRequest = store.getState().requests.teams.getTeamMembers;
const members = store.getState().entities.teams.membersInTeam;
if (createRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(createRequest.error));
}
if (membersRequest.status === RequestStatus.SUCCESS || membersRequest.status === RequestStatus.FAILURE) {
if (membersRequest.error) {
done(new Error(JSON.stringify(membersRequest.error)));
} else {
assert.ok(members[TestHelper.basicTeam.id]);
assert.ok(members[TestHelper.basicTeam.id].has(user.id));
done();
}
}
});
Actions.getTeamMember(TestHelper.basicTeam.id, user.id)(store.dispatch, store.getState);
});
}).timeout(3000);
it('getTeamMembersByIds', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
const user1 = await TestHelper.basicClient.createUserWithInvite(
TestHelper.fakeUser(),
null,
null,
TestHelper.basicTeam.invite_id
);
const user2 = await TestHelper.basicClient.createUserWithInvite(
TestHelper.fakeUser(),
null,
null,
TestHelper.basicTeam.invite_id
);
store.subscribe(() => {
const membersRequest = store.getState().requests.teams.getTeamMembers;
const members = store.getState().entities.teams.membersInTeam;
if (membersRequest.status === RequestStatus.SUCCESS || membersRequest.status === RequestStatus.FAILURE) {
if (membersRequest.error) {
done(new Error(JSON.stringify(membersRequest.error)));
} else {
assert.ok(members[TestHelper.basicTeam.id]);
assert.ok(members[TestHelper.basicTeam.id].has(user1.id));
assert.ok(members[TestHelper.basicTeam.id].has(user2.id));
done();
}
}
});
Actions.getTeamMembersByIds(
TestHelper.basicTeam.id,
[user1.id, user2.id]
)(store.dispatch, store.getState);
});
}).timeout(3000);
it('getTeamStats', (done) => {
TestHelper.initBasic(Client).then(() => {
const store = configureStore();
store.subscribe(() => {
const stats = store.getState().entities.teams.stats;
const statsRequest = store.getState().requests.teams.getTeamStats;
if (statsRequest.status === RequestStatus.SUCCESS) {
const stat = stats[TestHelper.basicTeam.id];
assert.ok(stat);
assert.equal(stat.total_member_count, 1);
assert.equal(stat.active_member_count, 1);
done();
} else if (statsRequest.status === RequestStatus.FAILURE) {
done(new Error(JSON.stringify(statsRequest.error)));
}
});
Actions.getTeamStats(TestHelper.basicTeam.id)(store.dispatch, store.getState);
});
const teamId = Object.keys(teams)[0];
assert.strictEqual(Object.keys(teams).length, 1);
assert.strictEqual(currentId, teamId);
assert.ok(myMembers[teamId]);
});
it('addUserToTeam', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
const user = await TestHelper.basicClient.createUser(TestHelper.fakeUser());
it('updateTeam', async () => {
const displayName = 'The Updated Team';
const description = 'This is a team created by unit tests';
const team = {
...TestHelper.basicTeam,
display_name: displayName,
description
};
store.subscribe(() => {
const membersRequest = store.getState().requests.teams.addUserToTeam;
const members = store.getState().entities.teams.membersInTeam;
await Actions.updateTeam(team)(store.dispatch, store.getState);
if (membersRequest.status === RequestStatus.SUCCESS || membersRequest.status === RequestStatus.FAILURE) {
if (membersRequest.error) {
done(new Error(JSON.stringify(membersRequest.error)));
} else {
assert.ok(members[TestHelper.basicTeam.id]);
assert.ok(members[TestHelper.basicTeam.id].has(user.id));
done();
}
}
});
const updateRequest = store.getState().requests.teams.updateTeam;
const {teams} = store.getState().entities.teams;
Actions.addUserToTeam(TestHelper.basicTeam.id, user.id)(store.dispatch, store.getState);
});
if (updateRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(updateRequest.error));
}
const updated = teams[TestHelper.basicTeam.id];
assert.ok(updated);
assert.strictEqual(updated.display_name, displayName);
assert.strictEqual(updated.description, description);
});
it('removeUserFromTeam', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
const user = await TestHelper.basicClient.createUser(TestHelper.fakeUser());
it('getMyTeamMembers', async () => {
await Actions.getMyTeamMembers()(store.dispatch, store.getState);
store.subscribe(() => {
const addRequest = store.getState().requests.teams.addUserToTeam;
const removeRequest = store.getState().requests.teams.removeUserFromTeam;
const members = store.getState().entities.teams.membersInTeam;
const membersRequest = store.getState().requests.teams.getMyTeamMembers;
const members = store.getState().entities.teams.myMembers;
if (removeRequest.status === RequestStatus.SUCCESS || removeRequest.status === RequestStatus.FAILURE) {
if (removeRequest.error) {
done(new Error(JSON.stringify(removeRequest.error)));
} else {
assert.ok(members[TestHelper.basicTeam.id]);
assert.ok(!members[TestHelper.basicTeam.id].has(user.id));
done();
}
}
if (membersRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(membersRequest.error));
}
if (removeRequest.status === RequestStatus.NOT_STARTED &&
(addRequest.status === RequestStatus.SUCCESS || addRequest.status === RequestStatus.FAILURE)) {
if (addRequest.error) {
done(new Error(JSON.stringify(addRequest.error)));
} else {
assert.ok(members[TestHelper.basicTeam.id]);
assert.ok(members[TestHelper.basicTeam.id].has(user.id));
Actions.removeUserFromTeam(TestHelper.basicTeam.id, user.id)(store.dispatch, store.getState);
}
}
});
assert.ok(members);
assert.ok(members[TestHelper.basicTeam.id]);
});
Actions.addUserToTeam(TestHelper.basicTeam.id, user.id)(store.dispatch, store.getState);
});
}).timeout(3000);
it('getTeamMember', async () => {
const user = await TestHelper.basicClient.createUserWithInvite(
TestHelper.fakeUser(),
null,
null,
TestHelper.basicTeam.invite_id
);
await Actions.getTeamMember(TestHelper.basicTeam.id, user.id)(store.dispatch, store.getState);
const membersRequest = store.getState().requests.teams.getTeamMembers;
const members = store.getState().entities.teams.membersInTeam;
if (membersRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(membersRequest.error));
}
assert.ok(members[TestHelper.basicTeam.id]);
assert.ok(members[TestHelper.basicTeam.id].has(user.id));
});
it('getTeamMembersByIds', async () => {
const user1 = await TestHelper.basicClient.createUserWithInvite(
TestHelper.fakeUser(),
null,
null,
TestHelper.basicTeam.invite_id
);
const user2 = await TestHelper.basicClient.createUserWithInvite(
TestHelper.fakeUser(),
null,
null,
TestHelper.basicTeam.invite_id
);
await Actions.getTeamMembersByIds(
TestHelper.basicTeam.id,
[user1.id, user2.id]
)(store.dispatch, store.getState);
const membersRequest = store.getState().requests.teams.getTeamMembers;
const members = store.getState().entities.teams.membersInTeam;
if (membersRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(membersRequest.error));
}
assert.ok(members[TestHelper.basicTeam.id]);
assert.ok(members[TestHelper.basicTeam.id].has(user1.id));
assert.ok(members[TestHelper.basicTeam.id].has(user2.id));
});
it('getTeamStats', async () => {
await Actions.getTeamStats(TestHelper.basicTeam.id)(store.dispatch, store.getState);
const {stats} = store.getState().entities.teams;
const statsRequest = store.getState().requests.teams.getTeamStats;
if (statsRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(statsRequest.error));
}
const stat = stats[TestHelper.basicTeam.id];
assert.ok(stat);
// we need to take into account the members of the tests above
assert.equal(stat.total_member_count, 4);
assert.equal(stat.active_member_count, 4);
});
it('addUserToTeam', async () => {
const user = await TestHelper.basicClient.createUser(TestHelper.fakeUser());
await Actions.addUserToTeam(TestHelper.basicTeam.id, user.id)(store.dispatch, store.getState);
const membersRequest = store.getState().requests.teams.addUserToTeam;
const members = store.getState().entities.teams.membersInTeam;
if (membersRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(membersRequest.error));
}
assert.ok(members[TestHelper.basicTeam.id]);
assert.ok(members[TestHelper.basicTeam.id].has(user.id));
});
it('removeUserFromTeam', async () => {
const user = await TestHelper.basicClient.createUser(TestHelper.fakeUser());
await Actions.addUserToTeam(TestHelper.basicTeam.id, user.id)(store.dispatch, store.getState);
let state = store.getState();
let members = state.entities.teams.membersInTeam;
const addRequest = state.requests.teams.addUserToTeam;
if (addRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(addRequest.error));
}
assert.ok(members[TestHelper.basicTeam.id]);
assert.ok(members[TestHelper.basicTeam.id].has(user.id));
await Actions.removeUserFromTeam(TestHelper.basicTeam.id, user.id)(store.dispatch, store.getState);
state = store.getState();
const removeRequest = state.requests.teams.removeUserFromTeam;
if (removeRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(removeRequest.error));
}
members = state.entities.teams.membersInTeam;
assert.ok(members[TestHelper.basicTeam.id]);
assert.ok(!members[TestHelper.basicTeam.id].has(user.id));
});
});

482
test/service/actions/users.test.js
View file

@ -11,353 +11,261 @@ import Routes from 'app/navigation/routes';
import TestHelper from 'test/test_helper';
describe('Actions.Users', () => {
it('login', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
let store;
before(async () => {
await TestHelper.initBasic(Client);
});
store.subscribe(() => {
const state = store.getState();
const loginRequest = state.requests.users.login;
const currentUserId = state.entities.users.currentId;
const profiles = state.entities.users.profiles;
const preferences = state.entities.preferences.myPreferences;
beforeEach(() => {
store = configureStore();
});
// TODO: uncomment when PLT-4167 is merged
// const teamMembers = state.entities.teams.myMembers;
after(async () => {
await TestHelper.basicClient.logout();
});
if (loginRequest.status === RequestStatus.SUCCESS || loginRequest.status === RequestStatus.FAILURE) {
if (loginRequest.error) {
done(new Error(JSON.stringify(loginRequest.error)));
} else {
assert.ok(currentUserId);
assert.ok(profiles);
assert.ok(profiles[currentUserId]);
assert.ok(Object.keys(preferences).length);
it('login', async () => {
const user = TestHelper.basicUser;
await TestHelper.basicClient.logout();
await Actions.login(user.email, 'password1')(store.dispatch, store.getState);
// TODO: uncomment when PLT-4167 is merged
// Object.keys(teamMembers).forEach((id) => {
// assert.ok(teamMembers[id].team_id);
// assert.equal(teamMembers[id].user_id, currentUserId);
// });
const state = store.getState();
const loginRequest = state.requests.users.login;
const {currentId, profiles} = state.entities.users;
const preferences = state.entities.preferences.myPreferences;
const teamMembers = state.entities.teams.myMembers;
done();
}
}
});
if (loginRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(loginRequest.error));
}
const user = TestHelper.basicUser;
await TestHelper.basicClient.logout();
Actions.login(user.email, 'password1')(store.dispatch, store.getState);
assert.ok(currentId);
assert.ok(profiles);
assert.ok(profiles[currentId]);
assert.ok(Object.keys(preferences).length);
Object.keys(teamMembers).forEach((id) => {
assert.ok(teamMembers[id].team_id);
assert.equal(teamMembers[id].user_id, currentId);
});
});
it('logout', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
it('logout', async () => {
await Actions.logout()(store.dispatch, store.getState);
store.subscribe(() => {
const state = store.getState();
const logoutRequest = state.requests.users.logout;
const general = state.entities.general;
const users = state.entities.users;
const loginView = state.views.login;
const teams = state.entities.teams;
const channels = state.entities.channels;
const posts = state.entities.posts;
const preferences = state.entities.preferences;
const navigation = state.navigation;
const state = store.getState();
const logoutRequest = state.requests.users.logout;
const general = state.entities.general;
const users = state.entities.users;
const loginView = state.views.login;
const teams = state.entities.teams;
const channels = state.entities.channels;
const posts = state.entities.posts;
const preferences = state.entities.preferences;
const navigation = state.navigation;
if (logoutRequest.status === RequestStatus.SUCCESS || logoutRequest.status === RequestStatus.FAILURE) {
if (logoutRequest.error) {
done(new Error(JSON.stringify(logoutRequest.error)));
} else {
assert.deepStrictEqual(general.config, {}, 'config not empty');
assert.deepStrictEqual(general.license, {}, 'license not empty');
assert.strictEqual(users.currentId, '', 'current user id not empty');
assert.deepStrictEqual(users.mySessions, [], 'user sessions not empty');
assert.deepStrictEqual(users.myAudits, [], 'user audits not empty');
assert.deepStrictEqual(users.profiles, {}, 'user profiles not empty');
assert.deepStrictEqual(users.profilesInTeam, {}, 'users profiles in team not empty');
assert.deepStrictEqual(users.profilesInChannel, {}, 'users profiles in channel not empty');
assert.deepStrictEqual(users.profilesNotInChannel, {}, 'users profiles NOT in channel not empty');
assert.deepStrictEqual(users.statuses, {}, 'users statuses not empty');
assert.strictEqual(loginView.loginId, '', 'login id not empty');
assert.strictEqual(loginView.password, '', 'password not empty');
assert.strictEqual(teams.currentId, '', 'current team id is not empty');
assert.deepStrictEqual(teams.teams, {}, 'teams is not empty');
assert.deepStrictEqual(teams.myMembers, {}, 'team members is not empty');
assert.deepStrictEqual(teams.membersInTeam, {}, 'members in team is not empty');
assert.deepStrictEqual(teams.stats, {}, 'team stats is not empty');
assert.deepStrictEqual(teams.openTeamIds, new Set(), 'team open ids is not empty');
assert.strictEqual(channels.currentId, '', 'current channel id is not empty');
assert.deepStrictEqual(channels.channels, {}, 'channels is not empty');
assert.deepStrictEqual(channels.myMembers, {}, 'channel members is not empty');
assert.deepStrictEqual(channels.stats, {}, 'channel stats is not empty');
assert.strictEqual(posts.selectedPostId, '', 'selected post id is not empty');
assert.strictEqual(posts.currentFocusedPostId, '', 'current focused post id is not empty');
assert.deepStrictEqual(posts.posts, {}, 'posts is not empty');
assert.deepStrictEqual(posts.postsByChannel, {}, 'posts by channel is not empty');
assert.deepStrictEqual(preferences.myPreferences, {}, 'user preferences not empty');
assert.strictEqual(navigation.index, 0, 'navigation not reset to first element of stack');
assert.deepStrictEqual(navigation.routes, [Routes.Root], 'navigation not reset to root route');
if (logoutRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(logoutRequest.error));
}
done();
}
}
});
Actions.logout()(store.dispatch, store.getState);
});
assert.deepStrictEqual(general.config, {}, 'config not empty');
assert.deepStrictEqual(general.license, {}, 'license not empty');
assert.strictEqual(users.currentId, '', 'current user id not empty');
assert.deepStrictEqual(users.mySessions, [], 'user sessions not empty');
assert.deepStrictEqual(users.myAudits, [], 'user audits not empty');
assert.deepStrictEqual(users.profiles, {}, 'user profiles not empty');
assert.deepStrictEqual(users.profilesInTeam, {}, 'users profiles in team not empty');
assert.deepStrictEqual(users.profilesInChannel, {}, 'users profiles in channel not empty');
assert.deepStrictEqual(users.profilesNotInChannel, {}, 'users profiles NOT in channel not empty');
assert.deepStrictEqual(users.statuses, {}, 'users statuses not empty');
assert.strictEqual(loginView.loginId, '', 'login id not empty');
assert.strictEqual(loginView.password, '', 'password not empty');
assert.strictEqual(teams.currentId, '', 'current team id is not empty');
assert.deepStrictEqual(teams.teams, {}, 'teams is not empty');
assert.deepStrictEqual(teams.myMembers, {}, 'team members is not empty');
assert.deepStrictEqual(teams.membersInTeam, {}, 'members in team is not empty');
assert.deepStrictEqual(teams.stats, {}, 'team stats is not empty');
assert.deepStrictEqual(teams.openTeamIds, new Set(), 'team open ids is not empty');
assert.strictEqual(channels.currentId, '', 'current channel id is not empty');
assert.deepStrictEqual(channels.channels, {}, 'channels is not empty');
assert.deepStrictEqual(channels.myMembers, {}, 'channel members is not empty');
assert.deepStrictEqual(channels.stats, {}, 'channel stats is not empty');
assert.strictEqual(posts.selectedPostId, '', 'selected post id is not empty');
assert.strictEqual(posts.currentFocusedPostId, '', 'current focused post id is not empty');
assert.deepStrictEqual(posts.posts, {}, 'posts is not empty');
assert.deepStrictEqual(posts.postsByChannel, {}, 'posts by channel is not empty');
assert.deepStrictEqual(preferences.myPreferences, {}, 'user preferences not empty');
assert.strictEqual(navigation.index, 0, 'navigation not reset to first element of stack');
assert.deepStrictEqual(navigation.routes, [Routes.Root], 'navigation not reset to root route');
});
it('getProfiles', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
await TestHelper.basicClient.createUser(TestHelper.fakeUser());
it('getProfiles', async () => {
await TestHelper.basicClient.login(TestHelper.basicUser.email, 'password1');
await TestHelper.basicClient.createUser(TestHelper.fakeUser());
await Actions.getProfiles(0)(store.dispatch, store.getState);
store.subscribe(() => {
const profilesRequest = store.getState().requests.users.getProfiles;
const profiles = store.getState().entities.users.profiles;
const profilesRequest = store.getState().requests.users.getProfiles;
const {profiles} = store.getState().entities.users;
if (profilesRequest.status === RequestStatus.SUCCESS || profilesRequest.status === RequestStatus.FAILURE) {
if (profilesRequest.error) {
done(new Error(JSON.stringify(profilesRequest.error)));
} else {
assert.ok(Object.keys(profiles).length);
if (profilesRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(profilesRequest.error));
}
done();
}
}
});
Actions.getProfiles(0)(store.dispatch, store.getState);
});
assert.ok(Object.keys(profiles).length);
});
it('getProfilesInTeam', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
it('getProfilesInTeam', async () => {
await Actions.getProfilesInTeam(TestHelper.basicTeam.id, 0)(store.dispatch, store.getState);
store.subscribe(() => {
const profilesRequest = store.getState().requests.users.getProfilesInTeam;
const profilesInTeam = store.getState().entities.users.profilesInTeam;
const profiles = store.getState().entities.users.profiles;
const profilesRequest = store.getState().requests.users.getProfilesInTeam;
const {profilesInTeam, profiles} = store.getState().entities.users;
if (profilesRequest.status === RequestStatus.SUCCESS || profilesRequest.status === RequestStatus.FAILURE) {
if (profilesRequest.error) {
done(new Error(JSON.stringify(profilesRequest.error)));
} else {
const team = profilesInTeam[TestHelper.basicTeam.id];
assert.ok(team);
assert.ok(team.has(TestHelper.basicUser.id));
assert.equal(Object.keys(profiles).length, team.size, 'profiles != profiles in team');
if (profilesRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(profilesRequest.error));
}
done();
}
}
});
Actions.getProfilesInTeam(TestHelper.basicTeam.id, 0)(store.dispatch, store.getState);
});
const team = profilesInTeam[TestHelper.basicTeam.id];
assert.ok(team);
assert.ok(team.has(TestHelper.basicUser.id));
assert.equal(Object.keys(profiles).length, team.size, 'profiles != profiles in team');
});
it('getProfilesInChannel', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
it('getProfilesInChannel', async () => {
await Actions.getProfilesInChannel(
TestHelper.basicTeam.id,
TestHelper.basicChannel.id,
0
)(store.dispatch, store.getState);
store.subscribe(() => {
const profilesRequest = store.getState().requests.users.getProfilesInChannel;
const profilesInChannel = store.getState().entities.users.profilesInChannel;
const profiles = store.getState().entities.users.profiles;
const profilesRequest = store.getState().requests.users.getProfilesInChannel;
const {profiles, profilesInChannel} = store.getState().entities.users;
if (profilesRequest.status === RequestStatus.SUCCESS || profilesRequest.status === RequestStatus.FAILURE) {
if (profilesRequest.error) {
done(new Error(JSON.stringify(profilesRequest.error)));
} else {
const channel = profilesInChannel[TestHelper.basicChannel.id];
assert.ok(channel.has(TestHelper.basicUser.id));
assert.equal(Object.keys(profiles).length, channel.size, 'profiles != profiles in channel');
if (profilesRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(profilesRequest.error));
}
done();
}
}
});
Actions.getProfilesInChannel(TestHelper.basicTeam.id, TestHelper.basicChannel.id, 0)(store.dispatch, store.getState);
});
const channel = profilesInChannel[TestHelper.basicChannel.id];
assert.ok(channel.has(TestHelper.basicUser.id));
assert.equal(Object.keys(profiles).length, channel.size, 'profiles != profiles in channel');
});
it('getProfilesNotInChannel', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
const user = await TestHelper.basicClient.createUserWithInvite(
TestHelper.fakeUser(),
null,
null,
TestHelper.basicTeam.invite_id
);
it('getProfilesNotInChannel', async () => {
const user = await TestHelper.basicClient.createUserWithInvite(
TestHelper.fakeUser(),
null,
null,
TestHelper.basicTeam.invite_id
);
store.subscribe(() => {
const profilesRequest = store.getState().requests.users.getProfilesNotInChannel;
const profilesNotInChannel = store.getState().entities.users.profilesNotInChannel;
const profiles = store.getState().entities.users.profiles;
await Actions.getProfilesNotInChannel(
TestHelper.basicTeam.id,
TestHelper.basicChannel.id,
0
)(store.dispatch, store.getState);
if (profilesRequest.status === RequestStatus.SUCCESS || profilesRequest.status === RequestStatus.FAILURE) {
if (profilesRequest.error) {
done(new Error(JSON.stringify(profilesRequest.error)));
} else {
const channel = profilesNotInChannel[TestHelper.basicChannel.id];
assert.ok(channel.has(user.id));
assert.equal(Object.keys(profiles).length, channel.size, 'profiles != profiles in channel');
const profilesRequest = store.getState().requests.users.getProfilesNotInChannel;
const {profiles, profilesNotInChannel} = store.getState().entities.users;
done();
}
}
});
if (profilesRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(profilesRequest.error));
}
Actions.getProfilesNotInChannel(TestHelper.basicTeam.id, TestHelper.basicChannel.id, 0, 500)(store.dispatch, store.getState);
});
const channel = profilesNotInChannel[TestHelper.basicChannel.id];
assert.ok(channel.has(user.id));
assert.equal(Object.keys(profiles).length, channel.size, 'profiles != profiles in channel');
});
it('getStatusesByIds', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
const user = await TestHelper.basicClient.createUser(TestHelper.fakeUser());
it('getStatusesByIds', async () => {
const user = await TestHelper.basicClient.createUser(TestHelper.fakeUser());
store.subscribe(() => {
const statusesRequest = store.getState().requests.users.getStatusesByIds;
const statuses = store.getState().entities.users.statuses;
await Actions.getStatusesByIds(
[TestHelper.basicUser.id, user.id]
)(store.dispatch, store.getState);
if (statusesRequest.status === RequestStatus.SUCCESS || statusesRequest.status === RequestStatus.FAILURE) {
if (statusesRequest.error) {
done(new Error(JSON.stringify(statusesRequest.error)));
} else {
assert.ok(statuses[TestHelper.basicUser.id]);
assert.ok(statuses[user.id]);
assert.equal(Object.keys(statuses).length, 2);
done();
}
}
});
const statusesRequest = store.getState().requests.users.getStatusesByIds;
const statuses = store.getState().entities.users.statuses;
Actions.getStatusesByIds([TestHelper.basicUser.id, user.id])(store.dispatch, store.getState);
});
if (statusesRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(statusesRequest.error));
}
assert.ok(statuses[TestHelper.basicUser.id]);
assert.ok(statuses[user.id]);
assert.equal(Object.keys(statuses).length, 2);
});
it('getSessions', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
it('getSessions', async () => {
await Actions.getSessions(TestHelper.basicUser.id)(store.dispatch, store.getState);
store.subscribe(() => {
const sessionsRequest = store.getState().requests.users.getSessions;
const sessions = store.getState().entities.users.mySessions;
const sessionsRequest = store.getState().requests.users.getSessions;
const sessions = store.getState().entities.users.mySessions;
if (sessionsRequest.status === RequestStatus.SUCCESS || sessionsRequest.status === RequestStatus.FAILURE) {
if (sessionsRequest.error) {
done(new Error(JSON.stringify(sessionsRequest.error)));
} else {
assert.ok(sessions.length);
assert.equal(sessions[0].user_id, TestHelper.basicUser.id);
done();
}
}
});
if (sessionsRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(sessionsRequest.error));
}
Actions.getSessions(TestHelper.basicUser.id)(store.dispatch, store.getState);
});
assert.ok(sessions.length);
assert.equal(sessions[0].user_id, TestHelper.basicUser.id);
});
it('revokeSession', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
it('revokeSession', async () => {
await Actions.getSessions(TestHelper.basicUser.id)(store.dispatch, store.getState);
store.subscribe(() => {
const sessionsRequest = store.getState().requests.users.getSessions;
const revokeRequest = store.getState().requests.users.revokeSession;
const sessions = store.getState().entities.users.mySessions;
const sessionsRequest = store.getState().requests.users.getSessions;
let sessions = store.getState().entities.users.mySessions;
if (sessionsRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(sessionsRequest.error));
}
if (revokeRequest.status === RequestStatus.SUCCESS || revokeRequest.status === RequestStatus.FAILURE) {
if (revokeRequest.error) {
done(new Error(JSON.stringify(revokeRequest.error)));
} else {
assert.ok(sessions.length === 0);
done();
}
}
await Actions.revokeSession(sessions[0].id)(store.dispatch, store.getState);
if (sessionsRequest.status === RequestStatus.SUCCESS || sessionsRequest.status === RequestStatus.FAILURE) {
if (sessionsRequest.error) {
done(new Error(JSON.stringify(sessionsRequest.error)));
} else if (revokeRequest.status === RequestStatus.NOT_STARTED) {
Actions.revokeSession(sessions[0].id)(store.dispatch, store.getState);
}
}
});
const revokeRequest = store.getState().requests.users.revokeSession;
if (revokeRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(revokeRequest.error));
}
Actions.getSessions(TestHelper.basicUser.id)(store.dispatch, store.getState);
});
sessions = store.getState().entities.users.mySessions;
assert.ok(sessions.length === 0);
});
it('revokeSession and logout', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
it('revokeSession and logout', async () => {
await TestHelper.basicClient.login(TestHelper.basicUser.email, 'password1');
await Actions.getSessions(TestHelper.basicUser.id)(store.dispatch, store.getState);
store.subscribe(() => {
const sessionsRequest = store.getState().requests.users.getSessions;
const revokeRequest = store.getState().requests.users.revokeSession;
const logoutRequest = store.getState().requests.users.logout;
const profilesRequest = store.getState().requests.users.getProfiles;
const sessions = store.getState().entities.users.mySessions;
const sessionsRequest = store.getState().requests.users.getSessions;
const sessions = store.getState().entities.users.mySessions;
if (logoutRequest.status === RequestStatus.SUCCESS || logoutRequest.status === RequestStatus.FAILURE) {
if (logoutRequest.error) {
done(new Error(JSON.stringify(logoutRequest.error)));
} else {
done();
}
}
if (sessionsRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(sessionsRequest.error));
}
if (revokeRequest.status === RequestStatus.SUCCESS || revokeRequest.status === RequestStatus.FAILURE) {
if (revokeRequest.error) {
done(new Error(JSON.stringify(revokeRequest.error)));
} else if (logoutRequest.status === RequestStatus.NOT_STARTED && profilesRequest.status === RequestStatus.NOT_STARTED) {
Actions.getProfiles(0)(store.dispatch, store.getState);
}
}
await Actions.revokeSession(sessions[0].id)(store.dispatch, store.getState);
if (sessionsRequest.status === RequestStatus.SUCCESS || sessionsRequest.status === RequestStatus.FAILURE) {
if (sessionsRequest.error) {
done(new Error(JSON.stringify(sessionsRequest.error)));
} else if (revokeRequest.status === RequestStatus.NOT_STARTED) {
Actions.revokeSession(sessions[0].id)(store.dispatch, store.getState);
}
}
});
const revokeRequest = store.getState().requests.users.revokeSession;
if (revokeRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(revokeRequest.error));
}
Actions.getSessions(TestHelper.basicUser.id)(store.dispatch, store.getState);
});
await Actions.getProfiles(0)(store.dispatch, store.getState);
const logoutRequest = store.getState().requests.users.logout;
if (logoutRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(logoutRequest.error));
}
});
it('getAudits', (done) => {
TestHelper.initBasic(Client).then(async () => {
const store = configureStore();
it('getAudits', async () => {
await TestHelper.basicClient.login(TestHelper.basicUser.email, 'password1');
await Actions.getAudits(TestHelper.basicUser.id)(store.dispatch, store.getState);
store.subscribe(() => {
const auditsRequest = store.getState().requests.users.getAudits;
const audits = store.getState().entities.users.myAudits;
const auditsRequest = store.getState().requests.users.getAudits;
const audits = store.getState().entities.users.myAudits;
if (auditsRequest.status === RequestStatus.SUCCESS || auditsRequest.status === RequestStatus.FAILURE) {
if (auditsRequest.error) {
done(new Error(JSON.stringify(auditsRequest.error)));
} else {
assert.ok(audits.length);
assert.equal(audits[0].user_id, TestHelper.basicUser.id);
done();
}
}
});
if (auditsRequest.status === RequestStatus.FAILURE) {
throw new Error(JSON.stringify(auditsRequest.error));
}
Actions.getAudits(TestHelper.basicUser.id)(store.dispatch, store.getState);
});
assert.ok(audits.length);
assert.equal(audits[0].user_id, TestHelper.basicUser.id);
});
});

41
test/service/actions/websocket.test.js
View file

@ -12,14 +12,15 @@ import TestHelper from 'test/test_helper';
describe('Actions.Websocket', () => {
let store;
beforeEach(async () => {
before(async () => {
store = configureStore();
await TestHelper.initBasic(Client);
return await Actions.init()(store.dispatch, store.getState);
});
afterEach(() => {
after(async () => {
Actions.close()();
await TestHelper.basicClient.logout();
});
it('WebSocket Connect', () => {
@ -119,7 +120,10 @@ describe('Actions.Websocket', () => {
await client.addUserToTeam(team.id, TestHelper.basicUser.id);
await client.addChannelMember(team.id, channel.id, TestHelper.basicUser.id);
await RootActions.setStoreFromLocalData({url: Client.getUrl(), token: Client.getToken()})(store.dispatch, store.getState);
await RootActions.setStoreFromLocalData({
url: Client.getUrl(),
token: Client.getToken()
})(store.dispatch, store.getState);
await TeamActions.selectTeam(team)(store.dispatch, store.getState);
await ChannelActions.selectChannel(channel.id)(store.dispatch, store.getState);
await client.removeUserFromTeam(team.id, TestHelper.basicUser.id);
@ -138,10 +142,6 @@ describe('Actions.Websocket', () => {
);
await TeamActions.selectTeam(TestHelper.basicTeam)(store.dispatch, store.getState);
await RootActions.setStoreFromLocalData({
url: Client.getUrl(),
token: Client.getToken()
})(store.dispatch, store.getState);
await ChannelActions.addChannelMember(
TestHelper.basicTeam.id,
@ -156,22 +156,31 @@ describe('Actions.Websocket', () => {
it('Websocket Handle User Removed', async () => {
await TeamActions.selectTeam(TestHelper.basicTeam)(store.dispatch, store.getState);
await RootActions.setStoreFromLocalData({
url: Client.getUrl(),
token: Client.getToken()
})(store.dispatch, store.getState);
const user = await TestHelper.basicClient.createUserWithInvite(
TestHelper.fakeUser(),
null,
null,
TestHelper.basicTeam.invite_id
);
await ChannelActions.addChannelMember(
TestHelper.basicTeam.id,
TestHelper.basicChannel.id,
user.id
)(store.dispatch, store.getState);
await ChannelActions.removeChannelMember(
TestHelper.basicTeam.id,
TestHelper.basicChannel.id,
TestHelper.basicUser.id
user.id
)(store.dispatch, store.getState);
const state = store.getState();
const entities = state.entities;
const profilesNotInChannel = entities.users.profilesNotInChannel;
assert.ok(profilesNotInChannel[TestHelper.basicChannel.id].has(TestHelper.basicUser.id));
assert.ok(profilesNotInChannel[TestHelper.basicChannel.id].has(user.id));
});
it('Websocket Handle User Updated', async () => {
@ -198,10 +207,6 @@ describe('Actions.Websocket', () => {
it('Websocket Handle Channel Viewed', (done) => {
async function test() {
await TeamActions.selectTeam(TestHelper.basicTeam)(store.dispatch, store.getState);
await RootActions.setStoreFromLocalData({
url: Client.getUrl(),
token: Client.getToken()
})(store.dispatch, store.getState);
await Client.updateLastViewedAt(
TestHelper.basicTeam.id,
@ -215,7 +220,7 @@ describe('Actions.Websocket', () => {
const {channels} = entities.channels;
assert.ok(channels[TestHelper.basicChannel.id]);
done();
}, 500);
}, 1500);
}
test();