Rocket.Chat.ReactNative/e2e/helpers/data_setup.js

180 lines
4.7 KiB
JavaScript
Raw Normal View History

const axios = require('axios').default;
const data = require('../data');
const TEAM_TYPE = {
PUBLIC: 0,
PRIVATE: 1
};
const { server } = data;
const rocketchat = axios.create({
baseURL: `${ server }/api/v1/`,
headers: {
'Content-Type': 'application/json;charset=UTF-8'
}
});
const login = async(username, password) => {
console.log(`Logging in as user ${ username }`);
const response = await rocketchat.post('login', {
user: username,
password
});
const { userId } = response.data.data;
const { authToken } = response.data.data;
rocketchat.defaults.headers.common['X-User-Id'] = userId;
rocketchat.defaults.headers.common['X-Auth-Token'] = authToken;
return { authToken, userId };
};
const createUser = async(username, password, name, email) => {
console.log(`Creating user ${ username }`);
try {
await rocketchat.post('users.create', {
username,
password,
name,
email
});
} catch (error) {
console.log(JSON.stringify(error));
throw new Error('Failed to create user');
}
};
const createChannelIfNotExists = async(channelname) => {
console.log(`Creating public channel ${ channelname }`);
try {
const room = await rocketchat.post('channels.create', {
name: channelname
});
return room;
} catch (createError) {
try { // Maybe it exists already?
const room = rocketchat.get(`channels.info?roomName=${ channelname }`);
return room;
} catch (infoError) {
console.log(JSON.stringify(createError));
console.log(JSON.stringify(infoError));
throw new Error('Failed to find or create public channel');
}
}
};
const createTeamIfNotExists = async(teamname) => {
console.log(`Creating private team ${ teamname }`);
try {
await rocketchat.post('teams.create', {
name: teamname,
type: TEAM_TYPE.PRIVATE
});
} catch (createError) {
try { // Maybe it exists already?
await rocketchat.get(`teams.info?teamName=${ teamname }`);
} catch (infoError) {
console.log(JSON.stringify(createError));
console.log(JSON.stringify(infoError));
throw new Error('Failed to find or create private team');
}
}
};
const createGroupIfNotExists = async(groupname) => {
console.log(`Creating private group ${ groupname }`);
try {
await rocketchat.post('groups.create', {
name: groupname
});
} catch (createError) {
try { // Maybe it exists already?
await rocketchat.get(`groups.info?roomName=${ groupname }`);
} catch (infoError) {
console.log(JSON.stringify(createError));
console.log(JSON.stringify(infoError));
throw new Error('Failed to find or create private group');
}
}
};
const changeChannelJoinCode = async(roomId, joinCode) => {
console.log(`Changing channel Join Code ${ roomId }`);
try {
await rocketchat.post('method.call/saveRoomSettings', {
message: JSON.stringify({
method: 'saveRoomSettings',
params: [
roomId,
{ joinCode }
]
})
});
} catch (createError) {
console.log(JSON.stringify(createError));
throw new Error('Failed to create protected channel');
}
};
const sendMessage = async(user, channel, msg) => {
console.log(`Sending message to ${ channel }`);
try {
await login(user.username, user.password);
await rocketchat.post('chat.postMessage', { channel, msg });
} catch (infoError) {
console.log(JSON.stringify(infoError));
throw new Error('Failed to find or create private group');
}
};
const setup = async() => {
await login(data.adminUser, data.adminPassword);
for (const userKey in data.users) {
if (Object.prototype.hasOwnProperty.call(data.users, userKey)) {
const user = data.users[userKey];
await createUser(user.username, user.password, user.username, user.email);
}
}
for (const channelKey in data.channels) {
if (Object.prototype.hasOwnProperty.call(data.channels, channelKey)) {
const channel = data.channels[channelKey];
const { data: { channel: { _id } } } = await createChannelIfNotExists(channel.name);
if (channel.joinCode) {
await changeChannelJoinCode(_id, channel.joinCode);
}
}
}
await login(data.users.regular.username, data.users.regular.password);
for (const groupKey in data.groups) {
if (Object.prototype.hasOwnProperty.call(data.groups, groupKey)) {
const group = data.groups[groupKey];
await createGroupIfNotExists(group.name);
}
}
for (const teamKey in data.teams) {
if (Object.prototype.hasOwnProperty.call(data.teams, teamKey)) {
const team = data.teams[teamKey];
await createTeamIfNotExists(team.name);
}
}
};
const get = (endpoint) => {
console.log(`GET /${ endpoint }`);
return rocketchat.get(endpoint);
};
const post = (endpoint, body) => {
console.log(`POST /${ endpoint } ${ JSON.stringify(body) }`);
return rocketchat.post(endpoint, body);
};
module.exports = {
setup, sendMessage, get, post, login
};