[REF] web: adapt code after jQuery update

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>

4 files changed, 351 insertions, 293 deletions

diff --git a/addons/web/static/tests/core/concurrency_tests.js b/addons/web/static/tests/core/concurrency_tests.js
index 516ce6a1b8f..1e195fde67d 100644
--- a/addons/web/static/tests/core/concurrency_tests.js
+++ b/addons/web/static/tests/core/concurrency_tests.js
@@ -2,166 +2,197 @@ odoo.define('web.concurrency_tests', function (require) {
 "use strict";
 
 var concurrency = require('web.concurrency');
+var testUtils = require('web.test_utils');
+
+var makeTestPromise = testUtils.makeTestPromise;
+var makeTestPromiseWithAssert = testUtils.makeTestPromiseWithAssert;
 
 QUnit.module('core', {}, function () {
 
     QUnit.module('concurrency');
 
+    QUnit.test('mutex: simple scheduling', async function (assert) {
+        assert.expect(5);
+        var mutex = new concurrency.Mutex();
 
-    QUnit.test('mutex: simple scheduling', function (assert) {
-        assert.expect(6);
+        var prom1 = makeTestPromiseWithAssert(assert, 'prom1');
+        var prom2 = makeTestPromiseWithAssert(assert, 'prom2');
 
-        var m = new concurrency.Mutex();
+        mutex.exec(function () { return prom1; });
+        mutex.exec(function () { return prom2; });
 
-        var def1 = $.Deferred(),
-            def2 = $.Deferred();
+        assert.verifySteps([]);
 
-        var p1 = m.exec(function () { return def1; });
-        var p2 = m.exec(function () { return def2; });
+        await prom1.resolve();
 
-        assert.strictEqual(p1.state(), "pending");
-        assert.strictEqual(p2.state(), "pending");
+        assert.verifySteps(['ok prom1']);
 
-        def1.resolve();
-        assert.strictEqual(p1.state(), "resolved");
-        assert.strictEqual(p2.state(), "pending");
+        await prom2.resolve();
 
-        def2.resolve();
-        assert.strictEqual(p1.state(), "resolved");
-        assert.strictEqual(p2.state(), "resolved");
+        assert.verifySteps(['ok prom2']);
     });
 
-    QUnit.test('mutex: simpleScheduling2', function (assert) {
-        assert.expect(6);
+    QUnit.test('mutex: simpleScheduling2', async function (assert) {
+        assert.expect(5);
+        var mutex = new concurrency.Mutex();
+
+        var prom1 = makeTestPromiseWithAssert(assert, 'prom1');
+        var prom2 = makeTestPromiseWithAssert(assert, 'prom2');
 
-        var m = new concurrency.Mutex();
+        mutex.exec(function () { return prom1; });
+        mutex.exec(function () { return prom2; });
 
-        var def1 = $.Deferred(),
-            def2 = $.Deferred();
+        assert.verifySteps([]);
 
-        var p1 = m.exec(function() { return def1; });
-        var p2 = m.exec(function() { return def2; });
+        await prom2.resolve();
 
-        assert.strictEqual(p1.state(), "pending");
-        assert.strictEqual(p2.state(), "pending");
-        def2.resolve();
+        assert.verifySteps(['ok prom2']);
 
-        assert.strictEqual(p1.state(), "pending");
-        assert.strictEqual(p2.state(), "pending");
+        await prom1.resolve();
 
-        def1.resolve();
-        assert.strictEqual(p1.state(), "resolved");
-        assert.strictEqual(p2.state(), "resolved");
+        assert.verifySteps(['ok prom1']);
     });
 
-    QUnit.test('mutex: reject', function (assert) {
-        assert.expect(12);
+    QUnit.test('mutex: reject', async function (assert) {
+        assert.expect(7);
+        var mutex = new concurrency.Mutex();
 
-        var m = new concurrency.Mutex();
+        var prom1 = makeTestPromiseWithAssert(assert, 'prom1');
+        var prom2 = makeTestPromiseWithAssert(assert, 'prom2');
+        var prom3 = makeTestPromiseWithAssert(assert, 'prom3');
 
-        var def1 = $.Deferred(),
-            def2 = $.Deferred(),
-            def3 = $.Deferred();
+        mutex.exec(function () { return prom1; }).catch(function () {});
+        mutex.exec(function () { return prom2; }).catch(function () {});
+        mutex.exec(function () { return prom3; }).catch(function () {});
 
-        var p1 = m.exec(function() {return def1;});
-        var p2 = m.exec(function() {return def2;});
-        var p3 = m.exec(function() {return def3;});
+        assert.verifySteps([]);
 
-        assert.strictEqual(p1.state(), "pending");
-        assert.strictEqual(p2.state(), "pending");
-        assert.strictEqual(p3.state(), "pending");
+        prom1.resolve();
+        await testUtils.nextMicrotaskTick();
 
-        def1.resolve();
-        assert.strictEqual(p1.state(), "resolved");
-        assert.strictEqual(p2.state(), "pending");
-        assert.strictEqual(p3.state(), "pending");
+        assert.verifySteps(['ok prom1']);
 
-        def2.reject();
-        assert.strictEqual(p1.state(), "resolved");
-        assert.strictEqual(p2.state(), "rejected");
-        assert.strictEqual(p3.state(), "pending");
+        prom2.catch(function () {
+           assert.verifySteps(['ko prom2']);
+        });
+        prom2.reject({name: "sdkjfmqsjdfmsjkdfkljsdq"});
+        await testUtils.nextMicrotaskTick();
+
+        prom3.resolve();
+        await testUtils.nextMicrotaskTick();
 
-        def3.resolve();
-        assert.strictEqual(p1.state(), "resolved");
-        assert.strictEqual(p2.state(), "rejected");
-        assert.strictEqual(p3.state(), "resolved");
+        assert.verifySteps(['ok prom3']);
     });
 
-    QUnit.test('mutex: getUnlockedDef checks', function (assert) {
-        assert.expect(5);
+    QUnit.test('mutex: getUnlockedDef checks', async function (assert) {
+        assert.expect(9);
+
+        var mutex = new concurrency.Mutex();
 
-        var m = new concurrency.Mutex();
+        var prom1 = makeTestPromiseWithAssert(assert, 'prom1');
+        var prom2 = makeTestPromiseWithAssert(assert, 'prom2');
 
-        var def1 = $.Deferred();
-        var def2 = $.Deferred();
+        mutex.getUnlockedDef().then(function () {
+            assert.step('mutex unlocked (1)');
+        });
+
+        await testUtils.nextMicrotaskTick();
 
-        assert.strictEqual(m.getUnlockedDef().state(), "resolved");
+        assert.verifySteps(['mutex unlocked (1)']);
 
-        m.exec(function() { return def1; });
+        mutex.exec(function () { return prom1; });
+        await testUtils.nextMicrotaskTick();
 
-        var unlockedDef = m.getUnlockedDef();
+        mutex.getUnlockedDef().then(function () {
+            assert.step('mutex unlocked (2)');
+        });
 
-        assert.strictEqual(unlockedDef.state(), "pending");
+        assert.verifySteps([]);
 
-        m.exec(function() { return def2; });
+        mutex.exec(function () { return prom2; });
+        await testUtils.nextMicrotaskTick();
 
-        assert.strictEqual(unlockedDef.state(), "pending");
+        assert.verifySteps([]);
 
-        def1.resolve();
+        await prom1.resolve();
 
-        assert.strictEqual(unlockedDef.state(), "pending");
+        assert.verifySteps(['ok prom1']);
 
-        def2.resolve();
+        prom2.resolve();
+        await testUtils.nextTick();
 
-        assert.strictEqual(unlockedDef.state(), "resolved");
+        assert.verifySteps(['ok prom2', 'mutex unlocked (2)']);
     });
 
-    QUnit.test('DropPrevious: basic usecase', function (assert) {
-        assert.expect(5);
+    QUnit.test('DropPrevious: basic usecase', async function (assert) {
+        assert.expect(4);
+
+        var dp = new concurrency.DropPrevious();
+
+        var prom1 = makeTestPromise(assert, 'prom1');
+        var prom2 = makeTestPromise(assert, 'prom2');
+
+        dp.add(prom1).then(() => assert.step('should not go here'))
+                     .catch(()=> assert.step("rejected dp1"));
+        dp.add(prom2).then(() => assert.step("ok dp2"));
+
+        await testUtils.nextMicrotaskTick();
+        assert.verifySteps(['rejected dp1']);
+
+        prom2.resolve();
+        await testUtils.nextMicrotaskTick();
+
+        assert.verifySteps(['ok dp2']);
+    });
+
+    QUnit.test('DropPrevious: resolve first before last', async function (assert) {
+        assert.expect(4);
 
         var dp = new concurrency.DropPrevious();
 
-        var def1 = $.Deferred();
-        var def2 = $.Deferred();
+        var prom1 = makeTestPromise(assert, 'prom1');
+        var prom2 = makeTestPromise(assert, 'prom2');
 
-        var r1 = dp.add(def1);
+        dp.add(prom1).then(() => assert.step('should not go here'))
+                     .catch(()=> assert.step("rejected dp1"));
+        dp.add(prom2).then(() => assert.step("ok dp2"));
 
-        assert.strictEqual(r1.state(), "pending");
 
-        var r2 = dp.add(def2);
+        await testUtils.nextMicrotaskTick();
 
-        assert.strictEqual(r1.state(), "rejected");
-        assert.strictEqual(r2.state(), "pending");
+        assert.verifySteps(['rejected dp1']);
 
-        def2.resolve();
+        prom1.resolve();
+        prom2.resolve();
+        await testUtils.nextMicrotaskTick();
 
-        assert.strictEqual(r1.state(), "rejected");
-        assert.strictEqual(r2.state(), "resolved");
+        assert.verifySteps(['ok dp2']);
     });
 
-    QUnit.test('DropMisordered: resolve all correctly ordered, sync', function (assert) {
+    QUnit.test('DropMisordered: resolve all correctly ordered, sync', async function (assert) {
         assert.expect(1);
 
         var dm = new concurrency.DropMisordered(),
             flag = false;
 
-        var d1 = $.Deferred(),
-            d2 = $.Deferred();
+        var d1 = makeTestPromise();
+        var d2 = makeTestPromise();
 
         var r1 = dm.add(d1),
             r2 = dm.add(d2);
 
-        $.when(r1, r2).done(function () {
+        Promise.all([r1, r2]).then(function () {
             flag = true;
         });
 
         d1.resolve();
         d2.resolve();
+        await testUtils.nextTick();
 
         assert.ok(flag);
     });
 
-    QUnit.test("DropMisordered: don't resolve mis-ordered, sync", function (assert) {
+    QUnit.test("DropMisordered: don't resolve mis-ordered, sync", async function (assert) {
         assert.expect(4);
 
         var dm = new concurrency.DropMisordered(),
@@ -170,45 +201,47 @@ QUnit.module('core', {}, function () {
             fail1 = false,
             fail2 = false;
 
-        var d1 = $.Deferred(),
-            d2 = $.Deferred();
+        var d1 = makeTestPromise();
+        var d2 = makeTestPromise();
 
-        dm.add(d1).done(function () { done1 = true; })
-                    .fail(function () { fail1 = true; });
-        dm.add(d2).done(function () { done2 = true; })
-                    .fail(function () { fail2 = true; });
+        dm.add(d1).then(function () { done1 = true; })
+                    .catch(function () { fail1 = true; });
+        dm.add(d2).then(function () { done2 = true; })
+                    .catch(function () { fail2 = true; });
 
         d2.resolve();
         d1.resolve();
+        await testUtils.nextMicrotaskTick();
 
         // d1 is in limbo
         assert.ok(!done1);
         assert.ok(!fail1);
 
-        // d2 is resolved
+        // d2 is fulfilled
         assert.ok(done2);
         assert.ok(!fail2);
     });
 
-    QUnit.test('DropMisordered: fail mis-ordered flag, sync', function (assert) {
+    QUnit.test('DropMisordered: fail mis-ordered flag, sync', async function (assert) {
         assert.expect(4);
 
-        var dm = new concurrency.DropMisordered(true),
+        var dm = new concurrency.DropMisordered(true/* failMisordered */),
             done1 = false,
             done2 = false,
             fail1 = false,
             fail2 = false;
 
-        var d1 = $.Deferred(),
-            d2 = $.Deferred();
+        var d1 = makeTestPromise();
+        var d2 = makeTestPromise();
 
-        dm.add(d1).done(function () { done1 = true; })
-                    .fail(function () { fail1 = true; });
-        dm.add(d2).done(function () { done2 = true; })
-                    .fail(function () { fail2 = true; });
+        dm.add(d1).then(function () { done1 = true; })
+                    .catch(function () { fail1 = true; });
+        dm.add(d2).then(function () { done2 = true; })
+                    .catch(function () { fail2 = true; });
 
         d2.resolve();
         d1.resolve();
+        await testUtils.nextMicrotaskTick();
 
         // d1 is in limbo
         assert.ok(!done1);
@@ -225,8 +258,8 @@ QUnit.module('core', {}, function () {
 
         var dm = new concurrency.DropMisordered();
 
-        var d1 = $.Deferred(),
-            d2 = $.Deferred();
+        var d1 = makeTestPromise();
+        var d2 = makeTestPromise();
 
         var r1 = dm.add(d1),
             r2 = dm.add(d2);
@@ -234,7 +267,7 @@ QUnit.module('core', {}, function () {
         setTimeout(function () { d1.resolve(); }, 10);
         setTimeout(function () { d2.resolve(); }, 20);
 
-        $.when(r1, r2).done(function () {
+        Promise.all([r1, r2]).then(function () {
             assert.ok(true);
             done();
         });
@@ -248,13 +281,13 @@ QUnit.module('core', {}, function () {
             done1 = false, done2 = false,
             fail1 = false, fail2 = false;
 
-        var d1 = $.Deferred(),
-            d2 = $.Deferred();
+        var d1 = makeTestPromise();
+        var d2 = makeTestPromise();
 
-        dm.add(d1).done(function () { done1 = true; })
-                    .fail(function () { fail1 = true; });
-        dm.add(d2).done(function () { done2 = true; })
-                    .fail(function () { fail2 = true; });
+        dm.add(d1).then(function () { done1 = true; })
+                    .catch(function () { fail1 = true; });
+        dm.add(d2).then(function () { done2 = true; })
+                    .catch(function () { fail2 = true; });
 
         setTimeout(function () { d1.resolve(); }, 20);
         setTimeout(function () { d2.resolve(); }, 10);
@@ -279,13 +312,13 @@ QUnit.module('core', {}, function () {
             done1 = false, done2 = false,
             fail1 = false, fail2 = false;
 
-        var d1 = $.Deferred(),
-            d2 = $.Deferred();
+        var d1 = makeTestPromise();
+        var d2 = makeTestPromise();
 
-        dm.add(d1).done(function () { done1 = true; })
-                    .fail(function () { fail1 = true; });
-        dm.add(d2).done(function () { done2 = true; })
-                    .fail(function () { fail2 = true; });
+        dm.add(d1).then(function () { done1 = true; })
+                    .catch(function () { fail1 = true; });
+        dm.add(d2).then(function () { done2 = true; })
+                    .catch(function () { fail2 = true; });
 
         setTimeout(function () { d1.resolve(); }, 20);
         setTimeout(function () { d2.resolve(); }, 10);
@@ -302,230 +335,242 @@ QUnit.module('core', {}, function () {
         }, 30);
     });
 
-    QUnit.test('MutexedDropPrevious: simple', function (assert) {
-        assert.expect(3);
+    QUnit.test('MutexedDropPrevious: simple', async function (assert) {
+        assert.expect(5);
 
         var m = new concurrency.MutexedDropPrevious();
+        var d1 = makeTestPromise();
 
-        var d1 = $.Deferred();
-        var p1 = m.exec(function () { return d1; }).then(function (result) {
+        d1.then(function () {
+            assert.step("d1 resolved");
+        });
+        m.exec(function () { return d1; }).then(function (result) {
+            assert.step("p1 done");
             assert.strictEqual(result, 'd1');
         });
 
-        assert.strictEqual(p1.state(), "pending");
-
+        assert.verifySteps([]);
         d1.resolve('d1');
-        assert.strictEqual(p1.state(), "resolved");
+        await testUtils.nextMicrotaskTick();
+
+        assert.verifySteps(["d1 resolved","p1 done"]);
     });
 
-    QUnit.test('MutexedDropPrevious: 2 arrives after 1 resolution', function (assert) {
-        assert.expect(6);
+    QUnit.test('MutexedDropPrevious: d2 arrives after d1 resolution', async function (assert) {
+        assert.expect(8);
 
         var m = new concurrency.MutexedDropPrevious();
+        var d1 = makeTestPromiseWithAssert(assert, 'd1');
 
-        var d1 = $.Deferred();
-        var p1 = m.exec(function () { return d1; }).then(function (result) {
-            assert.strictEqual(result, 'd1');
+        m.exec(function () { return d1; }).then(function () {
+            assert.step("p1 resolved");
         });
 
-        assert.strictEqual(p1.state(), "pending");
-
+        assert.verifySteps([]);
         d1.resolve('d1');
-        assert.strictEqual(p1.state(), "resolved");
+        await testUtils.nextMicrotaskTick();
 
-        var d2 = $.Deferred();
-        var p2 = m.exec(function () { return d2; }).then(function (result) {
-            assert.strictEqual(result, 'd2');
-        });
+        assert.verifySteps(['ok d1','p1 resolved']);
 
-        assert.strictEqual(p2.state(), "pending");
+        var d2 = makeTestPromiseWithAssert(assert, 'd2');
+        m.exec(function () { return d2; }).then(function () {
+            assert.step("p2 resolved");
+        });
 
+        assert.verifySteps([]);
         d2.resolve('d2');
-        assert.strictEqual(p2.state(), "resolved");
+        await testUtils.nextMicrotaskTick();
+
+        assert.verifySteps(['ok d2','p2 resolved']);
     });
 
-    QUnit.test('MutexedDropPrevious: 1 does not return a deferred', function (assert) {
-        assert.expect(5);
+    QUnit.test('MutexedDropPrevious: p1 does not return a deferred', async function (assert) {
+        assert.expect(7);
 
         var m = new concurrency.MutexedDropPrevious();
 
-        var p1 = m.exec(function () { return 42; }).then(function (result) {
-            assert.strictEqual(result, 42);
+        m.exec(function () { return 42; }).then(function () {
+            assert.step("p1 resolved");
         });
 
-        assert.strictEqual(p1.state(), "resolved");
+        assert.verifySteps([]);
+        await testUtils.nextMicrotaskTick();
 
-        var d2 = $.Deferred();
-        var p2 = m.exec(function () { return d2; }).then(function (result) {
-            assert.strictEqual(result, 'd2');
-        });
+        assert.verifySteps(['p1 resolved']);
 
-        assert.strictEqual(p2.state(), "pending");
+        var d2 = makeTestPromiseWithAssert(assert, 'd2');
+        m.exec(function () { return d2; }).then(function () {
+            assert.step("p2 resolved");
+        });
 
+        assert.verifySteps([]);
         d2.resolve('d2');
-        assert.strictEqual(p2.state(), "resolved");
+        await testUtils.nextMicrotaskTick();
+        assert.verifySteps(['ok d2','p2 resolved']);
     });
 
-    QUnit.test('MutexedDropPrevious: 2 arrives before 1 resolution', function (assert) {
-        assert.expect(13);
+    QUnit.test('MutexedDropPrevious: p2 arrives before p1 resolution', async function (assert) {
+        assert.expect(8);
 
         var m = new concurrency.MutexedDropPrevious();
+        var d1 = makeTestPromiseWithAssert(assert, 'd1');
 
-        var d1 = $.Deferred();
-        var d2 = $.Deferred();
-
-        var p1 = m.exec(function () {
-            assert.step('p1');
-            return d1;
+        m.exec(function () { return d1; }).catch(function () {
+            assert.step("p1 rejected");
         });
-        assert.strictEqual(p1.state(), "pending");
+        assert.verifySteps([]);
 
-        var p2 = m.exec(function () {
-            assert.step('p2');
-            return d2;
-        }).then(function (result) {
-            assert.strictEqual(result, 'd2');
+        var d2 = makeTestPromiseWithAssert(assert, 'd2');
+        m.exec(function () { return d2; }).then(function () {
+            assert.step("p2 resolved");
         });
 
-        assert.strictEqual(p1.state(), "rejected");
-        assert.strictEqual(p2.state(), "pending");
-
-        assert.step('d1 resolved');
+        assert.verifySteps([]);
         d1.resolve('d1');
-        assert.strictEqual(p1.state(), "rejected");
-        assert.strictEqual(p2.state(), "pending");
+        await testUtils.nextMicrotaskTick();
+        assert.verifySteps(['p1 rejected', 'ok d1']);
 
-        assert.step('d2 resolved');
         d2.resolve('d2');
-        assert.strictEqual(p1.state(), "rejected");
-        assert.strictEqual(p2.state(), "resolved");
-
-        assert.verifySteps(['p1', 'd1 resolved', 'p2', 'd2 resolved']);
+        await testUtils.nextMicrotaskTick();
+        assert.verifySteps(['ok d2', 'p2 resolved']);
     });
 
-    QUnit.test('MutexedDropPrevious: 3 arrives before 2 initialization', function (assert) {
-        assert.expect(13);
-
+    QUnit.test('MutexedDropPrevious: 3 arrives before 2 initialization', async function (assert) {
+        assert.expect(10);
         var m = new concurrency.MutexedDropPrevious();
 
-        var d1 = $.Deferred();
-        var d2 = $.Deferred();
-        var d3 = $.Deferred();
+        var d1 = makeTestPromiseWithAssert(assert, 'd1');
+        var d3 = makeTestPromiseWithAssert(assert, 'd3');
 
-        var p1 = m.exec(function () { return d1; });
-        assert.strictEqual(p1.state(), "pending");
+        m.exec(function () { return d1; }).catch(function () {
+            assert.step('p1 rejected');
+        });
 
-        var p2 = m.exec(function () {
+        m.exec(function () {
             assert.ok(false, "should not execute this function");
-            return d2;
+        }).catch(function () {
+            assert.step('p2 rejected');
         });
-        assert.strictEqual(p1.state(), "rejected");
-        assert.strictEqual(p2.state(), "pending");
 
-        var p3 = m.exec(function () { return d3; }).then(function (result) {
+        m.exec(function () { return d3; }).then(function (result) {
             assert.strictEqual(result, 'd3');
+            assert.step('p3 resolved');
         });
-        assert.strictEqual(p1.state(), "rejected");
-        assert.strictEqual(p2.state(), "rejected");
-        assert.strictEqual(p3.state(), "pending");
+
+        assert.verifySteps([]);
+
+        await testUtils.nextMicrotaskTick();
+
+        assert.verifySteps(['p1 rejected', 'p2 rejected']);
 
         d1.resolve('d1');
-        assert.strictEqual(p1.state(), "rejected");
-        assert.strictEqual(p2.state(), "rejected");
-        assert.strictEqual(p3.state(), "pending");
+        await testUtils.nextMicrotaskTick();
+
+        assert.verifySteps(['ok d1']);
 
         d3.resolve('d3');
-        assert.strictEqual(p1.state(), "rejected");
-        assert.strictEqual(p2.state(), "rejected");
-        assert.strictEqual(p3.state(), "resolved");
-    });
+        await testUtils.nextTick();
 
-    QUnit.test('MutexedDropPrevious: 3 arrives after 2 initialization', function (assert) {
-        assert.expect(19);
 
+        assert.verifySteps(['ok d3','p3 resolved']);
+    });
+
+    QUnit.test('MutexedDropPrevious: 3 arrives after 2 initialization', async function (assert) {
+        assert.expect(15);
         var m = new concurrency.MutexedDropPrevious();
 
-        var d1 = $.Deferred();
-        var d2 = $.Deferred();
-        var d3 = $.Deferred();
+        var d1 = makeTestPromiseWithAssert(assert, 'd1');
+        var d2 = makeTestPromiseWithAssert(assert, 'd2');
+        var d3 = makeTestPromiseWithAssert(assert, 'd3');
 
-        var p1 = m.exec(function () {
-            assert.step('p1');
+        m.exec(function () {
+            assert.step('execute d1');
             return d1;
+        }).catch(function () {
+            assert.step('p1 rejected');
         });
-        assert.strictEqual(p1.state(), "pending");
 
-        var p2 = m.exec(function () {
-            assert.step('p2');
+        m.exec(function () {
+            assert.step('execute d2');
             return d2;
+        }).catch(function () {
+            assert.step('p2 rejected');
         });
 
-        assert.strictEqual(p1.state(), "rejected");
-        assert.strictEqual(p2.state(), "pending");
+        assert.verifySteps(['execute d1']);
+
+        await testUtils.nextMicrotaskTick();
+        assert.verifySteps(['p1 rejected']);
 
-        assert.step('d1 resolved');
         d1.resolve('d1');
-        assert.strictEqual(p1.state(), "rejected");
-        assert.strictEqual(p2.state(), "pending");
+        await testUtils.nextMicrotaskTick();
+
+        assert.verifySteps(['ok d1', 'execute d2']);
 
-        var p3 = m.exec(function () {
-            assert.step('p3');
+        m.exec(function () {
+            assert.step('execute d3');
             return d3;
-        }).then(function (result) {
-            assert.strictEqual(result, 'd3');
+        }).then(function () {
+            assert.step('p3 resolved');
         });
+        await testUtils.nextMicrotaskTick();
+        assert.verifySteps(['p2 rejected']);
 
-        assert.step('d2 resolved');
-        d2.resolve('d2');
-        assert.strictEqual(p1.state(), "rejected");
-        assert.strictEqual(p2.state(), "rejected");
-        assert.strictEqual(p3.state(), "pending");
+        d2.resolve();
+        await testUtils.nextMicrotaskTick();
+        assert.verifySteps(['ok d2', 'execute d3']);
 
-        assert.step('d3 resolved');
-        d3.resolve('d3');
-        assert.strictEqual(p1.state(), "rejected");
-        assert.strictEqual(p2.state(), "rejected");
-        assert.strictEqual(p3.state(), "resolved");
+        d3.resolve();
+        await testUtils.nextTick();
+        assert.verifySteps(['ok d3', 'p3 resolved']);
 
-        assert.verifySteps(['p1', 'd1 resolved', 'p2', 'd2 resolved', 'p3', 'd3 resolved']);
-    });
+     });
 
-    QUnit.test('MutexedDropPrevious: 2 in then of 1 with 3', function (assert) {
-        assert.expect(6);
+    QUnit.test('MutexedDropPrevious: 2 in then of 1 with 3', async function (assert) {
+        assert.expect(9);
 
         var m = new concurrency.MutexedDropPrevious();
 
-        var d1 = $.Deferred();
-        var d2 = $.Deferred();
-        var d3 = $.Deferred();
+        var d1 = makeTestPromiseWithAssert(assert, 'd1');
+        var d2 = makeTestPromiseWithAssert(assert, 'd2');
+        var d3 = makeTestPromiseWithAssert(assert, 'd3');
         var p3;
 
-        var p1 = m.exec(function () { return d1; })
-            .always(function () {
+        m.exec(function () { return d1; })
+            .catch(function () {
+                assert.step('p1 rejected');
                 p3 = m.exec(function () {
                     return d3;
-                }).then(function (result) {
-                    assert.strictEqual(result, 'd3');
+                }).then(function () {
+                    assert.step('p3 resolved');
                 });
                 return p3;
             });
 
-        assert.strictEqual(p1.state(), "pending");
+        await testUtils.nextTick();
+        assert.verifySteps([]);
 
-        var p2 = m.exec(function () {
-            assert.ok(false, "should not execute this function");
+        m.exec(function () {
+            assert.ok(false, 'should not execute this function');
             return d2;
+        }).catch(function () {
+            assert.step('p2 rejected');
         });
-        assert.strictEqual(p1.state(), "rejected");
-        assert.strictEqual(p2.state(), "rejected");
+
+        await testUtils.nextTick();
+        assert.verifySteps(['p1 rejected', 'p2 rejected']);
 
         d1.resolve('d1');
-        assert.strictEqual(p3.state(), "pending");
+        await testUtils.nextTick();
+
+        assert.verifySteps(['ok d1']);
 
         d3.resolve('d3');
-        assert.strictEqual(p3.state(), "resolved");
+        await testUtils.nextTick();
+
+        assert.verifySteps(['ok d3', 'p3 resolved']);
     });
 
 });
 
-});
\ No newline at end of file
+});
diff --git a/addons/web/static/tests/core/dom_tests.js b/addons/web/static/tests/core/dom_tests.js
index ab10bbb78f8..c57ced52099 100644
--- a/addons/web/static/tests/core/dom_tests.js
+++ b/addons/web/static/tests/core/dom_tests.js
@@ -30,7 +30,11 @@ function prepareAutoresizeTextArea(options) {
 QUnit.module('core', {}, function () {
 QUnit.module('dom', {}, function () {
 
-    QUnit.module('autoresize');
+    QUnit.module('autoresize', {
+        afterEach: function () {
+            $('#qunit-fixture').find('textarea').remove();
+        },
+    });
 
     QUnit.test('autoresize (border-box): no padding + no border', function (assert) {
         assert.expect(3);
diff --git a/addons/web/static/tests/core/mixins_tests.js b/addons/web/static/tests/core/mixins_tests.js
index 27c87870876..8c71a2592ce 100644
--- a/addons/web/static/tests/core/mixins_tests.js
+++ b/addons/web/static/tests/core/mixins_tests.js
@@ -10,6 +10,7 @@ QUnit.module('core', {}, function () {
 
     QUnit.test('perform a do_action properly', function (assert) {
         assert.expect(3);
+        var done = assert.async();
 
         var widget = new Widget();
 
@@ -22,9 +23,10 @@ QUnit.module('core', {}, function () {
         });
 
         widget.do_action('test.some_action_id', {clear_breadcrumbs: true}).then(function () {
-            assert.step('deferred should have been resolved');
+            assert.ok(true, 'deferred should have been resolved');
+            widget.destroy();
+            done();
         });
-        widget.destroy();
     });
 
 
diff --git a/addons/web/static/tests/core/widget_tests.js b/addons/web/static/tests/core/widget_tests.js
index 0eb4192c4a1..440cc97b524 100644
--- a/addons/web/static/tests/core/widget_tests.js
+++ b/addons/web/static/tests/core/widget_tests.js
@@ -2,7 +2,6 @@ odoo.define('web.widget_tests', function (require) {
 "use strict";
 
 var AjaxService = require('web.AjaxService');
-var concurrency = require('web.concurrency');
 var core = require('web.core');
 var QWeb = require('web.QWeb');
 var Widget = require('web.Widget');
@@ -86,8 +85,6 @@ QUnit.module('core', {}, function () {
         w.destroy();
     });
 
-
-
     QUnit.test('renderElement, no template, default', function (assert) {
         assert.expect(7);
 
@@ -206,7 +203,7 @@ QUnit.module('core', {}, function () {
         widget.destroy();
     });
 
-    QUnit.test('repeated', function (assert) {
+    QUnit.test('repeated', async function (assert) {
         assert.expect(4);
         var $fix = $( "#qunit-fixture");
 
@@ -222,17 +219,16 @@ QUnit.module('core', {}, function () {
         }))();
         widget.value = 42;
 
-        return widget.appendTo($fix)
-            .done(function () {
+        await widget.appendTo($fix)
+            .then(function () {
                 assert.strictEqual($fix.find('p').text(), '42', "DOM fixture should contain initial value");
                 assert.strictEqual(widget.$el.text(), '42', "should set initial value");
                 widget.value = 36;
                 widget.renderElement();
                 assert.strictEqual($fix.find('p').text(), '36', "DOM fixture should use new value");
                 assert.strictEqual(widget.$el.text(), '36', "should set new value");
-            }).always(function () {
-                widget.destroy();
             });
+        widget.destroy();
     });
 
 
@@ -274,7 +270,7 @@ QUnit.module('core', {}, function () {
     });
 
 
-    QUnit.test('delegate', function (assert) {
+    QUnit.test('delegate', async function (assert) {
         assert.expect(5);
 
         var a = [];
@@ -292,9 +288,9 @@ QUnit.module('core', {}, function () {
         }))();
         widget.renderElement();
 
-        widget.$el.click();
-        widget.$('li:eq(3)').click();
-        widget.$('input:last').val('foo').change();
+        await testUtils.dom.click(widget.$el, {allowInvisible: true});
+        await testUtils.dom.click(widget.$('li:eq(3)'), {allowInvisible: true});
+        await testUtils.fields.editAndTrigger(widget.$('input:last'), 'foo', 'change');
 
         for(var i=0; i<3; ++i) {
             assert.ok(a[i], "should pass test " + i);
@@ -302,7 +298,7 @@ QUnit.module('core', {}, function () {
         widget.destroy();
     });
 
-    QUnit.test('undelegate', function (assert) {
+    QUnit.test('undelegate', async function (assert) {
         assert.expect(4);
 
         var clicked = false;
@@ -316,13 +312,13 @@ QUnit.module('core', {}, function () {
         widget.renderElement();
         widget.$el.on('click', 'li', function () { newclicked = true; });
 
-        widget.$('li').click();
+        await testUtils.dom.clickFirst(widget.$('li'), {allowInvisible: true});
         assert.ok(clicked, "should trigger bound events");
         assert.ok(newclicked, "should trigger bound events");
 
         clicked = newclicked = false;
         widget._undelegateEvents();
-        widget.$('li').click();
+        await testUtils.dom.clickFirst(widget.$('li'), {allowInvisible: true});
         assert.ok(!clicked, "undelegate should unbind events delegated");
         assert.ok(newclicked, "undelegate should only unbind events it created");
         widget.destroy();
@@ -330,50 +326,54 @@ QUnit.module('core', {}, function () {
 
     QUnit.module('Widget, and async stuff');
 
-    QUnit.test("alive(alive)", function (assert) {
+    QUnit.test("alive(alive)", async function (assert) {
         assert.expect(1);
 
         var widget = new (Widget.extend({}));
 
-        return concurrency.asyncWhen(widget.start())
-            .then(function () { return widget.alive(concurrency.asyncWhen()); })
-            .then(function () { assert.ok(true); })
-            .always(function () { widget.destroy(); });
+        await widget.start()
+            .then(function () {return widget.alive(Promise.resolve()) ;})
+            .then(function () { assert.ok(true); });
+
+        widget.destroy();
     });
 
     QUnit.test("alive(dead)", function (assert) {
         assert.expect(1);
         var widget = new (Widget.extend({}));
 
-        return $.Deferred(function (d) {
-            concurrency.asyncWhen(widget.start())
+        return new Promise(function (resolve, reject) {
+            widget.start()
             .then(function () {
                 // destroy widget
                 widget.destroy();
-                var promise = concurrency.asyncWhen();
+                var promise = Promise.resolve();
                 // leave time for alive() to do its stuff
                 promise.then(function () {
-                    return concurrency.asyncWhen();
+                    return Promise.resolve();
                 }).then(function () {
                     assert.ok(true);
-                    d.resolve();
+                    resolve();
                 });
                 // ensure that widget.alive() refuses to resolve or reject
                 return widget.alive(promise);
-            }).always(function () {
-                d.reject();
+            }).then(function () {
+                reject();
+                assert.ok(false, "alive() should not terminate by default");
+            }).catch(function() {
+                reject();
                 assert.ok(false, "alive() should not terminate by default");
             });
         });
     });
 
-    QUnit.test("alive(alive, true)", function (assert) {
+    QUnit.test("alive(alive, true)", async function (assert) {
         assert.expect(1);
         var widget = new (Widget.extend({}));
-        return concurrency.asyncWhen(widget.start())
-        .then(function () { return widget.alive(concurrency.asyncWhen(), true) })
-        .then(function () { assert.ok(true); })
-        .always(function () { widget.destroy(); });
+        await widget.start()
+            .then(function () { return widget.alive(Promise.resolve(), true); })
+            .then(function () { assert.ok(true); });
+        widget.destroy();
     });
 
     QUnit.test("alive(dead, true)", function (assert) {
@@ -382,11 +382,11 @@ QUnit.module('core', {}, function () {
 
         var widget = new (Widget.extend({}));
 
-        concurrency.asyncWhen(widget.start())
+        widget.start()
         .then(function () {
             // destroy widget
             widget.destroy();
-            return widget.alive(concurrency.asyncWhen(), true);
+            return widget.alive(Promise.resolve(), true);
         }).then(function () {
             assert.ok(false, "alive(p, true) should fail its promise");
             done();
@@ -396,7 +396,7 @@ QUnit.module('core', {}, function () {
         });
     });
 
-    QUnit.test("calling _rpc on destroyed widgets", function (assert) {
+    QUnit.test("calling _rpc on destroyed widgets", async function (assert) {
         assert.expect(3);
 
         var def;
@@ -404,7 +404,7 @@ QUnit.module('core', {}, function () {
         testUtils.mock.addMockEnvironment(parent, {
             session: {
                 rpc: function () {
-                    def = $.Deferred();
+                    def = testUtils.makeTestPromise();
                     def.abort = def.reject;
                     return def;
                 },
@@ -419,23 +419,30 @@ QUnit.module('core', {}, function () {
             assert.ok(true, "The ajax call should be resolve");
         });
         def.resolve();
+        await testUtils.nextMicrotaskTick();
         def = null;
 
-        widget._rpc({route: '/a/route'}).always(function () {
+        widget._rpc({route: '/a/route'}).then(function () {
             throw Error("Calling _rpc on a destroyed widget should return a " +
-                "deferred that is never resolved nor rejected");
+            "promise that remains pending forever");
+        }).catch(function () {
+            throw Error("Calling _rpc on a destroyed widget should return a " +
+            "promise that remains pending forever");
         });
         widget.destroy();
         def.resolve();
+        await testUtils.nextMicrotaskTick();
         def = null;
 
-        widget._rpc({route: '/a/route'}).always(function () {
+        widget._rpc({route: '/a/route'}).then(function () {
+            throw Error("Calling _rpc on a destroyed widget should return a " +
+                "promise that remains pending forever");
+        }).catch(function () {
             throw Error("Calling _rpc on a destroyed widget should return a " +
-                "deferred that is never resolved nor rejected");
+            "promise that remains pending forever");
         });
-        assert.ok(!def,
-            "The trigger_up is not performed and the call returns a deferred "+
-                "never resolved nor rejected");
+        assert.ok(!def, "trigger_up is not performed and the call returns a " +
+            "promise that remains pending forever");
 
         assert.ok(true,
             "there should be no crash when calling _rpc on a destroyed widget");
@@ -444,12 +451,12 @@ QUnit.module('core', {}, function () {
 
     QUnit.test('start is not called when widget is destroyed', function (assert) {
         assert.expect(0);
-        var slowWillStartDef = $.Deferred();
+        var slowWillStartPromise = testUtils.makeTestPromise();
         var $fix = $( "#qunit-fixture");
 
         var widget = new (Widget.extend({
             willStart: function () {
-                return slowWillStartDef;
+                return slowWillStartPromise;
             },
             start: function () {
                 throw new Error('Should not call start method');
@@ -458,7 +465,7 @@ QUnit.module('core', {}, function () {
 
         widget.appendTo($fix);
         widget.destroy();
-        slowWillStartDef.resolve();
+        slowWillStartPromise.resolve();
     });
 
 });