IntenseWebs/mattermost
3
0
Fork 0
mirror of https://github.com/mattermost/mattermost.git synced 2025-02-25 18:55:24 -06:00
Code Issues Packages Projects Releases Wiki Activity

PLT-2057 User as a first class object (#2648)

Browse Source 
* Adding TeamMember to system

* Fixing all unit tests on the backend

* Fixing merge conflicts

* Fixing merge conflict

* Adding javascript unit tests

* Adding TeamMember to system

* Fixing all unit tests on the backend

* Fixing merge conflicts

* Fixing merge conflict

* Adding javascript unit tests

* Adding client side unit test

* Cleaning up the clint side tests

* Fixing msg

* Adding more client side unit tests

* Adding more using tests

* Adding last bit of client side unit tests and adding make cmd

* Fixing bad merge

* Fixing libraries

* Updating to new client side API

* Fixing borken unit test

* Fixing unit tests

* ugg...trying to beat gofmt

* ugg...trying to beat gofmt

* Cleaning up remainder of the server side routes

* Adding inital load api

* Increased coverage of webhook unit tests (#2660)

* Adding loading ... to root html

* Fixing bad merge

* Removing explicit content type so superagent will guess corectly (#2685)

* Fixing merge and unit tests

* Adding create team UI

* Fixing signup flows

* Adding LDAP unit tests and enterprise unit test helper (#2702)

* Add the ability to reset MFA from the commandline (#2706)

* Fixing compliance unit tests

* Fixing client side tests

* Adding open server to system console

* Moving websocket connection

* Fixing unit test

* Fixing unit tests

* Fixing unit tests

* Adding nickname and more LDAP unit tests (#2717)

* Adding join open teams

* Cleaning up all TODOs in the code

* Fixing web sockets

* Removing unused webockets file

* PLT-2533 Add the ability to reset a user's MFA from the system console (#2715)

* Add the ability to reset a user's MFA from the system console

* Add client side unit test for adminResetMfa

* Reorganizing authentication to fix LDAP error message (#2723)

* Fixing failing unit test

* Initial upgrade db code

* Adding upgrade script

* Fixing upgrade script after running on core

* Update OAuth and Claim routes to work with user model changes (#2739)

* Fixing perminant deletion. Adding ability to delete all user and the entire database (#2740)

* Fixing team invite ldap login call (#2741)

* Fixing bluebar and some img stuff

* Fix all the different file upload web utils (#2743)

* Fixing invalid session redirect (#2744)

* Redirect on bad channel name (#2746)

* Fixing a bunch of issue and removing dead code

* Patch to fix error message on leave channel (#2747)

* Setting EnableOpenServer to false by default

* Fixing config

* Fixing upgrade

* Fixing reported bugs

* Bug fixes for PLT-2057

* PLT-2563 Redo password recovery to use a database table (#2745)

* Redo password recovery to use a database table

* Update reset password audits

* Split out admin and user reset password APIs to be separate

* Delete password recovery when user is permanently deleted

* Consolidate password resetting into a single function

* Removed private channels as an option for outgoing webhooks (#2752)

* PLT-2577/PLT-2552 Fixes for backstage (#2753)

* Added URL to incoming webhook list

* Fixed client functions for adding/removing integrations

* Disallowed slash commands without trigger words

* Fixed clientside handling of errors on AddCommand page

* Minor auth cleanup (#2758)

* Changed EditPostModal to just close if you save without making any changes (#2759)

* Renamed client -> Client in async_client.jsx and fixed eslint warnings (#2756)

* Fixed url in channel info modal (#2755)

* Fixing reported issues

* Moving to version 3 of the apis

* Fixing command unit tests (#2760)

* Adding team admins

* Fixing DM issue

* Fixing eslint error

* Properly set EditPostModal's originalText state in all cases (#2762)

* Update client config check to assume features is defined if server is licensed (#2772)

* Fixing url link

* Fixing issue with websocket crashing when sending messages to different teams
This commit is contained in:
Corey Hulen
2016-04-21 22:37:01 -07:00
parent 5c755463ed
commit 2e5617c29b
268 changed files with 13214 additions and 9686 deletions
Download Patch File Download Diff File Expand all files Collapse all files

334
webapp/tests/client_channel.test.jsx Normal file
View File

@@ -0,0 +1,334 @@
// Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
// See License.txt for license information.
/* eslint-disable no-console */
/* eslint-disable global-require */
/* eslint-disable func-names */
/* eslint-disable prefer-arrow-callback */
/* eslint-disable no-magic-numbers */
/* eslint-disable no-unreachable */
import assert from 'assert';
import TestHelper from './test_helper.jsx';
describe('Client.Channels', function() {
this.timeout(100000);
it('createChannel', function(done) {
TestHelper.initBasic(() => {
var channel = TestHelper.fakeChannel();
channel.team_id = TestHelper.basicTeam().id;
TestHelper.basicClient().createChannel(
channel,
function(data) {
assert.equal(data.id.length > 0, true);
assert.equal(data.name, channel.name);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('createDirectChannel', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().createUser(
TestHelper.fakeUser(),
function(user2) {
TestHelper.basicClient().addUserToTeam(
user2.id,
function() {
TestHelper.basicClient().createDirectChannel(
user2.id,
function(data) {
assert.equal(data.id.length > 0, true);
done();
},
function(err) {
done(new Error(err.message));
}
);
},
function(err) {
done(new Error(err.message));
}
);
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('updateChannel', function(done) {
TestHelper.initBasic(() => {
var channel = TestHelper.basicChannel();
channel.display_name = 'changed';
TestHelper.basicClient().updateChannel(
channel,
function(data) {
assert.equal(data.id.length > 0, true);
assert.equal(data.display_name, 'changed');
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('updateChannelHeader', function(done) {
TestHelper.initBasic(() => {
var channel = TestHelper.basicChannel();
channel.display_name = 'changed';
TestHelper.basicClient().updateChannelHeader(
channel.id,
'new header',
function(data) {
assert.equal(data.id.length > 0, true);
assert.equal(data.header, 'new header');
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('updateChannelPurpose', function(done) {
TestHelper.initBasic(() => {
var channel = TestHelper.basicChannel();
channel.display_name = 'changed';
TestHelper.basicClient().updateChannelPurpose(
channel.id,
'new purpose',
function(data) {
assert.equal(data.id.length > 0, true);
assert.equal(data.purpose, 'new purpose');
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('updateChannelNotifyProps', function(done) {
TestHelper.initBasic(() => {
var props = {};
props.channel_id = TestHelper.basicChannel().id;
props.user_id = TestHelper.basicUser().id;
props.desktop = 'all';
TestHelper.basicClient().updateChannelNotifyProps(
props,
function(data) {
assert.equal(data.desktop, 'all');
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('leaveChannel', function(done) {
TestHelper.initBasic(() => {
var channel = TestHelper.basicChannel();
TestHelper.basicClient().leaveChannel(
channel.id,
function(data) {
assert.equal(data.id, channel.id);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('joinChannel', function(done) {
TestHelper.initBasic(() => {
var channel = TestHelper.basicChannel();
TestHelper.basicClient().leaveChannel(
channel.id,
function() {
TestHelper.basicClient().joinChannel(
channel.id,
function(data) {
assert.equal(data.id, channel.id);
done();
},
function(err) {
done(new Error(err.message));
}
);
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('deleteChannel', function(done) {
TestHelper.initBasic(() => {
var channel = TestHelper.basicChannel();
TestHelper.basicClient().deleteChannel(
channel.id,
function(data) {
assert.equal(data.id, channel.id);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('updateLastViewedAt', function(done) {
TestHelper.initBasic(() => {
var channel = TestHelper.basicChannel();
TestHelper.basicClient().updateLastViewedAt(
channel.id,
function(data) {
assert.equal(data.id, channel.id);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('getChannels', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().getChannels(
function(data) {
assert.equal(data.channels.length, 3);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('getChannel', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().getChannel(
TestHelper.basicChannel().id,
function(data) {
assert.equal(TestHelper.basicChannel().id, data.channel.id);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('getMoreChannels', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().getMoreChannels(
function(data) {
assert.equal(data.channels.length, 0);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('getChannelCounts', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().getChannelCounts(
function(data) {
assert.equal(data.counts[TestHelper.basicChannel().id], 1);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('getChannelExtraInfo', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().getChannelExtraInfo(
TestHelper.basicChannel().id,
5,
function(data) {
assert.equal(data.member_count, 1);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('addChannelMember', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().createUser(
TestHelper.fakeUser(),
function(user2) {
TestHelper.basicClient().addUserToTeam(
user2.id,
function() {
TestHelper.basicClient().addChannelMember(
TestHelper.basicChannel().id,
user2.id,
function(data) {
assert.equal(data.channel_id.length > 0, true);
done();
},
function(err) {
done(new Error(err.message));
}
);
},
function(err) {
done(new Error(err.message));
}
);
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('removeChannelMember', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().removeChannelMember(
TestHelper.basicChannel().id,
TestHelper.basicUser().id,
function(data) {
assert.equal(data.channel_id.length > 0, true);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
});

123
webapp/tests/client_command.test.jsx Normal file
View File

@@ -0,0 +1,123 @@
// Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
// See License.txt for license information.
/* eslint-disable no-console */
/* eslint-disable global-require */
/* eslint-disable func-names */
/* eslint-disable prefer-arrow-callback */
/* eslint-disable no-magic-numbers */
/* eslint-disable no-unreachable */
import assert from 'assert';
import TestHelper from './test_helper.jsx';
describe('Client.Commands', function() {
this.timeout(100000);
it('listCommands', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().listCommands(
function(data) {
assert.equal(data.length > 0, true);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('listTeamCommands', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
TestHelper.basicClient().listTeamCommands(
function() {
done(new Error('cmds not enabled'));
},
function(err) {
assert.equal(err.id, 'api.command.disabled.app_error');
done();
}
);
});
});
it('executeCommand', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().executeCommand(
TestHelper.basicChannel().id,
'/shrug',
null,
function(data) {
assert.equal(data.response_type, 'in_channel');
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('addCommand', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
var cmd = {};
cmd.url = 'http://www.gonowhere.com';
cmd.trigger = '/hello';
cmd.method = 'P';
cmd.username = '';
cmd.icon_url = '';
cmd.auto_complete = false;
cmd.auto_complete_desc = '';
cmd.auto_complete_hint = '';
cmd.display_name = 'Unit Test';
TestHelper.basicClient().addCommand(
cmd,
function() {
done(new Error('cmds not enabled'));
},
function(err) {
assert.equal(err.id, 'api.command.disabled.app_error');
done();
}
);
});
});
it('deleteCommand', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
TestHelper.basicClient().deleteCommand(
TestHelper.generateId(),
function() {
done(new Error('cmds not enabled'));
},
function(err) {
assert.equal(err.id, 'api.command.disabled.app_error');
done();
}
);
});
});
it('regenCommandToken', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
TestHelper.basicClient().regenCommandToken(
TestHelper.generateId(),
function() {
done(new Error('cmds not enabled'));
},
function(err) {
assert.equal(err.id, 'api.command.disabled.app_error');
done();
}
);
});
});
});

333
webapp/tests/client_general.test.jsx Normal file
View File

@@ -0,0 +1,333 @@
// Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
// See License.txt for license information.
/* eslint-disable no-console */
/* eslint-disable global-require */
/* eslint-disable func-names */
/* eslint-disable prefer-arrow-callback */
/* eslint-disable no-magic-numbers */
/* eslint-disable no-unreachable */
var assert = require('assert');
import TestHelper from './test_helper.jsx';
describe('Client.General', function() {
this.timeout(10000);
it('Admin.getClientConfig', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().getClientConfig(
function(data) {
assert.equal(data.SiteName, 'Mattermost');
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('Admin.getComplianceReports', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
TestHelper.basicClient().getComplianceReports(
function() {
done(new Error('should need system admin permissions'));
},
function(err) {
assert.equal(err.id, 'api.context.system_permissions.app_error');
done();
}
);
});
});
it('Admin.saveComplianceReports', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
var job = {};
job.desc = 'desc';
job.emails = '';
job.keywords = 'test';
job.start_at = new Date();
job.end_at = new Date();
TestHelper.basicClient().saveComplianceReports(
job,
function() {
done(new Error('should need system admin permissions'));
},
function(err) {
assert.equal(err.id, 'api.context.system_permissions.app_error');
done();
}
);
});
});
it('Admin.getLogs', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
TestHelper.basicClient().getLogs(
function() {
done(new Error('should need system admin permissions'));
},
function(err) {
assert.equal(err.id, 'api.context.system_permissions.app_error');
done();
}
);
});
});
it('Admin.getServerAudits', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
TestHelper.basicClient().getServerAudits(
function() {
done(new Error('should need system admin permissions'));
},
function(err) {
assert.equal(err.id, 'api.context.system_permissions.app_error');
done();
}
);
});
});
it('Admin.getConfig', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
TestHelper.basicClient().getConfig(
function() {
done(new Error('should need system admin permissions'));
},
function(err) {
assert.equal(err.id, 'api.context.system_permissions.app_error');
done();
}
);
});
});
it('Admin.getAnalytics', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
TestHelper.basicClient().getAnalytics(
'standard',
null,
function() {
done(new Error('should need system admin permissions'));
},
function(err) {
assert.equal(err.id, 'api.context.system_permissions.app_error');
done();
}
);
});
});
it('Admin.getTeamAnalytics', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
TestHelper.basicClient().getTeamAnalytics(
TestHelper.basicTeam().id,
'standard',
function() {
done(new Error('should need system admin permissions'));
},
function(err) {
assert.equal(err.id, 'api.context.system_permissions.app_error');
done();
}
);
});
});
it('Admin.saveConfig', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
var config = {};
config.site_name = 'test';
TestHelper.basicClient().saveConfig(
config,
function() {
done(new Error('should need system admin permissions'));
},
function(err) {
assert.equal(err.id, 'api.context.system_permissions.app_error');
done();
}
);
});
});
it('Admin.testEmail', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
var config = {};
config.site_name = 'test';
TestHelper.basicClient().testEmail(
config,
function() {
done(new Error('should need system admin permissions'));
},
function(err) {
assert.equal(err.id, 'api.context.system_permissions.app_error');
done();
}
);
});
});
it('Admin.logClientError', function(done) {
TestHelper.initBasic(() => {
var config = {};
config.site_name = 'test';
TestHelper.basicClient().logClientError('this is a test');
done();
});
});
it('Admin.adminResetMfa', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
TestHelper.basicClient().adminResetMfa(
TestHelper.basicUser().id,
function() {
done(new Error('should need a license'));
},
function(err) {
assert.equal(err.id, 'api.context.permissions.app_error');
done();
}
);
});
});
it('Admin.adminResetPassword', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
var user = TestHelper.basicUser();
TestHelper.basicClient().resetPassword(
user.id,
'new_password',
function() {
throw Error('shouldnt work');
},
function(err) {
// this should fail since you're not a system admin
assert.equal(err.id, 'api.context.invalid_param.app_error');
done();
}
);
});
});
it('License.getClientLicenceConfig', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().getClientLicenceConfig(
function(data) {
assert.equal(data.IsLicensed, 'false');
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('License.removeLicenseFile', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
TestHelper.basicClient().removeLicenseFile(
function() {
done(new Error('not enabled'));
},
function(err) {
assert.equal(err.id, 'api.context.permissions.app_error');
done();
}
);
});
});
/*it('License.uploadLicenseFile', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
TestHelper.basicClient().uploadLicenseFile(
'form data',
function() {
done(new Error('not enabled'));
},
function(err) {
assert.equal(err.id, 'api.context.permissions.app_error');
done();
}
);
});
});*/
// TODO XXX FIX ME - this test depends on make dist
// it('General.getTranslations', function(done) {
// TestHelper.initBasic(() => {
// TestHelper.basicClient().getTranslations(
// 'http://localhost:8065/static/i18n/es.json',
// function(data) {
// assert.equal(data['login.or'], 'o');
// done();
// },
// function(err) {
// done(new Error(err.message));
// }
// );
// });
// });
it('File.getFileInfo', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
TestHelper.basicClient().getFileInfo(
`/${TestHelper.basicChannel().id}/${TestHelper.basicUser().id}/filename.txt`,
function(data) {
assert.equal(data.filename, 'filename.txt');
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('File.getPublicLink', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
var data = {};
data.channel_id = TestHelper.basicChannel().id;
data.user_id = TestHelper.basicUser().id;
data.filename = `/${TestHelper.basicChannel().id}/${TestHelper.basicUser().id}/filename.txt`;
TestHelper.basicClient().getPublicLink(
data,
function() {
done(new Error('not enabled'));
},
function(err) {
assert.equal(err.id, 'api.file.get_public_link.disabled.app_error');
done();
}
);
});
});
});

139
webapp/tests/client_hooks.test.jsx Normal file
View File

@@ -0,0 +1,139 @@
// Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
// See License.txt for license information.
/* eslint-disable no-console */
/* eslint-disable global-require */
/* eslint-disable func-names */
/* eslint-disable prefer-arrow-callback */
/* eslint-disable no-magic-numbers */
/* eslint-disable no-unreachable */
import assert from 'assert';
import TestHelper from './test_helper.jsx';
describe('Client.Hooks', function() {
this.timeout(100000);
it('addIncomingHook', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
var hook = {};
hook.channel_id = TestHelper.basicChannel().id;
hook.description = 'desc';
hook.display_name = 'Unit Test';
TestHelper.basicClient().addIncomingHook(
hook,
function() {
done(new Error('hooks not enabled'));
},
function(err) {
assert.equal(err.id, 'api.webhook.create_incoming.disabled.app_errror');
done();
}
);
});
});
it('deleteIncomingHook', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
TestHelper.basicClient().deleteIncomingHook(
TestHelper.generateId(),
function() {
done(new Error('hooks not enabled'));
},
function(err) {
assert.equal(err.id, 'api.webhook.delete_incoming.disabled.app_errror');
done();
}
);
});
});
it('listIncomingHooks', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
TestHelper.basicClient().listIncomingHooks(
function() {
done(new Error('hooks not enabled'));
},
function(err) {
assert.equal(err.id, 'api.webhook.get_incoming.disabled.app_error');
done();
}
);
});
});
it('addOutgoingHook', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
var hook = {};
hook.channel_id = TestHelper.basicChannel().id;
hook.description = 'desc';
hook.display_name = 'Unit Test';
TestHelper.basicClient().addOutgoingHook(
hook,
function() {
done(new Error('hooks not enabled'));
},
function(err) {
assert.equal(err.id, 'api.webhook.create_outgoing.disabled.app_error');
done();
}
);
});
});
it('deleteOutgoingHook', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
TestHelper.basicClient().deleteOutgoingHook(
TestHelper.generateId(),
function() {
done(new Error('hooks not enabled'));
},
function(err) {
assert.equal(err.id, 'api.webhook.delete_outgoing.disabled.app_error');
done();
}
);
});
});
it('listOutgoingHooks', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
TestHelper.basicClient().listOutgoingHooks(
function() {
done(new Error('hooks not enabled'));
},
function(err) {
assert.equal(err.id, 'api.webhook.get_outgoing.disabled.app_error');
done();
}
);
});
});
it('regenOutgoingHookToken', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
TestHelper.basicClient().regenOutgoingHookToken(
TestHelper.generateId(),
function() {
done(new Error('hooks not enabled'));
},
function(err) {
assert.equal(err.id, 'api.webhook.regen_outgoing_token.disabled.app_error');
done();
}
);
});
});
});

60
webapp/tests/client_oauth.test.jsx Normal file
View File

@@ -0,0 +1,60 @@
// Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
// See License.txt for license information.
/* eslint-disable no-console */
/* eslint-disable global-require */
/* eslint-disable func-names */
/* eslint-disable prefer-arrow-callback */
/* eslint-disable no-magic-numbers */
/* eslint-disable no-unreachable */
import assert from 'assert';
import TestHelper from './test_helper.jsx';
describe('Client.OAuth', function() {
this.timeout(100000);
it('registerOAuthApp', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
var app = {};
app.name = 'test';
app.homepage = 'homepage';
app.description = 'desc';
app.callback_urls = '';
TestHelper.basicClient().registerOAuthApp(
app,
function() {
done(new Error('not enabled'));
},
function(err) {
assert.equal(err.id, 'api.oauth.register_oauth_app.turn_off.app_error');
done();
}
);
});
});
it('allowOAuth2', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
TestHelper.basicClient().allowOAuth2(
'GET',
'123456',
'http://nowhere.com',
'state',
'scope',
function() {
done(new Error('not enabled'));
},
function(err) {
assert.equal(err.id, 'api.oauth.allow_oauth.turn_off.app_error');
done();
}
);
});
});
});

207
webapp/tests/client_post.test.jsx Normal file
View File

@@ -0,0 +1,207 @@
// Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
// See License.txt for license information.
/* eslint-disable no-console */
/* eslint-disable global-require */
/* eslint-disable func-names */
/* eslint-disable prefer-arrow-callback */
/* eslint-disable no-magic-numbers */
/* eslint-disable no-unreachable */
import assert from 'assert';
import TestHelper from './test_helper.jsx';
describe('Client.Posts', function() {
this.timeout(100000);
it('createPost', function(done) {
TestHelper.initBasic(() => {
var post = TestHelper.fakePost();
post.channel_id = TestHelper.basicChannel().id;
TestHelper.basicClient().createPost(
post,
function(data) {
assert.equal(data.id.length > 0, true);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('getPostById', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().getPostById(
TestHelper.basicPost().id,
function(data) {
assert.equal(data.order[0], TestHelper.basicPost().id);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('getPost', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().getPost(
TestHelper.basicChannel().id,
TestHelper.basicPost().id,
function(data) {
assert.equal(data.order[0], TestHelper.basicPost().id);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('updatePost', function(done) {
TestHelper.initBasic(() => {
var post = TestHelper.basicPost();
post.message = 'new message';
post.channel_id = TestHelper.basicChannel().id;
TestHelper.basicClient().updatePost(
post,
function(data) {
assert.equal(data.id.length > 0, true);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('deletePost', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().deletePost(
TestHelper.basicChannel().id,
TestHelper.basicPost().id,
function(data) {
assert.equal(data.id, TestHelper.basicPost().id);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('searchPost', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().search(
'unit test',
function(data) {
assert.equal(data.order[0], TestHelper.basicPost().id);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('getPostsPage', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().getPostsPage(
TestHelper.basicChannel().id,
0,
10,
function(data) {
assert.equal(data.order[0], TestHelper.basicPost().id);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('getPosts', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().getPosts(
TestHelper.basicChannel().id,
0,
function(data) {
assert.equal(data.order[0], TestHelper.basicPost().id);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('getPostsBefore', function(done) {
TestHelper.initBasic(() => {
var post = TestHelper.fakePost();
post.channel_id = TestHelper.basicChannel().id;
TestHelper.basicClient().createPost(
post,
function(rpost) {
TestHelper.basicClient().getPostsBefore(
TestHelper.basicChannel().id,
rpost.id,
0,
10,
function(data) {
assert.equal(data.order[0], TestHelper.basicPost().id);
done();
},
function(err) {
done(new Error(err.message));
}
);
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('getPostsAfter', function(done) {
TestHelper.initBasic(() => {
var post = TestHelper.fakePost();
post.channel_id = TestHelper.basicChannel().id;
TestHelper.basicClient().createPost(
post,
function(rpost) {
TestHelper.basicClient().getPostsAfter(
TestHelper.basicChannel().id,
TestHelper.basicPost().id,
0,
10,
function(data) {
assert.equal(data.order[0], rpost.id);
done();
},
function(err) {
done(new Error(err.message));
}
);
},
function(err) {
done(new Error(err.message));
}
);
});
});
});

72
webapp/tests/client_preferences.test.jsx Normal file
View File

@@ -0,0 +1,72 @@
// Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
// See License.txt for license information.
/* eslint-disable no-console */
/* eslint-disable global-require */
/* eslint-disable func-names */
/* eslint-disable prefer-arrow-callback */
/* eslint-disable no-magic-numbers */
/* eslint-disable no-unreachable */
import assert from 'assert';
import TestHelper from './test_helper.jsx';
describe('Client.Preferences', function() {
this.timeout(100000);
it('getAllPreferences', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().getAllPreferences(
function(data) {
assert.equal(data[0].category, 'tutorial_step');
assert.equal(data[0].user_id, TestHelper.basicUser().id);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('savePreferences', function(done) {
TestHelper.initBasic(() => {
var perf = {};
perf.user_id = TestHelper.basicUser().id;
perf.category = 'test';
perf.name = 'name';
perf.value = 'value';
var perfs = [];
perfs.push(perf);
TestHelper.basicClient().savePreferences(
perfs,
function(data) {
assert.equal(data, true);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('getPreferenceCategory', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().getPreferenceCategory(
'tutorial_step',
function(data) {
assert.equal(data[0].category, 'tutorial_step');
assert.equal(data[0].user_id, TestHelper.basicUser().id);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
});

235
webapp/tests/client_team.test.jsx Normal file
View File

@@ -0,0 +1,235 @@
// Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
// See License.txt for license information.
/* eslint-disable no-console */
/* eslint-disable global-require */
/* eslint-disable func-names */
/* eslint-disable prefer-arrow-callback */
/* eslint-disable no-magic-numbers */
/* eslint-disable no-unreachable */
import assert from 'assert';
import TestHelper from './test_helper.jsx';
describe('Client.Team', function() {
this.timeout(100000);
it('findTeamByName', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().findTeamByName(
TestHelper.basicTeam().name,
function(data) {
assert.equal(data, true);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('signupTeam', function(done) {
var client = TestHelper.createClient();
var email = TestHelper.fakeEmail();
client.signupTeam(
email,
function(data) {
assert.equal(data.email, email);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
it('createTeamFromSignup', function(done) {
var client = TestHelper.createClient();
var email = TestHelper.fakeEmail();
client.signupTeam(
email,
function(data) {
var teamSignup = {};
teamSignup.invites = [];
teamSignup.data = decodeURIComponent(data.follow_link.split('&h=')[0].replace('/signup_team_complete/?d=', ''));
teamSignup.hash = decodeURIComponent(data.follow_link.split('&h=')[1]);
teamSignup.user = TestHelper.fakeUser();
teamSignup.team = TestHelper.fakeTeam();
teamSignup.team.email = teamSignup.user.email;
client.createTeamFromSignup(
teamSignup,
function(data2) {
assert.equal(data2.team.id.length > 0, true);
assert.equal(data2.user.id.length > 0, true);
done();
},
function(err) {
done(new Error(err.message));
}
);
},
function(err) {
done(new Error(err.message));
}
);
});
it('createTeam', function(done) {
var client = TestHelper.createClient();
var team = TestHelper.fakeTeam();
client.createTeam(
team,
function(data) {
assert.equal(data.id.length > 0, true);
assert.equal(data.name, team.name);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
it('getAllTeams', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().getAllTeams(
function(data) {
assert.equal(data[TestHelper.basicTeam().id].name, TestHelper.basicTeam().name);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('getAllTeamListings', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().getAllTeamListings(
function(data) {
console.log(data);
assert.equal(data != null, true);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('getMyTeam', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().getMyTeam(
function(data) {
assert.equal(data.name, TestHelper.basicTeam().name);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('GetTeamMembers', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().getTeamMembers(
TestHelper.basicTeam().id,
function(data) {
assert.equal(data.length > 0, true);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('inviteMembers', function(done) {
TestHelper.initBasic(() => {
var data = {};
data.invites = [];
var invite = {};
invite.email = TestHelper.fakeEmail();
invite.firstName = 'first';
invite.lastName = 'last';
data.invites.push(invite);
TestHelper.basicClient().inviteMembers(
data,
function(dataBack) {
assert.equal(dataBack.invites.length, 1);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('updateTeam', function(done) {
TestHelper.initBasic(() => {
var team = TestHelper.basicTeam();
team.display_name = 'test_updated';
TestHelper.basicClient().updateTeam(
team,
function(data) {
assert.equal(data.display_name, 'test_updated');
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('addUserToTeam', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().createUser(
TestHelper.fakeUser(),
function(user2) {
TestHelper.basicClient().addUserToTeam(
user2.id,
function(data) {
assert.equal(data.user_id, user2.id);
done();
},
function(err) {
done(new Error(err.message));
}
);
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('getInviteInfo', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().getInviteInfo(
TestHelper.basicTeam().invite_id,
function(data) {
assert.equal(data.display_name.length > 0, true);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
});

550
webapp/tests/client_user.test.jsx Normal file
View File

@@ -0,0 +1,550 @@
// Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
// See License.txt for license information.
/* eslint-disable no-console */
/* eslint-disable global-require */
/* eslint-disable func-names */
/* eslint-disable prefer-arrow-callback */
/* eslint-disable no-magic-numbers */
/* eslint-disable no-unreachable */
import assert from 'assert';
import TestHelper from './test_helper.jsx';
describe('Client.User', function() {
this.timeout(100000);
it('getMe', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().getMe(
function(data) {
assert.equal(data.id, TestHelper.basicUser().id);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('getInitialLoad', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().getInitialLoad(
function(data) {
assert.equal(data.user.id.length > 0, true);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('createUser', function(done) {
var client = TestHelper.createClient();
var user = TestHelper.fakeUser();
client.createUser(
user,
function(data) {
assert.equal(data.id.length > 0, true);
assert.equal(data.email, user.email);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
it('loginByEmail', function(done) {
var client = TestHelper.createClient();
var user = TestHelper.fakeUser();
client.createUser(
user,
function() {
client.login(
user.email,
null,
user.password,
null,
function(data) {
assert.equal(data.id.length > 0, true);
assert.equal(data.email, user.email);
done();
},
function(err) {
done(new Error(err.message));
}
);
},
function(err) {
done(new Error(err.message));
}
);
});
it('loginByUsername', function(done) {
var client = TestHelper.createClient();
var user = TestHelper.fakeUser();
client.createUser(
user,
function() {
client.login(
null,
user.username,
user.password,
null,
function(data) {
assert.equal(data.id.length > 0, true);
assert.equal(data.email, user.email);
done();
},
function(err) {
done(new Error(err.message));
}
);
},
function(err) {
done(new Error(err.message));
}
);
});
it('loginByLdap', function(done) {
var client = TestHelper.createClient();
client.enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
var user = TestHelper.fakeUser();
client.createUser(
user,
function() {
client.loginByLdap(
user.username,
user.password,
null,
function() {
done(new Error());
},
function(err) {
assert.equal(err.id, 'api.user.login_ldap.disabled.app_error');
done();
}
);
},
function(err) {
done(new Error(err.message));
}
);
});
it('updateUser', function(done) {
TestHelper.initBasic(() => {
var user = TestHelper.basicUser();
user.nickname = 'updated';
TestHelper.basicClient().updateUser(
user,
function(data) {
assert.equal(data.nickname, 'updated');
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('updatePassword', function(done) {
TestHelper.initBasic(() => {
var user = TestHelper.basicUser();
TestHelper.basicClient().updatePassword(
user.id,
user.password,
'update_password',
function(data) {
assert.equal(data.user_id, user.id);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('updateUserNotifyProps', function(done) {
TestHelper.initBasic(() => {
var user = TestHelper.basicUser();
var notifyProps = {
all: 'true',
channel: 'true',
desktop: 'all',
desktop_sound: 'true',
email: 'false',
first_name: 'false',
mention_keys: '',
user_id: user.id
};
TestHelper.basicClient().updateUserNotifyProps(
notifyProps,
function(data) {
assert.equal(data.notify_props.email, 'false');
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('updateRoles', function(done) {
TestHelper.initBasic(() => {
var user = TestHelper.basicUser();
TestHelper.basicClient().updateRoles(
user.id,
'',
function(data) {
assert.equal(data.roles, '');
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('updateActive', function(done) {
TestHelper.initBasic(() => {
var user = TestHelper.basicUser();
TestHelper.basicClient().updateActive(
user.id,
false,
function(data) {
assert.equal(data.last_activity_at > 0, true);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('sendPasswordReset', function(done) {
TestHelper.initBasic(() => {
var user = TestHelper.basicUser();
TestHelper.basicClient().sendPasswordReset(
user.email,
function(data) {
assert.equal(data.email, user.email);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('resetPassword', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
TestHelper.basicClient().resetPassword(
'',
'new_password',
function() {
throw Error('shouldnt work');
},
function(err) {
// this should fail since you're not a system admin
assert.equal(err.id, 'api.context.invalid_param.app_error');
done();
}
);
});
});
it('emailToOAuth', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
var user = TestHelper.basicUser();
TestHelper.basicClient().emailToOAuth(
user.email,
'new_password',
'gitlab',
function() {
throw Error('shouldnt work');
},
function(err) {
// this should fail since you're not a system admin
assert.equal(err.id, 'api.user.check_user_password.invalid.app_error');
done();
}
);
});
});
it('oauthToEmail', function(done) {
TestHelper.initBasic(() => {
var user = TestHelper.basicUser();
TestHelper.basicClient().oauthToEmail(
user.email,
'new_password',
function(data) {
assert.equal(data.follow_link.length > 0, true);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('emailToLdap', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
var user = TestHelper.basicUser();
TestHelper.basicClient().emailToLdap(
user.email,
user.password,
'unknown_id',
'unknown_pwd',
function() {
throw Error('shouldnt work');
},
function(err) {
assert.equal(err.id, 'ent.ldap.do_login.licence_disable.app_error');
done();
}
);
});
});
it('ldapToEmail', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
var user = TestHelper.basicUser();
TestHelper.basicClient().ldapToEmail(
user.email,
'new_password',
'new_password',
function() {
throw Error('shouldnt work');
},
function(err) {
assert.equal(err.id, 'api.user.ldap_to_email.not_ldap_account.app_error');
done();
}
);
});
});
it('logout', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().logout(
function(data) {
assert.equal(data.user_id, TestHelper.basicUser().id);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('checkMfa', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().checkMfa(
'email',
TestHelper.generateId(),
function(data) {
assert.equal(data.mfa_required, 'false');
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('getSessions', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().getSessions(
TestHelper.basicUser().id,
function(data) {
assert.equal(data[0].user_id, TestHelper.basicUser().id);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('revokeSession', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().getSessions(
TestHelper.basicUser().id,
function(sessions) {
TestHelper.basicClient().revokeSession(
sessions[0].id,
function(data) {
assert.equal(data.id, sessions[0].id);
done();
},
function(err) {
done(new Error(err.message));
}
);
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('getAudits', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().getAudits(
TestHelper.basicUser().id,
function(data) {
assert.equal(data[0].user_id, TestHelper.basicUser().id);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('getDirectProfiles', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().getDirectProfiles(
function(data) {
assert.equal(Object.keys(data).length === 0, true);
done();
},
function(err) {
done(new Error(err.getDirectProfiles));
}
);
});
});
it('getProfiles', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().getProfiles(
function(data) {
assert.equal(data[TestHelper.basicUser().id].id, TestHelper.basicUser().id);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('getProfilesForTeam', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().getProfilesForTeam(
TestHelper.basicTeam().id,
function(data) {
assert.equal(data[TestHelper.basicUser().id].id, TestHelper.basicUser().id);
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('getStatuses', function(done) {
TestHelper.initBasic(() => {
var ids = [];
ids.push(TestHelper.basicUser().id);
TestHelper.basicClient().getStatuses(
ids,
function(data) {
assert.equal(data[TestHelper.basicUser().id], 'online');
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('verifyEmail', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
TestHelper.basicClient().verifyEmail(
'junk',
'junk',
function() {
done(new Error('should be invalid'));
},
function(err) {
assert.equal(err.id, 'api.context.invalid_param.app_error');
done();
}
);
});
});
it('resendVerification', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
TestHelper.basicClient().resendVerification(
TestHelper.basicUser().email,
function() {
done();
},
function(err) {
done(new Error(err.message));
}
);
});
});
it('updateMfa', function(done) {
TestHelper.initBasic(() => {
TestHelper.basicClient().enableLogErrorsToConsole(false); // Disabling since this unit test causes an error
TestHelper.basicClient().updateMfa(
'junk',
true,
function() {
done(new Error('not enabled'));
},
function(err) {
assert.equal(err.id, 'ent.mfa.license_disable.app_error');
done();
}
);
});
});
});

24
webapp/tests/spinner_button.test.jsx Normal file
View File

@@ -0,0 +1,24 @@
/* eslint-disable no-console */
/* eslint-disable global-require */
/* eslint-disable func-names */
/* eslint-disable prefer-arrow-callback */
/* eslint-disable no-magic-numbers */
/* eslint-disable no-unreachable */
var jsdom = require('mocha-jsdom');
var assert = require('assert');
import TestUtils from 'react-addons-test-utils';
import SpinnerButton from '../components/spinner_button.jsx';
import React from 'react';
describe('SpinnerButton', function() {
jsdom();
it('check props', function() {
const spinner = TestUtils.renderIntoDocument(
<SpinnerButton spinning={false}/>
);
assert.equal(spinner.props.spinning, false, 'should start in the default false state');
});
});

183
webapp/tests/test_helper.jsx Normal file
View File

@@ -0,0 +1,183 @@
// Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
// See License.txt for license information.
/* eslint-disable no-console */
/* eslint-disable global-require */
/* eslint-disable func-names */
/* eslint-disable prefer-arrow-callback */
/* eslint-disable no-magic-numbers */
/* eslint-disable no-unreachable */
/* eslint-disable new-cap */
import Client from '../client/client.jsx';
import jqd from 'jquery-deferred';
class TestHelperClass {
basicClient = () => {
return this.basicc;
}
basicTeam = () => {
return this.basict;
}
basicUser = () => {
return this.basicu;
}
basicChannel = () => {
return this.basicch;
}
basicPost = () => {
return this.basicp;
}
generateId = () => {
// implementation taken from http://stackoverflow.com/a/2117523
var id = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
id = id.replace(/[xy]/g, function replaceRandom(c) {
var r = Math.floor(Math.random() * 16);
var v;
if (c === 'x') {
v = r;
} else {
v = r & 0x3 | 0x8;
}
return v.toString(16);
});
return 'uid' + id;
}
createClient() {
var c = new Client();
c.setUrl('http://localhost:8065');
c.useHeaderToken();
c.enableLogErrorsToConsole(true);
return c;
}
fakeEmail = () => {
return 'success' + this.generateId() + '@simulator.amazonses.com';
}
fakeUser = () => {
var user = {};
user.email = this.fakeEmail();
user.allow_marketing = true;
user.password = 'password1';
user.username = this.generateId();
return user;
}
fakeTeam = () => {
var team = {};
team.name = this.generateId();
team.display_name = `Unit Test ${team.name}`;
team.type = 'O';
team.email = this.fakeEmail();
team.allowed_domains = '';
return team;
}
fakeChannel = () => {
var channel = {};
channel.name = this.generateId();
channel.display_name = `Unit Test ${channel.name}`;
channel.type = 'O'; // open channel
return channel;
}
fakePost = () => {
var post = {};
post.message = `Unit Test ${this.generateId()}`;
return post;
}
initBasic = (callback) => {
this.basicc = this.createClient();
var d1 = jqd.Deferred();
var email = this.fakeEmail();
var outer = this; // eslint-disable-line consistent-this
this.basicClient().signupTeam(
email,
function(rsignUp) {
var teamSignup = {};
teamSignup.invites = [];
teamSignup.data = decodeURIComponent(rsignUp.follow_link.split('&h=')[0].replace('/signup_team_complete/?d=', ''));
teamSignup.hash = decodeURIComponent(rsignUp.follow_link.split('&h=')[1]);
teamSignup.user = outer.fakeUser();
teamSignup.team = outer.fakeTeam();
teamSignup.team.email = email;
teamSignup.user.email = email;
var password = teamSignup.user.password;
outer.basicClient().createTeamFromSignup(
teamSignup,
function(rteamSignup) {
outer.basict = rteamSignup.team;
outer.basicu = rteamSignup.user;
outer.basicu.password = password;
outer.basicClient().setTeamId(outer.basict.id);
outer.basicClient().login(
rteamSignup.user.email,
null,
password,
null,
function() {
outer.basicClient().useHeaderToken();
var channel = outer.fakeChannel();
channel.team_id = outer.basicTeam().id;
outer.basicClient().createChannel(
channel,
function(rchannel) {
outer.basicch = rchannel;
var post = outer.fakePost();
post.channel_id = rchannel.id;
outer.basicClient().createPost(
post,
function(rpost) {
outer.basicp = rpost;
d1.resolve();
},
function(err) {
throw err;
}
);
},
function(err) {
throw err;
}
);
},
function(err) {
throw err;
}
);
},
function(err) {
throw err;
}
);
},
function(err) {
throw err;
}
);
jqd.when(d1).done(() => {
callback();
});
}
}
var TestHelper = new TestHelperClass();
export default TestHelper;