users.forEach(function(user) {
try {
return Meteor.call('addUserToRoom', {
rid: item.rid,
username: user.username,
});
} catch ({ error }) {
if (error === 'cant-invite-for-direct-room') {
RocketChat.Notifications.notifyUser(userId, 'message', {
_id: Random.id(),
rid: item.rid,
ts: new Date,
msg: TAPi18n.__('Cannot_invite_users_to_direct_rooms', null, currentUser.language),
});
} else {
RocketChat.Notifications.notifyUser(userId, 'message', {
_id: Random.id(),
rid: item.rid,
ts: new Date,
msg: TAPi18n.__(error, null, currentUser.language),
});
}
}
});
export const exampleMsg = () => {
const record = Template.instance().record.get();
return {
_id: Random.id(),
alias: record.alias,
emoji: record.emoji,
avatar: record.avatar,
msg: 'Example message',
bot: {
i: Random.id(),
},
groupable: false,
attachments: [{
title: 'Rocket.Chat',
title_link: 'https://rocket.chat',
text: 'Rocket.Chat, the best open source chat',
image_url: '/images/integration-attachment-example.png',
color: '#764FA5',
}],
ts: new Date(),
u: {
_id: Random.id(),
username: record.username,
},
};
};
it('do not increment achievement if no player', function() {
const gameId = Random.id(5);
const userId = Random.id(5);
const listener = (new Ninja()).forGame(gameId, userId);
Games.insert({_id: gameId, createdBy: userId, players: []});
assert.equal(0, UserAchievements.find().count());
listener.onGameFinished(new GameFinished(gameId, 121000));
assert.equal(0, UserAchievements.find().count());
});
it('do not increment achievement if no activated bonus in the game but game is under 2:00', function() {
const gameId = Random.id(5);
const creatorUserId = Random.id(5);
const opponentUserId = Random.id(5);
Games.insert({_id: gameId, createdBy: creatorUserId, players: [{id: creatorUserId}, {id: opponentUserId}]});
const listener = (new Ninja()).forGame(gameId, creatorUserId);
assert.equal(0, UserAchievements.find().count());
listener.onGameFinished(new GameFinished(gameId, 120000));
assert.equal(0, UserAchievements.find().count());
});
it('do not increment achievement if there was an activated bonus in the game and user is host', function() {
const gameId = Random.id(5);
const creatorUserId = Random.id(5);
const opponentUserId = Random.id(5);
Games.insert({_id: gameId, createdBy: creatorUserId, players: [{id: creatorUserId}, {id: opponentUserId}]});
const listener = (new Ninja()).forGame(gameId, creatorUserId);
listener.onBonusCaught(new BonusCaught(gameId, 'a', {activatedBonusClass: 'a', targetPlayerKey: 'player1', bonusClass: 'a', activatorPlayerKey: 'player1'}));
assert.equal(0, UserAchievements.find().count());
listener.onGameFinished(new GameFinished(gameId, 121000));
assert.equal(0, UserAchievements.find().count());
});
it('sends no symbols for a private circuit when logged in as another user', (done) => {
const collector = new PublicationCollector({ userId: Random.id() });
collector.collect('symbols.inCircuit', privateCircuit._id, (collections) => {
chai.assert.isUndefined(collections.Symbols);
done();
});
});
describe('methods', () => {
const userId = Random.id();
let taskId;
beforeEach(() => {
Tasks.remove({});
taskId = Tasks.insert({
text: 'test task',
createdAt: new Date(),
owner: userId,
username: '******',
});
});
it('can delete owned task', () => {
// Find the internal implementation of the task method so we can
// test it in isolation
const deleteTask = Meteor.server.method_handlers['tasks.remove'];
// Set up a fake method invocation that looks like what the method expects
const invocation = { userId };
// Run the method with `this` set to the fake invocation
deleteTask.apply(invocation, [taskId]);
// Verify that the method does what we expected
assert.equal(Tasks.find().count(), 0);
});
});
renderer.code = function(code, lang, escaped) {
if (this.options.highlight) {
const out = this.options.highlight(code, lang);
if (out != null && out !== code) {
escaped = true;
code = out;
}
}
let text = null;
if (!lang) {
text = `<pre><code class="code-colors hljs">${ (escaped ? code : s.escapeHTML(code, true)) }</code></pre>`;
} else {
text = `<pre><code class="code-colors hljs ${ escape(lang, true) }">${ (escaped ? code : s.escapeHTML(code, true)) }</code></pre>`;
}
if (_.isString(msg)) {
return text;
}
const token = `=!=${ Random.id() }=!=`;
msg.tokens.push({
highlight: true,
token,
text,
});
return token;
};
blockUnsafeImages(message) {
if (this.enabled && this.serviceAccount && message && message.file && message.file._id) {
const file = RocketChat.models.Uploads.findOne({ _id: message.file._id });
if (file && file.type && file.type.indexOf('image') !== -1 && file.store === 'GoogleCloudStorage:Uploads' && file.GoogleStorage) {
if (this.incCallCount(1)) {
const bucket = this.storageClient.bucket(RocketChat.settings.get('FileUpload_GoogleStorage_Bucket'));
const bucketFile = bucket.file(file.GoogleStorage.path);
const results = Meteor.wrapAsync(this.visionClient.detectSafeSearch, this.visionClient)(bucketFile);
if (results && results.adult === true) {
FileUpload.getStore('Uploads').deleteById(file._id);
const user = RocketChat.models.Users.findOneById(message.u && message.u._id);
if (user) {
RocketChat.Notifications.notifyUser(user._id, 'message', {
_id: Random.id(),
rid: message.rid,
ts: new Date,
msg: TAPi18n.__('Adult_images_are_not_allowed', {}, user.language),
});
}
throw new Meteor.Error('GoogleVisionError: Image blocked');
}
} else {
console.error('Google Vision: Usage limit exceeded');
}
return message;
}
}
}
describe('methods', () => {
//creating a task with a random userId
const userId = Random.id();
let taskId;
beforEach(() => {
Tasks.remove({});
//testing our random task with the remove method
taskId = Tasks.insert({
text: 'test task',
createdAt: new Date(),
owner: userId,
username: '******',
});
});
it('can delete owned task', () => {
//testing an isolated instance of the task
const deleteTask = Meteor.server.method_handlers['tasks.remove'];
//spy?
const invocation = {
userId
};
//run using spy
deleteTask.apply(incovation, [taskId]);
//checking if we are getting the expected outcome
assert.equal(Tasks.find().count(),0);
});
});
describe('emails.sendEnrollmentEmail', ()=> {
const sendEnrollmentEmailHandler = Meteor.server.method_handlers['sendEnrollmentEmail'];
let accountsSendEnrollmentEmailStub;
const agencyId = Random.id();
beforeEach(()=> {
accountsSendEnrollmentEmailStub = sinon.stub(Accounts, 'sendEnrollmentEmail', ()=> true);
});
afterEach(()=> {
Accounts.sendEnrollmentEmail.restore();
});
it('fails if user is not an administrator', ()=> {
const invocation = {userId: testUserId};
assert.throws(()=>sendEnrollmentEmailHandler.apply(invocation, [testUserId, agencyId]),
'Must be an agency administrator to send enrollment email. [unauthorized]');
});
it('fails if user is an administrator but not for this agency', ()=> {
const invocation = {userId: testUserId};
Roles.addUsersToRoles(testUserId, ['administrator'], 'anotherAgency');
assert.throws(()=>sendEnrollmentEmailHandler.apply(invocation, [testUserId, agencyId]),
'Must be an agency administrator to send enrollment email. [unauthorized]');
});
it('Accounts.sendEnrollmentEmail is called', ()=> {
const invocation = {userId: testUserId};
Roles.addUsersToRoles(testUserId, ['administrator'], agencyId);
sendEnrollmentEmailHandler.apply(invocation, [testUserId, agencyId]);
assert(accountsSendEnrollmentEmailStub.calledOnce);
});
});
it("should call StripeApi.methods.captureCharge with the proper parameters and return saved = true", function (done) {
const paymentPackageId = Random.id();
const paymentMethod = {
processor: "Stripe",
storedCard: "Visa 4242",
paymentPackageId,
paymentSettingsKey: "reaction-stripe",
method: "credit",
transactionId: "ch_17hZ4wBXXkbZQs3xL5JhlSgS",
amount: 19.99,
status: "approved",
mode: "capture",
createdAt: new Date()
};
// Stripe Charge Nock
nock("https://api.stripe.com:443")
.post(`/v1/charges/${paymentMethod.transactionId}/capture`)
.reply(200, stripeCaptureResult); // .log(console.log);
sandbox.stub(utils, "getStripeApi", function () {
return "sk_fake_fake";
});
let captureResult = null;
let captureError = null;
Meteor.call("stripe/payment/capture", paymentMethod, function (error, result) {
captureResult = result;
captureError = error;
expect(captureError).to.be.undefined;
expect(captureResult).to.not.be.undefined;
expect(captureResult.saved).to.be.true;
done();
});
});
describe('methods', () => {
const userId = Random.id();
let courseId;
const now = new Date();
beforeEach(() => {
Courses.remove({});
courseId = Courses.insert({
name: 'Vinyasa Flow',
start: new Date(),
end : new Date().setHour(now.getHour() + 1),
studio: 'Chiswell Street',
teacher: 'Issy',
url : 'http://www.flexlondon.com/',
});
});
it('can delete owned course', () => {
// use the actual implementation of the course method from the server
const deleteCourse = Meteor.server.method_handlers['courses.remove'];
// Make the input look similar on "this" in the function call
const invocation = { userId };
// run method with "this" set to fake invocation
deleteCourse.apply(invocation, [courseId]);
// verify that it worked
assert.equal(Courses.find().count(), 0);
});
});
convertAppMessage(message) {
if (!message) {
return undefined;
}
const room = RocketChat.models.Rooms.findOneById(message.room.id);
if (!room) {
throw new Error('Invalid room provided on the message.');
}
let u;
if (message.sender && message.sender.id) {
const user = RocketChat.models.Users.findOneById(message.sender.id);
if (user) {
u = {
_id: user._id,
username: user.username,
name: user.name,
};
} else {
u = {
_id: message.sender.id,
username: message.sender.username,
name: message.sender.name,
};
}
}
let editedBy;
if (message.editor) {
const editor = RocketChat.models.Users.findOneById(message.editor.id);
editedBy = {
_id: editor._id,
username: editor.username,
};
}
const attachments = this._convertAppAttachments(message.attachments);
return {
_id: message.id || Random.id(),
rid: room._id,
u,
msg: message.text,
ts: message.createdAt || new Date(),
_updatedAt: message.updatedAt || new Date(),
editedBy,
editedAt: message.editedAt,
emoji: message.emoji,
avatar: message.avatarUrl,
alias: message.alias,
customFields: message.customFields,
groupable: message.groupable,
attachments,
reactions: message.reactions,
};
}
it('do not create achievement if not created if not gameId on invisible bonus caught', function() {
Games.insert({_id: gameId, createdBy: userId, players: [{id: userId}, {id: opponentUserId}]});
const listener = (new InvisibleInAPoint()).forGame(gameId, userId);
assert.equal(0, UserAchievements.find().count());
listener.onBonusCaught(new BonusCaught(Random.id(5), 'a', {activatedBonusClass: BONUS_INVISIBLE_MONSTER, targetPlayerKey: 'player1', bonusClass: 'a', activatorPlayerKey: 'player1'}));
assert.equal(0, UserAchievements.find().count());
});
this.resetNewComment = () => {
this.newComment = {
_id: Random.id(),
noi_dung: {},
isActive: true,
metadata: {}
};
};
it('do not create achievement if not created if not userId on player won', function() {
Games.insert({_id: gameId, createdBy: userId, gameDuration: 59000, players: [{id: userId}, {id: opponentUserId}]});
assert.equal(0, UserAchievements.find().count());
const listener = (new GamesWonUnderAMinute()).forGame(gameId, userId);
listener.onPlayerWon(new PlayerWon(gameId, Random.id(5), 5, 0));
assert.equal(0, UserAchievements.find().count());
});
it('does not assign amounts of selections of other users', function () {
const otherUserId = Random.id();
Factory.create('selection', { programId, program, userId: otherUserId});
assign_initial_amounts.apply(invocation);
user_selection = Selections.findOne({userId});
other_selection = Selections.findOne({userId: otherUserId});
expect(user_selection.amount).to.exist;
expect(other_selection.amount).not.to.exist;
});
it('do not update achievement if not gameId on player won', function() {
Games.insert({_id: gameId, createdBy: userId, gameDuration: 59000, players: [{id: userId}, {id: opponentUserId}]});
UserAchievements.insert({userId: userId, achievementId: ACHIEVEMENT_GAMES_WON_UNDER_A_MINUTE, number: 1});
const listener = (new GamesWonUnderAMinute()).forGame(gameId, userId);
listener.onPlayerWon(new PlayerWon(Random.id(5), userId, 5, 0));
assertGamesWonUnderAMinuteUserAchievementNumberEquals(1);
});
encrypt(message) {
let ts;
if (isNaN(TimeSync.serverOffset())) {
ts = new Date();
} else {
ts = new Date(Date.now() + TimeSync.serverOffset());
}
const data = new TextEncoder('UTF-8').encode(EJSON.stringify({
_id: message._id,
text: message.msg,
userId: this.userId,
ack: Random.id((Random.fraction() + 1) * 20),
ts,
}));
const enc = this.encryptText(data);
return enc;
}
function getCouponRec(template){
const coupon = {
_id:Random.id(),
itemId:template.find('#select-item').value,
discount:template.find('#coupon-discount').value,
count:parseInt(template.find('#coupon-count').value)
};
if (checkNuber(coupon.discount) && checkNuber(coupon.count)) {return coupon;}
else {return false;}
}
encryptText(data) {
if (!_.isObject(data)) {
data = new TextEncoder('UTF-8').encode(EJSON.stringify({ text: data, ack: Random.id((Random.fraction() + 1) * 20) }));
}
const iv = crypto.getRandomValues(new Uint8Array(12));
return RocketChat.OTR.crypto.encrypt({
name: 'AES-GCM',
iv,
}, this.sessionKey, data).then((cipherText) => {
cipherText = new Uint8Array(cipherText);
const output = new Uint8Array(iv.length + cipherText.length);
output.set(iv, 0);
output.set(cipherText, iv.length);
return EJSON.stringify(output);
}).catch(() => {
throw new Meteor.Error('encryption-error', 'Encryption error.');
});
}
keys.forEach((key) => {
RocketChat.Notifications.notifyUser(Meteor.userId(), 'message', {
_id: Random.id(),
rid: item.rid,
ts: new Date,
msg: TAPi18n.__(Object.keys(key)[0], {
postProcess: 'sprintf',
sprintf: [key[Object.keys(key)[0]]],
}, user.language),
});
});
before(() => {
userId = Random.id();
publicCircuit = Factory.create('circuit');
privateCircuit = Factory.create('circuit', { userId });
_.times(3, () => {
Factory.create('symbol', { cid: publicCircuit._id });
// TODO get rid of userId, https://github.com/meteor/symbols/pull/49
Factory.create('symbol', { cid: privateCircuit._id, userId });
});
});
export function paymentMethod(doc) {
return {
...doc,
processor: doc.processor ? doc.processor : randomProcessor(),
storedCard: doc.storedCard ? doc.storedCard : "4242424242424242",
transactionId: doc.transactionId ? doc.transactionId : Random.id(),
status: doc.status ? doc.status : randomStatus(),
mode: doc.mode ? doc.mode : randomMode(),
authorization: "auth field",
amount: doc.amount ? doc.amount : faker.commerce.price()
};
}
context('given a program', function () {
const userId = Random.id();
let programId;
beforeEach(function () {
categoryId = Factory.create('category')._id;
programId = Factory.create('program', { userId, categoryId })._id;
});
describe('program', function () {
it.skip('returns associated program', function () {
const selection = Factory.create('selection', {userId, programId});
// TODO: solve timing issues here
expect(selection).to.exist;
expect(selection.program()).to.exist;
expect(selection.program()._id).to.equal(programid);
});
});
describe('user', function () {
it.skip('returns associated user', function () {
// TODO: implement
});
});
describe('validations', function () {
it.skip('checks dangling user id', function () {
// TODO: implement
});
it.skip('checks dangling program id', function () {
// TODO: implement
});
});
describe('selections.choose', function () {
it('creates a new selection', function () {
const chooseSelection = Meteor.server.method_handlers['selections.choose'];
const invocation = { userId };
chooseSelection.apply(invocation, [programId, 'Yes'])
expect(Selections.find().count()).to.equal(1);
});
it('rejects a new selection if not logged in', function () {
const chooseSelection = Meteor.server.method_handlers['selections.choose'];
const invocation = { userId: null };
expect(chooseSelection.apply.bind(chooseSelection, {
userId: null
}, [programId, 'Yes'])).to.throw('not-authorized');
expect(Selections.find().count()).to.equal(0);
});
});
});
renderer.codespan = function(text) {
text = `<code class="code-colors inline">${ text }</code>`;
if (_.isString(msg)) {
return text;
}
const token = `=!=${ Random.id() }=!=`;
msg.tokens.push({
token,
text,
});
return token;
};
items: function () {
const product = addProduct();
const variant = Products.findOne({ ancestors: [product._id] });
const childVariants = Products.find({ ancestors: [
product._id, variant._id
] }).fetch();
const selectedOption = Random.choice(childVariants);
const product2 = addProduct();
const variant2 = Products.findOne({ ancestors: [product2._id] });
const childVariants2 = Products.find({ ancestors: [
product2._id, variant2._id
] }).fetch();
const selectedOption2 = Random.choice(childVariants2);
return [{
_id: itemIdOne,
title: "firstItem",
shopId: product.shopId,
productId: product._id,
quantity: 1,
product: product,
variants: selectedOption,
workflow: {
status: "new"
}
}, {
_id: itemIdTwo,
title: "secondItem",
shopId: product2.shopId,
productId: product2._id,
quantity: 1,
product: product2,
variants: selectedOption2,
workflow: {
status: "new"
}
}];
},
beforeEach(() => {
// Clear
Lists.remove({});
Todos.remove({});
// Create a list and a todo in that list
listId = Factory.create('list')._id;
todoId = Factory.create('todo', { listId })._id;
// Create throwaway list, since the last public list can't be made private
otherListId = Factory.create('list')._id;
// Generate a 'user'
userId = Random.id();
});
describe('methods', () => {
const userId = Random.id();
let groupId;
beforeEach(() => {
Groups.remove({});
const now = new Date();
groupId = Groups.insert({
domain: 'pdrummond',
name: 'test',
createdAt: now,
updatedAt: now,
owner: userId,
username: '******'
});
});
it('can update own group', () => {
const method = Meteor.server.method_handlers['groups.update'];
// Set up a fake method invocation that looks like what the method expects
const invocation = { userId };
// Run the method with `this` set to the fake invocation
method.apply(invocation, [groupId, 'pdrummond-changed', 'test-changed']);
var group = Groups.findOne(groupId);
console.log("GROUP: " + JSON.stringify(group, null, 4));
expect(group.domain).to.equal("pdrummond-changed");
expect(group.name).to.equal("test-changed");
expect(group.updatedAt.getTime()).to.not.equal(group.createdAt.getTime());
});
it('can delete owned group', () => {
// Find the internal implementation of the group method so we can
// test it in isolation
const deleteGroup = Meteor.server.method_handlers['groups.remove'];
// Set up a fake method invocation that looks like what the method expects
const invocation = { userId };
// Run the method with `this` set to the fake invocation
deleteGroup.apply(invocation, [groupId]);
// Verify that the method does what we expected
assert.equal(Groups.find().count(), 0);
});
});