1ae64793fa
Part of task 1896658 Co-authored-by: Aaron Bohy <aab@odoo.com> Co-authored-by: Christophe Matthieu <chm@odoo.com> Co-authored-by: Mathieu Duckerts-Antoine <dam@odoo.com> Co-authored-by: David Monjoie <dmo@odoo.com> Co-authored-by: Martin Geubelle <mge@odoo.com> Co-authored-by: svs-odoo <svs@odoo.com> Co-authored-by: Vincent Schippefilt <vsc@odoo.com>
844 lines
33 KiB
JavaScript
844 lines
33 KiB
JavaScript
odoo.define('mail.discuss_moderation_tests', function (require) {
|
|
"use strict";
|
|
|
|
var Thread = require('mail.model.Thread');
|
|
var mailTestUtils = require('mail.testUtils');
|
|
|
|
var testUtils = require('web.test_utils');
|
|
|
|
var createDiscuss = mailTestUtils.createDiscuss;
|
|
|
|
QUnit.module('mail', {}, function () {
|
|
QUnit.module('Discuss (Moderation)', {
|
|
beforeEach: function () {
|
|
// patch _.debounce and _.throttle to be fast and synchronous
|
|
this.underscoreDebounce = _.debounce;
|
|
this.underscoreThrottle = _.throttle;
|
|
_.debounce = _.identity;
|
|
_.throttle = _.identity;
|
|
|
|
this.data = {
|
|
'mail.message': {
|
|
fields: {
|
|
body: {
|
|
string: "Contents",
|
|
type: 'html',
|
|
},
|
|
author_id: {
|
|
string: "Author",
|
|
relation: 'res.partner',
|
|
},
|
|
channel_ids: {
|
|
string: "Channels",
|
|
type: 'many2many',
|
|
relation: 'mail.channel',
|
|
},
|
|
starred: {
|
|
string: "Starred",
|
|
type: 'boolean',
|
|
},
|
|
needaction: {
|
|
string: "Need Action",
|
|
type: 'boolean',
|
|
},
|
|
starred_partner_ids: {
|
|
string: "partner ids",
|
|
type: 'integer',
|
|
},
|
|
model: {
|
|
string: "Related Document model",
|
|
type: 'char',
|
|
},
|
|
res_id: {
|
|
string: "Related Document ID",
|
|
type: 'integer',
|
|
},
|
|
need_moderation: {
|
|
string: "Need moderation",
|
|
type: 'boolean',
|
|
},
|
|
moderation_status: {
|
|
string: "Moderation Status",
|
|
type: 'integer',
|
|
selection: [
|
|
['pending_moderation', 'Pending Moderation'],
|
|
['accepted', 'Accepted'],
|
|
['rejected', 'Rejected']
|
|
],
|
|
},
|
|
},
|
|
},
|
|
};
|
|
this.services = mailTestUtils.getMailServices();
|
|
},
|
|
afterEach: function () {
|
|
// unpatch _.debounce and _.throttle
|
|
_.debounce = this.underscoreDebounce;
|
|
_.throttle = this.underscoreThrottle;
|
|
}
|
|
});
|
|
|
|
QUnit.test('moderator: display moderation box', function (assert) {
|
|
assert.expect(1);
|
|
var done = assert.async();
|
|
|
|
this.data.initMessaging = {
|
|
channel_slots: {
|
|
channel_channel: [{
|
|
id: 1,
|
|
channel_type: "channel",
|
|
name: "general",
|
|
moderation: true,
|
|
}],
|
|
},
|
|
is_moderator: true,
|
|
};
|
|
|
|
createDiscuss({
|
|
id: 1,
|
|
context: {},
|
|
params: {},
|
|
data: this.data,
|
|
services: this.services,
|
|
})
|
|
.then(function (discuss) {
|
|
var moderationBoxSelector = '.o_mail_discuss_item' +
|
|
'[data-thread-id="mailbox_moderation"]';
|
|
assert.containsOnce(discuss, moderationBoxSelector,
|
|
"there should be a moderation mailbox");
|
|
discuss.destroy();
|
|
done();
|
|
});
|
|
});
|
|
|
|
QUnit.test('moderator: moderated channel with pending moderation message', function (assert) {
|
|
assert.expect(33);
|
|
var done = assert.async();
|
|
|
|
this.data.initMessaging = {
|
|
channel_slots: {
|
|
channel_channel: [{
|
|
id: 1,
|
|
channel_type: "channel",
|
|
name: "general",
|
|
moderation: true,
|
|
}],
|
|
},
|
|
is_moderator: true,
|
|
moderation_counter: 1,
|
|
moderation_channel_ids: [1],
|
|
};
|
|
this.data['mail.message'].records = [{
|
|
author_id: [2, "Someone"],
|
|
body: "<p>test</p>",
|
|
id: 100,
|
|
model: 'mail.channel',
|
|
moderation_status: 'pending_moderation',
|
|
need_moderation: true,
|
|
res_id: 1,
|
|
}];
|
|
|
|
createDiscuss({
|
|
id: 1,
|
|
context: {},
|
|
params: {},
|
|
data: this.data,
|
|
services: this.services,
|
|
})
|
|
.then(async function (discuss) {
|
|
var $moderationBox = discuss.$(
|
|
'.o_mail_discuss_item' +
|
|
'[data-thread-id="mailbox_moderation"]');
|
|
var $mailboxCounter = $moderationBox.find('.o_mail_sidebar_needaction.badge');
|
|
assert.strictEqual($mailboxCounter.length, 1,
|
|
"there should be a counter next to the moderation mailbox in the sidebar");
|
|
assert.strictEqual($mailboxCounter.text().trim(), "1",
|
|
"the mailbox counter of the moderation mailbox should display '1'");
|
|
|
|
// 1. go to moderation mailbox
|
|
await testUtils.dom.click($moderationBox);
|
|
var $message = discuss.$('.o_thread_message');
|
|
// check message
|
|
assert.strictEqual($message.length, 1,
|
|
"there should be one message in the moderation box");
|
|
assert.strictEqual($message.data('message-id'), 100,
|
|
"this message pending moderation should have correct ID");
|
|
assert.strictEqual($message.find('a[data-oe-id="1"]').text(), "#general",
|
|
"the message pending moderation should have correct origin as its linked document");
|
|
assert.strictEqual($message.find('.moderation_checkbox').length, 1,
|
|
"there should be a moderation checkbox next to the message");
|
|
assert.notOk($message.find('.moderation_checkbox').prop('checked'), false,
|
|
"the moderation checkbox should be unchecked by default");
|
|
// check moderation actions next to message
|
|
assert.containsN(discuss, '.o_thread_message_moderation', 5,
|
|
"there should be 5 contextual moderation decisions next to the message");
|
|
assert.containsOnce(discuss, '.o_thread_message_moderation[data-decision="accept"]',
|
|
"there should be a contextual moderation decision to accept the message");
|
|
assert.containsOnce(discuss, '.o_thread_message_moderation[data-decision="reject"]',
|
|
"there should be a contextual moderation decision to reject the message");
|
|
assert.containsOnce(discuss, '.o_thread_message_moderation[data-decision="discard"]',
|
|
"there should be a contextual moderation decision to discard the message");
|
|
assert.containsOnce(discuss, '.o_thread_message_moderation[data-decision="allow"]',
|
|
"there should be a contextual moderation decision to allow the user of the message)");
|
|
assert.containsOnce(discuss, '.o_thread_message_moderation[data-decision="ban"]',
|
|
"there should be a contextual moderation decision to ban the user of the message");
|
|
|
|
// check select all (enabled) / unselect all (disabled) buttons
|
|
assert.strictEqual($('.o_mail_discuss_button_select_all').length, 1,
|
|
"there should be a 'Select All' button in the control panel");
|
|
assert.doesNotHaveClass($('.o_mail_discuss_button_select_all'), 'disabled',
|
|
"the 'Select All' button should not be disabled");
|
|
assert.strictEqual($('.o_mail_discuss_button_unselect_all').length, 1,
|
|
"there should be a 'Unselect All' button in the control panel");
|
|
assert.hasClass($('.o_mail_discuss_button_unselect_all'),'disabled',
|
|
"the 'Unselect All' button should be disabled");
|
|
// check moderate all buttons (invisible)
|
|
var moderateAllSelector = '.o_mail_discuss_button_moderate_all';
|
|
assert.strictEqual($(moderateAllSelector).length, 3,
|
|
"there should be 3 buttons to moderate selected messages in the control panel");
|
|
assert.strictEqual($(moderateAllSelector + '[data-decision="accept"]').length, 1,
|
|
"there should one moderate button to accept messages pending moderation");
|
|
assert.hasClass($(moderateAllSelector + '[data-decision="accept"]'),'d-none',
|
|
'the moderate button "Accept" should be invisible by default');
|
|
assert.strictEqual($(moderateAllSelector + '[data-decision="reject"]').length, 1,
|
|
"there should one moderate button to reject messages pending moderation");
|
|
assert.hasClass($(moderateAllSelector + '[data-decision="reject"]'),'d-none',
|
|
'the moderate button "Reject" should be invisible by default');
|
|
assert.strictEqual($(moderateAllSelector + '[data-decision="discard"]').length, 1,
|
|
"there should one moderate button to discard messages pending moderation");
|
|
assert.hasClass($(moderateAllSelector + '[data-decision="discard"]'),'d-none',
|
|
'the moderate button "Discard" should be invisible by default');
|
|
|
|
// click on message moderation checkbox
|
|
await testUtils.dom.click($message.find('.moderation_checkbox'));
|
|
assert.ok($message.find('.moderation_checkbox').prop('checked'),
|
|
"the moderation checkbox should become checked after click");
|
|
// check select all (disabled) / unselect all buttons (enabled)
|
|
assert.hasClass($('.o_mail_discuss_button_select_all'),'disabled',
|
|
"the 'Select All' button should be disabled");
|
|
assert.doesNotHaveClass($('.o_mail_discuss_button_unselect_all'), 'disabled',
|
|
"the 'Unselect All' button should not be disabled");
|
|
// check moderate all buttons updated (visible)
|
|
assert.doesNotHaveClass($(moderateAllSelector + '[data-decision="accept"]'), 'd-none',
|
|
'the moderate button "Accept" should become visible');
|
|
assert.doesNotHaveClass($(moderateAllSelector + '[data-decision="reject"]'), 'd-none',
|
|
'the moderate button "Reject" should become visible');
|
|
assert.doesNotHaveClass($(moderateAllSelector + '[data-decision="discard"]'), 'd-none',
|
|
'the moderate button "Discard" should become visible');
|
|
|
|
// 2. go to channel 'general'
|
|
await testUtils.dom.click(discuss.$('.o_mail_discuss_item[data-thread-id="1"]'));
|
|
$message = discuss.$('.o_thread_message');
|
|
// check correct message
|
|
assert.strictEqual($message.length, 1,
|
|
"there should be one message in the general channel");
|
|
assert.strictEqual($message.data('message-id'), 100,
|
|
"this message should have correct ID");
|
|
assert.notOk($message.find('.moderation_checkbox').prop('checked'),
|
|
"the moderation checkbox should be unchecked by default");
|
|
|
|
// don't check moderation actions visibility, since it is similar to moderation box.
|
|
discuss.destroy();
|
|
done();
|
|
});
|
|
});
|
|
|
|
QUnit.test('moderator: accept pending moderation message', function (assert) {
|
|
assert.expect(12);
|
|
var done = assert.async();
|
|
|
|
this.data.initMessaging = {
|
|
channel_slots: {
|
|
channel_channel: [{
|
|
id: 1,
|
|
channel_type: "channel",
|
|
name: "general",
|
|
moderation: true,
|
|
}],
|
|
},
|
|
is_moderator: true,
|
|
moderation_counter: 1,
|
|
moderation_channel_ids: [1],
|
|
};
|
|
this.data['mail.message'].records = [{
|
|
author_id: [2, "Someone"],
|
|
body: "<p>test</p>",
|
|
channel_ids: [],
|
|
id: 100,
|
|
model: 'mail.channel',
|
|
moderation_status: 'pending_moderation',
|
|
need_moderation: true,
|
|
res_id: 1,
|
|
}];
|
|
|
|
createDiscuss({
|
|
id: 1,
|
|
context: {},
|
|
params: {},
|
|
data: this.data,
|
|
services: this.services,
|
|
mockRPC: function (route, args) {
|
|
if (args.method === 'moderate') {
|
|
assert.step('moderate');
|
|
var messageIDs = args.args[0];
|
|
var decision = args.args[1];
|
|
assert.strictEqual(messageIDs.length, 1, "should moderate one message");
|
|
assert.strictEqual(messageIDs[0], 100, "should moderate message with ID 100");
|
|
assert.strictEqual(decision, 'accept', "should accept the message");
|
|
}
|
|
return this._super.apply(this, arguments);
|
|
},
|
|
})
|
|
.then(async function (discuss) {
|
|
// 1. go to moderation box
|
|
var $moderationBox = discuss.$(
|
|
'.o_mail_discuss_item' +
|
|
'[data-thread-id="mailbox_moderation"]');
|
|
await testUtils.dom.click($moderationBox);
|
|
// check there is a message to moderate
|
|
var $message = discuss.$('.o_thread_message');
|
|
assert.strictEqual($message.length, 1,
|
|
"there should be one message in the moderation box");
|
|
assert.strictEqual($message.data('message-id'), 100,
|
|
"this message should have correct ID");
|
|
assert.strictEqual($message.find('.moderation_checkbox').length, 1,
|
|
"the message should have a moderation checkbox");
|
|
// accept the message pending moderation
|
|
await testUtils.dom.click(discuss.$('.o_thread_message_moderation[data-decision="accept"]'));
|
|
assert.verifySteps(['moderate']);
|
|
|
|
// stop the fadeout animation and immediately remove the element
|
|
discuss.$('.o_thread_message').stop(false, true);
|
|
assert.containsNone(discuss, '.o_thread_message',
|
|
"should now have no message displayed in moderation box");
|
|
|
|
// 2. go to channel 'general'
|
|
await testUtils.dom.click(discuss.$('.o_mail_discuss_item[data-thread-id="1"]'));
|
|
$message = discuss.$('.o_thread_message');
|
|
// check message is there and has no moderate checkbox
|
|
assert.strictEqual($message.length, 1,
|
|
"there should be one message in the general channel");
|
|
assert.strictEqual($message.data('message-id'), 100,
|
|
"this message should have correct ID");
|
|
assert.strictEqual($message.find('.moderation_checkbox').length, 0,
|
|
"the message should not have any moderation checkbox");
|
|
|
|
discuss.destroy();
|
|
done();
|
|
});
|
|
});
|
|
|
|
QUnit.test('moderator: reject pending moderation message (reject with explanation)', function (assert) {
|
|
assert.expect(21);
|
|
var done = assert.async();
|
|
|
|
this.data.initMessaging = {
|
|
channel_slots: {
|
|
channel_channel: [{
|
|
id: 1,
|
|
channel_type: "channel",
|
|
name: "general",
|
|
moderation: true,
|
|
}],
|
|
},
|
|
is_moderator: true,
|
|
moderation_counter: 1,
|
|
moderation_channel_ids: [1],
|
|
};
|
|
this.data['mail.message'].records = [{
|
|
author_id: [2, "Someone"],
|
|
body: "<p>test</p>",
|
|
channel_ids: [],
|
|
id: 100,
|
|
model: 'mail.channel',
|
|
moderation_status: 'pending_moderation',
|
|
need_moderation: true,
|
|
res_id: 1,
|
|
}];
|
|
|
|
createDiscuss({
|
|
id: 1,
|
|
context: {},
|
|
params: {},
|
|
data: this.data,
|
|
services: this.services,
|
|
mockRPC: function (route, args) {
|
|
if (args.method === 'moderate') {
|
|
assert.step('moderate');
|
|
var messageIDs = args.args[0];
|
|
var decision = args.args[1];
|
|
var kwargs = args.kwargs;
|
|
assert.strictEqual(messageIDs.length, 1, "should moderate one message");
|
|
assert.strictEqual(messageIDs[0], 100, "should moderate message with ID 100");
|
|
assert.strictEqual(decision, 'reject', "should reject the message");
|
|
assert.strictEqual(kwargs.title, "Message Rejected",
|
|
"should have correct reject message title");
|
|
assert.strictEqual(kwargs.comment, "Your message was rejected by moderator.",
|
|
"should have correct reject message body / comment");
|
|
}
|
|
return this._super.apply(this, arguments);
|
|
},
|
|
})
|
|
.then(async function (discuss) {
|
|
// 1. go to moderation box
|
|
var $moderationBox = discuss.$(
|
|
'.o_mail_discuss_item' +
|
|
'[data-thread-id="mailbox_moderation"]');
|
|
await testUtils.dom.click($moderationBox);
|
|
// check there is a message to moderate
|
|
var $message = discuss.$('.o_thread_message');
|
|
assert.strictEqual($message.length, 1,
|
|
"there should be one message in the moderation box");
|
|
assert.strictEqual($message.data('message-id'), 100,
|
|
"this message should have correct ID");
|
|
assert.strictEqual($message.find('.moderation_checkbox').length, 1,
|
|
"the message should have a moderation checkbox");
|
|
// reject the message pending moderation
|
|
await testUtils.dom.click(discuss.$('.o_thread_message_moderation[data-decision="reject"]'));
|
|
|
|
// check reject dialog prompt
|
|
assert.strictEqual($('.modal-dialog').length, 1,
|
|
"a dialog should be prompt to the moderator on click reject");
|
|
assert.strictEqual($('.modal-title').text(), "Send explanation to author",
|
|
"dialog should have correct title");
|
|
var $messageTitle = $('.modal-body input[id="message_title"]');
|
|
assert.strictEqual($messageTitle.length, 1,
|
|
"should have a title of message for rejecting the message");
|
|
assert.hasAttrValue($messageTitle, 'placeholder', "Subject",
|
|
"message title for reject reason should have correct placeholder");
|
|
assert.strictEqual($messageTitle.val(), "Message Rejected",
|
|
"message title for reject reason should have correct default value");
|
|
var $messageBody = $('.modal-body textarea[id="reject_message"]');
|
|
assert.strictEqual($messageBody.length, 1,
|
|
"should have a body of message for rejecting the message");
|
|
assert.hasAttrValue($messageBody, 'placeholder', "Mail Body",
|
|
"message body for reject reason should have correct placeholder");
|
|
assert.strictEqual($messageBody.text(), "Your message was rejected by moderator.",
|
|
"message body for reject reason should have correct default text content");
|
|
assert.strictEqual($('.modal-footer button').text(), "Send",
|
|
"should have a send button on the reject dialog");
|
|
|
|
// send mesage
|
|
await testUtils.dom.click($('.modal-footer button'));
|
|
assert.verifySteps(['moderate']);
|
|
|
|
// // stop the fadeout animation and immediately remove the element
|
|
discuss.$('.o_thread_message').stop(false, true);
|
|
assert.containsNone(discuss, '.o_thread_message',
|
|
"should now have no message displayed in moderation box");
|
|
|
|
// 2. go to channel 'general'
|
|
await testUtils.dom.click(discuss.$('.o_mail_discuss_item[data-thread-id="1"]'));
|
|
assert.containsNone(discuss, '.o_thread_message')
|
|
|
|
discuss.destroy();
|
|
done();
|
|
});
|
|
});
|
|
|
|
QUnit.test('moderator: discard pending moderation message (reject without explanation)', function (assert) {
|
|
assert.expect(15);
|
|
var done = assert.async();
|
|
|
|
this.data.initMessaging = {
|
|
channel_slots: {
|
|
channel_channel: [{
|
|
id: 1,
|
|
channel_type: "channel",
|
|
name: "general",
|
|
moderation: true,
|
|
}],
|
|
},
|
|
is_moderator: true,
|
|
moderation_counter: 1,
|
|
moderation_channel_ids: [1],
|
|
};
|
|
this.data['mail.message'].records = [{
|
|
author_id: [2, "Someone"],
|
|
body: "<p>test</p>",
|
|
channel_ids: [],
|
|
id: 100,
|
|
model: 'mail.channel',
|
|
moderation_status: 'pending_moderation',
|
|
need_moderation: true,
|
|
res_id: 1,
|
|
}];
|
|
|
|
createDiscuss({
|
|
id: 1,
|
|
context: {},
|
|
params: {},
|
|
data: this.data,
|
|
services: this.services,
|
|
mockRPC: function (route, args) {
|
|
if (args.method === 'moderate') {
|
|
assert.step('moderate');
|
|
var messageIDs = args.args[0];
|
|
var decision = args.args[1];
|
|
assert.strictEqual(messageIDs.length, 1, "should moderate one message");
|
|
assert.strictEqual(messageIDs[0], 100, "should moderate message with ID 100");
|
|
assert.strictEqual(decision, 'discard', "should discard the message");
|
|
}
|
|
return this._super.apply(this, arguments);
|
|
},
|
|
})
|
|
.then(async function (discuss) {
|
|
// 1. go to moderation box
|
|
var $moderationBox = discuss.$(
|
|
'.o_mail_discuss_item' +
|
|
'[data-thread-id="mailbox_moderation"]');
|
|
await testUtils.dom.click($moderationBox);
|
|
// check there is a message to moderate
|
|
var $message = discuss.$('.o_thread_message');
|
|
assert.strictEqual($message.length, 1,
|
|
"there should be one message in the moderation box");
|
|
assert.strictEqual($message.data('message-id'), 100,
|
|
"this message should have correct ID");
|
|
assert.strictEqual($message.find('.moderation_checkbox').length, 1,
|
|
"the message should have a moderation checkbox");
|
|
// discard the message pending moderation
|
|
await testUtils.dom.click(discuss.$('.o_thread_message_moderation[data-decision="discard"]'));
|
|
|
|
// check discard dialog prompt
|
|
assert.strictEqual($('.modal-dialog').length, 1,
|
|
"a dialog should be prompt to the moderator on click discard");
|
|
assert.strictEqual($('.modal-body:first').text(),
|
|
"You are going to discard 1 message. Do you confirm the action?",
|
|
"should warn the user on discard action");
|
|
assert.strictEqual($('.modal-footer button').length, 2,
|
|
"should have two buttons in the footer of the dialog");
|
|
assert.strictEqual($('.modal-footer button.btn-primary').text(), "Ok",
|
|
"should have a confirm button in the dialog for discard");
|
|
assert.strictEqual($('.modal-footer button.btn-secondary').text(), "Cancel",
|
|
"should have a cancel button in the dialog for discard");
|
|
|
|
// discard mesage
|
|
await testUtils.dom.click($('.modal-footer button.btn-primary'));
|
|
assert.verifySteps(['moderate']);
|
|
|
|
// stop the fadeout animation and immediately remove the element
|
|
discuss.$('.o_thread_message').stop(false, true);
|
|
assert.containsNone(discuss, '.o_thread_message',
|
|
"should now have no message displayed in moderation box");
|
|
|
|
// 2. go to channel 'general'
|
|
await testUtils.dom.click(discuss.$('.o_mail_discuss_item[data-thread-id="1"]'));
|
|
assert.containsNone(discuss, '.o_thread_message')
|
|
|
|
discuss.destroy();
|
|
done();
|
|
});
|
|
});
|
|
|
|
QUnit.test('author: send message in moderated channel', function (assert) {
|
|
assert.expect(4);
|
|
var done = assert.async();
|
|
|
|
var messagePostDef = testUtils.makeTestPromise();
|
|
|
|
this.data.initMessaging = {
|
|
channel_slots: {
|
|
channel_channel: [{
|
|
id: 1,
|
|
channel_type: "channel",
|
|
name: "general",
|
|
moderation: true,
|
|
}],
|
|
},
|
|
};
|
|
|
|
var objectDiscuss;
|
|
createDiscuss({
|
|
id: 1,
|
|
context: {},
|
|
params: {},
|
|
data: this.data,
|
|
services: this.services,
|
|
mockRPC: async function (route, args) {
|
|
if (args.method === 'message_post') {
|
|
var message = {
|
|
id: 100,
|
|
author_id: [2, 'Someone'],
|
|
body: args.kwargs.body,
|
|
message_type: args.kwargs.message_type,
|
|
model: 'mail.channel',
|
|
moderation_status: 'pending_moderation',
|
|
res_id: 1,
|
|
};
|
|
var metaData = [undefined, 'res.partner'];
|
|
var notifData = {
|
|
type: 'author',
|
|
message: message,
|
|
};
|
|
var notification = [metaData, notifData];
|
|
objectDiscuss.call('bus_service', 'trigger', 'notification', [notification]);
|
|
await testUtils.nextTick();
|
|
|
|
messagePostDef.resolve();
|
|
return Promise.resolve(message.id);
|
|
}
|
|
return this._super.apply(this, arguments);
|
|
},
|
|
session: {
|
|
partner_id: 2,
|
|
},
|
|
})
|
|
.then(async function (discuss) {
|
|
objectDiscuss = discuss;
|
|
|
|
// go to channel 'general'
|
|
await testUtils.dom.click(discuss.$('.o_mail_discuss_item[data-thread-id="1"]'));
|
|
// post a message
|
|
discuss.$('.o_composer_input textarea').first().val("some text");
|
|
await testUtils.dom.click(discuss.$('.o_composer_send button'));
|
|
|
|
messagePostDef
|
|
.then(function () {
|
|
|
|
var $message = discuss.$('.o_thread_message');
|
|
assert.strictEqual($message.length, 1,
|
|
"should have a message in the thread");
|
|
assert.strictEqual($message.data('message-id'), 100,
|
|
"message should have ID returned from 'message_post'");
|
|
assert.strictEqual($message.find('.o_thread_author').text().trim(),
|
|
"Someone", "message should have correct author displayed name");
|
|
assert.strictEqual(discuss.$('.o_thread_icons i.text-danger').text(),
|
|
"Pending moderation", "the message should be pending moderation");
|
|
|
|
discuss.destroy();
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
QUnit.test('author: sent message accepted in moderated channel', function (assert) {
|
|
assert.expect(8);
|
|
var done = assert.async();
|
|
|
|
this.data.initMessaging = {
|
|
channel_slots: {
|
|
channel_channel: [{
|
|
id: 1,
|
|
channel_type: "channel",
|
|
name: "general",
|
|
moderation: true,
|
|
}],
|
|
},
|
|
};
|
|
|
|
this.data['mail.message'].records = [{
|
|
author_id: [2, "Someone"],
|
|
body: "<p>test</p>",
|
|
channel_ids: [],
|
|
id: 100,
|
|
model: 'mail.channel',
|
|
moderation_status: 'pending_moderation',
|
|
need_moderation: true,
|
|
res_id: 1,
|
|
}];
|
|
|
|
createDiscuss({
|
|
id: 1,
|
|
context: {},
|
|
params: {},
|
|
data: this.data,
|
|
services: this.services,
|
|
session: {
|
|
partner_id: 2,
|
|
},
|
|
})
|
|
.then(async function (discuss) {
|
|
|
|
// go to channel 'general'
|
|
await testUtils.dom.click(discuss.$('.o_mail_discuss_item[data-thread-id="1"]'));
|
|
// check message is pending
|
|
var $message = discuss.$('.o_thread_message');
|
|
assert.strictEqual($message.length, 1,
|
|
"should have a message in the thread");
|
|
assert.strictEqual($message.data('message-id'), 100,
|
|
"message should have ID returned from 'message_post'");
|
|
assert.strictEqual($message.find('.o_thread_author').text().trim(),
|
|
"Someone", "message should have correct author displayed name");
|
|
assert.strictEqual(discuss.$('.o_thread_icons i.text-danger').text(),
|
|
"Pending moderation", "the message should be pending moderation");
|
|
|
|
// simulate accepted message
|
|
var dbName = undefined; // useless for tests
|
|
var messageData = {
|
|
author_id: [2, "Someone"],
|
|
body: "<p>test</p>",
|
|
channel_ids: [],
|
|
id: 100,
|
|
model: 'mail.channel',
|
|
moderation_status: 'accepted'
|
|
};
|
|
var metaData = [dbName, 'mail.channel'];
|
|
var notification = [metaData, messageData];
|
|
discuss.call('bus_service', 'trigger', 'notification', [notification]);
|
|
await testUtils.nextTick();
|
|
// check message is accepted
|
|
$message = discuss.$('.o_thread_message');
|
|
assert.strictEqual($message.length, 1,
|
|
"should still have a message in the thread");
|
|
assert.strictEqual($message.data('message-id'), 100,
|
|
"message should still have ID returned from 'message_post'");
|
|
assert.strictEqual($message.find('.o_thread_author').text().trim(),
|
|
"Someone", "message should still have correct author displayed name");
|
|
assert.containsNone(discuss, '.o_thread_icons i.text-danger',
|
|
"the message should not be in pending moderation anymore");
|
|
|
|
discuss.destroy();
|
|
done();
|
|
});
|
|
});
|
|
|
|
QUnit.test('author: sent message rejected in moderated channel', function (assert) {
|
|
assert.expect(5);
|
|
var done = assert.async();
|
|
|
|
this.data.initMessaging = {
|
|
channel_slots: {
|
|
channel_channel: [{
|
|
id: 1,
|
|
channel_type: "channel",
|
|
name: "general",
|
|
moderation: true,
|
|
}],
|
|
},
|
|
};
|
|
|
|
this.data['mail.message'].records = [{
|
|
author_id: [2, "Someone"],
|
|
body: "<p>test</p>",
|
|
channel_ids: [],
|
|
id: 100,
|
|
model: 'mail.channel',
|
|
moderation_status: 'pending_moderation',
|
|
need_moderation: true,
|
|
res_id: 1,
|
|
}];
|
|
|
|
createDiscuss({
|
|
id: 1,
|
|
context: {},
|
|
params: {},
|
|
data: this.data,
|
|
services: this.services,
|
|
session: {
|
|
partner_id: 2,
|
|
},
|
|
})
|
|
.then(async function (discuss) {
|
|
|
|
// go to channel 'general'
|
|
await testUtils.dom.click(discuss.$('.o_mail_discuss_item[data-thread-id="1"]'));
|
|
// check message is pending
|
|
var $message = discuss.$('.o_thread_message');
|
|
assert.strictEqual($message.length, 1,
|
|
"should have a message in the thread");
|
|
assert.strictEqual($message.data('message-id'), 100,
|
|
"message should have ID returned from 'message_post'");
|
|
assert.strictEqual($message.find('.o_thread_author').text().trim(),
|
|
"Someone", "message should have correct author displayed name");
|
|
assert.strictEqual(discuss.$('.o_thread_icons i.text-danger').text(),
|
|
"Pending moderation", "the message should be pending moderation");
|
|
|
|
// simulate reject from moderator
|
|
var dbName = undefined; // useless for tests
|
|
var notifData = {
|
|
type: 'deletion',
|
|
message_ids: [100],
|
|
};
|
|
var metaData = [dbName, 'res.partner'];
|
|
var notification = [metaData, notifData];
|
|
discuss.call('bus_service', 'trigger', 'notification', [notification]);
|
|
await testUtils.nextTick();
|
|
// // check no message
|
|
assert.containsNone(discuss, '.o_thread_message',
|
|
"message should be removed from channel after reject");
|
|
|
|
discuss.destroy();
|
|
done();
|
|
});
|
|
});
|
|
|
|
QUnit.test('no crash when load-more fetching "accepted" message twice', async function (assert) {
|
|
// This tests requires discuss not loading more messages due to having less
|
|
// messages to fetch than available height. This justifies we simply do not
|
|
// patch FETCH_LIMIT to 1, as it would detect that more messages could fit
|
|
// the empty space (it behaviour is linked to "auto load more").
|
|
assert.expect(2);
|
|
|
|
var FETCH_LIMIT = Thread.prototype._FETCH_LIMIT;
|
|
// FETCH LIMIT + 30 should be enough to cover the whole available space in
|
|
// the thread of discuss app.
|
|
var messageData = [];
|
|
_.each(_.range(1, FETCH_LIMIT+31), function (num) {
|
|
messageData.push({
|
|
id: num,
|
|
body: "<p>test" + num + "</p>",
|
|
author_id: [100, "Someone"],
|
|
channel_ids: [1],
|
|
model: 'mail.channel',
|
|
res_id: 1,
|
|
moderation_status: 'accepted',
|
|
}
|
|
);
|
|
});
|
|
|
|
this.data['mail.message'].records = messageData;
|
|
|
|
this.data.initMessaging = {
|
|
channel_slots: {
|
|
channel_channel: [{
|
|
id: 1,
|
|
channel_type: "channel",
|
|
name: "general",
|
|
}],
|
|
},
|
|
};
|
|
var count = 0;
|
|
|
|
var discuss = await createDiscuss({
|
|
id: 1,
|
|
context: {},
|
|
params: {},
|
|
data: this.data,
|
|
services: this.services,
|
|
session: { partner_id: 3 },
|
|
mockRPC: function (route, args) {
|
|
if (args.method === 'message_fetch') {
|
|
count++;
|
|
if (count === 1) {
|
|
// inbox message_fetch
|
|
return Promise.resolve([]);
|
|
}
|
|
// general message_fetch
|
|
return Promise.resolve(messageData);
|
|
}
|
|
return this._super.apply(this, arguments);
|
|
},
|
|
});
|
|
|
|
var $general = discuss.$('.o_mail_discuss_sidebar')
|
|
.find('.o_mail_discuss_item[data-thread-id=1]');
|
|
assert.strictEqual($general.length, 1,
|
|
"should have the channel item with id 1");
|
|
assert.strictEqual($general.attr('title'), 'general',
|
|
"should have the title 'general'");
|
|
|
|
// click on general
|
|
await testUtils.dom.click($general);
|
|
|
|
// simulate search
|
|
discuss.trigger_up('search', {
|
|
domains: [['author_id', '=', 100]],
|
|
});
|
|
await testUtils.nextTick();
|
|
|
|
discuss.destroy();
|
|
});
|
|
|
|
});
|
|
});
|