const generateTestGroups = function(restContext, total, callback, _groups) {
_groups = _groups || [];
if (total === 0) {
SearchTestUtil.whenIndexingComplete(() => {
return callback.apply(callback, _groups);
});
return;
}
// Create the next group and store its full group profile
RestAPI.Group.createGroup(
restContext,
generateTestGroupId('random-title'),
generateTestGroupId('random-description'),
PUBLIC,
'yes',
[],
[],
(err, group) => {
assert.ok(!err);
RestAPI.Group.getGroup(restContext, group.id, (err, fullGroupProfile) => {
assert.ok(!err);
_groups.push({ restContext, group: fullGroupProfile });
// Recursively continue creating groups
return generateTestGroups(restContext, --total, callback, _groups);
});
}
);
};
RestAPI.Group.createGroup(jackCtx, groupAlias, groupAlias, groupAlias, 'public', 'yes', [], [], function(err, group) {
assert.ok(!err);
// Join as jane
var membership = {};
membership[jane.id] = 'member';
RestAPI.Group.setGroupMembers(jackCtx, group.id, membership, function(err) {
assert.ok(!err);
// Join as branden
membership = {};
membership[branden.id] = 'member';
RestAPI.Group.setGroupMembers(jackCtx, group.id, membership, function(err) {
assert.ok(!err);
ActivityTestsUtil.collectAndGetActivityStream(jackCtx, null, null, function(err, activityStream) {
assert.ok(!err);
// Verify 1 for the group create, plus 1 for the aggregated group-add-member activities
assert.equal(activityStream.items.length, 2);
// Verify the first is the group join, with a collection of 2 actor entities (jane and branden)
var entity = activityStream.items[0].object;
assert.ok(entity['oae:collection']);
assert.equal(entity['oae:collection'].length, 2);
callback();
});
});
});
});
var updateAllGroups = module.exports.updateAllGroups = function(publicTenant1, publicTenant2, privateTenant, modifications, callback) {
// Update the groups from publicTenant1
RestAPI.Group.updateGroup(publicTenant1.adminRestContext, publicTenant1.publicGroup.id, modifications, function(err) {
assert.ok(!err);
RestAPI.Group.updateGroup(publicTenant1.adminRestContext, publicTenant1.loggedinGroup.id, modifications, function(err) {
assert.ok(!err);
RestAPI.Group.updateGroup(publicTenant1.adminRestContext, publicTenant1.privateGroup.id, modifications, function(err) {
assert.ok(!err);
// Update the groups from publicTenant2
RestAPI.Group.updateGroup(publicTenant2.adminRestContext, publicTenant2.publicGroup.id, modifications, function(err) {
assert.ok(!err);
RestAPI.Group.updateGroup(publicTenant2.adminRestContext, publicTenant2.loggedinGroup.id, modifications, function(err) {
assert.ok(!err);
RestAPI.Group.updateGroup(publicTenant2.adminRestContext, publicTenant2.privateGroup.id, modifications, function(err) {
assert.ok(!err);
// Update the groups from privateTenant
RestAPI.Group.updateGroup(privateTenant.adminRestContext, privateTenant.publicGroup.id, modifications, function(err) {
assert.ok(!err);
RestAPI.Group.updateGroup(privateTenant.adminRestContext, privateTenant.loggedinGroup.id, modifications, function(err) {
assert.ok(!err);
RestAPI.Group.updateGroup(privateTenant.adminRestContext, privateTenant.privateGroup.id, modifications, function(err) {
assert.ok(!err);
return callback();
});
});
});
});
});
});
});
});
});
};
RestAPI.User.createUser(camAdminRestContext, brandenUsername, 'password', 'Branden', null, function(err, branden) {
assert.ok(!err);
var brandenCtx = TestsUtil.createTenantRestContext(global.oaeTests.tenants.cam.host, brandenUsername, 'password');
RestAPI.Group.createGroup(jackCtx, groupAlias, groupAlias, groupAlias, 'public', 'yes', [], [], function(err, group) {
assert.ok(!err);
// Join as jane
RestAPI.Group.joinGroup(janeCtx, group.id, function(err) {
assert.ok(!err);
// Join as branden
RestAPI.Group.joinGroup(brandenCtx, group.id, function(err) {
assert.ok(!err);
// Get jack's own feed
ActivityTestsUtil.collectAndGetActivityStream(jackCtx, null, null, function(err, activityStream) {
assert.ok(!err);
// Verify 1 for the group create, plus 1 for the aggregated group-join activities
assert.equal(activityStream.items.length, 2);
// Verify the first is the group join, with a collection of 2 actor entities (jane and branden)
var entity = activityStream.items[0].actor;
assert.ok(entity['oae:collection']);
assert.equal(entity['oae:collection'].length, 2);
callback();
});
});
});
});
});
RestAPI.Group.createGroup(jackCtx, groupAlias, groupAlias, groupAlias, 'public', 'yes', [], [], function(err, group) {
assert.ok(!err);
// Join as jane
RestAPI.Group.joinGroup(janeCtx, group.id, function(err) {
assert.ok(!err);
// Join as branden
RestAPI.Group.joinGroup(brandenCtx, group.id, function(err) {
assert.ok(!err);
// Get jack's own feed
ActivityTestsUtil.collectAndGetActivityStream(jackCtx, null, null, function(err, activityStream) {
assert.ok(!err);
// Verify 1 for the group create, plus 1 for the aggregated group-join activities
assert.equal(activityStream.items.length, 2);
// Verify the first is the group join, with a collection of 2 actor entities (jane and branden)
var entity = activityStream.items[0].actor;
assert.ok(entity['oae:collection']);
assert.equal(entity['oae:collection'].length, 2);
callback();
});
});
});
});
RestAPI.Group.uploadPicture(ctx, groupA.group.id, _getPictureStream, selectedArea, function(err) {
assert.ok(!err);
// Download the different sizes
RestAPI.Group.downloadPicture(ctx, groupA.group.id, 'small', function(err, body, response) {
assert.ok(!err);
assert.equal(response.statusCode, 204);
RestAPI.Group.downloadPicture(ctx, groupA.group.id, 'medium', function(err, body, response) {
assert.ok(!err);
assert.equal(response.statusCode, 204);
RestAPI.Group.downloadPicture(ctx, groupA.group.id, 'large', function(err, body, response) {
assert.ok(!err);
assert.equal(response.statusCode, 204);
// Now try downloading it with some invalid parameters
RestAPI.Group.downloadPicture(ctx, 'invalid-group-id', 'small', function(err, body, response) {
assert.equal(err.code, 400);
RestAPI.Group.downloadPicture(ctx, groupA.group.id, null, function(err, body, response) {
assert.equal(err.code, 400);
// The other group has no picture, this should result in a 404
RestAPI.Group.downloadPicture(ctx, groupB.group.id, 'small', function(err, body, response) {
assert.equal(err.code, 404);
callback();
});
});
});
});
});
});
});
RestAPI.Group.createGroup(doerRestContext, publicGroupMemberAlias, publicGroupMemberAlias, publicGroupMemberAlias, 'public', 'no', [], [], function(err, _publicGroupMember) {
assert.ok(!err);
publicGroupMember = _publicGroupMember;
RestAPI.Group.createGroup(doerRestContext, privateGroupMemberAlias, privateGroupMemberAlias, privateGroupMemberAlias, 'public', 'no', [], [], function(err, _privateGroupMember) {
assert.ok(!err);
privateGroupMember = _privateGroupMember;
var memberships = {};
memberships[publicGroupMember.id] = 'member';
memberships[privateGroupMember.id] = 'member';
memberships[publicUserMember.id] = 'member';
memberships[loggedinUserMember.id] = 'member';
memberships[privateUserMember.id] = 'member';
RestAPI.Group.setGroupMembers(doerRestContext, targetPublicGroup.id, memberships, function(err) {
assert.ok(!err);
RestAPI.Group.setGroupMembers(doerRestContext, targetLoggedinGroup.id, memberships, function(err) {
assert.ok(!err);
RestAPI.Group.setGroupMembers(doerRestContext, targetPrivateGroup.id, memberships, function(err) {
assert.ok(!err);
callback();
});
});
});
});
});
RestAPI.Group.updateGroup(publicTenant1.adminRestContext, publicTenant1.privateGroup.id, modifications, function(err) {
assert.ok(!err);
// Update the groups from publicTenant2
RestAPI.Group.updateGroup(publicTenant2.adminRestContext, publicTenant2.publicGroup.id, modifications, function(err) {
assert.ok(!err);
RestAPI.Group.updateGroup(publicTenant2.adminRestContext, publicTenant2.loggedinGroup.id, modifications, function(err) {
assert.ok(!err);
RestAPI.Group.updateGroup(publicTenant2.adminRestContext, publicTenant2.privateGroup.id, modifications, function(err) {
assert.ok(!err);
// Update the groups from privateTenant
RestAPI.Group.updateGroup(privateTenant.adminRestContext, privateTenant.publicGroup.id, modifications, function(err) {
assert.ok(!err);
RestAPI.Group.updateGroup(privateTenant.adminRestContext, privateTenant.loggedinGroup.id, modifications, function(err) {
assert.ok(!err);
RestAPI.Group.updateGroup(privateTenant.adminRestContext, privateTenant.privateGroup.id, modifications, function(err) {
assert.ok(!err);
return callback();
});
});
});
});
});
});
});
TestsUtil.generateTestGroups(ctx, 1, function(err, groups) {
var group = groups[Object.keys(groups)[0]];
RestAPI.Group.uploadPicture(ctx, group.id, getPictureStream, null, function(err) {
assert.ok(!err);
verifyCropping(ctx, group, createSelectedArea(-10, 10, 200), 400, function() {
verifyCropping(ctx, group, createSelectedArea(10, -10, 200), 400, function() {
verifyCropping(ctx, group, createSelectedArea(-10, -10, 200), 400, function() {
verifyCropping(ctx, group, createSelectedArea(10, 10, 200), 200, function() {
// Download the different sizes.
RestAPI.Group.downloadPicture(ctx, group.id, 'small', function(err, body, request) {
assert.ok(!err);
assert.equal(request.statusCode, 204);
RestAPI.Group.downloadPicture(ctx, group.id, 'medium', function(err, body, request) {
assert.ok(!err);
assert.equal(request.statusCode, 204);
RestAPI.Group.downloadPicture(ctx, group.id, 'large', function(err, body, request) {
assert.ok(!err);
assert.equal(request.statusCode, 204);
callback();
});
});
});
});
});
});
});
});
});
RestAPI.Group.downloadPicture(ctx, groupA, 'small', function(err, body, response) {
assert.ok(!err);
assert.equal(response.statusCode, 204);
RestAPI.Group.downloadPicture(ctx, groupA, 'medium', function(err, body, response) {
assert.ok(!err);
assert.equal(response.statusCode, 204);
RestAPI.Group.downloadPicture(ctx, groupA, 'large', function(err, body, response) {
assert.ok(!err);
assert.equal(response.statusCode, 204);
// Now try downloading it with some invalid parameters
RestAPI.Group.downloadPicture(ctx, 'invalid-group-id', 'small', function(err, body, response) {
assert.equal(err.code, 400);
RestAPI.Group.downloadPicture(ctx, groupA, null, function(err, body, response) {
assert.equal(err.code, 400);
// The other group has no picture, this should result in a 404
RestAPI.Group.downloadPicture(ctx, groupB, 'small', function(err, body, response) {
assert.equal(err.code, 404);
callback();
});
});
});
});
});
});
RestAPI.Group.setGroupMembers(simong.restContext, group.id, changes, function(err) {
assert.ok(!err);
RestAPI.Group.getGroup(branden.restContext, group.id, function(err, group) {
assert.ok(!err);
assert.ok(group.signature);
return callback();
});
});
RestAPI.User.getMe(restCtx, function(err, meObj) {
if (err) {
return callback({'code': 500, 'msg': 'An error occured whilst trying to log in the user'});
}
for (var g = 0; g < total; g++) {
RestAPI.Group.createGroup(restCtx, generateTestGroupId('random-title'), generateTestGroupId('random-description'), 'public', 'yes', [], [], groupCreated);
}
});
RestAPI.Group.setGroupMembers(camAdminRestContext, targetLoggedinGroup.id, memberships, function(err) {
assert.ok(!err);
RestAPI.Group.setGroupMembers(camAdminRestContext, targetPrivateGroup.id, memberships, function(err) {
assert.ok(!err);
callback();
});
});
RestAPI.Group.downloadPicture(ctx, groupA, null, function(err, body, response) {
assert.equal(err.code, 400);
// The other group has no picture, this should result in a 404
RestAPI.Group.downloadPicture(ctx, groupB, 'small', function(err, body, response) {
assert.equal(err.code, 404);
callback();
});
});
RestAPI.Group.downloadPicture(ctx, group.id, 'medium', function(err, body, request) {
assert.ok(!err);
assert.equal(request.statusCode, 204);
RestAPI.Group.downloadPicture(ctx, group.id, 'large', function(err, body, request) {
assert.ok(!err);
assert.equal(request.statusCode, 204);
callback();
});
});
var _createGroupWithVisibility = function(tenant, visibility, memberPrincipalId, callback) {
var randomId = util.format('%s-%s', visibility, ShortId.generate());
var displayName = 'displayName-' + randomId;
var description = 'description-' + randomId;
RestAPI.Group.createGroup(tenant.adminRestContext, displayName, description, visibility, 'request', [], [memberPrincipalId], function(err, newGroup) {
assert.ok(!err);
return callback(newGroup);
});
};
RestAPI.Group.updateGroup(privateTenant.adminRestContext, privateTenant.publicGroup.id, modifications, function(err) {
assert.ok(!err);
RestAPI.Group.updateGroup(privateTenant.adminRestContext, privateTenant.loggedinGroup.id, modifications, function(err) {
assert.ok(!err);
RestAPI.Group.updateGroup(privateTenant.adminRestContext, privateTenant.privateGroup.id, modifications, function(err) {
assert.ok(!err);
return callback();
});
});
});
RestAPI.Group.createGroup(restContext, generateTestGroupId('random-title'), generateTestGroupId('random-description'), 'public', 'yes', [], [], function(err, group) {
assert.ok(!err);
RestAPI.Group.getGroup(restContext, group.id, function(err, fullGroupProfile) {
assert.ok(!err);
_groups.push({'restContext': restContext, 'group': fullGroupProfile});
// Recursively continue creating groups
return generateTestGroups(restContext, --total, callback, _groups);
});
});
(err, group) => {
assert.ok(!err);
RestAPI.Group.getGroup(restContext, group.id, (err, fullGroupProfile) => {
assert.ok(!err);
_groups.push({ restContext, group: fullGroupProfile });
// Recursively continue creating groups
return generateTestGroups(restContext, --total, callback, _groups);
});
}
RestAPI.Group.createGroup(mrvisser.restContext, 'Group title', 'Group description', 'public', 'yes', [], [], function(err, group) {
assert.ok(!err);
RestAPI.Group.getGroup(mrvisser.restContext, group.id, function(err, group) {
assert.ok(!err);
client.subscribe(group.id, 'activity', group.signature, null, function(err, msg) {
assert.ok(!err);
client.close(callback);
});
});
});
ActivityTestsUtil.collectAndGetActivityStream(contexts['simon'].restContext, null, null, function() {
// Changing nico's role to a manager should result in a message on the socket as well
membersToAdd[contexts['nico'].user.id] = 'manager';
RestAPI.Group.setGroupMembers(contexts['branden'].restContext, group.id, membersToAdd, function(err) {
assert.ok(!err);
// Route and deliver activities
ActivityTestsUtil.collectAndGetActivityStream(contexts['simon'].restContext, null, null, function() {});
});
});
RestAPI.Group.setGroupMembers(privateTenant.adminRestContext, privateTenant.loggedinGroup.id, permissions, function(err) {
assert.ok(!err);
RestAPI.Group.setGroupMembers(privateTenant.adminRestContext, privateTenant.privateGroup.id, permissions, function(err) {
assert.ok(!err);
// Make the private tenant private again
ConfigTestsUtil.updateConfigAndWait(TestsUtil.createGlobalAdminRestContext(), privateTenant.tenant.alias, {'oae-tenants/tenantprivacy/tenantprivate': true}, function(err) {
assert.ok(!err);
return callback();
});
});
});
RestAPI.LtiTool.createLtiTool(camAdminRestContext, group.id, 'http://lti.launch.url', 'secret', '12345', 'LTI tool title', 'LTI tool description', function(err, tool) {
assert.ok(!err);
RestAPI.Group.deleteGroup(camAdminRestContext, group.id, function(err) {
assert.ok(!err);
RestAPI.LtiTool.deleteLtiTool(camAdminRestContext, group.id, tool.id, function(err) {
assert.ok(err) ;
assert.equal(err.code, 404);
assert.equal(err.msg, util.format('Couldn\'t find group: %s', group.id));
return callback();
});
});
});
setupFixture(function(contexts, group, client) {
// Nicolaas joins the group
RestAPI.Group.joinGroup(contexts['nico'].restContext, group.id, function(err) {
assert.ok(!err);
});
client.on('message', function(message) {
ActivityTestsUtil.assertActivity(message.activities[0], PrincipalsConstants.activity.ACTIVITY_GROUP_JOIN, ActivityConstants.verbs.JOIN, contexts['nico'].user.id, group.id);
client.close(callback);
});
});
it('verify that missing OAUTH consumer key is not accepted', function(callback) {
RestAPI.Group.createGroup(camAdminRestContext, 'This is a group', null, 'public', 'yes', [], [], function(err, group) {
assert.ok(!err);
var launchUrl = 'http://lti.launch.url';
var secret = 'secret';
RestAPI.LtiTool.createLtiTool(camAdminRestContext, group.id, launchUrl, secret, null, 'LTI tool title', null, function(err, toolObject) {
assert.ok(err);
assert.equal(err.code, 400);
assert.equal(err.msg, 'You need to provide an OAUTH consumer key for this LTI tool');
return callback();
});
});
});
RestAPI.Group.createGroup(doerRestContext, TestsUtil.generateTestGroupId('group'), TestsUtil.generateTestGroupId('group'), 'public', 'yes', [], [], function(err, group) {
assert.ok(!err);
RestAPI.Group.joinGroup(userRestContext, group.id, function(err) {
assert.ok(!err);
ActivityTestsUtil.collectAndGetActivityStream(userRestContext, user.id, null, function(err, activityStream) {
assert.ok(!err);
assert.ok(_getActivity(activityStream, 'group-join', 'object', group.id));
callback();
});
});
});
it('verify that missing launchUrl is not accepted', function(callback) {
RestAPI.Group.createGroup(camAdminRestContext, 'This is a group', null, 'public', 'yes', [], [], function(err, group) {
assert.ok(!err);
var secret = 'secret';
var key = '12345';
RestAPI.LtiTool.createLtiTool(camAdminRestContext, group.id, '', secret, key, 'LTI tool title', null, function(err, toolObject) {
assert.ok(err);
assert.equal(err.code, 400);
assert.equal(err.msg, 'You need to provide a launch URL for this LTI tool');
return callback();
});
});
});
RestAPI.User.createUser(camAdminRestContext, privateUserMemberUsername, 'password', 'Private User Member', privateOpts, function(err, _privateUserMember) {
assert.ok(!err);
privateUserMember = _privateUserMember;
RestAPI.Group.createGroup(doerRestContext, TestsUtil.generateTestUserId('targetPublicGroup'), TestsUtil.generateTestUserId('targetPublicGroup'), 'public', 'no', [], [], function(err, _targetPublicGroup) {
assert.ok(!err);
targetPublicGroup = _targetPublicGroup;
RestAPI.Group.createGroup(doerRestContext, TestsUtil.generateTestUserId('targetLoggedinGroup'), TestsUtil.generateTestUserId('targetLoggedinGroup'), 'loggedin', 'no', [], [], function(err, _targetLoggedinGroup) {
assert.ok(!err);
targetLoggedinGroup = _targetLoggedinGroup;
RestAPI.Group.createGroup(doerRestContext, TestsUtil.generateTestUserId('targetPrivateGroup'), TestsUtil.generateTestUserId('targetPrivateGroup'), 'private', 'no', [], [], function(err, _targetPrivateGroup) {
assert.ok(!err);
targetPrivateGroup = _targetPrivateGroup;
RestAPI.Group.createGroup(doerRestContext, TestsUtil.generateTestUserId('publicGroupMemberAlias'), TestsUtil.generateTestUserId('publicGroupMemberAlias'), 'public', 'no', [], [], function(err, _publicGroupMember) {
assert.ok(!err);
publicGroupMember = _publicGroupMember;
RestAPI.Group.createGroup(doerRestContext, TestsUtil.generateTestUserId('privateGroupMemberAlias'), TestsUtil.generateTestUserId('privateGroupMemberAlias'), 'public', 'no', [], [], function(err, _privateGroupMember) {
assert.ok(!err);
privateGroupMember = _privateGroupMember;
var memberships = {};
memberships[publicGroupMember.id] = 'member';
memberships[privateGroupMember.id] = 'member';
memberships[publicUserMember.id] = 'member';
memberships[loggedinUserMember.id] = 'member';
memberships[privateUserMember.id] = 'member';
// Set the members of the groups with the cam admin since they are the only ones with access to make the private
// user a member
RestAPI.Group.setGroupMembers(camAdminRestContext, targetPublicGroup.id, memberships, function(err) {
assert.ok(!err);
RestAPI.Group.setGroupMembers(camAdminRestContext, targetLoggedinGroup.id, memberships, function(err) {
assert.ok(!err);
RestAPI.Group.setGroupMembers(camAdminRestContext, targetPrivateGroup.id, memberships, function(err) {
assert.ok(!err);
callback();
});
});
});
});
});
});
});
});
});
it('verify that a non-manager can not create LTI tool', function(callback) {
RestAPI.Group.createGroup(camAdminRestContext, 'This is a group', null, 'public', 'yes', [], [], function(err, group) {
assert.ok(!err);
var launchUrl = 'http://lti.launch.url';
var secret = 'secret';
var key = '12345';
RestAPI.LtiTool.createLtiTool(anonymousRestContext, group.id, launchUrl, secret, key, 'LTI tool title', 'LTI tool description', function(err, toolObject) {
assert.ok(err);
assert.equal(err.code, 401);
assert.equal(err.msg, 'The current user is not authorized to create an LTI tool');
return callback();
});
});
});
const createGroupAndLibrary = function(restCtx, groupVisibility, callback) {
RestAPI.Group.createGroup(restCtx, 'displayName', 'description', groupVisibility, 'no', [], [], (err, group) => {
assert.ok(!err);
// Fill up the group library with 3 meeting items
RestAPI.MeetingsJitsi.createMeeting(
restCtx,
'name',
'description',
false,
false,
'private',
[group.id],
null,
(err, privateMeeting) => {
assert.ok(!err);
RestAPI.MeetingsJitsi.createMeeting(
restCtx,
'name',
'description',
false,
false,
'loggedin',
[group.id],
null,
(err, loggedinMeeting) => {
assert.ok(!err);
RestAPI.MeetingsJitsi.createMeeting(
restCtx,
'name',
'description',
false,
false,
'public',
[group.id],
null,
(err, publicMeeting) => {
assert.ok(!err);
return callback(group, privateMeeting, loggedinMeeting, publicMeeting);
}
);
}
);
}
);
});
};