Aaron Bohy
c4bddd6ba2
After each test, a check is done that there is no leftover in the DOM. If there are, the suite fails, but there is no indication on the test that left elements in the DOM. This commit logs that missing information. We also stop dumping the DOM when this happens, as it was rather creating noise than providing useful information (the remaining elements are still logged though). closes odoo/odoo#58806 X-original-commit: 598d036b59012af0a95894d759fe3b6276fc8ccb Signed-off-by: Christophe Monniez (moc) <moc@odoo.com> Signed-off-by: Aaron Bohy (aab) <aab@odoo.com>
249 lines
8.4 KiB
JavaScript
249 lines
8.4 KiB
JavaScript
(function() {
|
|
"use strict";
|
|
|
|
/**
|
|
* QUnit Config
|
|
*
|
|
* The Odoo javascript test framework is based on QUnit (http://qunitjs.com/).
|
|
* This file is necessary to setup Qunit and to prepare its interactions with
|
|
* Odoo. It has to be loaded before any tests are defined.
|
|
*
|
|
* Note that it is not an Odoo module, because we want this code to be executed
|
|
* as soon as possible, not whenever the Odoo module system feels like it.
|
|
*/
|
|
|
|
|
|
/**
|
|
* This configuration variable is not strictly necessary, but it ensures more
|
|
* safety for asynchronous tests. With it, each test has to explicitely tell
|
|
* QUnit how many assertion it expects, otherwise the test will fail.
|
|
*/
|
|
QUnit.config.requireExpects = true;
|
|
|
|
/**
|
|
* not important in normal mode, but in debug=assets, the files are loaded
|
|
* asynchroneously, which can lead to various issues with QUnit... Notice that
|
|
* this is done outside of odoo modules, otherwise the setting would not take
|
|
* effect on time.
|
|
*/
|
|
QUnit.config.autostart = false;
|
|
|
|
/**
|
|
* A test timeout of 1 min, before an async test is considered failed.
|
|
*/
|
|
QUnit.config.testTimeout = 1 * 60 * 1000;
|
|
|
|
/**
|
|
* Hide passed tests by default in the QUnit page
|
|
*/
|
|
QUnit.config.hidepassed = (window.location.href.match(/[?&]testId=/) === null);
|
|
|
|
var sortButtonAppended = false;
|
|
|
|
/**
|
|
* If we want to log several errors, we have to log all of them at once, as
|
|
* browser_js is closed as soon as an error is logged.
|
|
*/
|
|
const errorMessages = [];
|
|
/**
|
|
* List of elements tolerated in the body after a test. The property "keep"
|
|
* prevents the element from being removed (typically: qunit suite elements).
|
|
*/
|
|
const validElements = [
|
|
// always in the body:
|
|
{ tagName: 'DIV', attr: 'id', value: 'qunit', keep: true },
|
|
{ tagName: 'DIV', attr: 'id', value: 'qunit-fixture', keep: true },
|
|
// shouldn't be in the body after a test but are tolerated:
|
|
{ tagName: 'SCRIPT', attr: 'id', value: '' },
|
|
{ tagName: 'DIV', attr: 'className', value: 'o_notification_manager' },
|
|
{ tagName: 'DIV', attr: 'className', value: 'tooltip fade bs-tooltip-auto' },
|
|
{ tagName: 'DIV', attr: 'className', value: 'tooltip fade bs-tooltip-auto show' },
|
|
{ tagName: 'SPAN', attr: 'className', value: 'select2-hidden-accessible' },
|
|
// Due to a Document Kanban bug (already present in 12.0)
|
|
{ tagName: 'DIV', attr: 'className', value: 'ui-helper-hidden-accessible' },
|
|
{ tagName: 'UL', attr: 'className', value: 'ui-menu ui-widget ui-widget-content ui-autocomplete ui-front' },
|
|
];
|
|
|
|
/**
|
|
* Waits for the module system to end processing the JS modules, so that we can
|
|
* make the suite fail if some modules couldn't be loaded (e.g. because of a
|
|
* missing dependency).
|
|
*
|
|
* @returns {Promise<boolean>}
|
|
*/
|
|
async function checkModules() {
|
|
// do not mark the suite as successful already, as we still need to ensure
|
|
// that all modules have been correctly loaded
|
|
$('#qunit-banner').removeClass('qunit-pass');
|
|
const $modulesAlert = $('<div>')
|
|
.addClass('alert alert-info')
|
|
.text('Waiting for modules check...');
|
|
$modulesAlert.appendTo('#qunit');
|
|
|
|
// wait for the module system to end processing the JS modules
|
|
await odoo.__DEBUG__.didLogInfo;
|
|
|
|
const info = odoo.__DEBUG__.jsModules;
|
|
if (info.missing.length || info.failed.length) {
|
|
$('#qunit-banner').addClass('qunit-fail');
|
|
$modulesAlert.toggleClass('alert-info alert-danger');
|
|
const failingModules = info.missing.concat(info.failed);
|
|
const error = `Some modules couldn't be started: ${failingModules.join(', ')}.`;
|
|
$modulesAlert.text(error);
|
|
errorMessages.unshift(error);
|
|
return false;
|
|
} else {
|
|
$modulesAlert.toggleClass('alert-info alert-success');
|
|
$modulesAlert.text('All modules have been correctly loaded.');
|
|
$('#qunit-banner').addClass('qunit-pass');
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This is the way the testing framework knows that tests passed or failed. It
|
|
* only look in the phantomJS console and check if there is a ok or an error.
|
|
*
|
|
* Someday, we should devise a safer strategy...
|
|
*/
|
|
QUnit.done(async function (result) {
|
|
const allModulesLoaded = await checkModules();
|
|
if (result.failed) {
|
|
errorMessages.push(`${result.failed} / ${result.total} tests failed.`);
|
|
}
|
|
if (!result.failed && allModulesLoaded) {
|
|
console.log('test successful');
|
|
} else {
|
|
console.error(errorMessages.join('\n'));
|
|
}
|
|
|
|
if (!sortButtonAppended) {
|
|
_addSortButton();
|
|
}
|
|
});
|
|
|
|
/**
|
|
* This logs various data in the console, which will be available in the log
|
|
* .txt file generated by the runbot.
|
|
*/
|
|
QUnit.log(function (result) {
|
|
if (!result.result) {
|
|
var info = '"QUnit test failed: "' + result.module + ' > ' + result.name + '"';
|
|
info += ' [message: "' + result.message + '"';
|
|
if (result.actual !== null) {
|
|
info += ', actual: "' + result.actual + '"';
|
|
}
|
|
if (result.expected !== null) {
|
|
info += ', expected: "' + result.expected + '"';
|
|
}
|
|
info += ']';
|
|
errorMessages.push(info);
|
|
}
|
|
});
|
|
|
|
/**
|
|
* This is done mostly for the .txt log file generated by the runbot.
|
|
*/
|
|
QUnit.moduleDone(function(result) {
|
|
if (!result.failed) {
|
|
console.log('"' + result.name + '"', "passed", result.total, "tests.");
|
|
} else {
|
|
console.log('"' + result.name + '"',
|
|
"failed", result.failed,
|
|
"tests out of", result.total, ".");
|
|
}
|
|
|
|
});
|
|
|
|
/**
|
|
* After each test, we check that there is no leftover in the DOM.
|
|
*
|
|
* Note: this event is not QUnit standard, we added it for this specific use case.
|
|
* As a payload, an object with keys 'moduleName' and 'testName' is provided. It
|
|
* is used to indicate the test that left elements in the DOM, when it happens.
|
|
*/
|
|
QUnit.on('OdooAfterTestHook', function (info) {
|
|
const toRemove = [];
|
|
// check for leftover elements in the body
|
|
for (const bodyChild of document.body.children) {
|
|
const tolerated = validElements.find((e) =>
|
|
e.tagName === bodyChild.tagName && bodyChild[e.attr] === e.value
|
|
);
|
|
if (!tolerated) {
|
|
console.error(`Test ${info.moduleName} > ${info.testName}`);
|
|
console.error('Body still contains undesirable elements:' +
|
|
'\nInvalid element:\n' + bodyChild.outerHTML);
|
|
QUnit.pushFailure(`Body still contains undesirable elements`);
|
|
}
|
|
if (!tolerated || !tolerated.keep) {
|
|
toRemove.push(bodyChild);
|
|
}
|
|
}
|
|
|
|
// check for leftovers in #qunit-fixture
|
|
const qunitFixture = document.getElementById('qunit-fixture');
|
|
if (qunitFixture.children.length) {
|
|
// console.error('#qunit-fixture still contains elements:' +
|
|
// '\n#qunit-fixture HTML:\n' + qunitFixture.outerHTML);
|
|
// QUnit.pushFailure(`#qunit-fixture still contains elements`);
|
|
toRemove.push(...qunitFixture.children);
|
|
}
|
|
|
|
// remove unwanted elements if not in debug
|
|
if (!document.body.classList.contains('debug')) {
|
|
for (const el of toRemove) {
|
|
el.remove();
|
|
}
|
|
}
|
|
});
|
|
|
|
/**
|
|
* Add a sort button on top of the QUnit result page, so we can see which tests
|
|
* take the most time.
|
|
*/
|
|
function _addSortButton() {
|
|
sortButtonAppended = true;
|
|
var $sort = $('<label> sort by time (desc)</label>').css({float: 'right'});
|
|
$('h2#qunit-userAgent').append($sort);
|
|
$sort.click(function() {
|
|
var $ol = $('ol#qunit-tests');
|
|
var $results = $ol.children('li').get();
|
|
$results.sort(function (a, b) {
|
|
var timeA = Number($(a).find('span.runtime').first().text().split(" ")[0]);
|
|
var timeB = Number($(b).find('span.runtime').first().text().split(" ")[0]);
|
|
if (timeA < timeB) {
|
|
return 1;
|
|
} else if (timeA > timeB) {
|
|
return -1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
});
|
|
$.each($results, function(idx, $itm) { $ol.append($itm); });
|
|
|
|
});
|
|
}
|
|
|
|
/**
|
|
* We add here a 'fail fast' feature: we often want to stop the test suite after
|
|
* the first failed test. This is also useful for the runbot test suites.
|
|
*/
|
|
|
|
QUnit.config.urlConfig.push({
|
|
id: "failfast",
|
|
label: "Fail Fast",
|
|
tooltip: "Stop the test suite immediately after the first failed test."
|
|
});
|
|
|
|
QUnit.begin(function() {
|
|
if (QUnit.config.failfast) {
|
|
QUnit.testDone(function(details) {
|
|
if (details.failed > 0) {
|
|
QUnit.config.queue.length = 0;
|
|
}
|
|
});
|
|
}
|
|
});
|
|
|
|
})();
|