363 lines
17 KiB
JavaScript
363 lines
17 KiB
JavaScript
// Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
|
|
// See License.txt for license information.
|
|
|
|
import assert from 'assert';
|
|
|
|
import * as Actions from 'actions/users';
|
|
import Client from 'client';
|
|
import configureStore from 'store/configureStore';
|
|
import {RequestStatus} from 'constants';
|
|
import Routes from 'navigation/routes';
|
|
import TestHelper from 'test_helper';
|
|
|
|
describe('Actions.Users', () => {
|
|
it('login', (done) => {
|
|
TestHelper.initBasic(Client).then(async () => {
|
|
const store = configureStore();
|
|
|
|
store.subscribe(() => {
|
|
const loginRequest = store.getState().requests.users.login;
|
|
const currentUserId = store.getState().entities.users.currentId;
|
|
const profiles = store.getState().entities.users.profiles;
|
|
const preferences = store.getState().entities.users.myPreferences;
|
|
|
|
// TODO: uncomment when PLT-4167 is merged
|
|
// const teamMembers = store.getState().entities.teams.myMembers;
|
|
|
|
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);
|
|
|
|
// 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);
|
|
// });
|
|
|
|
done();
|
|
}
|
|
}
|
|
});
|
|
|
|
const user = TestHelper.basicUser;
|
|
await TestHelper.basicClient.logout();
|
|
Actions.login(user.email, 'password1')(store.dispatch, store.getState);
|
|
});
|
|
});
|
|
|
|
it('logout', (done) => {
|
|
TestHelper.initBasic(Client).then(async () => {
|
|
const store = configureStore();
|
|
|
|
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 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.myPreferences, {}, 'user preferences 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.membersNotInTeam, {}, 'members NOT 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.moreChannels, {}, 'more channels 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.postsInfo, {}, 'posts info is not empty');
|
|
assert.deepStrictEqual(posts.latestPageTime, {}, 'posts latest page time is 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');
|
|
|
|
done();
|
|
}
|
|
}
|
|
});
|
|
|
|
Actions.logout()(store.dispatch, store.getState);
|
|
});
|
|
});
|
|
|
|
it('getProfiles', (done) => {
|
|
TestHelper.initBasic(Client).then(async () => {
|
|
const store = configureStore();
|
|
const user = await TestHelper.basicClient.createUser(TestHelper.fakeUser());
|
|
|
|
store.subscribe(() => {
|
|
const profilesRequest = store.getState().requests.users.getProfiles;
|
|
const profiles = store.getState().entities.users.profiles;
|
|
|
|
if (profilesRequest.status === RequestStatus.SUCCESS || profilesRequest.status === RequestStatus.FAILURE) {
|
|
if (profilesRequest.error) {
|
|
done(new Error(JSON.stringify(profilesRequest.error)));
|
|
} else {
|
|
assert.ok(profiles[user.id]);
|
|
|
|
done();
|
|
}
|
|
}
|
|
});
|
|
|
|
Actions.getProfiles(0)(store.dispatch, store.getState);
|
|
});
|
|
});
|
|
|
|
it('getProfilesInTeam', (done) => {
|
|
TestHelper.initBasic(Client).then(async () => {
|
|
const store = configureStore();
|
|
|
|
store.subscribe(() => {
|
|
const profilesRequest = store.getState().requests.users.getProfilesInTeam;
|
|
const profilesInTeam = store.getState().entities.users.profilesInTeam;
|
|
const profiles = store.getState().entities.users.profiles;
|
|
|
|
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');
|
|
|
|
done();
|
|
}
|
|
}
|
|
});
|
|
|
|
Actions.getProfilesInTeam(TestHelper.basicTeam.id, 0)(store.dispatch, store.getState);
|
|
});
|
|
});
|
|
|
|
it('getProfilesInChannel', (done) => {
|
|
TestHelper.initBasic(Client).then(async () => {
|
|
const store = configureStore();
|
|
|
|
store.subscribe(() => {
|
|
const profilesRequest = store.getState().requests.users.getProfilesInChannel;
|
|
const profilesInChannel = store.getState().entities.users.profilesInChannel;
|
|
const profiles = store.getState().entities.users.profiles;
|
|
|
|
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');
|
|
|
|
done();
|
|
}
|
|
}
|
|
});
|
|
|
|
Actions.getProfilesInChannel(TestHelper.basicTeam.id, TestHelper.basicChannel.id, 0)(store.dispatch, store.getState);
|
|
});
|
|
});
|
|
|
|
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
|
|
);
|
|
|
|
store.subscribe(() => {
|
|
const profilesRequest = store.getState().requests.users.getProfilesNotInChannel;
|
|
const profilesNotInChannel = store.getState().entities.users.profilesNotInChannel;
|
|
const profiles = store.getState().entities.users.profiles;
|
|
|
|
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');
|
|
|
|
done();
|
|
}
|
|
}
|
|
});
|
|
|
|
Actions.getProfilesNotInChannel(TestHelper.basicTeam.id, TestHelper.basicChannel.id, 0)(store.dispatch, store.getState);
|
|
});
|
|
});
|
|
|
|
it('getStatusesByIds', (done) => {
|
|
TestHelper.initBasic(Client).then(async () => {
|
|
const store = configureStore();
|
|
const user = await TestHelper.basicClient.createUser(TestHelper.fakeUser());
|
|
|
|
store.subscribe(() => {
|
|
const statusesRequest = store.getState().requests.users.getStatusesByIds;
|
|
const statuses = store.getState().entities.users.statuses;
|
|
|
|
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();
|
|
}
|
|
}
|
|
});
|
|
|
|
Actions.getStatusesByIds([TestHelper.basicUser.id, user.id])(store.dispatch, store.getState);
|
|
});
|
|
});
|
|
|
|
it('getSessions', (done) => {
|
|
TestHelper.initBasic(Client).then(async () => {
|
|
const store = configureStore();
|
|
|
|
store.subscribe(() => {
|
|
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();
|
|
}
|
|
}
|
|
});
|
|
|
|
Actions.getSessions(TestHelper.basicUser.id)(store.dispatch, store.getState);
|
|
});
|
|
});
|
|
|
|
it('revokeSession', (done) => {
|
|
TestHelper.initBasic(Client).then(async () => {
|
|
const store = configureStore();
|
|
|
|
store.subscribe(() => {
|
|
const sessionsRequest = store.getState().requests.users.getSessions;
|
|
const revokeRequest = store.getState().requests.users.revokeSession;
|
|
const sessions = store.getState().entities.users.mySessions;
|
|
|
|
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();
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
});
|
|
|
|
Actions.getSessions(TestHelper.basicUser.id)(store.dispatch, store.getState);
|
|
});
|
|
});
|
|
|
|
it('revokeSession and logout', (done) => {
|
|
TestHelper.initBasic(Client).then(async () => {
|
|
const store = configureStore();
|
|
|
|
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;
|
|
|
|
if (logoutRequest.status === RequestStatus.SUCCESS || logoutRequest.status === RequestStatus.FAILURE) {
|
|
if (logoutRequest.error) {
|
|
done(new Error(JSON.stringify(logoutRequest.error)));
|
|
} else {
|
|
done();
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
});
|
|
|
|
Actions.getSessions(TestHelper.basicUser.id)(store.dispatch, store.getState);
|
|
});
|
|
});
|
|
|
|
it('getAudits', (done) => {
|
|
TestHelper.initBasic(Client).then(async () => {
|
|
const store = configureStore();
|
|
|
|
store.subscribe(() => {
|
|
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();
|
|
}
|
|
}
|
|
});
|
|
|
|
Actions.getAudits(TestHelper.basicUser.id)(store.dispatch, store.getState);
|
|
});
|
|
});
|
|
});
|