vanilla 19.0

odoo-bringout-oca-ocb-web/web/static/tests/webclient/actions/client_action.test.js

@@ -0,0 +1,500 @@
+import { beforeEach, expect, test } from "@odoo/hoot";
+import { animationFrame, runAllTimers } from "@odoo/hoot-mock";
+import { Component, onMounted, xml } from "@odoo/owl";
+import {
+    contains,
+    defineActions,
+    defineModels,
+    getService,
+    models,
+    mountWithCleanup,
+    onRpc,
+    patchWithCleanup,
+    stepAllNetworkCalls,
+    webModels,
+} from "@web/../tests/web_test_helpers";
+
+import { browser } from "@web/core/browser/browser";
+import { registry } from "@web/core/registry";
+import { redirect } from "@web/core/utils/urls";
+import { WebClient } from "@web/webclient/webclient";
+
+const { ResCompany, ResPartner, ResUsers } = webModels;
+const actionRegistry = registry.category("actions");
+
+class TestClientAction extends Component {
+    static template = xml`
+        <div class="test_client_action">
+            ClientAction_<t t-esc="props.action.params?.description"/>
+        </div>`;
+    static props = ["*"];
+    setup() {
+        onMounted(() => this.env.config.setDisplayName(`Client action ${this.props.action.id}`));
+    }
+}
+
+class Partner extends models.Model {
+    _rec_name = "display_name";
+
+    _records = [
+        { id: 1, display_name: "First record" },
+        { id: 2, display_name: "Second record" },
+    ];
+    _views = {
+        form: /* xml */ `
+            <form>
+                <group>
+                    <field name="display_name"/>
+                </group>
+            </form>
+        `,
+        "kanban,1": /* xml */ `
+            <kanban>
+                <templates>
+                    <t t-name="card">
+                        <field name="display_name"/>
+                    </t>
+                </templates>
+            </kanban>
+        `,
+        list: /* xml */ `
+            <list>
+                <field name="display_name" />
+            </list>
+        `,
+    };
+}
+
+defineModels([Partner, ResCompany, ResPartner, ResUsers]);
+
+defineActions([
+    {
+        id: 1,
+        xml_id: "action_1",
+        name: "Partners Action 1",
+        res_model: "partner",
+        views: [[1, "kanban"]],
+    },
+    {
+        id: 3,
+        xml_id: "action_3",
+        name: "Partners",
+        res_model: "partner",
+        views: [
+            [false, "list"],
+            [1, "kanban"],
+            [false, "form"],
+        ],
+    },
+]);
+
+beforeEach(() => {
+    actionRegistry.add("__test__client__action__", TestClientAction);
+});
+
+test("can display client actions in Dialog", async () => {
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction({
+        name: "Dialog Test",
+        target: "new",
+        tag: "__test__client__action__",
+        type: "ir.actions.client",
+    });
+
+    expect(".modal .test_client_action").toHaveCount(1);
+    expect(".modal-title").toHaveText("Dialog Test");
+});
+
+test("can display client actions in Dialog and close the dialog", async () => {
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction({
+        name: "Dialog Test",
+        target: "new",
+        tag: "__test__client__action__",
+        type: "ir.actions.client",
+    });
+
+    expect(".modal .test_client_action").toHaveCount(1);
+    expect(".modal-title").toHaveText("Dialog Test");
+    await contains(".modal footer .btn.btn-primary").click();
+    expect(".modal .test_client_action").toHaveCount(0);
+});
+
+test("can display client actions as main, then in Dialog", async () => {
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction("__test__client__action__");
+    expect(".o_action_manager .test_client_action").toHaveCount(1);
+
+    await getService("action").doAction({
+        target: "new",
+        tag: "__test__client__action__",
+        type: "ir.actions.client",
+    });
+    expect(".o_action_manager .test_client_action").toHaveCount(1);
+    expect(".modal .test_client_action").toHaveCount(1);
+});
+
+test("can display client actions in Dialog, then as main destroys Dialog", async () => {
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction({
+        target: "new",
+        tag: "__test__client__action__",
+        type: "ir.actions.client",
+    });
+    expect(".test_client_action").toHaveCount(1);
+    expect(".modal .test_client_action").toHaveCount(1);
+    await getService("action").doAction("__test__client__action__");
+
+    expect(".test_client_action").toHaveCount(1);
+    expect(".modal .test_client_action").toHaveCount(0);
+});
+
+test("dialog no header", async () => {
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction({
+        name: "Dialog Test",
+        target: "new",
+        tag: "__test__client__action__",
+        type: "ir.actions.client",
+        context: { header: false },
+    });
+
+    expect(".modal .test_client_action").toHaveCount(1);
+    expect(".modal-title").toHaveCount(0);
+});
+
+test("soft_reload will refresh data", async () => {
+    onRpc("web_search_read", () => {
+        expect.step("web_search_read");
+    });
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(1);
+    expect.verifySteps(["web_search_read"]);
+
+    await getService("action").doAction("soft_reload");
+    expect.verifySteps(["web_search_read"]);
+});
+
+test("soft_reload a form view", async () => {
+    onRpc("web_read", ({ args }) => {
+        expect.step(`read ${args[0][0]}`);
+    });
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction({
+        name: "Partners",
+        res_model: "partner",
+        views: [
+            [false, "list"],
+            [false, "form"],
+        ],
+        type: "ir.actions.act_window",
+    });
+    await contains(".o_data_row .o_data_cell").click();
+    await contains(".o_form_view .o_pager_next").click();
+    expect.verifySteps(["read 1", "read 2"]);
+
+    await getService("action").doAction("soft_reload");
+    expect.verifySteps(["read 2"]);
+});
+
+test("soft_reload when there is no controller", async () => {
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction("soft_reload");
+    expect(true).toBe(true, {
+        message: "No ControllerNotFoundError when there is no controller to restore",
+    });
+});
+
+test("can execute client actions from tag name", async () => {
+    class ClientAction extends Component {
+        static template = xml`<div class="o_client_action_test">Hello World</div>`;
+        static props = ["*"];
+    }
+    actionRegistry.add("HelloWorldTest", ClientAction);
+
+    stepAllNetworkCalls();
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction("HelloWorldTest");
+    expect(".o_control_panel").toHaveCount(0);
+    expect(".o_client_action_test").toHaveText("Hello World");
+    expect.verifySteps(["/web/webclient/translations", "/web/webclient/load_menus"]);
+});
+
+test("async client action (function) returning another action", async () => {
+    actionRegistry.add("my_action", async () => {
+        await Promise.resolve();
+        return 1; // execute action 1
+    });
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction("my_action");
+    expect(".o_kanban_view").toHaveCount(1);
+});
+
+test("'CLEAR-UNCOMMITTED-CHANGES' is not triggered for function client actions", async () => {
+    actionRegistry.add("my_action", () => {
+        expect.step("my_action");
+    });
+
+    const webClient = await mountWithCleanup(WebClient);
+    webClient.env.bus.addEventListener("CLEAR-UNCOMMITTED-CHANGES", () => {
+        expect.step("CLEAR-UNCOMMITTED-CHANGES");
+    });
+
+    await getService("action").doAction("my_action");
+    expect.verifySteps(["my_action"]);
+});
+
+test.tags("desktop");
+test("ClientAction receives breadcrumbs and exports title", async () => {
+    expect.assertions(4);
+
+    class ClientAction extends Component {
+        static template = xml`<div class="my_action" t-on-click="onClick">client action</div>`;
+        static props = ["*"];
+        setup() {
+            this.breadcrumbTitle = "myAction";
+            const { breadcrumbs } = this.env.config;
+            expect(breadcrumbs).toHaveLength(2);
+            expect(breadcrumbs[0].name).toBe("Partners Action 1");
+            onMounted(() => {
+                this.env.config.setDisplayName(this.breadcrumbTitle);
+            });
+        }
+        onClick() {
+            this.breadcrumbTitle = "newTitle";
+            this.env.config.setDisplayName(this.breadcrumbTitle);
+        }
+    }
+    actionRegistry.add("SomeClientAction", ClientAction);
+
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(1);
+    await getService("action").doAction("SomeClientAction");
+    expect(".my_action").toHaveCount(1);
+    await contains(".my_action").click();
+    await getService("action").doAction(3);
+    expect(".o_breadcrumb").toHaveText("Partners Action 1\nnewTitle\nPartners");
+});
+
+test("ClientAction receives arbitrary props from doAction", async () => {
+    expect.assertions(1);
+    class ClientAction extends Component {
+        static template = xml`<div></div>`;
+        static props = ["*"];
+        setup() {
+            expect(this.props.division).toBe("bell");
+        }
+    }
+    actionRegistry.add("SomeClientAction", ClientAction);
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction("SomeClientAction", {
+        props: { division: "bell" },
+    });
+});
+
+test("ClientAction with extractProps", async () => {
+    defineActions([
+        {
+            id: 128,
+            name: "My Client Action",
+            tag: "SomeClientAction",
+            type: "ir.actions.client",
+            params: {
+                my_prop: "coucou",
+            },
+        },
+    ]);
+    class ClientAction extends Component {
+        static template = xml`<div class="my_client_action" t-esc="props.myProp"/>`;
+        static props = ["*"];
+        static extractProps(action) {
+            return { myProp: action.params.my_prop };
+        }
+    }
+    actionRegistry.add("SomeClientAction", ClientAction);
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(128);
+    expect(".my_client_action").toHaveText("coucou");
+});
+
+test("test display_notification client action", async () => {
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(1);
+    expect(".o_kanban_view").toHaveCount(1);
+
+    await getService("action").doAction({
+        type: "ir.actions.client",
+        tag: "display_notification",
+        params: {
+            message: "message",
+            sticky: true,
+        },
+    });
+    await animationFrame(); // wait for the notification to be displayed
+    expect(".o_notification_manager .o_notification").toHaveCount(1);
+    expect(".o_notification_manager .o_notification .o_notification_content").toHaveText("message");
+    expect(".o_kanban_view").toHaveCount(1);
+    await contains(".o_notification_close").click();
+    expect(".o_notification_manager .o_notification").toHaveCount(0);
+});
+
+test("test display_notification client action with links", async () => {
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(1);
+    expect(".o_kanban_view").toHaveCount(1);
+
+    await getService("action").doAction({
+        type: "ir.actions.client",
+        tag: "display_notification",
+        params: {
+            message: "message %s <R&D>",
+            sticky: true,
+            links: [
+                {
+                    label: "test <R&D>",
+                    url: "#action={action.id}&id={order.id}&model=purchase.order",
+                },
+            ],
+        },
+    });
+    await animationFrame(); // wait for the notification to be displayed
+    expect(".o_notification_manager .o_notification").toHaveCount(1);
+    expect(".o_notification_manager .o_notification .o_notification_content").toHaveText(
+        "message test <R&D> <R&D>"
+    );
+    expect(".o_kanban_view").toHaveCount(1);
+    await contains(".o_notification_close").click();
+    expect(".o_notification_manager .o_notification").toHaveCount(0);
+
+    // display_notification without title
+    await getService("action").doAction({
+        type: "ir.actions.client",
+        tag: "display_notification",
+        params: {
+            message: "message %s <R&D>",
+            sticky: true,
+            links: [
+                {
+                    label: "test <R&D>",
+                    url: "#action={action.id}&id={order.id}&model=purchase.order",
+                },
+            ],
+        },
+    });
+    await animationFrame(); // wait for the notification to be displayed
+    expect(".o_notification_manager .o_notification").toHaveCount(1);
+    expect(".o_notification_manager .o_notification .o_notification_title").toHaveCount(0);
+});
+
+test("test next action on display_notification client action", async () => {
+    await mountWithCleanup(WebClient);
+    const options = {
+        onClose: function () {
+            expect.step("onClose");
+        },
+    };
+    await getService("action").doAction(
+        {
+            type: "ir.actions.client",
+            tag: "display_notification",
+            params: {
+                title: "title",
+                message: "message",
+                sticky: true,
+                next: {
+                    type: "ir.actions.act_window_close",
+                },
+            },
+        },
+        options
+    );
+    await animationFrame(); // wait for the notification to be displayed
+    expect(".o_notification_manager .o_notification").toHaveCount(1);
+    expect.verifySteps(["onClose"]);
+});
+
+test("test reload client action", async () => {
+    redirect("/odoo?test=42");
+    browser.location.search = "?test=42";
+
+    patchWithCleanup(browser.history, {
+        pushState: (_state, _unused, url) => {
+            expect.step(`pushState ${url.replace(browser.location.origin, "")}`);
+        },
+        replaceState: (_state, _unused, url) => {
+            expect.step(`replaceState ${url.replace(browser.location.origin, "")}`);
+        },
+    });
+    patchWithCleanup(browser.location, {
+        reload: function () {
+            expect.step("window_reload");
+        },
+    });
+
+    await mountWithCleanup(WebClient);
+    await runAllTimers();
+
+    await getService("action").doAction({
+        type: "ir.actions.client",
+        tag: "reload",
+    });
+    await runAllTimers();
+    await getService("action").doAction({
+        type: "ir.actions.client",
+        tag: "reload",
+        params: {
+            action_id: 2,
+        },
+    });
+    await runAllTimers();
+    await getService("action").doAction({
+        type: "ir.actions.client",
+        tag: "reload",
+        params: {
+            menu_id: 1,
+        },
+    });
+    await runAllTimers();
+    await getService("action").doAction({
+        type: "ir.actions.client",
+        tag: "reload",
+        params: {
+            action_id: 1,
+            menu_id: 2,
+        },
+    });
+    await runAllTimers();
+    expect.verifySteps([
+        "replaceState /odoo?test=42",
+        "window_reload",
+        "pushState /odoo/action-2",
+        "window_reload",
+        "pushState /odoo?menu_id=1",
+        "window_reload",
+        "pushState /odoo/action-1?menu_id=2",
+        "window_reload",
+    ]);
+});
+
+test("test home client action", async () => {
+    redirect("/odoo");
+    browser.location.search = "";
+
+    patchWithCleanup(browser.location, {
+        assign: (url) => expect.step(`assign ${url}`),
+    });
+
+    onRpc("/web/webclient/version_info", () => {
+        expect.step("/web/webclient/version_info");
+        return true;
+    });
+
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction({
+        type: "ir.actions.client",
+        tag: "home",
+    });
+    await runAllTimers();
+    await animationFrame();
+    expect.verifySteps(["/web/webclient/version_info", "assign /"]);
+});

odoo-bringout-oca-ocb-web/web/static/tests/webclient/actions/client_action_tests.js

@@ -1,632 +0,0 @@
-/** @odoo-module **/
-
-import { browser } from "@web/core/browser/browser";
-import { registry } from "@web/core/registry";
-import core from "web.core";
-import AbstractAction from "web.AbstractAction";
-import testUtils from "web.test_utils";
-import { registerCleanup } from "../../helpers/cleanup";
-import {
-    click,
-    getFixture,
-    legacyExtraNextTick,
-    nextTick,
-    patchWithCleanup,
-} from "../../helpers/utils";
-import { createWebClient, doAction, getActionManagerServerData } from "./../helpers";
-
-import { Component, xml } from "@odoo/owl";
-
-let serverData;
-let target;
-const actionRegistry = registry.category("actions");
-
-QUnit.module("ActionManager", (hooks) => {
-    hooks.beforeEach(() => {
-        serverData = getActionManagerServerData();
-        target = getFixture();
-    });
-
-    QUnit.module("Client Actions");
-
-    QUnit.test("can display client actions in Dialog", async function (assert) {
-        assert.expect(2);
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, {
-            name: "Dialog Test",
-            target: "new",
-            tag: "__test__client__action__",
-            type: "ir.actions.client",
-        });
-        assert.containsOnce(target, ".modal .test_client_action");
-        assert.strictEqual(target.querySelector(".modal-title").textContent, "Dialog Test");
-    });
-
-    QUnit.test(
-        "can display client actions in Dialog and close the dialog",
-        async function (assert) {
-            assert.expect(3);
-            const webClient = await createWebClient({ serverData });
-            await doAction(webClient, {
-                name: "Dialog Test",
-                target: "new",
-                tag: "__test__client__action__",
-                type: "ir.actions.client",
-            });
-            assert.containsOnce(target, ".modal .test_client_action");
-            assert.strictEqual(target.querySelector(".modal-title").textContent, "Dialog Test");
-            target.querySelector(".modal footer .btn.btn-primary").click();
-            await nextTick();
-            assert.containsNone(target, ".modal .test_client_action");
-        }
-    );
-
-    QUnit.test("can display client actions as main, then in Dialog", async function (assert) {
-        assert.expect(3);
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, "__test__client__action__");
-        assert.containsOnce(target, ".o_action_manager .test_client_action");
-        await doAction(webClient, {
-            target: "new",
-            tag: "__test__client__action__",
-            type: "ir.actions.client",
-        });
-        assert.containsOnce(target, ".o_action_manager .test_client_action");
-        assert.containsOnce(target, ".modal .test_client_action");
-    });
-
-    QUnit.test(
-        "can display client actions in Dialog, then as main destroys Dialog",
-        async function (assert) {
-            assert.expect(4);
-            const webClient = await createWebClient({ serverData });
-            await doAction(webClient, {
-                target: "new",
-                tag: "__test__client__action__",
-                type: "ir.actions.client",
-            });
-            assert.containsOnce(target, ".test_client_action");
-            assert.containsOnce(target, ".modal .test_client_action");
-            await doAction(webClient, "__test__client__action__");
-            assert.containsOnce(target, ".test_client_action");
-            assert.containsNone(target, ".modal .test_client_action");
-        }
-    );
-
-    QUnit.test("soft_reload will refresh data", async (assert) => {
-        const mockRPC = async function (route, args) {
-            if (route === "/web/dataset/call_kw/partner/web_search_read") {
-                assert.step("web_search_read");
-            }
-        };
-        const webClient = await createWebClient({ serverData, mockRPC });
-        await doAction(webClient, 1);
-        assert.verifySteps(["web_search_read"]);
-        await doAction(webClient, "soft_reload");
-        assert.verifySteps(["web_search_read"]);
-    });
-
-    QUnit.test("soft_reload when there is no controller", async (assert) => {
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, "soft_reload");
-        assert.ok(true, "No ControllerNotFoundError when there is no controller to restore");
-    });
-
-    QUnit.test("can execute client actions from tag name (legacy)", async function (assert) {
-        // remove this test as soon as legacy Widgets are no longer supported
-        assert.expect(4);
-        const ClientAction = AbstractAction.extend({
-            start: function () {
-                this.$el.text("Hello World");
-                this.$el.addClass("o_client_action_test");
-            },
-        });
-        const mockRPC = async function (route, args) {
-            assert.step((args && args.method) || route);
-        };
-        core.action_registry.add("HelloWorldTestLeg", ClientAction);
-        registerCleanup(() => delete core.action_registry.map.HelloWorldTestLeg);
-        const webClient = await createWebClient({ serverData, mockRPC });
-        await doAction(webClient, "HelloWorldTestLeg");
-        assert.containsNone(
-            document.body,
-            ".o_control_panel",
-            "shouldn't have rendered a control panel"
-        );
-        assert.strictEqual(
-            $(target).find(".o_client_action_test").text(),
-            "Hello World",
-            "should have correctly rendered the client action"
-        );
-        assert.verifySteps(["/web/webclient/load_menus"]);
-    });
-
-    QUnit.test("can execute client actions from tag name", async function (assert) {
-        assert.expect(4);
-        class ClientAction extends Component {}
-        ClientAction.template = xml`<div class="o_client_action_test">Hello World</div>`;
-        actionRegistry.add("HelloWorldTest", ClientAction);
-
-        const mockRPC = async function (route, args) {
-            assert.step((args && args.method) || route);
-        };
-        const webClient = await createWebClient({ serverData, mockRPC });
-        await doAction(webClient, "HelloWorldTest");
-        assert.containsNone(
-            document.body,
-            ".o_control_panel",
-            "shouldn't have rendered a control panel"
-        );
-        assert.strictEqual(
-            $(target).find(".o_client_action_test").text(),
-            "Hello World",
-            "should have correctly rendered the client action"
-        );
-        assert.verifySteps(["/web/webclient/load_menus"]);
-    });
-
-    QUnit.test("async client action (function) returning another action", async function (assert) {
-        assert.expect(1);
-
-        registry.category("actions").add("my_action", async () => {
-            await Promise.resolve();
-            return 1; // execute action 1
-        });
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, "my_action");
-        assert.containsOnce(target, ".o_kanban_view");
-    });
-
-    QUnit.test(
-        "'CLEAR-UNCOMMITTED-CHANGES' is not triggered for function client actions",
-        async function (assert) {
-            assert.expect(2);
-
-            registry.category("actions").add("my_action", async () => {
-                assert.step("my_action");
-            });
-
-            const webClient = await createWebClient({ serverData });
-            webClient.env.bus.addEventListener("CLEAR-UNCOMMITTED-CHANGES", () => {
-                assert.step("CLEAR-UNCOMMITTED-CHANGES");
-            });
-
-            await doAction(webClient, "my_action");
-            assert.verifySteps(["my_action"]);
-        }
-    );
-
-    QUnit.test("client action with control panel (legacy)", async function (assert) {
-        assert.expect(4);
-        // LPE Fixme: at this time we don't really know the API that wowl ClientActions implement
-        const ClientAction = AbstractAction.extend({
-            hasControlPanel: true,
-            start() {
-                this.$(".o_content").text("Hello World");
-                this.$el.addClass("o_client_action_test");
-                this.controlPanelProps.title = "Hello";
-                return this._super.apply(this, arguments);
-            },
-        });
-        core.action_registry.add("HelloWorldTest", ClientAction);
-        registerCleanup(() => delete core.action_registry.map.HelloWorldTest);
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, "HelloWorldTest");
-        assert.strictEqual(
-            $(".o_control_panel:visible").length,
-            1,
-            "should have rendered a control panel"
-        );
-        assert.containsN(
-            target,
-            ".o_control_panel .breadcrumb-item",
-            1,
-            "there should be one controller in the breadcrumbs"
-        );
-        assert.strictEqual(
-            $(".o_control_panel .breadcrumb-item").text(),
-            "Hello",
-            "breadcrumbs should still display the title of the controller"
-        );
-        assert.strictEqual(
-            $(target).find(".o_client_action_test .o_content").text(),
-            "Hello World",
-            "should have correctly rendered the client action"
-        );
-    });
-
-    QUnit.test("state is pushed for client action (legacy)", async function (assert) {
-        assert.expect(6);
-        const ClientAction = AbstractAction.extend({
-            getTitle: function () {
-                return "a title";
-            },
-            getState: function () {
-                return { foo: "baz" };
-            },
-        });
-        const pushState = browser.history.pushState;
-        patchWithCleanup(browser, {
-            history: Object.assign({}, browser.history, {
-                pushState() {
-                    pushState(...arguments);
-                    assert.step("push_state");
-                },
-            }),
-        });
-
-        core.action_registry.add("HelloWorldTest", ClientAction);
-        registerCleanup(() => delete core.action_registry.map.HelloWorldTest);
-        const webClient = await createWebClient({ serverData });
-        let currentTitle = webClient.env.services.title.current;
-        assert.strictEqual(currentTitle, '{"zopenerp":"Odoo"}');
-        let currentHash = webClient.env.services.router.current.hash;
-        assert.deepEqual(currentHash, {});
-        await doAction(webClient, "HelloWorldTest");
-        currentTitle = webClient.env.services.title.current;
-        assert.strictEqual(currentTitle, '{"zopenerp":"Odoo","action":"a title"}');
-        currentHash = webClient.env.services.router.current.hash;
-        assert.deepEqual(currentHash, {
-            action: "HelloWorldTest",
-            foo: "baz",
-        });
-        assert.verifySteps(["push_state"]);
-    });
-
-    QUnit.test("action can use a custom control panel (legacy)", async function (assert) {
-        assert.expect(1);
-        class CustomControlPanel extends Component {}
-        CustomControlPanel.template = xml`
-        <div class="custom-control-panel">My custom control panel</div>
-      `;
-        const ClientAction = AbstractAction.extend({
-            hasControlPanel: true,
-            config: {
-                ControlPanel: CustomControlPanel,
-            },
-        });
-        core.action_registry.add("HelloWorldTest", ClientAction);
-        registerCleanup(() => delete core.action_registry.map.HelloWorldTest);
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, "HelloWorldTest");
-        assert.containsOnce(target, ".custom-control-panel", "should have a custom control panel");
-    });
-
-    QUnit.test("breadcrumb is updated on title change (legacy)", async function (assert) {
-        assert.expect(2);
-        const ClientAction = AbstractAction.extend({
-            hasControlPanel: true,
-            events: {
-                click: function () {
-                    this.updateControlPanel({ title: "new title" });
-                },
-            },
-            start: async function () {
-                this.$(".o_content").text("Hello World");
-                this.$el.addClass("o_client_action_test");
-                this.controlPanelProps.title = "initial title";
-                await this._super.apply(this, arguments);
-            },
-        });
-        core.action_registry.add("HelloWorldTest", ClientAction);
-        registerCleanup(() => delete core.action_registry.map.HelloWorldTest);
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, "HelloWorldTest");
-        assert.strictEqual(
-            $("ol.breadcrumb").text(),
-            "initial title",
-            "should have initial title as breadcrumb content"
-        );
-        await testUtils.dom.click($(target).find(".o_client_action_test"));
-        await legacyExtraNextTick();
-        assert.strictEqual(
-            $("ol.breadcrumb").text(),
-            "new title",
-            "should have updated title as breadcrumb content"
-        );
-    });
-
-    QUnit.test("client actions can have breadcrumbs (legacy)", async function (assert) {
-        assert.expect(4);
-        const ClientAction = AbstractAction.extend({
-            hasControlPanel: true,
-            init(parent, action) {
-                action.display_name = "Goldeneye";
-                this._super.apply(this, arguments);
-            },
-            start() {
-                this.$el.addClass("o_client_action_test");
-                return this._super.apply(this, arguments);
-            },
-        });
-        const ClientAction2 = AbstractAction.extend({
-            hasControlPanel: true,
-            init(parent, action) {
-                action.display_name = "No time for sweetness";
-                this._super.apply(this, arguments);
-            },
-            start() {
-                this.$el.addClass("o_client_action_test_2");
-                return this._super.apply(this, arguments);
-            },
-        });
-        core.action_registry.add("ClientAction", ClientAction);
-        core.action_registry.add("ClientAction2", ClientAction2);
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, "ClientAction");
-        assert.containsOnce(target, ".breadcrumb-item");
-        assert.strictEqual(
-            target.querySelector(".breadcrumb-item.active").textContent,
-            "Goldeneye"
-        );
-        await doAction(webClient, "ClientAction2", { clearBreadcrumbs: false });
-        assert.containsN(target, ".breadcrumb-item", 2);
-        assert.strictEqual(
-            target.querySelector(".breadcrumb-item.active").textContent,
-            "No time for sweetness"
-        );
-        delete core.action_registry.map.ClientAction;
-        delete core.action_registry.map.ClientAction2;
-    });
-
-    QUnit.test("client action restore scrollbar (legacy)", async function (assert) {
-        assert.expect(7);
-        const ClientAction = AbstractAction.extend({
-            hasControlPanel: true,
-            init(parent, action) {
-                action.display_name = "Title1";
-                this._super.apply(this, arguments);
-            },
-            async start() {
-                for (let i = 0; i < 100; i++) {
-                    const content = document.createElement("div");
-                    content.innerText = "Paper company";
-                    content.className = "lorem";
-                    this.el.querySelector(".o_content").appendChild(content);
-                }
-                await this._super(arguments);
-            },
-        });
-        const ClientAction2 = AbstractAction.extend({
-            hasControlPanel: true,
-            init(parent, action) {
-                action.display_name = "Title2";
-                this._super.apply(this, arguments);
-            },
-            start() {
-                return this._super.apply(this, arguments);
-            },
-        });
-        core.action_registry.add("ClientAction", ClientAction);
-        core.action_registry.add("ClientAction2", ClientAction2);
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, "ClientAction");
-        assert.containsOnce(target, ".breadcrumb-item");
-        assert.strictEqual(target.querySelector(".breadcrumb-item.active").textContent, "Title1");
-
-        target.querySelector(".lorem:last-child").scrollIntoView();
-        const scrollPosition = target.querySelector(".o_content").scrollTop;
-        assert.ok(scrollPosition > 0);
-        await doAction(webClient, "ClientAction2", { clearBreadcrumbs: false });
-        assert.containsN(target, ".breadcrumb-item", 2);
-        assert.strictEqual(target.querySelector(".breadcrumb-item.active").textContent, "Title2");
-
-        await click(target.querySelector(".breadcrumb-item:first-child"));
-        assert.strictEqual(target.querySelector(".breadcrumb-item.active").textContent, "Title1");
-
-        assert.strictEqual(
-            target.querySelector(".o_content").scrollTop,
-            scrollPosition,
-            "Should restore the scroll"
-        );
-        delete core.action_registry.map.ClientAction;
-        delete core.action_registry.map.ClientAction2;
-    });
-
-    QUnit.test("ClientAction receives breadcrumbs and exports title (wowl)", async (assert) => {
-        assert.expect(4);
-        class ClientAction extends Component {
-            setup() {
-                this.breadcrumbTitle = "myOwlAction";
-                const { breadcrumbs } = this.env.config;
-                assert.strictEqual(breadcrumbs.length, 2);
-                assert.strictEqual(breadcrumbs[0].name, "Favorite Ponies");
-                owl.onMounted(() => {
-                    this.env.config.setDisplayName(this.breadcrumbTitle);
-                });
-            }
-            onClick() {
-                this.breadcrumbTitle = "newOwlTitle";
-                this.env.config.setDisplayName(this.breadcrumbTitle);
-            }
-        }
-        ClientAction.template = xml`<div class="my_owl_action" t-on-click="onClick">owl client action</div>`;
-        actionRegistry.add("OwlClientAction", ClientAction);
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, 8);
-        await doAction(webClient, "OwlClientAction");
-        assert.containsOnce(target, ".my_owl_action");
-        await click(target, ".my_owl_action");
-        await doAction(webClient, 3);
-        assert.strictEqual(
-            target.querySelector(".breadcrumb").textContent,
-            "Favorite PoniesnewOwlTitlePartners"
-        );
-    });
-
-    QUnit.test("ClientAction receives arbitrary props from doAction (wowl)", async (assert) => {
-        assert.expect(1);
-        class ClientAction extends Component {
-            setup() {
-                assert.strictEqual(this.props.division, "bell");
-            }
-        }
-        ClientAction.template = xml`<div class="my_owl_action"></div>`;
-        actionRegistry.add("OwlClientAction", ClientAction);
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, "OwlClientAction", {
-            props: { division: "bell" },
-        });
-    });
-
-    QUnit.test("ClientAction receives arbitrary props from doAction (legacy)", async (assert) => {
-        assert.expect(1);
-        const ClientAction = AbstractAction.extend({
-            init(parent, action, options) {
-                assert.strictEqual(options.division, "bell");
-                this._super.apply(this, arguments);
-            },
-        });
-        core.action_registry.add("ClientAction", ClientAction);
-        registerCleanup(() => delete core.action_registry.map.ClientAction);
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, "ClientAction", {
-            props: { division: "bell" },
-        });
-    });
-
-    QUnit.test("test display_notification client action", async function (assert) {
-        assert.expect(6);
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, 1);
-        assert.containsOnce(target, ".o_kanban_view");
-        await doAction(webClient, {
-            type: "ir.actions.client",
-            tag: "display_notification",
-            params: {
-                title: "title",
-                message: "message",
-                sticky: true,
-            },
-        });
-        const notificationSelector = ".o_notification_manager .o_notification";
-        assert.containsOnce(
-            document.body,
-            notificationSelector,
-            "a notification should be present"
-        );
-        const notificationElement = document.body.querySelector(notificationSelector);
-        assert.strictEqual(
-            notificationElement.querySelector(".o_notification_title").textContent,
-            "title",
-            "the notification should have the correct title"
-        );
-        assert.strictEqual(
-            notificationElement.querySelector(".o_notification_content").textContent,
-            "message",
-            "the notification should have the correct message"
-        );
-        assert.containsOnce(target, ".o_kanban_view");
-        await testUtils.dom.click(notificationElement.querySelector(".o_notification_close"));
-        assert.containsNone(
-            document.body,
-            notificationSelector,
-            "the notification should be destroy "
-        );
-    });
-
-    QUnit.test("test display_notification client action with links", async function (assert) {
-        assert.expect(8);
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, 1);
-        assert.containsOnce(target, ".o_kanban_view");
-        await doAction(webClient, {
-            type: "ir.actions.client",
-            tag: "display_notification",
-            params: {
-                title: "title",
-                message: "message %s <R&D>",
-                sticky: true,
-                links: [
-                    {
-                        label: "test <R&D>",
-                        url: "#action={action.id}&id={order.id}&model=purchase.order",
-                    },
-                ],
-            },
-        });
-        const notificationSelector = ".o_notification_manager .o_notification";
-        assert.containsOnce(
-            document.body,
-            notificationSelector,
-            "a notification should be present"
-        );
-        let notificationElement = document.body.querySelector(notificationSelector);
-        assert.strictEqual(
-            notificationElement.querySelector(".o_notification_title").textContent,
-            "title",
-            "the notification should have the correct title"
-        );
-        assert.strictEqual(
-            notificationElement.querySelector(".o_notification_content").textContent,
-            "message test <R&D> <R&D>",
-            "the notification should have the correct message"
-        );
-        assert.containsOnce(target, ".o_kanban_view");
-        await testUtils.dom.click(notificationElement.querySelector(".o_notification_close"));
-        assert.containsNone(
-            document.body,
-            notificationSelector,
-            "the notification should be destroy "
-        );
-
-        // display_notification without title
-        await doAction(webClient, {
-            type: "ir.actions.client",
-            tag: "display_notification",
-            params: {
-                message: "message %s <R&D>",
-                sticky: true,
-                links: [
-                    {
-                        label: "test <R&D>",
-                        url: "#action={action.id}&id={order.id}&model=purchase.order",
-                    },
-                ],
-            },
-        });
-        assert.containsOnce(
-            document.body,
-            notificationSelector,
-            "a notification should be present"
-        );
-        notificationElement = document.body.querySelector(notificationSelector);
-        assert.containsNone(
-            notificationElement,
-            ".o_notification_title",
-            "the notification should not have title"
-        );
-    });
-
-    QUnit.test("test next action on display_notification client action", async function (assert) {
-        const webClient = await createWebClient({ serverData });
-        const options = {
-            onClose: function () {
-                assert.step("onClose");
-            },
-        };
-        await doAction(
-            webClient,
-            {
-                type: "ir.actions.client",
-                tag: "display_notification",
-                params: {
-                    title: "title",
-                    message: "message",
-                    sticky: true,
-                    next: {
-                        type: "ir.actions.act_window_close",
-                    },
-                },
-            },
-            options
-        );
-        const notificationSelector = ".o_notification_manager .o_notification";
-        assert.containsOnce(
-            document.body,
-            notificationSelector,
-            "a notification should be present"
-        );
-        assert.verifySteps(["onClose"]);
-    });
-});

odoo-bringout-oca-ocb-web/web/static/tests/webclient/actions/close_action.test.js

@@ -0,0 +1,202 @@
+import { expect, test } from "@odoo/hoot";
+import { animationFrame, Deferred } from "@odoo/hoot-mock";
+import {
+    contains,
+    defineActions,
+    defineModels,
+    getService,
+    models,
+    mountWithCleanup,
+    onRpc,
+    patchWithCleanup,
+    webModels,
+} from "@web/../tests/web_test_helpers";
+
+import { listView } from "@web/views/list/list_view";
+import { WebClient } from "@web/webclient/webclient";
+
+const { ResCompany, ResPartner, ResUsers } = webModels;
+
+class Partner extends models.Model {
+    _rec_name = "display_name";
+
+    _records = [
+        { id: 1, display_name: "First record" },
+        { id: 2, display_name: "Second record" },
+    ];
+    _views = {
+        form: `
+            <form>
+                <group>
+                    <field name="display_name"/>
+                </group>
+            </form>`,
+        "kanban,1": `
+            <kanban>
+                <templates>
+                    <t t-name="card">
+                        <field name="display_name"/>
+                    </t>
+                </templates>
+            </kanban>`,
+        list: `<list><field name="display_name"/></list>`,
+    };
+}
+
+defineModels([Partner, ResCompany, ResPartner, ResUsers]);
+
+defineActions([
+    {
+        id: 1,
+        xml_id: "action_1",
+        name: "Partners Action 1",
+        res_model: "partner",
+        views: [[1, "kanban"]],
+    },
+    {
+        id: 3,
+        xml_id: "action_3",
+        name: "Partners",
+        res_model: "partner",
+        views: [
+            [false, "list"],
+            [1, "kanban"],
+            [false, "form"],
+        ],
+    },
+    {
+        id: 5,
+        xml_id: "action_5",
+        name: "Create a Partner",
+        res_model: "partner",
+        target: "new",
+        views: [[false, "form"]],
+    },
+]);
+
+test("close the currently opened dialog", async () => {
+    await mountWithCleanup(WebClient);
+    // execute an action in target="new"
+    await getService("action").doAction(5);
+    expect(".o_technical_modal .o_form_view").toHaveCount(1);
+    // execute an 'ir.actions.act_window_close' action
+    await getService("action").doAction({
+        type: "ir.actions.act_window_close",
+    });
+    await animationFrame();
+    expect(".o_technical_modal .o_form_view").toHaveCount(0);
+});
+
+test("close dialog by clicking on the header button", async () => {
+    await mountWithCleanup(WebClient);
+    // execute an action in target="new"
+    function onClose() {
+        expect.step("on_close");
+    }
+    await getService("action").doAction(5, { onClose });
+    expect(".o_dialog").toHaveCount(1);
+    await contains(".o_dialog .modal-header button").click();
+    expect(".o_dialog").toHaveCount(0);
+    expect.verifySteps(["on_close"]);
+
+    // execute an 'ir.actions.act_window_close' action
+    // should not call 'on_close' as it was already called.
+    await getService("action").doAction({ type: "ir.actions.act_window_close" });
+    expect.verifySteps([]);
+});
+
+test('execute "on_close" only if there is no dialog to close', async () => {
+    await mountWithCleanup(WebClient);
+    // execute an action in target="new"
+    await getService("action").doAction(5);
+    function onClose() {
+        expect.step("on_close");
+    }
+    const options = { onClose };
+    // execute an 'ir.actions.act_window_close' action
+    // should not call 'on_close' as there is a dialog to close
+    await getService("action").doAction({ type: "ir.actions.act_window_close" }, options);
+    expect.verifySteps([]);
+    // execute again an 'ir.actions.act_window_close' action
+    // should call 'on_close' as there is no dialog to close
+    await getService("action").doAction({ type: "ir.actions.act_window_close" }, options);
+    expect.verifySteps(["on_close"]);
+});
+
+test("close action with provided infos", async () => {
+    expect.assertions(1);
+
+    await mountWithCleanup(WebClient);
+    const options = {
+        onClose: function (infos) {
+            expect(infos).toBe("just for testing", {
+                message: "should have the correct close infos",
+            });
+        },
+    };
+    await getService("action").doAction(
+        {
+            type: "ir.actions.act_window_close",
+            infos: "just for testing",
+        },
+        options
+    );
+});
+
+test.tags("desktop");
+test("history back called within on_close", async () => {
+    let list;
+    patchWithCleanup(listView.Controller.prototype, {
+        setup() {
+            super.setup(...arguments);
+            list = this;
+        },
+    });
+    await mountWithCleanup(WebClient);
+
+    await getService("action").doAction(1);
+    expect(".o_kanban_view").toHaveCount(1);
+    await getService("action").doAction(3);
+    expect(".o_list_view").toHaveCount(1);
+
+    function onClose() {
+        list.env.config.historyBack();
+        expect.step("on_close");
+    }
+    // open a new dialog form
+    await getService("action").doAction(5, { onClose });
+
+    await contains(".modal-header button.btn-close").click();
+    // await nextTick();
+    expect(".modal").toHaveCount(0);
+    expect(".o_list_view").toHaveCount(0);
+    expect(".o_kanban_view").toHaveCount(1);
+    expect.verifySteps(["on_close"]);
+});
+
+test.tags("desktop");
+test("web client is not deadlocked when a view crashes", async () => {
+    expect.assertions(4);
+    expect.errors(1);
+
+    const readOnFirstRecordDef = new Deferred();
+    onRpc("web_read", ({ args }) => {
+        if (args[0][0] === 1) {
+            return readOnFirstRecordDef;
+        }
+    });
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(3);
+    // open first record in form view. this will crash and will not
+    // display a form view
+    await contains(".o_list_view .o_data_cell").click();
+    readOnFirstRecordDef.reject(new Error("not working as intended"));
+    await animationFrame();
+    expect.verifyErrors(["not working as intended"]);
+
+    expect(".o_list_view").toHaveCount(1, { message: "there should still be a list view in dom" });
+    // open another record, the read will not crash
+    await contains(".o_list_view .o_data_row:eq(1) .o_data_cell").click();
+    expect(".o_list_view").toHaveCount(0, { message: "there should not be a list view in dom" });
+    expect(".o_form_view").toHaveCount(1, { message: "there should be a form view in dom" });
+});

odoo-bringout-oca-ocb-web/web/static/tests/webclient/actions/close_action_tests.js

@@ -1,230 +0,0 @@
-/** @odoo-module **/
-
-import testUtils from "web.test_utils";
-import { registerCleanup } from "../../helpers/cleanup";
-import {
-    click,
-    getFixture,
-    legacyExtraNextTick,
-    nextTick,
-    patchWithCleanup,
-} from "../../helpers/utils";
-import { createWebClient, doAction, getActionManagerServerData } from "./../helpers";
-
-import { registry } from "@web/core/registry";
-import { formView } from "@web/views/form/form_view";
-import { listView } from "../../../src/views/list/list_view";
-
-let serverData;
-let target;
-QUnit.module("ActionManager", (hooks) => {
-    hooks.beforeEach(() => {
-        serverData = getActionManagerServerData();
-        target = getFixture();
-    });
-
-    QUnit.module('"ir.actions.act_window_close" actions');
-
-    QUnit.test("close the currently opened dialog", async function (assert) {
-        assert.expect(2);
-        const webClient = await createWebClient({ serverData });
-        // execute an action in target="new"
-        await doAction(webClient, 5);
-        assert.containsOnce(
-            document.body,
-            ".o_technical_modal .o_form_view",
-            "should have rendered a form view in a modal"
-        );
-        // execute an 'ir.actions.act_window_close' action
-        await doAction(webClient, {
-            type: "ir.actions.act_window_close",
-        });
-        assert.containsNone(document.body, ".o_technical_modal", "should have closed the modal");
-    });
-
-    QUnit.test("close dialog by clicking on the header button", async function (assert) {
-        assert.expect(5);
-        const webClient = await createWebClient({ serverData });
-        // execute an action in target="new"
-        function onClose() {
-            assert.step("on_close");
-        }
-        await doAction(webClient, 5, { onClose });
-        assert.containsOnce(target, ".o_dialog_container .o_dialog");
-        await click(target.querySelector(".o_dialog_container .o_dialog .modal-header button"));
-        assert.containsNone(target, ".o_dialog_container .o_dialog");
-        assert.verifySteps(["on_close"]);
-
-        // execute an 'ir.actions.act_window_close' action
-        // should not call 'on_close' as it was already called.
-        await doAction(webClient, { type: "ir.actions.act_window_close" });
-        assert.verifySteps([]);
-    });
-
-    QUnit.test('execute "on_close" only if there is no dialog to close', async function (assert) {
-        assert.expect(3);
-        const webClient = await createWebClient({ serverData });
-        // execute an action in target="new"
-        await doAction(webClient, 5);
-        function onClose() {
-            assert.step("on_close");
-        }
-        const options = { onClose };
-        // execute an 'ir.actions.act_window_close' action
-        // should not call 'on_close' as there is a dialog to close
-        await doAction(webClient, { type: "ir.actions.act_window_close" }, options);
-        assert.verifySteps([]);
-        // execute again an 'ir.actions.act_window_close' action
-        // should call 'on_close' as there is no dialog to close
-        await doAction(webClient, { type: "ir.actions.act_window_close" }, options);
-        assert.verifySteps(["on_close"]);
-    });
-
-    QUnit.test("close action with provided infos", async function (assert) {
-        assert.expect(1);
-        const webClient = await createWebClient({ serverData });
-        const options = {
-            onClose: function (infos) {
-                assert.strictEqual(
-                    infos,
-                    "just for testing",
-                    "should have the correct close infos"
-                );
-            },
-        };
-        await doAction(
-            webClient,
-            {
-                type: "ir.actions.act_window_close",
-                infos: "just for testing",
-            },
-            options
-        );
-    });
-
-    QUnit.test("history back calls on_close handler of dialog action", async function (assert) {
-        assert.expect(4);
-        let form;
-        patchWithCleanup(formView.Controller.prototype, {
-            setup() {
-                this._super(...arguments);
-                form = this;
-            },
-        });
-        const webClient = await createWebClient({ serverData });
-        function onClose() {
-            assert.step("on_close");
-        }
-        // open a new dialog form
-        await doAction(webClient, 5, { onClose });
-        assert.containsOnce(target, ".modal");
-        form.env.config.historyBack();
-        assert.verifySteps(["on_close"], "should have called the on_close handler");
-        await nextTick();
-        assert.containsNone(target, ".modal");
-    });
-
-    QUnit.test("history back called within on_close", async function (assert) {
-        assert.expect(7);
-        let list;
-        patchWithCleanup(listView.Controller.prototype, {
-            setup() {
-                this._super(...arguments);
-                list = this;
-            },
-        });
-        const webClient = await createWebClient({ serverData });
-
-        await doAction(webClient, 1);
-        assert.containsOnce(target, ".o_kanban_view");
-        await doAction(webClient, 3);
-        assert.containsOnce(target, ".o_list_view");
-
-        function onClose() {
-            list.env.config.historyBack();
-            assert.step("on_close");
-        }
-        // open a new dialog form
-        await doAction(webClient, 5, { onClose });
-
-        await click(target, ".modal-header button.btn-close");
-        await nextTick();
-        await legacyExtraNextTick();
-        assert.containsNone(target, ".modal");
-        assert.containsNone(target, ".o_list_view");
-        assert.containsOnce(target, ".o_kanban_view");
-        assert.verifySteps(["on_close"]);
-    });
-
-    QUnit.test(
-        "history back calls on_close handler of dialog action with 2 breadcrumbs",
-        async function (assert) {
-            assert.expect(7);
-            let list;
-            patchWithCleanup(listView.Controller.prototype, {
-                setup() {
-                    this._super(...arguments);
-                    list = this;
-                },
-            });
-            const webClient = await createWebClient({ serverData });
-            await doAction(webClient, 1); // kanban
-            await doAction(webClient, 3); // list
-            assert.containsOnce(target, ".o_list_view");
-            function onClose() {
-                assert.step("on_close");
-            }
-            // open a new dialog form
-            await doAction(webClient, 5, { onClose });
-            assert.containsOnce(target, ".modal");
-            assert.containsOnce(target, ".o_list_view");
-            list.env.config.historyBack();
-            assert.verifySteps(["on_close"], "should have called the on_close handler");
-            await nextTick();
-            await legacyExtraNextTick();
-            assert.containsOnce(target, ".o_list_view");
-            assert.containsNone(target, ".modal");
-        }
-    );
-
-    QUnit.test("web client is not deadlocked when a view crashes", async function (assert) {
-        assert.expect(6);
-        const handler = (ev) => {
-            assert.step("error");
-            // need to preventDefault to remove error from console (so python test pass)
-            ev.preventDefault();
-        };
-        // fake error service so that the odoo qunit handlers don't think that they need to handle the error
-        registry.category("services").add("error", { start: () => {} });
-        window.addEventListener("unhandledrejection", handler);
-        registerCleanup(() => window.removeEventListener("unhandledrejection", handler));
-        patchWithCleanup(QUnit, {
-            onUnhandledRejection: () => {},
-        });
-
-        const readOnFirstRecordDef = testUtils.makeTestPromise();
-        const mockRPC = (route, args) => {
-            if (args.method === "read" && args.args[0][0] === 1) {
-                return readOnFirstRecordDef;
-            }
-        };
-        const webClient = await createWebClient({ serverData, mockRPC });
-        await doAction(webClient, 3);
-        // open first record in form view. this will crash and will not
-        // display a form view
-        await testUtils.dom.click($(target).find(".o_list_view .o_data_cell:first"));
-        assert.verifySteps([]);
-        await legacyExtraNextTick();
-        readOnFirstRecordDef.reject(new Error("not working as intended"));
-        await nextTick();
-        assert.verifySteps(["error"]);
-        assert.containsOnce(target, ".o_list_view", "there should still be a list view in dom");
-        // open another record, the read will not crash
-        await testUtils.dom.click(
-            $(target).find(".o_list_view .o_data_row:eq(2) .o_data_cell:first")
-        );
-        await legacyExtraNextTick();
-        assert.containsNone(target, ".o_list_view", "there should not be a list view in dom");
-        assert.containsOnce(target, ".o_form_view", "there should be a form view in dom");
-    });
-});

odoo-bringout-oca-ocb-web/web/static/tests/webclient/actions/concurrency.test.js

@@ -0,0 +1,799 @@
+import { expect, test } from "@odoo/hoot";
+import { queryAll, queryAllTexts, runAllTimers } from "@odoo/hoot-dom";
+import { animationFrame, Deferred } from "@odoo/hoot-mock";
+import { Component, onWillStart, xml } from "@odoo/owl";
+import {
+    contains,
+    defineActions,
+    defineModels,
+    fields,
+    getService,
+    isItemSelected,
+    models,
+    mountWithCleanup,
+    onRpc,
+    patchWithCleanup,
+    serverState,
+    stepAllNetworkCalls,
+    switchView,
+    toggleMenuItem,
+    toggleSearchBarMenu,
+    webModels,
+} from "@web/../tests/web_test_helpers";
+
+import { registry } from "@web/core/registry";
+import { redirect } from "@web/core/utils/urls";
+import { ControlPanel } from "@web/search/control_panel/control_panel";
+import { SearchBar } from "@web/search/search_bar/search_bar";
+import { useSetupAction } from "@web/search/action_hook";
+import { WebClient } from "@web/webclient/webclient";
+import { browser } from "@web/core/browser/browser";
+import { router } from "@web/core/browser/router";
+
+const { ResCompany, ResPartner, ResUsers } = webModels;
+const actionRegistry = registry.category("actions");
+
+class Partner extends models.Model {
+    _rec_name = "display_name";
+
+    start = fields.Date();
+
+    _records = [
+        { id: 1, display_name: "First record" },
+        { id: 2, display_name: "Second record" },
+    ];
+    _views = {
+        form: /* xml */ `
+            <form>
+                <header>
+                    <button name="object" string="Call method" type="object"/>
+                </header>
+                <group>
+                    <field name="display_name"/>
+                </group>
+            </form>
+        `,
+        "kanban,1": /* xml */ `
+            <kanban>
+                <templates>
+                    <t t-name="card">
+                        <field name="display_name"/>
+                    </t>
+                </templates>
+            </kanban>`,
+        list: /* xml */ `<list><field name="display_name"/></list>`,
+        calendar: /* xml */ `<calendar date_start="start"/>`,
+    };
+}
+
+class Pony extends models.Model {
+    name = fields.Char();
+
+    _records = [
+        { id: 4, name: "Twilight Sparkle" },
+        { id: 6, name: "Applejack" },
+        { id: 9, name: "Fluttershy" },
+    ];
+    _views = {
+        list: /* xml */ `<list><field name="name"/></list>`,
+        form: /* xml */ `<form><field name="name"/></form>`,
+    };
+}
+
+defineModels([Partner, Pony, ResCompany, ResPartner, ResUsers]);
+
+defineActions([
+    {
+        id: 3,
+        xml_id: "action_3",
+        name: "Partners",
+        res_model: "partner",
+        views: [
+            [false, "list"],
+            [1, "kanban"],
+            [false, "calendar"],
+            [false, "form"],
+        ],
+    },
+    {
+        id: 4,
+        xml_id: "action_4",
+        name: "Partners Action 4",
+        res_model: "partner",
+        views: [
+            [1, "kanban"],
+            [false, "list"],
+            [false, "form"],
+        ],
+    },
+    {
+        id: 5,
+        xml_id: "action_5",
+        name: "Create a Partner",
+        res_model: "partner",
+        target: "new",
+        views: [[false, "form"]],
+    },
+    {
+        id: 8,
+        xml_id: "action_8",
+        name: "Favorite Ponies",
+        res_model: "pony",
+        views: [
+            [false, "list"],
+            [false, "form"],
+        ],
+    },
+]);
+
+test("drop previous actions if possible", async () => {
+    const def = new Deferred();
+    stepAllNetworkCalls();
+    onRpc("/web/action/load", () => def);
+
+    await mountWithCleanup(WebClient);
+    getService("action").doAction(4);
+    getService("action").doAction(8);
+    def.resolve();
+    await animationFrame();
+    // action 4 loads a kanban view first, 6 loads a list view. We want a list
+    expect(".o_list_view").toHaveCount(1);
+    expect.verifySteps([
+        "/web/webclient/translations",
+        "/web/webclient/load_menus",
+        "/web/action/load",
+        "/web/action/load",
+        "get_views",
+        "web_search_read",
+        "has_group",
+    ]);
+});
+
+test.tags("desktop");
+test("handle switching view and switching back on slow network", async () => {
+    const def = new Deferred();
+    const defs = [null, def, null];
+    stepAllNetworkCalls();
+    onRpc("web_search_read", () => defs.shift());
+
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(4);
+    // kanban view is loaded, switch to list view
+    await switchView("list");
+    // here, list view is not ready yet, because def is not resolved
+    // switch back to kanban view
+    await switchView("kanban");
+    // here, we want the kanban view to reload itself, regardless of list view
+    expect.verifySteps([
+        "/web/webclient/translations",
+        "/web/webclient/load_menus",
+        "/web/action/load",
+        "get_views",
+        "web_search_read",
+        "has_group",
+        "web_search_read",
+    ]);
+
+    // we resolve def => list view is now ready (but we want to ignore it)
+    def.resolve();
+    await animationFrame();
+    expect(".o_kanban_view").toHaveCount(1, { message: "there should be a kanban view in dom" });
+    expect(".o_list_view").toHaveCount(0, { message: "there should not be a list view in dom" });
+});
+
+test.tags("desktop");
+test("clicking quickly on breadcrumbs...", async () => {
+    let def;
+    onRpc("web_read", () => def);
+
+    await mountWithCleanup(WebClient);
+    // create a situation with 3 breadcrumbs: kanban/form/list
+    await getService("action").doAction(4);
+    await contains(".o_kanban_record").click();
+    await getService("action").doAction(8);
+
+    // now, the next read operations will be promise (this is the read
+    // operation for the form view reload)
+    def = new Deferred();
+    // click on the breadcrumbs for the form view, then on the kanban view
+    // before the form view is fully reloaded
+    await contains(queryAll(".o_control_panel .breadcrumb-item")[1]).click();
+    await contains(".o_control_panel .breadcrumb-item").click();
+
+    // resolve the form view read
+    def.resolve();
+    await animationFrame();
+    expect(queryAllTexts(".breadcrumb-item, .o_breadcrumb .active")).toEqual(["Partners Action 4"]);
+});
+
+test.tags("desktop");
+test("execute a new action while loading a lazy-loaded controller", async () => {
+    defineActions([
+        {
+            id: 77,
+            type: "ir.actions.act_window",
+            res_model: "partner",
+            views: [
+                [false, "calendar"],
+                [false, "form"],
+            ],
+        },
+    ]);
+    redirect("/odoo/action-77/2?cids=1");
+
+    let def;
+    onRpc("partner", "search_read", () => def);
+    stepAllNetworkCalls();
+
+    await mountWithCleanup(WebClient);
+    await animationFrame(); // blank component
+    expect(".o_form_view").toHaveCount(1, { message: "should display the form view of action 4" });
+
+    // click to go back to Kanban (this request is blocked)
+    def = new Deferred();
+    await contains(".o_control_panel .breadcrumb a").click();
+    expect(".o_form_view").toHaveCount(1, {
+        message: "should still display the form view of action 4",
+    });
+
+    // execute another action meanwhile (don't block this request)
+    await getService("action").doAction(8, { clearBreadcrumbs: true });
+    expect(".o_list_view").toHaveCount(1, { message: "should display action 8" });
+    expect(".o_form_view").toHaveCount(0, { message: "should no longer display the form view" });
+    expect.verifySteps([
+        "/web/webclient/translations",
+        "/web/webclient/load_menus",
+        "/web/action/load",
+        "get_views",
+        "web_read",
+        "search_read",
+        "/web/action/load",
+        "get_views",
+        "web_search_read",
+        "has_group",
+    ]);
+
+    // unblock the switch to Kanban in action 4
+    def.resolve();
+    await animationFrame();
+    expect(".o_list_view").toHaveCount(1, { message: "should still display action 8" });
+    expect(".o_kanban_view").toHaveCount(0, {
+        message: "should not display the kanban view of action 4",
+    });
+    expect.verifySteps([]);
+});
+
+test.tags("desktop");
+test("execute a new action while handling a call_button", async () => {
+    const def = new Deferred();
+    onRpc("/web/dataset/call_button/*", async () => {
+        await def;
+        return {
+            name: "Partners Action 1",
+            res_model: "partner",
+            views: [[1, "kanban"]],
+        };
+    });
+    stepAllNetworkCalls();
+
+    await mountWithCleanup(WebClient);
+    // execute action 3 and open a record in form view
+    await getService("action").doAction(3);
+    await contains(".o_list_view .o_data_cell").click();
+    expect(".o_form_view").toHaveCount(1, { message: "should display the form view of action 3" });
+
+    // click on 'Call method' button (this request is blocked)
+    await contains('.o_form_view button[name="object"]').click();
+    expect(".o_form_view").toHaveCount(1, {
+        message: "should still display the form view of action 3",
+    });
+
+    // execute another action
+    await getService("action").doAction(8, { clearBreadcrumbs: true });
+    expect(".o_list_view").toHaveCount(1, { message: "should display the list view of action 8" });
+    expect(".o_form_view").toHaveCount(0, { message: "should no longer display the form view" });
+    expect.verifySteps([
+        "/web/webclient/translations",
+        "/web/webclient/load_menus",
+        "/web/action/load",
+        "get_views",
+        "web_search_read",
+        "has_group",
+        "web_read",
+        "object",
+        "/web/action/load",
+        "get_views",
+        "web_search_read",
+    ]);
+
+    // unblock the call_button request
+    def.resolve();
+    await animationFrame();
+    expect(".o_list_view").toHaveCount(1, {
+        message: "should still display the list view of action 8",
+    });
+    expect(".o_kanban_view").toHaveCount(0, { message: "should not display action 1" });
+    expect.verifySteps([]);
+});
+
+test.tags("desktop");
+test("execute a new action while switching to another controller", async () => {
+    // This test's bottom line is that a doAction always has priority
+    // over a switch controller (clicking on a record row to go to form view).
+    // In general, the last actionManager's operation has priority because we want
+    // to allow the user to make mistakes, or to rapidly reconsider her next action.
+    // Here we assert that the actionManager's RPC are in order, but a 'read' operation
+    // is expected, with the current implementation, to take place when switching to the form view.
+    // Ultimately the form view's 'read' is superfluous, but can happen at any point of the flow,
+    // except at the very end, which should always be the final action's list's 'search_read'.
+    let def;
+    stepAllNetworkCalls();
+    onRpc("web_read", () => def);
+
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(3);
+    expect(".o_list_view").toHaveCount(1, { message: "should display the list view of action 3" });
+
+    // switch to the form view (this request is blocked)
+    def = new Deferred();
+    await contains(".o_list_view .o_data_cell").click();
+    expect(".o_list_view").toHaveCount(1, {
+        message: "should still display the list view of action 3",
+    });
+
+    // execute another action meanwhile (don't block this request)
+    await getService("action").doAction(4, { clearBreadcrumbs: true });
+    expect(".o_kanban_view").toHaveCount(1, {
+        message: "should display the kanban view of action 8",
+    });
+    expect(".o_list_view").toHaveCount(0, { message: "should no longer display the list view" });
+    expect.verifySteps([
+        "/web/webclient/translations",
+        "/web/webclient/load_menus",
+        "/web/action/load",
+        "get_views",
+        "web_search_read",
+        "has_group",
+        "web_read",
+        "/web/action/load",
+        "get_views",
+        "web_search_read",
+    ]);
+
+    // unblock the switch to the form view in action 3
+    def.resolve();
+    await animationFrame();
+    expect(".o_kanban_view").toHaveCount(1, {
+        message: "should still display the kanban view of action 8",
+    });
+    expect(".o_form_view").toHaveCount(0, {
+        message: "should not display the form view of action 3",
+    });
+    expect.verifySteps([]);
+});
+
+test("execute a new action while loading views", async () => {
+    const def = new Deferred();
+    stepAllNetworkCalls();
+    onRpc("get_views", () => def);
+
+    await mountWithCleanup(WebClient);
+    // execute a first action (its 'get_views' RPC is blocked)
+    getService("action").doAction(3);
+    await animationFrame();
+    expect(".o_list_view").toHaveCount(0, {
+        message: "should not display the list view of action 3",
+    });
+
+    // execute another action meanwhile (and unlock the RPC)
+    getService("action").doAction(4);
+    await animationFrame();
+    def.resolve();
+    await animationFrame();
+    expect(".o_kanban_view").toHaveCount(1, {
+        message: "should display the kanban view of action 4",
+    });
+    expect(".o_list_view").toHaveCount(0, {
+        message: "should not display the list view of action 3",
+    });
+    expect(queryAllTexts(".breadcrumb-item, .o_breadcrumb .active")).toEqual(["Partners Action 4"]);
+    expect.verifySteps([
+        "/web/webclient/translations",
+        "/web/webclient/load_menus",
+        "/web/action/load",
+        "get_views",
+        "/web/action/load",
+        "get_views",
+        "web_search_read",
+        "has_group",
+    ]);
+});
+
+test.tags("desktop");
+test("execute a new action while loading data of default view", async () => {
+    const def = new Deferred();
+    stepAllNetworkCalls();
+    onRpc("web_read", () => def);
+
+    await mountWithCleanup(WebClient);
+    // execute a first action (its 'web_read' RPC is blocked)
+    getService("action").doAction({
+        name: "A Partner",
+        res_model: "partner",
+        res_id: 1,
+        type: "ir.actions.act_window",
+        views: [[false, "form"]],
+    });
+    await animationFrame();
+    expect(".o_form_view").toHaveCount(0, {
+        message: "should not display the form view",
+    });
+
+    // execute another action meanwhile (and unlock the RPC)
+    getService("action").doAction(4);
+    def.resolve();
+    await animationFrame();
+    expect(".o_kanban_view").toHaveCount(1, {
+        message: "should display the kanban view of action 4",
+    });
+    expect(".o_form_view").toHaveCount(0, {
+        message: "should not display the form view",
+    });
+    expect(queryAllTexts(".breadcrumb-item, .o_breadcrumb .active")).toEqual(["Partners Action 4"]);
+    expect.verifySteps([
+        "/web/webclient/translations",
+        "/web/webclient/load_menus",
+        "get_views",
+        "web_read",
+        "/web/action/load",
+        "get_views",
+        "web_search_read",
+        "has_group",
+    ]);
+});
+
+test.tags("desktop");
+test("open a record while reloading the list view", async () => {
+    let def;
+    onRpc("search_read", () => def);
+
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(3);
+    expect(".o_calendar_view").toHaveCount(0);
+    expect(".o_list_view").toHaveCount(1);
+    expect(".o_list_view .o_data_row").toHaveCount(2);
+    expect(".o_control_panel .o_list_button_add").toHaveCount(1);
+
+    // reload (the search_read RPC will be blocked)
+    def = new Deferred();
+    await switchView("calendar");
+    expect(".o_list_view .o_data_row").toHaveCount(2);
+    expect(".o_control_panel .o_list_button_add").toHaveCount(1);
+
+    // open a record in form view
+    await contains(".o_list_view .o_data_cell").click();
+    expect(".o_form_view").toHaveCount(1);
+    expect(".o_control_panel .o_list_button_add").toHaveCount(0);
+
+    // unblock the search_read RPC
+    def.resolve();
+    await animationFrame();
+    expect(".o_form_view").toHaveCount(1);
+    expect(".o_list_view").toHaveCount(0);
+    expect(".o_calendar_view").toHaveCount(0);
+    expect(".o_control_panel .o_list_button_add").toHaveCount(0);
+});
+
+test("properly drop client actions after new action is initiated", async () => {
+    const slowWillStartDef = new Deferred();
+    class ClientAction extends Component {
+        static template = xml`<div class="client_action">ClientAction</div>`;
+        static props = ["*"];
+        setup() {
+            onWillStart(() => slowWillStartDef);
+        }
+    }
+    actionRegistry.add("slowAction", ClientAction);
+
+    await mountWithCleanup(WebClient);
+    getService("action").doAction("slowAction");
+    await animationFrame();
+    expect(".client_action").toHaveCount(0, { message: "client action isn't ready yet" });
+
+    getService("action").doAction(4);
+    await animationFrame();
+    expect(".o_kanban_view").toHaveCount(1, { message: "should have loaded a kanban view" });
+
+    slowWillStartDef.resolve();
+    await animationFrame();
+    expect(".o_kanban_view").toHaveCount(1, { message: "should still display the kanban view" });
+});
+
+test.tags("desktop");
+test("restoring a controller when doing an action -- load_action slow", async () => {
+    let def;
+    onRpc("/web/action/load", () => def);
+    stepAllNetworkCalls();
+
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(3);
+    expect(".o_list_view").toHaveCount(1);
+
+    await contains(".o_list_view .o_data_cell").click();
+    expect(".o_form_view").toHaveCount(1);
+
+    def = new Deferred();
+    getService("action").doAction(4, { clearBreadcrumbs: true });
+    await animationFrame();
+    expect(".o_form_view").toHaveCount(1, { message: "should still contain the form view" });
+
+    await contains(".o_control_panel .breadcrumb-item a").click();
+    def.resolve();
+    await animationFrame();
+    expect(".o_list_view").toHaveCount(1);
+    expect(queryAllTexts(".breadcrumb-item, .o_breadcrumb .active")).toEqual(["Partners"]);
+    expect(".o_form_view").toHaveCount(0);
+    expect.verifySteps([
+        "/web/webclient/translations",
+        "/web/webclient/load_menus",
+        "/web/action/load",
+        "get_views",
+        "web_search_read",
+        "has_group",
+        "web_read",
+        "/web/action/load",
+        "web_search_read",
+    ]);
+});
+
+test.tags("desktop");
+test("switching when doing an action -- load_action slow", async () => {
+    let def;
+    onRpc("/web/action/load", () => def);
+    stepAllNetworkCalls();
+
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(3);
+    expect(".o_list_view").toHaveCount(1);
+
+    def = new Deferred();
+    getService("action").doAction(4, { clearBreadcrumbs: true });
+    await animationFrame();
+    expect(".o_list_view").toHaveCount(1, { message: "should still contain the list view" });
+
+    await switchView("kanban");
+    def.resolve();
+    await animationFrame();
+    expect(".o_kanban_view").toHaveCount(1);
+    expect(queryAllTexts(".breadcrumb-item, .o_breadcrumb .active")).toEqual(["Partners"]);
+    expect(".o_list_view").toHaveCount(0);
+    expect.verifySteps([
+        "/web/webclient/translations",
+        "/web/webclient/load_menus",
+        "/web/action/load",
+        "get_views",
+        "web_search_read",
+        "has_group",
+        "/web/action/load",
+        "web_search_read",
+    ]);
+});
+
+test.tags("desktop");
+test("switching when doing an action -- get_views slow", async () => {
+    let def;
+    onRpc("get_views", () => def);
+    stepAllNetworkCalls();
+
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(3);
+    expect(".o_list_view").toHaveCount(1);
+
+    def = new Deferred();
+    getService("action").doAction(4);
+    await animationFrame();
+    expect(".o_list_view").toHaveCount(1, { message: "should still contain the list view" });
+
+    await switchView("kanban");
+    def.resolve();
+    await animationFrame();
+    expect(".o_kanban_view").toHaveCount(1);
+    expect(queryAllTexts(".breadcrumb-item, .o_breadcrumb .active")).toEqual(["Partners"]);
+    expect(".o_list_view").toHaveCount(0);
+    expect.verifySteps([
+        "/web/webclient/translations",
+        "/web/webclient/load_menus",
+        "/web/action/load",
+        "get_views",
+        "web_search_read",
+        "has_group",
+        "/web/action/load",
+        "get_views",
+        "web_search_read",
+    ]);
+});
+
+test.tags("desktop");
+test("switching when doing an action -- search_read slow", async () => {
+    const def = new Deferred();
+    onRpc("search_read", () => def);
+    stepAllNetworkCalls();
+
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(3);
+    expect(".o_list_view").toHaveCount(1);
+
+    getService("action").doAction({
+        type: "ir.actions.act_window",
+        res_model: "partner",
+        views: [[false, "calendar"]],
+    });
+    await animationFrame();
+    await switchView("kanban");
+    def.resolve();
+    await animationFrame();
+    expect(".o_kanban_view").toHaveCount(1);
+    expect(queryAllTexts(".breadcrumb-item, .o_breadcrumb .active")).toEqual(["Partners"]);
+    expect(".o_list_view").toHaveCount(0);
+    expect.verifySteps([
+        "/web/webclient/translations",
+        "/web/webclient/load_menus",
+        "/web/action/load",
+        "get_views",
+        "web_search_read",
+        "has_group",
+        "get_views",
+        "search_read",
+        "web_search_read",
+    ]);
+});
+
+test.tags("desktop");
+test("click multiple times to open a record", async () => {
+    const def = new Deferred();
+    onRpc("web_read", () => def);
+
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(3);
+    expect(".o_list_view").toHaveCount(1);
+
+    const row1 = queryAll(".o_list_view .o_data_row")[0];
+    const row2 = queryAll(".o_list_view .o_data_row")[1];
+    await contains(row1.querySelector(".o_data_cell")).click();
+    await contains(row2.querySelector(".o_data_cell")).click();
+
+    def.resolve();
+    await animationFrame();
+    expect(".o_form_view").toHaveCount(1);
+    expect(queryAllTexts(".breadcrumb-item, .o_breadcrumb .active")).toEqual([
+        "Partners",
+        "Second record",
+    ]);
+});
+
+test("dialog will only open once for two rapid actions with the target new", async () => {
+    const def = new Deferred();
+    onRpc("onchange", () => def);
+
+    await mountWithCleanup(WebClient);
+    getService("action").doAction(5);
+    await animationFrame();
+    expect(".o_dialog .o_form_view").toHaveCount(0);
+
+    getService("action").doAction(5);
+    await animationFrame();
+    expect(".o_dialog .o_form_view").toHaveCount(0);
+
+    def.resolve();
+    await animationFrame();
+    expect(".o_dialog .o_form_view").toHaveCount(1);
+});
+
+test.tags("desktop");
+test("local state, global state, and race conditions", async () => {
+    patchWithCleanup(serverState.view_info, {
+        toy: { multi_record: true, display_name: "Toy", icon: "fab fa-android" },
+    });
+    Partner._views = {
+        toy: `<toy/>`,
+        list: `<list><field name="display_name"/></list>`,
+        search: `<search><filter name="display_name" string="Foo" domain="[]"/></search>`,
+    };
+
+    let def = Promise.resolve();
+    let id = 1;
+    class ToyController extends Component {
+        static template = xml`
+            <div class="o_toy_view">
+                <ControlPanel />
+                <SearchBar />
+            </div>`;
+        static components = { ControlPanel, SearchBar };
+        static props = ["*"];
+        setup() {
+            this.id = id++;
+            expect.step(this.props.state || "no state");
+            useSetupAction({
+                getLocalState: () => ({ fromId: this.id }),
+            });
+            onWillStart(() => def);
+        }
+    }
+
+    registry.category("views").add("toy", {
+        type: "toy",
+        Controller: ToyController,
+    });
+
+    await mountWithCleanup(WebClient);
+
+    await getService("action").doAction({
+        res_model: "partner",
+        type: "ir.actions.act_window",
+        // list (or something else) must be added to have the view switcher displayed
+        views: [
+            [false, "toy"],
+            [false, "list"],
+        ],
+    });
+
+    await toggleSearchBarMenu();
+    await toggleMenuItem("Foo");
+    expect(isItemSelected("Foo")).toBe(true);
+
+    // reload twice by clicking on toy view switcher
+    def = new Deferred();
+    await contains(".o_control_panel .o_switch_view.o_toy").click();
+    await contains(".o_control_panel .o_switch_view.o_toy").click();
+
+    def.resolve();
+    await animationFrame();
+
+    await toggleSearchBarMenu();
+    expect(isItemSelected("Foo")).toBe(true);
+    // this test is not able to detect that getGlobalState is put on the right place:
+    // currentController.action.globalState contains in any case the search state
+    // of the first instantiated toy view.
+
+    expect.verifySteps([
+        "no state", // setup first view instantiated
+        { fromId: 1 }, // setup second view instantiated
+        { fromId: 1 }, // setup third view instantiated
+    ]);
+});
+
+test.tags("desktop");
+test("doing browser back temporarily disables the UI", async () => {
+    let def;
+    onRpc("partner", "web_search_read", () => def);
+    await mountWithCleanup(WebClient);
+
+    await getService("action").doAction(4);
+    await getService("action").doAction(8);
+    await runAllTimers(); // wait for the update of the router
+    expect(router.current).toEqual({
+        action: 8,
+        actionStack: [
+            {
+                action: 4,
+                displayName: "Partners Action 4",
+                view_type: "kanban",
+            },
+            {
+                action: 8,
+                displayName: "Favorite Ponies",
+                view_type: "list",
+            },
+        ],
+    });
+
+    def = new Deferred();
+    browser.history.back();
+    expect(document.body.style.pointerEvents).toBe("none");
+    // await contains(".o_control_panel .breadcrumb-item").click(); todo JUM: click on breadcrumb
+    def.resolve();
+
+    await animationFrame();
+    expect(queryAllTexts(".breadcrumb-item, .o_breadcrumb .active")).toEqual(["Partners Action 4"]);
+    expect(document.body.style.pointerEvents).toBe("auto");
+});

odoo-bringout-oca-ocb-web/web/static/tests/webclient/actions/concurrency_tests.js

@@ -1,736 +0,0 @@
-/** @odoo-module **/
-
-import {
-    click,
-    getFixture,
-    legacyExtraNextTick,
-    makeDeferred,
-    nextTick,
-} from "@web/../tests/helpers/utils";
-import { ControlPanel } from "@web/search/control_panel/control_panel";
-import {
-    isItemSelected,
-    toggleFilterMenu,
-    toggleMenuItem,
-    switchView,
-} from "@web/../tests/search/helpers";
-import { registry } from "@web/core/registry";
-import { useSetupView } from "@web/views/view_hook";
-import {
-    createWebClient,
-    doAction,
-    getActionManagerServerData,
-    loadState,
-} from "@web/../tests/webclient/helpers";
-
-import { Component, xml } from "@odoo/owl";
-const actionRegistry = registry.category("actions");
-
-let serverData;
-let target;
-
-QUnit.module("ActionManager", (hooks) => {
-    hooks.beforeEach(() => {
-        serverData = getActionManagerServerData();
-        target = getFixture();
-    });
-
-    QUnit.module("Concurrency management");
-
-    QUnit.test("drop previous actions if possible", async function (assert) {
-        assert.expect(7);
-        const def = makeDeferred();
-        const mockRPC = async function (route) {
-            assert.step(route);
-            if (route === "/web/action/load") {
-                await def;
-            }
-        };
-        const webClient = await createWebClient({ serverData, mockRPC });
-        doAction(webClient, 4);
-        doAction(webClient, 8);
-        def.resolve();
-        await nextTick();
-        // action 4 loads a kanban view first, 6 loads a list view. We want a list
-        assert.containsOnce(target, ".o_list_view");
-        assert.verifySteps([
-            "/web/webclient/load_menus",
-            "/web/action/load",
-            "/web/action/load",
-            "/web/dataset/call_kw/pony/get_views",
-            "/web/dataset/call_kw/pony/web_search_read",
-        ]);
-    });
-
-    QUnit.test("handle switching view and switching back on slow network", async function (assert) {
-        assert.expect(9);
-        const def = makeDeferred();
-        const defs = [Promise.resolve(), def, Promise.resolve()];
-        const mockRPC = async function (route, { method }) {
-            assert.step(route);
-            if (method === "web_search_read") {
-                await defs.shift();
-            }
-        };
-        const webClient = await createWebClient({ serverData, mockRPC });
-        await doAction(webClient, 4);
-        // kanban view is loaded, switch to list view
-        await switchView(target, "list");
-        // here, list view is not ready yet, because def is not resolved
-        // switch back to kanban view
-        await switchView(target, "kanban");
-        // here, we want the kanban view to reload itself, regardless of list view
-        assert.verifySteps([
-            "/web/webclient/load_menus",
-            "/web/action/load",
-            "/web/dataset/call_kw/partner/get_views",
-            "/web/dataset/call_kw/partner/web_search_read",
-            "/web/dataset/call_kw/partner/web_search_read",
-            "/web/dataset/call_kw/partner/web_search_read",
-        ]);
-        // we resolve def => list view is now ready (but we want to ignore it)
-        def.resolve();
-        await nextTick();
-        assert.containsOnce(target, ".o_kanban_view", "there should be a kanban view in dom");
-        assert.containsNone(target, ".o_list_view", "there should not be a list view in dom");
-    });
-
-    QUnit.test("when an server action takes too much time...", async function (assert) {
-        assert.expect(1);
-        const def = makeDeferred();
-        const mockRPC = async function (route, args) {
-            if (route === "/web/action/run") {
-                await def;
-                return 1;
-            }
-        };
-        const webClient = await createWebClient({ serverData, mockRPC });
-        doAction(webClient, 2);
-        doAction(webClient, 4);
-        def.resolve();
-        await nextTick();
-        await legacyExtraNextTick();
-        assert.strictEqual(
-            $(target).find(".o_control_panel .breadcrumb-item.active").text(),
-            "Partners Action 4",
-            "action 4 should be loaded"
-        );
-    });
-
-    QUnit.test("clicking quickly on breadcrumbs...", async function (assert) {
-        assert.expect(1);
-        let def;
-        const mockRPC = async function (route, args) {
-            if (args && args.method === "read") {
-                await def;
-            }
-        };
-        const webClient = await createWebClient({ serverData, mockRPC });
-        // create a situation with 3 breadcrumbs: kanban/form/list
-        await doAction(webClient, 4);
-        await click(target.querySelector(".o_kanban_record"));
-        await doAction(webClient, 8);
-        // now, the next read operations will be promise (this is the read
-        // operation for the form view reload)
-        def = makeDeferred();
-        // click on the breadcrumbs for the form view, then on the kanban view
-        // before the form view is fully reloaded
-        await click(target.querySelectorAll(".o_control_panel .breadcrumb-item")[1]);
-        await click(target.querySelector(".o_control_panel .breadcrumb-item"));
-        // resolve the form view read
-        def.resolve();
-        await nextTick();
-        assert.strictEqual(
-            $(target).find(".o_control_panel .breadcrumb-item.active").text(),
-            "Partners Action 4",
-            "action 4 should be loaded and visible"
-        );
-    });
-
-    QUnit.test(
-        "execute a new action while loading a lazy-loaded controller",
-        async function (assert) {
-            assert.expect(16);
-            let def;
-            const mockRPC = async function (route, { method, model }) {
-                assert.step(method || route);
-                if (method === "web_search_read" && model === "partner") {
-                    await def;
-                }
-            };
-            const webClient = await createWebClient({ serverData, mockRPC });
-            await loadState(webClient, {
-                action: 4,
-                id: 2,
-                view_type: "form",
-            });
-            assert.containsOnce(target, ".o_form_view", "should display the form view of action 4");
-            // click to go back to Kanban (this request is blocked)
-            def = makeDeferred();
-            await click(target.querySelector(".o_control_panel .breadcrumb a"));
-            assert.containsOnce(
-                target,
-                ".o_form_view",
-                "should still display the form view of action 4"
-            );
-            // execute another action meanwhile (don't block this request)
-            await doAction(webClient, 8, { clearBreadcrumbs: true });
-            assert.containsOnce(target, ".o_list_view", "should display action 8");
-            assert.containsNone(target, ".o_form_view", "should no longer display the form view");
-            assert.verifySteps([
-                "/web/webclient/load_menus",
-                "/web/action/load",
-                "get_views",
-                "read",
-                "web_search_read",
-                "/web/action/load",
-                "get_views",
-                "web_search_read",
-            ]);
-            // unblock the switch to Kanban in action 4
-            def.resolve();
-            await nextTick();
-            assert.containsOnce(target, ".o_list_view", "should still display action 8");
-            assert.containsNone(
-                target,
-                ".o_kanban_view",
-                "should not display the kanban view of action 4"
-            );
-            assert.verifySteps([]);
-        }
-    );
-
-    QUnit.test("execute a new action while handling a call_button", async function (assert) {
-        assert.expect(17);
-        const def = makeDeferred();
-        const mockRPC = async function (route, args) {
-            assert.step((args && args.method) || route);
-            if (route === "/web/dataset/call_button") {
-                await def;
-                return serverData.actions[1];
-            }
-        };
-        const webClient = await createWebClient({ serverData, mockRPC });
-        // execute action 3 and open a record in form view
-        await doAction(webClient, 3);
-        await click(target.querySelector(".o_list_view .o_data_cell"));
-        assert.containsOnce(target, ".o_form_view", "should display the form view of action 3");
-        // click on 'Call method' button (this request is blocked)
-        await click(target.querySelector('.o_form_view button[name="object"]'));
-        assert.containsOnce(
-            target,
-            ".o_form_view",
-            "should still display the form view of action 3"
-        );
-        // execute another action
-        await doAction(webClient, 8, { clearBreadcrumbs: true });
-        assert.containsOnce(target, ".o_list_view", "should display the list view of action 8");
-        assert.containsNone(target, ".o_form_view", "should no longer display the form view");
-        assert.verifySteps([
-            "/web/webclient/load_menus",
-            "/web/action/load",
-            "get_views",
-            "web_search_read",
-            "read",
-            "object",
-            "/web/action/load",
-            "get_views",
-            "web_search_read",
-        ]);
-        // unblock the call_button request
-        def.resolve();
-        await nextTick();
-        assert.containsOnce(
-            target,
-            ".o_list_view",
-            "should still display the list view of action 8"
-        );
-        assert.containsNone(target, ".o_kanban_view", "should not display action 1");
-        assert.verifySteps([]);
-    });
-
-    QUnit.test(
-        "execute a new action while switching to another controller",
-        async function (assert) {
-            assert.expect(16);
-            // This test's bottom line is that a doAction always has priority
-            // over a switch controller (clicking on a record row to go to form view).
-            // In general, the last actionManager's operation has priority because we want
-            // to allow the user to make mistakes, or to rapidly reconsider her next action.
-            // Here we assert that the actionManager's RPC are in order, but a 'read' operation
-            // is expected, with the current implementation, to take place when switching to the form view.
-            // Ultimately the form view's 'read' is superfluous, but can happen at any point of the flow,
-            // except at the very end, which should always be the final action's list's 'search_read'.
-            let def;
-            const mockRPC = async function (route, args) {
-                assert.step((args && args.method) || route);
-                if (args && args.method === "read") {
-                    await def;
-                }
-            };
-            const webClient = await createWebClient({ serverData, mockRPC });
-            await doAction(webClient, 3);
-            assert.containsOnce(target, ".o_list_view", "should display the list view of action 3");
-            // switch to the form view (this request is blocked)
-            def = makeDeferred();
-            await click(target.querySelector(".o_list_view .o_data_cell"));
-            assert.containsOnce(
-                target,
-                ".o_list_view",
-                "should still display the list view of action 3"
-            );
-            // execute another action meanwhile (don't block this request)
-            await doAction(webClient, 4, { clearBreadcrumbs: true });
-            assert.containsOnce(
-                target,
-                ".o_kanban_view",
-                "should display the kanban view of action 8"
-            );
-            assert.containsNone(target, ".o_list_view", "should no longer display the list view");
-            assert.verifySteps([
-                "/web/webclient/load_menus",
-                "/web/action/load",
-                "get_views",
-                "web_search_read",
-                "read",
-                "/web/action/load",
-                "get_views",
-                "web_search_read",
-            ]);
-            // unblock the switch to the form view in action 3
-            def.resolve();
-            await nextTick();
-            assert.containsOnce(
-                target,
-                ".o_kanban_view",
-                "should still display the kanban view of action 8"
-            );
-            assert.containsNone(
-                target,
-                ".o_form_view",
-                "should not display the form view of action 3"
-            );
-            assert.verifySteps([]);
-        }
-    );
-
-    QUnit.test("execute a new action while loading views", async function (assert) {
-        assert.expect(11);
-        const def = makeDeferred();
-        const mockRPC = async function (route, args) {
-            assert.step((args && args.method) || route);
-            if (args && args.method === "get_views") {
-                await def;
-            }
-        };
-        const webClient = await createWebClient({ serverData, mockRPC });
-        // execute a first action (its 'get_views' RPC is blocked)
-        doAction(webClient, 3);
-        await nextTick();
-        assert.containsNone(target, ".o_list_view", "should not display the list view of action 3");
-        // execute another action meanwhile (and unlock the RPC)
-        doAction(webClient, 4);
-        await nextTick();
-        def.resolve();
-        await nextTick();
-        assert.containsOnce(target, ".o_kanban_view", "should display the kanban view of action 4");
-        assert.containsNone(target, ".o_list_view", "should not display the list view of action 3");
-        assert.containsOnce(
-            target,
-            ".o_control_panel .breadcrumb-item",
-            "there should be one controller in the breadcrumbs"
-        );
-        assert.verifySteps([
-            "/web/webclient/load_menus",
-            "/web/action/load",
-            "get_views",
-            "/web/action/load",
-            "get_views",
-            "web_search_read",
-        ]);
-    });
-
-    QUnit.test("execute a new action while loading data of default view", async function (assert) {
-        assert.expect(12);
-        const def = makeDeferred();
-        const mockRPC = async function (route, { method }) {
-            assert.step(method || route);
-            if (method === "web_search_read") {
-                await def;
-            }
-        };
-        const webClient = await createWebClient({ serverData, mockRPC });
-        // execute a first action (its 'search_read' RPC is blocked)
-        doAction(webClient, 3);
-        await nextTick();
-        assert.containsNone(target, ".o_list_view", "should not display the list view of action 3");
-        // execute another action meanwhile (and unlock the RPC)
-        doAction(webClient, 4);
-        def.resolve();
-        await nextTick();
-        assert.containsOnce(target, ".o_kanban_view", "should display the kanban view of action 4");
-        assert.containsNone(target, ".o_list_view", "should not display the list view of action 3");
-        assert.containsOnce(
-            target,
-            ".o_control_panel .breadcrumb-item",
-            "there should be one controller in the breadcrumbs"
-        );
-        assert.verifySteps([
-            "/web/webclient/load_menus",
-            "/web/action/load",
-            "get_views",
-            "web_search_read",
-            "/web/action/load",
-            "get_views",
-            "web_search_read",
-        ]);
-    });
-
-    QUnit.test("open a record while reloading the list view", async function (assert) {
-        assert.expect(10);
-        let def;
-        const mockRPC = async function (route) {
-            if (route === "/web/dataset/search_read") {
-                await def;
-            }
-        };
-        const webClient = await createWebClient({ serverData, mockRPC });
-        await doAction(webClient, 3);
-        assert.containsOnce(target, ".o_list_view");
-        assert.containsN(target, ".o_list_view .o_data_row", 5);
-        assert.containsOnce(target, ".o_control_panel .o_list_buttons");
-        // reload (the search_read RPC will be blocked)
-        def = makeDeferred();
-        await switchView(target, "list");
-        assert.containsN(target, ".o_list_view .o_data_row", 5);
-        assert.containsOnce(target, ".o_control_panel .o_list_buttons");
-        // open a record in form view
-        await click(target.querySelector(".o_list_view .o_data_cell"));
-        assert.containsOnce(target, ".o_form_view");
-        assert.containsNone(target, ".o_control_panel .o_list_buttons");
-        // unblock the search_read RPC
-        def.resolve();
-        await nextTick();
-        assert.containsOnce(target, ".o_form_view");
-        assert.containsNone(target, ".o_list_view");
-        assert.containsNone(target, ".o_control_panel .o_list_buttons");
-    });
-
-    QUnit.test(
-        "properly drop client actions after new action is initiated",
-        async function (assert) {
-            assert.expect(3);
-            const slowWillStartDef = makeDeferred();
-            class ClientAction extends Component {
-                setup() {
-                    owl.onWillStart(() => slowWillStartDef);
-                }
-            }
-            ClientAction.template = xml`<div class="client_action">ClientAction</div>`;
-            actionRegistry.add("slowAction", ClientAction);
-            const webClient = await createWebClient({ serverData });
-            doAction(webClient, "slowAction");
-            await nextTick();
-            await legacyExtraNextTick();
-            assert.containsNone(target, ".client_action", "client action isn't ready yet");
-            doAction(webClient, 4);
-            await nextTick();
-            await legacyExtraNextTick();
-            assert.containsOnce(target, ".o_kanban_view", "should have loaded a kanban view");
-            slowWillStartDef.resolve();
-            await nextTick();
-            await legacyExtraNextTick();
-            assert.containsOnce(target, ".o_kanban_view", "should still display the kanban view");
-        }
-    );
-
-    QUnit.test(
-        "restoring a controller when doing an action -- load_action slow",
-        async function (assert) {
-            assert.expect(14);
-            let def;
-            const mockRPC = async (route, args) => {
-                assert.step((args && args.method) || route);
-                if (route === "/web/action/load") {
-                    return Promise.resolve(def);
-                }
-            };
-            const webClient = await createWebClient({ serverData, mockRPC });
-            await doAction(webClient, 3);
-            assert.containsOnce(target, ".o_list_view");
-            await click(target.querySelector(".o_list_view .o_data_cell"));
-            assert.containsOnce(target, ".o_form_view");
-            def = makeDeferred();
-            doAction(webClient, 4, { clearBreadcrumbs: true });
-            await nextTick();
-            assert.containsOnce(target, ".o_form_view", "should still contain the form view");
-            await click(target.querySelector(".o_control_panel .breadcrumb-item a"));
-            def.resolve();
-            await nextTick();
-            assert.containsOnce(target, ".o_list_view");
-            assert.strictEqual(
-                target.querySelector(".o_control_panel .breadcrumb-item").textContent,
-                "Partners"
-            );
-            assert.containsNone(target, ".o_form_view");
-            assert.verifySteps([
-                "/web/webclient/load_menus",
-                "/web/action/load",
-                "get_views",
-                "web_search_read",
-                "read",
-                "/web/action/load",
-                "web_search_read",
-            ]);
-        }
-    );
-
-    QUnit.test("switching when doing an action -- load_action slow", async function (assert) {
-        assert.expect(12);
-        let def;
-        const mockRPC = async (route, args) => {
-            assert.step((args && args.method) || route);
-            if (route === "/web/action/load") {
-                return Promise.resolve(def);
-            }
-        };
-        const webClient = await createWebClient({ serverData, mockRPC });
-        await doAction(webClient, 3);
-        assert.containsOnce(target, ".o_list_view");
-        def = makeDeferred();
-        doAction(webClient, 4, { clearBreadcrumbs: true });
-        await nextTick();
-        assert.containsOnce(target, ".o_list_view", "should still contain the list view");
-        await switchView(target, "kanban");
-        def.resolve();
-        await nextTick();
-        assert.containsOnce(target, ".o_kanban_view");
-        assert.strictEqual(
-            target.querySelector(".o_control_panel .breadcrumb-item").textContent,
-            "Partners"
-        );
-        assert.containsNone(target, ".o_list_view");
-        assert.verifySteps([
-            "/web/webclient/load_menus",
-            "/web/action/load",
-            "get_views",
-            "web_search_read",
-            "/web/action/load",
-            "web_search_read",
-        ]);
-    });
-
-    QUnit.test("switching when doing an action -- get_views slow", async function (assert) {
-        assert.expect(13);
-        let def;
-        const mockRPC = async (route, args) => {
-            assert.step((args && args.method) || route);
-            if (args && args.method === "get_views") {
-                return Promise.resolve(def);
-            }
-        };
-        const webClient = await createWebClient({ serverData, mockRPC });
-        await doAction(webClient, 3);
-        assert.containsOnce(target, ".o_list_view");
-        def = makeDeferred();
-        doAction(webClient, 4, { clearBreadcrumbs: true });
-        await nextTick();
-        assert.containsOnce(target, ".o_list_view", "should still contain the list view");
-        await switchView(target, "kanban");
-        def.resolve();
-        await nextTick();
-        assert.containsOnce(target, ".o_kanban_view");
-        assert.strictEqual(
-            target.querySelector(".o_control_panel .breadcrumb-item").textContent,
-            "Partners"
-        );
-        assert.containsNone(target, ".o_list_view");
-        assert.verifySteps([
-            "/web/webclient/load_menus",
-            "/web/action/load",
-            "get_views",
-            "web_search_read",
-            "/web/action/load",
-            "get_views",
-            "web_search_read",
-        ]);
-    });
-
-    QUnit.test("switching when doing an action -- search_read slow", async function (assert) {
-        assert.expect(13);
-        const def = makeDeferred();
-        const defs = [null, def, null];
-        const mockRPC = async (route, { method }) => {
-            assert.step(method || route);
-            if (method === "web_search_read") {
-                await Promise.resolve(defs.shift());
-            }
-        };
-        const webClient = await createWebClient({ serverData, mockRPC });
-        await doAction(webClient, 3);
-        assert.containsOnce(target, ".o_list_view");
-        doAction(webClient, 4, { clearBreadcrumbs: true });
-        await nextTick();
-        await switchView(target, "kanban");
-        def.resolve();
-        await nextTick();
-        assert.containsOnce(target, ".o_kanban_view");
-        assert.strictEqual(
-            target.querySelector(".o_control_panel .breadcrumb-item").textContent,
-            "Partners"
-        );
-        assert.containsNone(target, ".o_list_view");
-        assert.verifySteps([
-            "/web/webclient/load_menus",
-            "/web/action/load",
-            "get_views",
-            "web_search_read",
-            "/web/action/load",
-            "get_views",
-            "web_search_read",
-            "web_search_read",
-        ]);
-    });
-
-    QUnit.test("click multiple times to open a record", async function (assert) {
-        const def = makeDeferred();
-        const defs = [null, def];
-        const mockRPC = async (route, args) => {
-            if (args.method === "read") {
-                await Promise.resolve(defs.shift());
-            }
-        };
-
-        const webClient = await createWebClient({ serverData, mockRPC });
-        await doAction(webClient, 3);
-        assert.containsOnce(target, ".o_list_view");
-
-        await click(target.querySelector(".o_list_view .o_data_cell"));
-        assert.containsOnce(target, ".o_form_view");
-
-        await click(target.querySelector(".o_back_button"));
-        assert.containsOnce(target, ".o_list_view");
-
-        const row1 = target.querySelectorAll(".o_list_view .o_data_row")[0];
-        const row2 = target.querySelectorAll(".o_list_view .o_data_row")[1];
-        await click(row1.querySelector(".o_data_cell"));
-        await click(row2.querySelector(".o_data_cell"));
-        assert.containsOnce(target, ".o_form_view");
-        assert.strictEqual(
-            target.querySelector(".breadcrumb-item.active").innerText,
-            "Second record"
-        );
-
-        def.resolve();
-        await nextTick();
-        assert.containsOnce(target, ".o_form_view");
-        assert.strictEqual(
-            target.querySelector(".breadcrumb-item.active").innerText,
-            "Second record"
-        );
-    });
-
-    QUnit.test(
-        "dialog will only open once for two rapid actions with the target new",
-        async function (assert) {
-            assert.expect(3)
-            const def = makeDeferred();
-            const mockRPC = async (route, args) => {
-                if (args.method === "onchange") {
-                   return def;
-                }
-            };
-
-            const webClient = await createWebClient({ serverData, mockRPC });
-            doAction(webClient, 5);
-            await nextTick();
-            assert.containsNone(target, ".o_dialog .o_form_view");
-
-            doAction(webClient, 5);
-            await nextTick();
-            assert.containsNone(target, ".o_dialog .o_form_view");
-
-            def.resolve();
-            await nextTick();
-            assert.containsOnce(target, ".o_dialog .o_form_view", "dialog should open only once");
-        }
-    );
-
-    QUnit.test("local state, global state, and race conditions", async function (assert) {
-        serverData.views = {
-            "partner,false,toy": `<toy/>`,
-            "partner,false,list": `<list><field name="foo"/></list>`,
-            "partner,false,search": `
-                <search>
-                    <filter name="foo" string="Foo" domain="[]"/>
-                </search>
-            `,
-        };
-
-        let def = Promise.resolve();
-
-        let id = 1;
-        class ToyController extends Component {
-            setup() {
-                this.id = id++;
-                assert.step(JSON.stringify(this.props.state || "no state"));
-                useSetupView({
-                    getLocalState: () => {
-                        return { fromId: this.id };
-                    },
-                });
-                owl.onWillStart(() => def);
-            }
-        }
-        ToyController.template = xml`
-            <div class="o_toy_view">
-                <ControlPanel />
-            </div>`;
-        ToyController.components = { ControlPanel };
-
-        registry.category("views").add("toy", {
-            type: "toy",
-            display_name: "Toy",
-            icon: "fab fa-android",
-            multiRecord: true,
-            searchMenuTypes: ["filter"],
-            Controller: ToyController,
-        });
-
-        const webClient = await createWebClient({ serverData });
-
-        await doAction(webClient, {
-            res_model: "partner",
-            type: "ir.actions.act_window",
-            // list (or something else) must be added to have the view switcher displayed
-            views: [
-                [false, "toy"],
-                [false, "list"],
-            ],
-        });
-
-        await toggleFilterMenu(target);
-        await toggleMenuItem(target, "Foo");
-        assert.ok(isItemSelected(target, "Foo"));
-
-        // reload twice by clicking on toy view switcher
-        def = makeDeferred();
-        await click(target.querySelector(".o_control_panel .o_switch_view.o_toy"));
-        await click(target.querySelector(".o_control_panel .o_switch_view.o_toy"));
-
-        def.resolve();
-        await nextTick();
-
-        await toggleFilterMenu(target);
-        assert.ok(isItemSelected(target, "Foo"));
-        // this test is not able to detect that getGlobalState is put on the right place:
-        // currentController.action.globalState contains in any case the search state
-        // of the first instantiated toy view.
-
-        assert.verifySteps([
-            `"no state"`, // setup first view instantiated
-            `{"fromId":1}`, // setup second view instantiated
-            `{"fromId":1}`, // setup third view instantiated
-        ]);
-    });
-});

odoo-bringout-oca-ocb-web/web/static/tests/webclient/actions/effect.test.js

@@ -0,0 +1,169 @@
+import { expect, test } from "@odoo/hoot";
+import { animationFrame } from "@odoo/hoot-mock";
+import {
+    contains,
+    defineActions,
+    defineModels,
+    getService,
+    models,
+    mountWithCleanup,
+    onRpc,
+    patchWithCleanup,
+    webModels,
+} from "@web/../tests/web_test_helpers";
+
+import { user } from "@web/core/user";
+import { WebClient } from "@web/webclient/webclient";
+
+const { ResCompany, ResPartner, ResUsers } = webModels;
+
+class Partner extends models.Model {
+    _rec_name = "display_name";
+
+    _records = [
+        { id: 1, display_name: "First record" },
+        { id: 2, display_name: "Second record" },
+    ];
+    _views = {
+        form: `
+            <form>
+                <header>
+                    <button name="object" string="Call method" type="object"/>
+                    <button name="4" string="Execute action" type="action"/>
+                </header>
+                <group>
+                    <field name="display_name"/>
+                </group>
+            </form>`,
+        "kanban,1": `
+            <kanban>
+                <templates>
+                    <t t-name="card">
+                        <field name="display_name"/>
+                    </t>
+                </templates>
+            </kanban>`,
+        list: `<list><field name="display_name"/></list>`,
+    };
+}
+
+defineModels([Partner, ResCompany, ResPartner, ResUsers]);
+
+defineActions([
+    {
+        id: 1,
+        xml_id: "action_1",
+        name: "Partners Action 1",
+        res_model: "partner",
+        views: [[1, "kanban"]],
+    },
+    {
+        id: 3,
+        xml_id: "action_3",
+        name: "Partners",
+        res_model: "partner",
+        views: [
+            [false, "list"],
+            [1, "kanban"],
+            [false, "form"],
+        ],
+    },
+    {
+        id: 6,
+        xml_id: "action_6",
+        name: "Partner",
+        res_id: 2,
+        res_model: "partner",
+        views: [[false, "form"]],
+    },
+]);
+
+test.tags("desktop");
+test("rainbowman integrated to webClient", async () => {
+    patchWithCleanup(user, { showEffect: true });
+
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(1);
+    expect(".o_kanban_view").toHaveCount(1);
+    expect(".o_reward").toHaveCount(0);
+    getService("effect").add({ type: "rainbow_man", message: "", fadeout: "no" });
+    await animationFrame();
+    expect(".o_reward").toHaveCount(1);
+    expect(".o_kanban_view").toHaveCount(1);
+    await contains(".o_reward").click();
+    expect(".o_reward").toHaveCount(0);
+    expect(".o_kanban_view").toHaveCount(1);
+    getService("effect").add({ type: "rainbow_man", message: "", fadeout: "no" });
+    await animationFrame();
+    expect(".o_reward").toHaveCount(1);
+    expect(".o_kanban_view").toHaveCount(1);
+    // Do not force rainbow man to destroy on doAction
+    // we let it die either after its animation or on user click
+    await getService("action").doAction(3);
+    expect(".o_reward").toHaveCount(1);
+    expect(".o_list_view").toHaveCount(1);
+});
+
+test.tags("desktop");
+test("on close with effect from server", async () => {
+    patchWithCleanup(user, { showEffect: true });
+    onRpc("/web/dataset/call_button/*", () => {
+        return {
+            type: "ir.actions.act_window_close",
+            effect: {
+                type: "rainbow_man",
+                message: "button called",
+            },
+        };
+    });
+
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(6);
+    await contains("button[name=object]").click();
+    expect(".o_reward").toHaveCount(1);
+});
+
+test.tags("desktop");
+test("on close with effect in xml on desktop", async () => {
+    patchWithCleanup(user, { showEffect: true });
+
+    Partner._views["form"] = `
+        <form>
+            <header>
+            <button string="Call method" name="object" type="object"
+                effect="{'type': 'rainbow_man', 'message': 'rainBowInXML'}"
+            />
+            </header>
+            <field name="display_name"/>
+        </form>`;
+    onRpc("/web/dataset/call_button/*", () => false);
+
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(6);
+    await contains("button[name=object]").click();
+    expect(".o_reward").toHaveCount(1);
+    expect(".o_reward .o_reward_msg_content").toHaveText("rainBowInXML");
+});
+
+test.tags("mobile");
+test("on close with effect in xml on mobile", async () => {
+    patchWithCleanup(user, { showEffect: true });
+
+    Partner._views["form"] = `
+        <form>
+            <header>
+            <button string="Call method" name="object" type="object"
+                effect="{'type': 'rainbow_man', 'message': 'rainBowInXML'}"
+            />
+            </header>
+            <field name="display_name"/>
+        </form>`;
+    onRpc("/web/dataset/call_button/*", () => false);
+
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(6);
+    await contains(`.o_cp_action_menus button:has(.fa-cog)`).click();
+    await contains("button[name=object]").click();
+    expect(".o_reward").toHaveCount(1);
+    expect(".o_reward .o_reward_msg_content").toHaveText("rainBowInXML");
+});

odoo-bringout-oca-ocb-web/web/static/tests/webclient/actions/effects_tests.js

@@ -1,110 +0,0 @@
-/** @odoo-module **/
-
-import { registry } from "@web/core/registry";
-import testUtils from "web.test_utils";
-import { clearRegistryWithCleanup } from "../../helpers/mock_env";
-import {
-    click,
-    getFixture,
-    legacyExtraNextTick,
-    nextTick,
-    patchWithCleanup,
-} from "../../helpers/utils";
-import { createWebClient, doAction, getActionManagerServerData } from "./../helpers";
-import { session } from "@web/session";
-
-let serverData;
-let target;
-
-const mainComponentRegistry = registry.category("main_components");
-
-QUnit.module("ActionManager", (hooks) => {
-    hooks.beforeEach(() => {
-        serverData = getActionManagerServerData();
-        target = getFixture();
-    });
-
-    QUnit.module("Effects");
-
-    QUnit.test("rainbowman integrated to webClient", async function (assert) {
-        assert.expect(10);
-        patchWithCleanup(session, { show_effect: true });
-        clearRegistryWithCleanup(mainComponentRegistry);
-
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, 1);
-        assert.containsOnce(target, ".o_kanban_view");
-        assert.containsNone(target, ".o_reward");
-        webClient.env.services.effect.add({ type: "rainbow_man", message: "", fadeout: "no" });
-        await nextTick();
-        await legacyExtraNextTick();
-        assert.containsOnce(target, ".o_reward");
-        assert.containsOnce(target, ".o_kanban_view");
-        await testUtils.dom.click(target.querySelector(".o_kanban_record"));
-        await legacyExtraNextTick();
-        assert.containsNone(target, ".o_reward");
-        assert.containsOnce(target, ".o_kanban_view");
-        webClient.env.services.effect.add({ type: "rainbow_man", message: "", fadeout: "no" });
-        await nextTick();
-        await legacyExtraNextTick();
-        assert.containsOnce(target, ".o_reward");
-        assert.containsOnce(target, ".o_kanban_view");
-        // Do not force rainbow man to destroy on doAction
-        // we let it die either after its animation or on user click
-        await doAction(webClient, 3);
-        assert.containsOnce(target, ".o_reward");
-        assert.containsOnce(target, ".o_list_view");
-    });
-
-    QUnit.test("on close with effect from server", async function (assert) {
-        assert.expect(1);
-        patchWithCleanup(session, { show_effect: true });
-        const mockRPC = async (route) => {
-            if (route === "/web/dataset/call_button") {
-                return Promise.resolve({
-                    type: "ir.actions.act_window_close",
-                    effect: {
-                        type: "rainbow_man",
-                        message: "button called",
-                    },
-                });
-            }
-        };
-        clearRegistryWithCleanup(mainComponentRegistry);
-
-        const webClient = await createWebClient({ serverData, mockRPC });
-        await doAction(webClient, 6);
-        await click(target.querySelector('button[name="object"]'));
-        assert.containsOnce(target, ".o_reward");
-    });
-
-    QUnit.test("on close with effect in xml", async function (assert) {
-        assert.expect(2);
-        serverData.views["partner,false,form"] = `
-            <form>
-              <header>
-                <button string="Call method" name="object" type="object"
-                 effect="{'type': 'rainbow_man', 'message': 'rainBowInXML'}"
-                />
-              </header>
-              <field name="display_name"/>
-            </form>`;
-        patchWithCleanup(session, { show_effect: true });
-        const mockRPC = async (route) => {
-            if (route === "/web/dataset/call_button") {
-                return Promise.resolve(false);
-            }
-        };
-        clearRegistryWithCleanup(mainComponentRegistry);
-
-        const webClient = await createWebClient({ serverData, mockRPC });
-        await doAction(webClient, 6);
-        await click(target.querySelector('button[name="object"]'));
-        await legacyExtraNextTick();
-        assert.containsOnce(target, ".o_reward");
-        assert.strictEqual(
-            target.querySelector(".o_reward .o_reward_msg_content").textContent,
-            "rainBowInXML"
-        );
-    });
-});

odoo-bringout-oca-ocb-web/web/static/tests/webclient/actions/embedded_action.test.js

@@ -0,0 +1,638 @@
+import { describe, expect, test, beforeEach } from "@odoo/hoot";
+import { queryAllTexts, waitFor } from "@odoo/hoot-dom";
+import {
+    contains,
+    defineActions,
+    defineModels,
+    fields,
+    getService,
+    models,
+    mountWithCleanup,
+    onRpc,
+    toggleMenuItem,
+    toggleSearchBarMenu,
+    webModels,
+    getKwArgs,
+} from "@web/../tests/web_test_helpers";
+
+import { mockTouch, runAllTimers } from "@odoo/hoot-mock";
+import { browser } from "@web/core/browser/browser";
+import { router } from "@web/core/browser/router";
+import { user } from "@web/core/user";
+import { WebClient } from "@web/webclient/webclient";
+
+describe.current.tags("desktop");
+
+const { ResCompany, ResPartner, ResUsers, ResUsersSettings: WebResUsersSettings } = webModels;
+
+class Partner extends models.Model {
+    _rec_name = "display_name";
+
+    display_name = fields.Char();
+    foo = fields.Char();
+    m2o = fields.Many2one({ relation: "partner" });
+    o2m = fields.One2many({ relation: "partner" });
+
+    _records = [
+        { id: 1, display_name: "First record", foo: "yop", m2o: 3, o2m: [2, 3] },
+        { id: 2, display_name: "Second record", foo: "blip", m2o: 3, o2m: [1, 4, 5] },
+        { id: 3, display_name: "Third record", foo: "gnap", m2o: 1, o2m: [] },
+        { id: 4, display_name: "Fourth record", foo: "plop", m2o: 1, o2m: [] },
+        { id: 5, display_name: "Fifth record", foo: "zoup", m2o: 1, o2m: [] },
+    ];
+    _views = {
+        form: `
+            <form>
+                <header>
+                    <button name="object" string="Call method" type="object"/>
+                    <button name="4" string="Execute action" type="action"/>
+                </header>
+                <group>
+                    <field name="display_name"/>
+                    <field name="foo"/>
+                </group>
+            </form>`,
+        "form,74": `
+            <form>
+                <sheet>
+                    <div class="oe_button_box" name="button_box">
+                        <button class="oe_stat_button" type="action" name="1" icon="fa-star" context="{'default_partner': id}">
+                            <field string="Partners" name="o2m" widget="statinfo"/>
+                        </button>
+                    </div>
+                    <field name="display_name"/>
+                </sheet>
+            </form>`,
+        "kanban,1": `
+            <kanban>
+                <templates>
+                    <t t-name="card">
+                        <field name="foo"/>
+                    </t>
+                </templates>
+            </kanban>`,
+        list: `<list><field name="foo"/></list>`,
+        search: `<search><field name="foo" string="Foo"/></search>`,
+    };
+}
+
+class Pony extends models.Model {
+    name = fields.Char();
+
+    _records = [
+        { id: 4, name: "Twilight Sparkle" },
+        { id: 6, name: "Applejack" },
+        { id: 9, name: "Fluttershy" },
+    ];
+    _views = {
+        list: `<list>
+                            <field name="name"/>
+                            <button name="action_test" type="object" string="Action Test" column_invisible="not context.get('display_button')"/>
+                        </list>`,
+        kanban: `<kanban>
+                            <templates>
+                                <t t-name="card">
+                                    <field name="name"/>
+                                </t>
+                            </templates>
+                        </kanban>`,
+        form: `<form><field name="name"/></form>`,
+        search: `<search>
+                            <filter name="my_filter" string="My filter" domain="[['name', '=', 'Applejack']]"/>
+                        </search>`,
+    };
+}
+
+class ResUsersSettings extends WebResUsersSettings {
+    /** @param {number[]} id */
+    get_embedded_actions_settings(id) {
+        /** @type {import("mock_models").ResUsersSettingsEmbeddedAction} */
+        const ResUsersSettingsEmbeddedAction = this.env["res.users.settings.embedded.action"];
+        return ResUsersSettingsEmbeddedAction.embedded_action_settings_format(id);
+    }
+
+    /**
+     * @param {number} action_id
+     * @param {number} res_id
+     * @param {number} vals
+     */
+    set_embedded_actions_setting(id, action_id, res_id, vals) {
+        const kwargs = getKwArgs(arguments, "id", "action_id", "res_id", "vals");
+        id = kwargs.id;
+        action_id = kwargs.action_id;
+        res_id = kwargs.res_id;
+        vals = kwargs.vals;
+
+        /** @type {import("mock_models").ResUsersSettingsEmbeddedAction} */
+        const ResUsersSettingsEmbeddedAction = this.env["res.users.settings.embedded.action"];
+
+        let [embeddedSettings] = ResUsersSettingsEmbeddedAction.search_read([
+            ["user_setting_id", "=", id],
+            ["action_id", "=", action_id],
+            ["res_id", "=", res_id],
+        ]);
+        for (const [field, value] of Object.entries(vals)) {
+            if (["embedded_actions_order", "embedded_actions_visibility"].includes(field)) {
+                vals[field] = value
+                    .map((action_id) => (action_id === false ? "false" : String(action_id)))
+                    .join(",");
+            }
+        }
+        if (!embeddedSettings) {
+            embeddedSettings = ResUsersSettingsEmbeddedAction.create({
+                action_id,
+                res_id,
+                ...vals,
+            });
+        } else {
+            ResUsersSettingsEmbeddedAction.write(embeddedSettings.id, vals);
+        }
+        return embeddedSettings;
+    }
+}
+
+class ResUsersSettingsEmbeddedAction extends models.ServerModel {
+    _name = "res.users.settings.embedded.action";
+
+    /** @param {number[]} ids */
+    embedded_action_settings_format(ids) {
+        const embeddedSettings = {};
+        for (const embeddedSettingsRecord of this.browse(ids)) {
+            embeddedSettings[
+                `${embeddedSettingsRecord.action_id}+${embeddedSettingsRecord.resId || ""}`
+            ] = {
+                embedded_actions_order: embeddedSettingsRecord.embedded_actions_order
+                    ? embeddedSettingsRecord.embedded_actions_order
+                          .split(",")
+                          .map((action_id) => (action_id === "false" ? false : parseInt(action_id)))
+                    : [],
+                embedded_actions_visibility: embeddedSettingsRecord.embedded_actions_visibility
+                    ? embeddedSettingsRecord.embedded_actions_visibility
+                          .split(",")
+                          .map((action_id) => (action_id === "false" ? false : parseInt(action_id)))
+                    : [],
+                embedded_visibility: embeddedSettingsRecord.embedded_visibility,
+            };
+        }
+        return embeddedSettings;
+    }
+}
+
+class IrActionsAct_Window extends models.ServerModel {
+    _name = "ir.actions.act_window";
+
+    _records = [{ id: 1 }, { id: 4 }];
+}
+
+defineModels([
+    Partner,
+    Pony,
+    ResCompany,
+    ResPartner,
+    ResUsers,
+    ResUsersSettings,
+    ResUsersSettingsEmbeddedAction,
+    IrActionsAct_Window,
+]);
+
+defineActions([
+    {
+        id: 1,
+        xml_id: "action_1",
+        name: "Partners Action 1",
+        res_model: "partner",
+        views: [[1, "kanban"]],
+    },
+    {
+        id: 2,
+        xml_id: "action_2",
+        name: "Partners",
+        res_model: "partner",
+        views: [
+            [false, "list"],
+            [1, "kanban"],
+            [false, "form"],
+        ],
+    },
+    {
+        id: 3,
+        xml_id: "action_3",
+        name: "Favorite Ponies",
+        res_model: "pony",
+        views: [
+            [false, "list"],
+            [false, "kanban"],
+            [false, "form"],
+        ],
+    },
+    {
+        id: 4,
+        xml_id: "action_4",
+        name: "Ponies",
+        res_model: "pony",
+        views: [
+            [false, "list"],
+            [false, "kanban"],
+            [false, "form"],
+        ],
+    },
+    {
+        id: 102,
+        xml_id: "embedded_action_2",
+        name: "Embedded Action 2",
+        parent_res_model: "partner",
+        type: "ir.embedded.actions",
+        parent_action_id: 1,
+        action_id: 3,
+        context: {
+            display_button: true,
+        },
+    },
+    {
+        id: 103,
+        name: "Embedded Action 3",
+        parent_res_model: "partner",
+        type: "ir.embedded.actions",
+        parent_action_id: 1,
+        python_method: "do_python_method",
+    },
+    {
+        id: 104,
+        name: "Custom Embedded Action 4",
+        type: "ir.embedded.actions",
+        user_id: user.userId,
+        parent_action_id: 4,
+        action_id: 4,
+    },
+]);
+
+beforeEach(() => {
+    user.updateUserSettings("id", 1); // workaround to populate the user settings
+});
+
+test("can display embedded actions linked to the current action", async () => {
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(1);
+    expect(".o_control_panel").toHaveCount(1, { message: "should have rendered a control panel" });
+    expect(".o_kanban_view").toHaveCount(1, { message: "should have rendered a kanban view" });
+    expect(".o_control_panel_navigation > button > i.fa-sliders").toHaveCount(1, {
+        message: "should display the toggle embedded button",
+    });
+    await contains(".o_control_panel_navigation > button > i.fa-sliders").click();
+    expect(".o_embedded_actions").toHaveCount(1, { message: "should display the embedded" });
+    expect(".o_embedded_actions > button > span").toHaveText("Partners Action 1", {
+        message:
+            "The first embedded action should be the parent one and should be shown by default",
+    });
+    expect(user.settings.embedded_actions_config_ids).toEqual({
+        "1+": {
+            embedded_actions_order: [],
+            embedded_actions_visibility: [false],
+            embedded_visibility: true,
+            res_model: "partner",
+        },
+    });
+});
+
+test("can toggle visibility of embedded actions", async () => {
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(1);
+    await contains(".o_control_panel_navigation > button > i.fa-sliders").click();
+    await waitFor(".o_popover.dropdown-menu");
+    expect(".o_popover.dropdown-menu .dropdown-item").toHaveCount(4, {
+        message: "Three embedded actions should be displayed in the dropdown + button 'Save View'",
+    });
+    expect(".dropdown-menu .dropdown-item.selected").toHaveCount(1, {
+        message: "only one embedded action should be selected",
+    });
+    await contains(
+        ".o_popover.dropdown-menu .dropdown-item > div > span:contains('Embedded Action 2')"
+    ).click();
+    expect(".o_embedded_actions > button").toHaveCount(3, {
+        message: "Should have 2 embedded actions in the embedded + the dropdown button",
+    });
+});
+
+test("can click on a embedded action and execute the corresponding action (with xml_id)", async () => {
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(1);
+    await contains(".o_control_panel_navigation > button > i.fa-sliders").click();
+    await waitFor(".o_popover.dropdown-menu");
+    await contains(
+        ".o_popover.dropdown-menu .dropdown-item > div > span:contains('Embedded Action 2')"
+    ).click();
+    await contains(".o_embedded_actions > button > span:contains('Embedded Action 2')").click();
+    await runAllTimers();
+    expect(router.current.action).toBe(3, {
+        message: "the current action should be the one of the embedded action previously clicked",
+    });
+    expect(".o_list_view").toHaveCount(1, { message: "the view should be a list view" });
+    expect(".o_embedded_actions").toHaveCount(1, { message: "the embedded should stay open" });
+    expect(".o_embedded_actions > button.active").toHaveText("Embedded Action 2", {
+        message: "The second embedded action should be active",
+    });
+});
+
+test("can click on a embedded action and execute the corresponding action (with python_method)", async () => {
+    await mountWithCleanup(WebClient);
+    onRpc("do_python_method", () => ({
+        id: 4,
+        name: "Favorite Ponies from python action",
+        res_model: "pony",
+        type: "ir.actions.act_window",
+        views: [[false, "kanban"]],
+    }));
+    await getService("action").doAction(1);
+    await contains(".o_control_panel_navigation > button > i.fa-sliders").click();
+    await waitFor(".o_popover.dropdown-menu");
+    await contains(
+        ".o_popover.dropdown-menu .dropdown-item > div > span:contains('Embedded Action 3')"
+    ).click();
+    await contains(".o_embedded_actions > button > span:contains('Embedded Action 3')").click();
+    await runAllTimers();
+    expect(router.current.action).toBe(4, {
+        message: "the current action should be the one of the embedded action previously clicked",
+    });
+    expect(".o_kanban_view").toHaveCount(1, { message: "the view should be a kanban view" });
+    expect(".o_embedded_actions").toHaveCount(1, { message: "the embedded should stay open" });
+    expect(".o_embedded_actions > button.active").toHaveText("Embedded Action 3", {
+        message: "The third embedded action should be active",
+    });
+});
+
+test("breadcrumbs are updated when clicking on embeddeds", async () => {
+    await mountWithCleanup(WebClient);
+    onRpc("do_python_method", () => ({
+        id: 4,
+        name: "Favorite Ponies from python action",
+        res_model: "pony",
+        type: "ir.actions.act_window",
+        views: [[false, "kanban"]],
+    }));
+    await getService("action").doAction(1);
+    await contains(".o_control_panel_navigation > button > i.fa-sliders").click();
+    await waitFor(".o_popover.dropdown-menu");
+    await contains(
+        ".o_popover.dropdown-menu .dropdown-item > div > span:contains('Embedded Action 2')"
+    ).click();
+    await contains(
+        ".o_popover.dropdown-menu .dropdown-item > div > span:contains('Embedded Action 3')"
+    ).click();
+    expect(".o_control_panel .breadcrumb-item").toHaveCount(0);
+    expect(".o_control_panel .o_breadcrumb .active").toHaveText("Partners Action 1");
+    expect(browser.location.href).toBe("https://www.hoot.test/odoo/action-1");
+    await contains(".o_embedded_actions > button > span:contains('Embedded Action 2')").click();
+    await runAllTimers();
+    expect(browser.location.href).toBe("https://www.hoot.test/odoo/action-3");
+    expect(router.current.action).toBe(3, {
+        message: "the current action should be the one of the embedded action previously clicked",
+    });
+    expect(queryAllTexts(".breadcrumb-item, .o_breadcrumb .active")).toEqual(["Favorite Ponies"]);
+    await contains(".o_embedded_actions > button > span:contains('Embedded Action 3')").click();
+    await runAllTimers();
+    expect(browser.location.href).toBe("https://www.hoot.test/odoo/action-4");
+    expect(router.current.action).toBe(4, {
+        message: "the current action should be the one of the embedded action previously clicked",
+    });
+    expect(queryAllTexts(".breadcrumb-item, .o_breadcrumb .active")).toEqual([
+        "Favorite Ponies from python action",
+    ]);
+});
+
+test("a view coming from a embedded can be saved in the embedded actions", async () => {
+    onRpc("create", ({ args }) => {
+        const values = args[0][0];
+        expect(values.name).toBe("Custom Embedded Action 2");
+        expect(values.action_id).toBe(3);
+        expect(values).not.toInclude("python_method");
+        return [4, values.name]; // Fake new embedded action id
+    });
+    onRpc("create_filter", ({ args }) => {
+        expect(args[0].domain).toBe(`[["name", "=", "Applejack"]]`);
+        expect(args[0].embedded_action_id).toBe(4);
+        expect(args[0].user_ids).toEqual([]);
+        return [5]; // Fake new filter id
+    });
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(1);
+    await contains(".o_control_panel_navigation > button > i.fa-sliders").click();
+    await waitFor(".o_popover.dropdown-menu");
+    await contains(
+        ".o_popover.dropdown-menu .dropdown-item > div > span:contains('Embedded Action 2')"
+    ).click();
+    await contains(".o_embedded_actions > button > span:contains('Embedded Action 2')").click();
+    await runAllTimers();
+    expect(router.current.action).toBe(3, {
+        message: "the current action should be the one of the embedded action previously clicked",
+    });
+    expect(".o_list_view").toHaveCount(1, { message: "the view should be a list view" });
+    await contains("button.o_switch_view.o_kanban").click();
+    expect(".o_kanban_view").toHaveCount(1, { message: "the view should be a kanban view" });
+    await toggleSearchBarMenu();
+    await toggleMenuItem("My filter");
+    await toggleSearchBarMenu();
+    expect(".o_kanban_record:not(.o_kanban_ghost)").toHaveCount(1, {
+        message: "There should be one record",
+    });
+    await contains(".o_embedded_actions .dropdown").click();
+    await contains(".o_save_current_view ").click();
+    await contains("input.form-check-input").click();
+    await contains(".o_save_favorite ").click();
+    expect(".o_embedded_actions > button").toHaveCount(4, {
+        message: "Should have 2 embedded actions in the embedded + the dropdown button",
+    });
+});
+
+test("a view coming from a embedded with python_method can be saved in the embedded actions", async () => {
+    onRpc(({ args, method }) => {
+        let values;
+        if (method === "create") {
+            values = args[0][0];
+            expect(values.name).toBe("Custom Embedded Action 3");
+            expect(values.python_method).toBe("do_python_method");
+            expect(values).not.toInclude("action_id");
+            return [4, values.name]; // Fake new embedded action id
+        } else if (method === "create_filter") {
+            values = args[0][0];
+            expect(args[0].domain).toBe(`[["name", "=", "Applejack"]]`);
+            expect(args[0].embedded_action_id).toBe(4);
+            expect(args[0].user_ids).toEqual([]);
+            return 5; // Fake new filter id
+        } else if (method === "do_python_method") {
+            return {
+                id: 4,
+                name: "Favorite Ponies from python action",
+                res_model: "pony",
+                type: "ir.actions.act_window",
+                views: [
+                    [false, "list"],
+                    [false, "kanban"],
+                ],
+            };
+        }
+    });
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(1);
+    await contains(".o_control_panel_navigation > button > i.fa-sliders").click();
+    await waitFor(".o_popover.dropdown-menu");
+    await contains(
+        ".o_popover.dropdown-menu .dropdown-item > div > span:contains('Embedded Action 3')"
+    ).click();
+    await contains(".o_embedded_actions > button > span:contains('Embedded Action 3')").click();
+    await runAllTimers();
+    expect(router.current.action).toBe(4, {
+        message: "the current action should be the one of the embedded action previously clicked",
+    });
+    expect(".o_list_view").toHaveCount(1, { message: "the view should be a list view" });
+    await contains("button.o_switch_view.o_kanban").click();
+    expect(".o_kanban_view").toHaveCount(1, { message: "the view should be a kanban view" });
+    await toggleSearchBarMenu();
+    await toggleMenuItem("My filter");
+    await toggleSearchBarMenu();
+    expect(".o_kanban_record:not(.o_kanban_ghost)").toHaveCount(1, {
+        message: "There should be one record",
+    });
+    await contains(".o_embedded_actions .dropdown").click();
+    await contains(".o_save_current_view ").click();
+    await contains("input.form-check-input").click();
+    await contains(".o_save_favorite ").click();
+    expect(".o_embedded_actions > button").toHaveCount(4, {
+        message: "Should have 2 embedded actions in the embedded + the dropdown button",
+    });
+});
+
+test("the embedded actions should not be displayed when switching view", async () => {
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(1);
+    await contains(".o_control_panel_navigation > button > i.fa-sliders").click();
+    await waitFor(".o_popover.dropdown-menu");
+    await contains(
+        ".o_popover.dropdown-menu .dropdown-item > div > span:contains('Embedded Action 2')"
+    ).click();
+    await contains(".o_embedded_actions > button > span:contains('Embedded Action 2')").click();
+    await contains(".o_control_panel_navigation > button > i.fa-sliders").click();
+    await contains("button.o_switch_view.o_kanban").click();
+    expect(".o_embedded_actions").toHaveCount(0, {
+        message: "The embedded actions menu should not be displayed",
+    });
+});
+
+test("User can move the main (first) embedded action", async () => {
+    mockTouch(true);
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(1);
+    await contains(".o_control_panel_navigation > button > i.fa-sliders").click();
+    await waitFor(".o_popover.dropdown-menu");
+    await contains(
+        ".o_popover.dropdown-menu .dropdown-item > div > span:contains('Embedded Action 2')"
+    ).click();
+    await contains(".o_embedded_actions > button:first-child").dragAndDrop(
+        ".o_embedded_actions > button:nth-child(2)"
+    );
+    expect(".o_embedded_actions > button:nth-child(2) > span").toHaveText("Partners Action 1", {
+        message: "Main embedded action should've been moved to 2nd position",
+    });
+});
+
+test("User can unselect the main (first) embedded action", async () => {
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(1);
+    await contains(".o_control_panel_navigation > button > i.fa-sliders").click();
+    await waitFor(".o_popover.dropdown-menu");
+    const dropdownItem =
+        ".o_popover.dropdown-menu .dropdown-item > div > span:contains('Partners Action 1')";
+    expect(dropdownItem).not.toHaveClass("text-muted", {
+        message: "Main embedded action should not be displayed in muted",
+    });
+    await contains(dropdownItem).click();
+    expect(dropdownItem).not.toHaveClass("selected", {
+        message: "Main embedded action should be unselected",
+    });
+});
+
+test("User should be redirected to the first embedded action set in user settings", async () => {
+    // set embedded action 2 in first
+    user.updateUserSettings("embedded_actions_config_ids", {
+        "1+": {
+            embedded_actions_visibility: [102],
+            embedded_visibility: false,
+            embedded_actions_order: [102, false, 103],
+        },
+    });
+    await mountWithCleanup(WebClient);
+    await getService("action").doActionButton({
+        name: 1,
+        type: "action",
+    });
+    await contains(".o_control_panel_navigation > button > i.fa-sliders").click();
+    expect(".o_embedded_actions > button:first-child").toHaveClass("active", {
+        message: "First embedded action in order should have the 'active' class",
+    });
+    expect(".o_embedded_actions > button:first-child > span").toHaveText("Embedded Action 2", {
+        message: "First embedded action in order should be 'Embedded Action 2'",
+    });
+    expect(".o_last_breadcrumb_item > span").toHaveText("Favorite Ponies", {
+        message: "'Favorite Ponies' view should be loaded",
+    });
+    expect(".o_list_renderer .btn-link").toHaveCount(3, {
+        message:
+            "The button should be displayed since `display_button` is true in the context of the embedded action 2",
+    });
+});
+
+test("execute a regular action from an embedded action", async () => {
+    Pony._views["form"] = `
+        <form>
+            <button type="action" name="2" string="Execute another action"/>
+            <field name="name"/>
+        </form>`;
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(1);
+    expect(".o_kanban_view").toHaveCount(1);
+
+    await contains(".o_control_panel_navigation button .fa-sliders").click();
+    expect(".o_control_panel .o_embedded_actions button:not(.dropdown-toggle)").toHaveCount(1);
+
+    await waitFor(".o_popover.dropdown-menu");
+    await contains(".dropdown-menu .dropdown-item span:contains('Embedded Action 2')").click();
+    expect(".o_control_panel .o_embedded_actions button:not(.dropdown-toggle)").toHaveCount(2);
+
+    await contains(".o_control_panel .o_embedded_actions button:eq(1)").click();
+    expect(".o_list_view").toHaveCount(1);
+
+    await contains(".o_data_row .o_data_cell").click();
+    expect(".o_form_view").toHaveCount(1);
+
+    await contains(".o_form_view button[type=action]").click();
+    expect(".o_control_panel .o_embedded_actions").toHaveCount(0);
+});
+
+test("custom embedded action loaded first", async () => {
+    // set embedded action 4 in first
+    user.updateUserSettings("embedded_actions_config_ids", {
+        "4+": {
+            embedded_actions_visibility: [104],
+            embedded_visibility: false,
+            embedded_actions_order: [104, false],
+        },
+    });
+    await mountWithCleanup(WebClient);
+    await getService("action").doActionButton({
+        name: 4,
+        type: "action",
+    });
+    expect(".o_list_view").toHaveCount(1);
+    await contains(".o_control_panel_navigation > button > i.fa-sliders").click();
+    expect(".o_embedded_actions > button:first-child").toHaveClass("active", {
+        message: "First embedded action in order should have the 'active' class",
+    });
+    expect(".o_embedded_actions > button:first-child > span").toHaveText(
+        "Custom Embedded Action 4",
+        {
+            message: "First embedded action in order should be 'Embedded Action 4'",
+        }
+    );
+    expect(".o_last_breadcrumb_item > span").toHaveText("Ponies", {
+        message: "'Favorite Ponies' view should be loaded",
+    });
+});

odoo-bringout-oca-ocb-web/web/static/tests/webclient/actions/error_handling.test.js

@@ -0,0 +1,288 @@
+import { expect, test } from "@odoo/hoot";
+import { queryAllTexts } from "@odoo/hoot-dom";
+import { animationFrame, mockFetch, runAllTimers } from "@odoo/hoot-mock";
+import { Component, onMounted, xml } from "@odoo/owl";
+import {
+    contains,
+    defineActions,
+    defineModels,
+    fields,
+    getService,
+    models,
+    mountWithCleanup,
+    onRpc,
+    patchWithCleanup,
+    stepAllNetworkCalls,
+    webModels,
+} from "@web/../tests/web_test_helpers";
+
+import { registry } from "@web/core/registry";
+import { BooleanField } from "@web/views/fields/boolean/boolean_field";
+import { FormController } from "@web/views/form/form_controller";
+import { WebClient } from "@web/webclient/webclient";
+
+const actionRegistry = registry.category("actions");
+
+const { ResCompany, ResPartner, ResUsers } = webModels;
+
+class Partner extends models.Model {
+    _rec_name = "display_name";
+
+    _records = [
+        { id: 1, display_name: "First record" },
+        { id: 2, display_name: "Second record" },
+    ];
+    _views = {
+        "kanban,1": `
+            <kanban>
+                <templates>
+                    <t t-name="card">
+                        <field name="display_name"/>
+                    </t>
+                </templates>
+            </kanban>`,
+        form: `<form><field name="display_name"/></form>`,
+    };
+}
+
+defineModels([Partner, ResCompany, ResPartner, ResUsers]);
+
+defineActions([
+    {
+        id: 1,
+        xml_id: "action_1",
+        name: "Partners Action 1",
+        res_model: "partner",
+        views: [
+            [1, "kanban"],
+            [false, "form"],
+        ],
+    },
+]);
+
+test("error in a client action (at rendering)", async () => {
+    expect.assertions(9);
+    class Boom extends Component {
+        static template = xml`<div><t t-esc="a.b.c"/></div>`;
+        static props = ["*"];
+    }
+    actionRegistry.add("Boom", Boom);
+    onRpc("web_search_read", () => {
+        expect.step("web_search_read");
+    });
+
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(1);
+    expect(".o_kanban_view").toHaveCount(1);
+    expect(".o_breadcrumb").toHaveText("Partners Action 1");
+    expect(queryAllTexts(".o_kanban_record span")).toEqual(["First record", "Second record"]);
+    expect.verifySteps(["web_search_read"]);
+
+    try {
+        await getService("action").doAction("Boom");
+    } catch (e) {
+        expect(e.cause).toBeInstanceOf(TypeError);
+    }
+    await animationFrame();
+    expect(".o_kanban_view").toHaveCount(1);
+    expect(".o_breadcrumb").toHaveText("Partners Action 1");
+    expect(queryAllTexts(".o_kanban_record span")).toEqual(["First record", "Second record"]);
+    expect.verifySteps(["web_search_read"]);
+});
+
+test("error in a client action (after the first rendering)", async () => {
+    expect.errors(1);
+
+    class Boom extends Component {
+        static template = xml`
+            <div>
+                <t t-if="boom" t-esc="a.b.c"/>
+                <button t-else="" class="my_button" t-on-click="onClick">Click Me</button>
+            </div>`;
+        static props = ["*"];
+        setup() {
+            this.boom = false;
+        }
+        get a() {
+            // a bit artificial, but makes the test firefox compliant
+            throw new Error("Cannot read properties of undefined (reading 'b')");
+        }
+        onClick() {
+            this.boom = true;
+            this.render();
+        }
+    }
+    actionRegistry.add("Boom", Boom);
+
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction("Boom");
+    expect(".my_button").toHaveCount(1);
+
+    await contains(".my_button").click();
+    await animationFrame();
+    expect(".my_button").toHaveCount(1);
+    expect(".o_error_dialog").toHaveCount(1);
+    expect.verifyErrors(["Cannot read properties of undefined (reading 'b')"]);
+});
+
+test("connection lost when opening form view from kanban", async () => {
+    expect.errors(2);
+
+    stepAllNetworkCalls();
+
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(1);
+    expect(".o_kanban_view").toHaveCount(1);
+
+    mockFetch((input) => {
+        expect.step(input);
+        if (input === "/web/webclient/version_info") {
+            // simulate a connection restore at the end of the test, to have no
+            // impact on other tests (see connectionLostNotifRemove)
+            return true;
+        }
+        throw new Error(); // simulate a ConnectionLost error
+    });
+    await contains(".o_kanban_record").click();
+    expect(".o_kanban_view").toHaveCount(1);
+    expect(".o_notification").toHaveCount(1);
+    expect(".o_notification").toHaveText("Connection lost. Trying to reconnect...");
+    expect.verifySteps([
+        "/web/webclient/translations",
+        "/web/webclient/load_menus",
+        "/web/action/load",
+        "get_views",
+        "web_search_read",
+        "has_group",
+        "/web/dataset/call_kw/partner/web_read", // from mockFetch
+        "/web/dataset/call_kw/partner/web_search_read", // from mockFetch
+    ]);
+    await animationFrame();
+    expect.verifySteps([]); // doesn't indefinitely try to reload the list
+
+    // cleanup
+    await runAllTimers();
+    await animationFrame();
+    expect.verifySteps(["/web/webclient/version_info"]);
+    expect.verifyErrors([Error, Error]);
+});
+
+test.tags("desktop");
+test("connection lost when coming back to kanban from form", async () => {
+    expect.errors(1);
+
+    let offline = false;
+    onRpc(
+        "/*",
+        (req) => {
+            const url = new URL(req.url).pathname;
+            if (!url.startsWith("/web/webclient/translations")) {
+                expect.step(url);
+            }
+            if (url === "/web/webclient/version_info") {
+                // simulate a connection restore
+                return true;
+            }
+            if (offline) {
+                throw new Error(); // simulate a ConnectionLost error
+            }
+        },
+        { pure: true }
+    );
+
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(1);
+    expect(".o_kanban_view").toHaveCount(1);
+
+    await contains(".o_kanban_record").click();
+    expect(".o_form_view").toHaveCount(1);
+
+    offline = true;
+    await contains(".o_breadcrumb .o_back_button a").click();
+    await animationFrame();
+    expect(".o_form_view").toHaveCount(0);
+    expect(".o_kanban_view").toHaveCount(1);
+    expect(".o_kanban_view .o_kanban_renderer").toHaveCount(1);
+    expect(".o_kanban_view .o_kanban_record:not(.o_kanban_ghost)").toHaveCount(2);
+    expect(".o_notification").toHaveCount(1);
+    expect(".o_notification").toHaveText("Connection lost. Trying to reconnect...");
+    expect.verifySteps([
+        "/web/webclient/load_menus",
+        "/web/action/load",
+        "/web/dataset/call_kw/partner/get_views",
+        "/web/dataset/call_kw/partner/web_search_read",
+        "/web/dataset/call_kw/res.users/has_group",
+        "/web/dataset/call_kw/partner/web_read",
+        "/web/dataset/call_kw/partner/web_search_read",
+    ]);
+    await animationFrame();
+    expect.verifySteps([]); // doesn't indefinitely try to reload the list
+
+    await runAllTimers();
+    await animationFrame();
+    expect.verifySteps(["/web/webclient/version_info"]);
+    expect.verifyErrors([Error]);
+
+    offline = false;
+    await contains(".o_searchview .o_searchview_icon").click();
+    expect(".o_kanban_view .o_kanban_record:not(.o_kanban_ghost)").toHaveCount(2);
+    expect.verifySteps(["/web/dataset/call_kw/partner/web_search_read"]);
+});
+
+test("error on onMounted", async () => {
+    expect.errors(1);
+
+    Partner._fields.bar = fields.Boolean();
+    Partner._views = {
+        "kanban,1": `
+            <kanban>
+                <templates>
+                    <t t-name="card">
+                        <field name="display_name"/>
+                    </t>
+                </templates>
+            </kanban>`,
+        form: `<form><field name="display_name"/><field name="bar"/></form>`,
+    };
+    stepAllNetworkCalls();
+    patchWithCleanup(BooleanField.prototype, {
+        setup() {
+            super.setup();
+            onMounted(() => {
+                throw new Error("faulty on mounted");
+            });
+        },
+    });
+    patchWithCleanup(FormController.prototype, {
+        setup() {
+            super.setup();
+            onMounted(() => {
+                // If a onMounted hook is faulty, the rest of the onMounted will not be executed
+                // leading to inconsistent views.
+                throw new Error("Never Executed code");
+            });
+        },
+    });
+
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(1);
+    await animationFrame();
+    expect(".o_kanban_view").toHaveCount(1);
+    expect.verifySteps([
+        "/web/webclient/translations",
+        "/web/webclient/load_menus",
+        "/web/action/load",
+        "get_views",
+        "web_search_read",
+        "has_group",
+    ]);
+
+    await contains(".o_kanban_record").click();
+    await animationFrame();
+    expect(".o_form_view").toHaveCount(0);
+    // check that the action manager is empty
+    expect(".o_action_manager").toHaveText("");
+    expect(".o_error_dialog").toHaveCount(1);
+    expect.verifySteps(["web_read"]);
+    expect.verifyErrors(["Error: faulty on mounted"]);
+});

odoo-bringout-oca-ocb-web/web/static/tests/webclient/actions/error_handling_tests.js

@@ -1,81 +0,0 @@
-/** @odoo-module **/
-
-import { registry } from "@web/core/registry";
-import { createWebClient, doAction, getActionManagerServerData } from "./../helpers";
-import { registerCleanup } from "../../helpers/cleanup";
-import { click, getFixture, nextTick, patchWithCleanup } from "../../helpers/utils";
-import { errorService } from "@web/core/errors/error_service";
-
-import { Component, xml } from "@odoo/owl";
-
-let serverData;
-let target;
-const actionRegistry = registry.category("actions");
-
-QUnit.module("ActionManager", (hooks) => {
-    hooks.beforeEach(() => {
-        serverData = getActionManagerServerData();
-        target = getFixture();
-    });
-
-    QUnit.module("Error handling");
-
-    QUnit.test("error in a client action (at rendering)", async function (assert) {
-        assert.expect(4);
-        class Boom extends Component {}
-        Boom.template = xml`<div><t t-esc="a.b.c"/></div>`;
-        actionRegistry.add("Boom", Boom);
-
-        const webClient = await createWebClient({ serverData });
-        assert.strictEqual(target.querySelector(".o_action_manager").innerHTML, "");
-        await doAction(webClient, "1");
-        const contents = target.querySelector(".o_action_manager").innerHTML;
-        assert.ok(contents !== "");
-        try {
-            await doAction(webClient, "Boom");
-        } catch (e) {
-            assert.ok(e.cause instanceof TypeError);
-        }
-        assert.strictEqual(target.querySelector(".o_action_manager").innerHTML, contents);
-    });
-
-    QUnit.test("error in a client action (after the first rendering)", async function (assert) {
-        const handler = (ev) => {
-            // need to preventDefault to remove error from console (so python test pass)
-            ev.preventDefault();
-        };
-        window.addEventListener("unhandledrejection", handler);
-        registerCleanup(() => window.removeEventListener("unhandledrejection", handler));
-
-        patchWithCleanup(QUnit, {
-            onUnhandledRejection: () => {},
-        });
-
-        registry.category("services").add("error", errorService);
-
-        class Boom extends Component {
-            setup() {
-                this.boom = false;
-            }
-            onClick() {
-                this.boom = true;
-                this.render();
-            }
-        }
-        Boom.template = xml`
-            <div>
-                <t t-if="boom" t-esc="a.b.c"/>
-                <button t-else="" class="my_button" t-on-click="onClick">Click Me</button>
-            </div>`;
-        actionRegistry.add("Boom", Boom);
-
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, "Boom");
-        assert.containsOnce(target, ".my_button");
-
-        await click(document.querySelector(".my_button"));
-        await nextTick();
-        assert.containsOnce(target, ".my_button");
-        assert.containsOnce(target, ".o_dialog_error");
-    });
-});

odoo-bringout-oca-ocb-web/web/static/tests/webclient/actions/legacy_tests.js

@@ -1,776 +0,0 @@
-/** @odoo-module **/
-
-import { registry } from "@web/core/registry";
-import testUtils from "web.test_utils";
-import ListController from "web.ListController";
-import FormView from "web.FormView";
-import ListView from "web.ListView";
-import {
-    click,
-    destroy,
-    getFixture,
-    makeDeferred,
-    legacyExtraNextTick,
-    patchWithCleanup,
-    triggerEvents,
-} from "../../helpers/utils";
-import KanbanView from "web.KanbanView";
-import { registerCleanup } from "../../helpers/cleanup";
-import { makeTestEnv } from "../../helpers/mock_env";
-import { createWebClient, doAction, getActionManagerServerData } from "./../helpers";
-import makeTestEnvironment from "web.test_env";
-
-import { ClientActionAdapter, ViewAdapter } from "@web/legacy/action_adapters";
-import { makeLegacyCrashManagerService } from "@web/legacy/utils";
-import { useDebugCategory } from "@web/core/debug/debug_context";
-import { ErrorDialog } from "@web/core/errors/error_dialogs";
-import * as cpHelpers from "@web/../tests/search/helpers";
-
-import AbstractView from "web.AbstractView";
-import ControlPanel from "web.ControlPanel";
-import core from "web.core";
-import AbstractAction from "web.AbstractAction";
-import Widget from "web.Widget";
-import SystrayMenu from "web.SystrayMenu";
-import legacyViewRegistry from "web.view_registry";
-
-let serverData;
-let target;
-
-QUnit.module("ActionManager", (hooks) => {
-    hooks.beforeEach(() => {
-        registry.category("views").remove("form"); // remove new form from registry
-        registry.category("views").remove("kanban"); // remove new kanban from registry
-        registry.category("views").remove("list"); // remove new list from registry
-        legacyViewRegistry.add("form", FormView); // add legacy form -> will be wrapped and added to new registry
-        legacyViewRegistry.add("kanban", KanbanView); // add legacy kanban -> will be wrapped and added to new registry
-        legacyViewRegistry.add("list", ListView); // add legacy list -> will be wrapped and added to new registry
-
-        serverData = getActionManagerServerData();
-        target = getFixture();
-    });
-
-    QUnit.module("Legacy tests (to eventually drop)");
-
-    QUnit.test("display warning as notification", async function (assert) {
-        // this test can be removed as soon as the legacy layer is dropped
-        assert.expect(5);
-        let list;
-        patchWithCleanup(ListController.prototype, {
-            init() {
-                this._super(...arguments);
-                list = this;
-            },
-        });
-
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, 3);
-        assert.containsOnce(target, ".o_legacy_list_view");
-        list.trigger_up("warning", {
-            title: "Warning!!!",
-            message: "This is a warning...",
-        });
-        await testUtils.nextTick();
-        await legacyExtraNextTick();
-        assert.containsOnce(target, ".o_legacy_list_view");
-        assert.containsOnce(document.body, ".o_notification.border-warning");
-        assert.strictEqual($(".o_notification_title").text(), "Warning!!!");
-        assert.strictEqual($(".o_notification_content").text(), "This is a warning...");
-    });
-
-    QUnit.test("display warning as modal", async function (assert) {
-        // this test can be removed as soon as the legacy layer is dropped
-        assert.expect(5);
-        let list;
-        patchWithCleanup(ListController.prototype, {
-            init() {
-                this._super(...arguments);
-                list = this;
-            },
-        });
-
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, 3);
-        assert.containsOnce(target, ".o_legacy_list_view");
-        list.trigger_up("warning", {
-            title: "Warning!!!",
-            message: "This is a warning...",
-            type: "dialog",
-        });
-        await testUtils.nextTick();
-        await legacyExtraNextTick();
-        assert.containsOnce(target, ".o_legacy_list_view");
-        assert.containsOnce(document.body, ".modal");
-        assert.strictEqual($(".modal-title").text(), "Warning!!!");
-        assert.strictEqual($(".modal-body").text(), "This is a warning...");
-    });
-
-    QUnit.test("display multiline warning as modal", async function (assert) {
-        assert.expect(5);
-        let list;
-        patchWithCleanup(ListController.prototype, {
-            init() {
-                this._super(...arguments);
-                list = this;
-            },
-        });
-
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, 3);
-        assert.containsOnce(target, ".o_legacy_list_view");
-        list.trigger_up("warning", {
-            title: "Warning!!!",
-            message: "This is a warning...\nabc",
-            type: "dialog",
-        });
-        await testUtils.nextTick();
-        await legacyExtraNextTick();
-        assert.containsOnce(target, ".o_legacy_list_view");
-        assert.containsOnce(document.body, ".modal");
-        assert.strictEqual($(".modal-title").text(), "Warning!!!");
-        assert.strictEqual($(".modal-body")[0].innerText, "This is a warning...\nabc");
-    });
-
-    QUnit.test(
-        "legacy crash manager is still properly remapped to error service",
-        async function (assert) {
-            // this test can be removed as soon as the legacy layer is dropped
-            assert.expect(2);
-
-            const legacyEnv = makeTestEnvironment();
-            registry
-                .category("services")
-                .add("legacy_crash_manager", makeLegacyCrashManagerService(legacyEnv))
-                .add("dialog", {
-                    start() {
-                        return {
-                            add(dialogClass, props) {
-                                assert.strictEqual(dialogClass, ErrorDialog);
-                                assert.strictEqual(props.traceback, "BOOM");
-                            },
-                        };
-                    },
-                });
-            await makeTestEnv();
-            legacyEnv.services.crash_manager.show_message("BOOM");
-        }
-    );
-
-    QUnit.test("redraw a controller and open debugManager does not crash", async (assert) => {
-        assert.expect(11);
-
-        const LegacyAction = AbstractAction.extend({
-            start() {
-                const ret = this._super(...arguments);
-                const el = document.createElement("div");
-                el.classList.add("custom-action");
-                this.el.append(el);
-                return ret;
-            },
-        });
-        core.action_registry.add("customLegacy", LegacyAction);
-
-        patchWithCleanup(ClientActionAdapter.prototype, {
-            setup() {
-                useDebugCategory("custom", { widget: this });
-                this._super();
-            },
-        });
-
-        registry
-            .category("debug")
-            .category("custom")
-            .add("item1", ({ widget }) => {
-                assert.step("debugItems executed");
-                assert.ok(widget);
-                return {};
-            });
-        patchWithCleanup(odoo, { debug: true });
-
-        const mockRPC = (route) => {
-            if (route.includes("check_access_rights")) {
-                return true;
-            }
-        };
-
-        const webClient = await createWebClient({ serverData, mockRPC });
-        await doAction(webClient, "customLegacy");
-        assert.containsOnce(target, ".custom-action");
-        assert.verifySteps([]);
-
-        await click(target, ".o_debug_manager button");
-        assert.verifySteps(["debugItems executed"]);
-
-        await doAction(webClient, 5); // action in Dialog
-        await click(target, ".modal .o_form_button_cancel");
-        assert.containsNone(target, ".modal");
-        assert.containsOnce(target, ".custom-action");
-        assert.verifySteps([]);
-
-        // close debug menu
-        await click(target, ".o_debug_manager button");
-        // open debug menu
-        await click(target, ".o_debug_manager button");
-        assert.verifySteps(["debugItems executed"]);
-        delete core.action_registry.map.customLegacy;
-    });
-
-    QUnit.test("willUnmount is called down the legacy layers", async (assert) => {
-        assert.expect(7);
-
-        let mountCount = 0;
-        patchWithCleanup(ControlPanel.prototype, {
-            setup() {
-                this._super();
-                owl.onMounted(() => {
-                    mountCount = mountCount + 1;
-                    this.__uniqueId = mountCount;
-                    assert.step(`mounted ${this.__uniqueId}`);
-                });
-                owl.onWillUnmount(() => {
-                    assert.step(`willUnmount ${this.__uniqueId}`);
-                });
-            },
-        });
-
-        const LegacyAction = AbstractAction.extend({
-            hasControlPanel: true,
-            start() {
-                const ret = this._super(...arguments);
-                const el = document.createElement("div");
-                el.classList.add("custom-action");
-                this.el.append(el);
-                return ret;
-            },
-        });
-        core.action_registry.add("customLegacy", LegacyAction);
-
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, 1);
-        await doAction(webClient, "customLegacy");
-        await click(target.querySelectorAll(".breadcrumb-item")[0]);
-        await legacyExtraNextTick();
-
-        destroy(webClient);
-
-        assert.verifySteps([
-            "mounted 1",
-            "willUnmount 1",
-            "mounted 2",
-            "willUnmount 2",
-            "mounted 3",
-            "willUnmount 3",
-        ]);
-
-        delete core.action_registry.map.customLegacy;
-    });
-
-    QUnit.test("Checks the availability of all views in the action", async (assert) => {
-        assert.expect(2);
-        patchWithCleanup(ListView.prototype, {
-            init(viewInfo, params) {
-                const action = params.action;
-                const views = action.views.map((view) => [view.viewID, view.type]);
-                assert.deepEqual(views, [
-                    [1, "list"],
-                    [2, "kanban"],
-                    [3, "form"],
-                ]);
-                assert.deepEqual(action._views, [
-                    [1, "list"],
-                    [2, "kanban"],
-                    [3, "form"],
-                    [false, "search"],
-                ]);
-                this._super(...arguments);
-            },
-        });
-        const models = {
-            partner: {
-                fields: {
-                    display_name: { string: "Displayed name", type: "char", searchable: true },
-                    foo: {
-                        string: "Foo",
-                        type: "char",
-                        default: "My little Foo Value",
-                        searchable: true,
-                    },
-                    bar: { string: "Bar", type: "boolean" },
-                    int_field: { string: "Integer field", type: "integer", group_operator: "sum" },
-                },
-                records: [
-                    {
-                        id: 1,
-                        display_name: "first record",
-                        foo: "yop",
-                        int_field: 3,
-                    },
-                    {
-                        id: 2,
-                        display_name: "second record",
-                        foo: "lalala",
-                        int_field: 5,
-                    },
-                    {
-                        id: 4,
-                        display_name: "aaa",
-                        foo: "abc",
-                        int_field: 2,
-                    },
-                ],
-            },
-        };
-        const views = {
-            "partner,1,list": '<list><field name="foo"/></list>',
-            "partner,2,kanban": "<kanban></kanban>",
-            "partner,3,form": `<form></form>`,
-            "partner,false,search": "<search></search>",
-        };
-        const serverData = { models, views };
-
-        const webClient = await createWebClient({ serverData });
-
-        await doAction(webClient, {
-            id: 1,
-            res_model: "partner",
-            type: "ir.actions.act_window",
-            views: [
-                [1, "list"],
-                [2, "kanban"],
-                [3, "form"],
-            ],
-        });
-    });
-
-    QUnit.test("client actions may take and push their params", async function (assert) {
-        assert.expect(2);
-
-        const ClientAction = AbstractAction.extend({
-            init(parent, action) {
-                this._super(...arguments);
-                assert.deepEqual(action.params, {
-                    active_id: 99,
-                    take: "five",
-                    active_ids: "1,2",
-                    list: [9, 10],
-                });
-            },
-        });
-        core.action_registry.add("clientAction", ClientAction);
-        registerCleanup(() => delete core.action_registry.map.clientAction);
-        const webClient = await createWebClient({});
-
-        await doAction(webClient, {
-            type: "ir.actions.client",
-            tag: "clientAction",
-            params: {
-                active_id: 99,
-                take: "five",
-                active_ids: "1,2",
-                list: [9, 10],
-            },
-        });
-
-        assert.deepEqual(webClient.env.services.router.current.hash, {
-            action: "clientAction",
-            active_id: 99,
-            take: "five",
-            active_ids: "1,2",
-        });
-    });
-
-    QUnit.test("client actions honour do_push_state", async function (assert) {
-        assert.expect(2);
-
-        const ClientAction = AbstractAction.extend({
-            init(parent) {
-                this._super(...arguments);
-                this.parent = parent;
-                this.parent.do_push_state({ pinball: "wizard" });
-            },
-
-            async start() {
-                await this._super(...arguments);
-                const btn = document.createElement("button");
-                btn.classList.add("tommy");
-                btn.addEventListener("click", () => {
-                    this.parent.do_push_state({ gipsy: "the acid queen" });
-                });
-                this.el.append(btn);
-            },
-
-            getState() {
-                return {
-                    doctor: "quackson",
-                };
-            },
-        });
-        core.action_registry.add("clientAction", ClientAction);
-        registerCleanup(() => delete core.action_registry.map.clientAction);
-        const webClient = await createWebClient({});
-
-        await doAction(webClient, {
-            type: "ir.actions.client",
-            tag: "clientAction",
-        });
-
-        assert.deepEqual(webClient.env.services.router.current.hash, {
-            action: "clientAction",
-            pinball: "wizard",
-            doctor: "quackson",
-        });
-
-        await click(target, ".tommy");
-        assert.deepEqual(webClient.env.services.router.current.hash, {
-            action: "clientAction",
-            pinball: "wizard",
-            gipsy: "the acid queen",
-            doctor: "quackson",
-        });
-    });
-
-    QUnit.test("Systray item triggers do action on legacy service provider", async (assert) => {
-        assert.expect(3);
-        function createMockActionService(assert) {
-            return {
-                dependencies: [],
-                start() {
-                    return {
-                        doAction(params) {
-                            assert.step("do action");
-                            assert.strictEqual(params, 128, "The doAction parameters are invalid.");
-                        },
-                        loadState() {},
-                    };
-                },
-            };
-        }
-        registry.category("services").add("action", createMockActionService(assert));
-        const FakeSystrayItemWidget = Widget.extend({
-            on_attach_callback() {
-                this.do_action(128);
-            },
-        });
-        SystrayMenu.Items.push(FakeSystrayItemWidget);
-        await createWebClient({ serverData });
-        assert.verifySteps(["do action"]);
-        delete SystrayMenu.Items.FakeSystrayItemWidget;
-    });
-
-    QUnit.test("usercontext always added to legacy actions", async (assert) => {
-        assert.expect(8);
-        core.action_registry.add("testClientAction", AbstractAction);
-        registerCleanup(() => delete core.action_registry.map.testClientAction);
-        patchWithCleanup(ClientActionAdapter.prototype, {
-            setup() {
-                assert.step("ClientActionAdapter");
-                const action = { ...this.props.widgetArgs[0] };
-                const originalAction = JSON.parse(action._originalAction);
-                assert.deepEqual(originalAction.context, undefined);
-                assert.deepEqual(action.context, this.env.services.user.context);
-                this._super();
-            },
-        });
-        patchWithCleanup(ViewAdapter.prototype, {
-            setup() {
-                assert.step("ViewAdapter");
-                const action = { ...this.props.viewParams.action };
-                const originalAction = JSON.parse(action._originalAction);
-                assert.deepEqual(originalAction.context, undefined);
-                assert.deepEqual(action.context, this.env.services.user.context);
-                this._super();
-            },
-        });
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, "testClientAction");
-        assert.verifySteps(["ClientActionAdapter"]);
-        await doAction(webClient, 1);
-        assert.verifySteps(["ViewAdapter"]);
-    });
-
-    QUnit.test("correctly transports legacy Props for doAction", async (assert) => {
-        assert.expect(4);
-
-        let ID = 0;
-        const MyAction = AbstractAction.extend({
-            init() {
-                this._super(...arguments);
-                this.ID = ID++;
-                assert.step(`id: ${this.ID} props: ${JSON.stringify(arguments[2])}`);
-            },
-            async start() {
-                const res = await this._super(...arguments);
-                const link = document.createElement("a");
-                link.innerText = "some link";
-                link.setAttribute("id", `client_${this.ID}`);
-                link.addEventListener("click", () => {
-                    this.do_action("testClientAction", {
-                        clear_breadcrumbs: true,
-                        props: { chain: "never break" },
-                    });
-                });
-
-                this.el.appendChild(link);
-                return res;
-            },
-        });
-        core.action_registry.add("testClientAction", MyAction);
-        registerCleanup(() => delete core.action_registry.map.testClientAction);
-
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, "testClientAction");
-        assert.verifySteps(['id: 0 props: {"className":"o_action","breadcrumbs":[]}']);
-
-        await click(document.getElementById("client_0"));
-        assert.verifySteps([
-            'id: 1 props: {"chain":"never break","className":"o_action","breadcrumbs":[]}',
-        ]);
-    });
-
-    QUnit.test("bootstrap tooltip in dialog action auto destroy", async (assert) => {
-        assert.expect(2);
-
-        const mockRPC = (route) => {
-            if (route === "/web/dataset/call_button") {
-                return false;
-            }
-        };
-
-        serverData.views["partner,3,form"] = /*xml*/ `
-            <form>
-                <field name="display_name" />
-                <footer>
-                    <button name="echoes" type="object" string="Echoes" help="echoes"/>
-                </footer>
-            </form>
-        `;
-        const webClient = await createWebClient({ serverData, mockRPC });
-
-        await doAction(webClient, 25);
-
-        const tooltipProm = makeDeferred();
-        $(target).one("shown.bs.tooltip", () => {
-            tooltipProm.resolve();
-        });
-
-        triggerEvents(target, ".modal footer button", ["mouseover", "focusin"]);
-        await tooltipProm;
-        // check on webClient dom
-        assert.containsOnce(document.body, ".tooltip");
-        await doAction(webClient, {
-            type: "ir.actions.act_window_close",
-        });
-        // check on the whole DOM
-        assert.containsNone(document.body, ".tooltip");
-    });
-
-    QUnit.test("bootstrap tooltip destroyed on click", async (assert) => {
-        assert.expect(2);
-
-        const mockRPC = (route) => {
-            if (route === "/web/dataset/call_button") {
-                return false;
-            }
-        };
-
-        serverData.views["partner,666,form"] = /*xml*/ `
-            <form>
-                <header>
-                    <button name="echoes" type="object" string="Echoes" help="echoes"/>
-                </header>
-                <field name="display_name" />
-            </form>
-        `;
-        const webClient = await createWebClient({ serverData, mockRPC });
-
-        await doAction(webClient, 24);
-
-        const tooltipProm = makeDeferred();
-        $(target).one("shown.bs.tooltip", () => {
-            tooltipProm.resolve();
-        });
-
-        triggerEvents(target, ".o_form_statusbar button", ["mouseover", "focusin"]);
-        await tooltipProm;
-        // check on webClient DOM
-        assert.containsOnce(document.body, ".tooltip");
-        await click(target, ".o_content");
-        // check on the whole DOM
-        assert.containsNone(document.body, ".tooltip");
-    });
-
-    QUnit.test("breadcrumbs are correct in stacked legacy client actions", async function (assert) {
-        const ClientAction = AbstractAction.extend({
-            hasControlPanel: true,
-            async start() {
-                this.$el.addClass("client_action");
-                return this._super(...arguments);
-            },
-            getTitle() {
-                return "Blabla";
-            },
-        });
-        core.action_registry.add("clientAction", ClientAction);
-        registerCleanup(() => delete core.action_registry.map.clientAction);
-
-        const webClient = await createWebClient({ serverData });
-
-        await doAction(webClient, 3);
-        assert.containsOnce(target, ".o_legacy_list_view");
-        assert.strictEqual($(target).find(".breadcrumb-item").text(), "Partners");
-
-        await doAction(webClient, {
-            type: "ir.actions.client",
-            tag: "clientAction",
-        });
-        assert.containsOnce(target, ".client_action");
-        assert.strictEqual($(target).find(".breadcrumb-item").text(), "PartnersBlabla");
-    });
-
-    QUnit.test("view with js_class attribute (legacy)", async function (assert) {
-        assert.expect(2);
-        const TestView = AbstractView.extend({
-            viewType: "test_view",
-        });
-        const TestJsClassView = TestView.extend({
-            init() {
-                this._super.call(this, ...arguments);
-                assert.step("init js class");
-            },
-        });
-        serverData.views["partner,false,test_view"] = `<div js_class="test_jsClass"></div>`;
-        serverData.actions[9999] = {
-            id: 1,
-            name: "Partners Action 1",
-            res_model: "partner",
-            type: "ir.actions.act_window",
-            views: [[false, "test_view"]],
-        };
-        legacyViewRegistry.add("test_view", TestView);
-        legacyViewRegistry.add("test_jsClass", TestJsClassView);
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, 9999);
-        assert.verifySteps(["init js class"]);
-        delete legacyViewRegistry.map.test_view;
-        delete legacyViewRegistry.map.test_jsClass;
-    });
-
-    QUnit.test(
-        "execute action without modal closes bootstrap tooltips anyway",
-        async function (assert) {
-            assert.expect(12);
-            Object.assign(serverData.views, {
-                "partner,666,form": `<form>
-            <header>
-              <button name="object" string="Call method" type="object" help="need somebody"/>
-            </header>
-            <field name="display_name"/>
-          </form>`,
-            });
-            const mockRPC = async (route) => {
-                assert.step(route);
-                if (route === "/web/dataset/call_button") {
-                    // Some business stuff server side, then return an implicit close action
-                    return Promise.resolve(false);
-                }
-            };
-
-            const webClient = await createWebClient({ serverData, mockRPC });
-            await doAction(webClient, 24);
-            assert.verifySteps([
-                "/web/webclient/load_menus",
-                "/web/action/load",
-                "/web/dataset/call_kw/partner/get_views",
-                "/web/dataset/call_kw/partner/read",
-            ]);
-            assert.containsN(target, ".o_form_buttons_view button:not([disabled])", 2);
-            const actionButton = target.querySelector("button[name=object]");
-            const tooltipProm = new Promise((resolve) => {
-                document.body.addEventListener(
-                    "shown.bs.tooltip",
-                    () => {
-                        actionButton.dispatchEvent(new Event("mouseout"));
-                        resolve();
-                    },
-                    {
-                        once: true,
-                    }
-                );
-            });
-            actionButton.dispatchEvent(new Event("mouseover"));
-            await tooltipProm;
-            assert.containsOnce(document.body, ".tooltip");
-            await click(actionButton);
-            await legacyExtraNextTick();
-            assert.verifySteps(["/web/dataset/call_button", "/web/dataset/call_kw/partner/read"]);
-            assert.containsNone(document.body, ".tooltip"); // body different from webClient in tests !
-            assert.containsN(target, ".o_form_buttons_view button:not([disabled])", 2);
-        }
-    );
-
-    QUnit.test("click multiple times to open a record", async function (assert) {
-        assert.expect(5);
-
-        const def = testUtils.makeTestPromise();
-        const defs = [null, def];
-        const mockRPC = async (route, args) => {
-            if (args.method === "read") {
-                await Promise.resolve(defs.shift());
-            }
-        };
-
-        const webClient = await createWebClient({ serverData, mockRPC });
-        await doAction(webClient, 3);
-
-        assert.containsOnce(target, ".o_legacy_list_view");
-
-        await testUtils.dom.click(target.querySelector(".o_legacy_list_view .o_data_row"));
-        await legacyExtraNextTick();
-        assert.containsOnce(target, ".o_legacy_form_view");
-
-        await testUtils.dom.click(target.querySelector(".o_back_button"));
-        await legacyExtraNextTick();
-
-        assert.containsOnce(target, ".o_legacy_list_view");
-
-        await testUtils.dom.click(target.querySelector(".o_legacy_list_view .o_data_row"));
-        await testUtils.dom.click(target.querySelector(".o_legacy_list_view .o_data_row"));
-        await legacyExtraNextTick();
-        assert.containsOnce(target, ".o_legacy_list_view");
-
-        def.resolve();
-        await testUtils.nextTick();
-        await legacyExtraNextTick();
-        assert.containsOnce(target, ".o_legacy_form_view");
-    });
-
-    QUnit.test("correct pager when coming from list (legacy)", async (assert) => {
-        assert.expect(4);
-
-        registry.category("views").remove("list");
-        legacyViewRegistry.add("list", ListView);
-        serverData.views = {
-            "partner,false,search": `<search />`,
-            "partner,99,list": `<list limit="4"><field name="display_name" /></list>`,
-            "partner,100,form": `<form><field name="display_name" /></form>`,
-        };
-
-        const wc = await createWebClient({ serverData });
-        await doAction(wc, {
-            res_model: "partner",
-            type: "ir.actions.act_window",
-            views: [
-                [99, "list"],
-                [100, "form"],
-            ],
-        });
-
-        assert.deepEqual(cpHelpers.getPagerValue(target), [1, 4]);
-        assert.deepEqual(cpHelpers.getPagerLimit(target), 5);
-
-        await click(target, ".o_data_row:nth-child(2) .o_data_cell");
-        await legacyExtraNextTick();
-        assert.deepEqual(cpHelpers.getPagerValue(target), [2]);
-        assert.deepEqual(cpHelpers.getPagerLimit(target), 4);
-    });
-});

odoo-bringout-oca-ocb-web/web/static/tests/webclient/actions/misc.test.js

@@ -0,0 +1,794 @@
+import { expect, getFixture, test } from "@odoo/hoot";
+import { queryOne, scroll, waitFor } from "@odoo/hoot-dom";
+import { animationFrame, Deferred } from "@odoo/hoot-mock";
+import { Component, onWillStart, xml } from "@odoo/owl";
+import {
+    contains,
+    defineActions,
+    defineMenus,
+    defineModels,
+    fields,
+    getDropdownMenu,
+    getService,
+    makeMockEnv,
+    models,
+    mountWithCleanup,
+    onRpc,
+    patchWithCleanup,
+    serverState,
+    stepAllNetworkCalls,
+    switchView,
+    webModels,
+} from "@web/../tests/web_test_helpers";
+
+import { browser } from "@web/core/browser/browser";
+import { registry } from "@web/core/registry";
+import { router } from "@web/core/browser/router";
+import { listView } from "@web/views/list/list_view";
+import { PivotModel } from "@web/views/pivot/pivot_model";
+import { WebClient } from "@web/webclient/webclient";
+import { redirect } from "@web/core/utils/urls";
+
+const { ResCompany, ResPartner, ResUsers } = webModels;
+
+class Partner extends models.Model {
+    _rec_name = "display_name";
+
+    o2m = fields.One2many({ relation: "partner", relation_field: "bar" });
+
+    _records = [
+        { id: 1, display_name: "First record", o2m: [2, 3] },
+        {
+            id: 2,
+            display_name: "Second record",
+            o2m: [1, 4, 5],
+        },
+        { id: 3, display_name: "Third record", o2m: [] },
+        { id: 4, display_name: "Fourth record", o2m: [] },
+        { id: 5, display_name: "Fifth record", o2m: [] },
+    ];
+    _views = {
+        form: `
+            <form>
+                <header>
+                    <button name="object" string="Call method" type="object"/>
+                    <button name="4" string="Execute action" type="action"/>
+                </header>
+                <group>
+                    <field name="display_name"/>
+                </group>
+            </form>`,
+        "kanban,1": `
+            <kanban>
+                <templates>
+                    <t t-name="card">
+                        <field name="display_name"/>
+                    </t>
+                </templates>
+            </kanban>`,
+        list: `<list><field name="display_name"/></list>`,
+        "list,2": `<list limit="3"><field name="display_name"/></list>`,
+    };
+}
+
+class Pony extends models.Model {
+    name = fields.Char();
+
+    _records = [
+        { id: 4, name: "Twilight Sparkle" },
+        { id: 6, name: "Applejack" },
+        { id: 9, name: "Fluttershy" },
+    ];
+    _views = {
+        list: '<list><field name="name"/></list>',
+        form: `<form><field name="name"/></form>`,
+    };
+}
+
+defineModels([Partner, Pony, ResCompany, ResPartner, ResUsers]);
+
+defineActions([
+    {
+        id: 1,
+        xml_id: "action_1",
+        name: "Partners Action 1",
+        res_model: "partner",
+        views: [[1, "kanban"]],
+    },
+    {
+        id: 3,
+        xml_id: "action_3",
+        name: "Partners",
+        res_model: "partner",
+        views: [
+            [false, "list"],
+            [1, "kanban"],
+            [false, "form"],
+        ],
+    },
+    {
+        id: 5,
+        xml_id: "action_5",
+        name: "Create a Partner",
+        res_model: "partner",
+        target: "new",
+        views: [[false, "form"]],
+    },
+    {
+        id: 4,
+        xml_id: "action_4",
+        name: "Partners Action 4",
+        res_model: "partner",
+        views: [
+            [1, "kanban"],
+            [2, "list"],
+            [false, "form"],
+        ],
+    },
+    {
+        id: 8,
+        xml_id: "action_8",
+        name: "Favorite Ponies",
+        res_model: "pony",
+        views: [
+            [false, "list"],
+            [false, "form"],
+        ],
+    },
+]);
+
+const actionRegistry = registry.category("actions");
+const actionHandlersRegistry = registry.category("action_handlers");
+
+test("can execute actions from id, xmlid and tag", async () => {
+    defineActions([
+        {
+            id: 10,
+            tag: "client_action_by_db_id",
+            target: "main",
+            type: "ir.actions.client",
+        },
+        {
+            id: 20,
+            xml_id: "some_action",
+            tag: "client_action_by_xml_id",
+            target: "main",
+            type: "ir.actions.client",
+        },
+        {
+            id: 30,
+            path: "my_action",
+            tag: "client_action_by_path",
+            target: "main",
+            type: "ir.actions.client",
+        },
+    ]);
+    actionRegistry
+        .add("client_action_by_db_id", () => expect.step("client_action_db_id"))
+        .add("client_action_by_xml_id", () => expect.step("client_action_xml_id"))
+        .add("client_action_by_path", () => expect.step("client_action_path"))
+        .add("client_action_by_tag", () => expect.step("client_action_tag"))
+        .add("client_action_by_object", () => expect.step("client_action_object"));
+
+    await makeMockEnv();
+    await getService("action").doAction(10);
+    expect.verifySteps(["client_action_db_id"]);
+    await getService("action").doAction("some_action");
+    expect.verifySteps(["client_action_xml_id"]);
+    await getService("action").doAction("my_action");
+    expect.verifySteps(["client_action_path"]);
+    await getService("action").doAction("client_action_by_tag");
+    expect.verifySteps(["client_action_tag"]);
+    await getService("action").doAction({
+        tag: "client_action_by_object",
+        target: "current",
+        type: "ir.actions.client",
+    });
+    expect.verifySteps(["client_action_object"]);
+});
+
+test("action doesn't exists", async () => {
+    expect.assertions(1);
+    await makeMockEnv();
+    try {
+        await getService("action").doAction({
+            tag: "this_is_a_tag",
+            target: "current",
+            type: "ir.not_action.error",
+        });
+    } catch (e) {
+        expect(e.message).toBe(
+            "The ActionManager service can't handle actions of type ir.not_action.error"
+        );
+    }
+});
+
+test("getCurrentAction", async () => {
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(1);
+    const currentAction = await getService("action").currentAction;
+    expect(currentAction).toEqual({
+        binding_type: "action",
+        binding_view_types: "list,form",
+        id: 1,
+        type: "ir.actions.act_window",
+        xml_id: "action_1",
+        name: "Partners Action 1",
+        res_model: "partner",
+        views: [[1, "kanban"]],
+        context: {},
+        embedded_action_ids: [],
+        group_ids: [],
+        limit: 80,
+        mobile_view_mode: "kanban",
+        target: "current",
+        view_ids: [],
+        view_mode: "list,form",
+        cache: true,
+    });
+});
+
+test("getCurrentAction (virtual controller)", async () => {
+    stepAllNetworkCalls();
+    class ClientAction extends Component {
+        static template = xml`<div class="o_client_action_test">Hello World</div>`;
+        static props = ["*"];
+        static path = "plop";
+        setup() {
+            onWillStart(async () => {
+                const currentAction = await getService("action").currentAction;
+                expect.step(currentAction);
+            });
+        }
+    }
+    actionRegistry.add("HelloWorldTest", ClientAction);
+
+    redirect("/odoo/action-1/plop");
+    await mountWithCleanup(WebClient);
+
+    await animationFrame();
+
+    expect.verifySteps([
+        "/web/webclient/translations",
+        "/web/webclient/load_menus",
+        "/web/action/load_breadcrumbs",
+        "/web/action/load",
+        {
+            binding_type: "action",
+            binding_view_types: "list,form",
+            id: 1,
+            type: "ir.actions.act_window",
+            xml_id: "action_1",
+            name: "Partners Action 1",
+            res_model: "partner",
+            views: [[1, "kanban"]],
+            context: {},
+            embedded_action_ids: [],
+            group_ids: [],
+            limit: 80,
+            mobile_view_mode: "kanban",
+            target: "current",
+            view_ids: [],
+            view_mode: "list,form",
+            cache: true,
+        },
+    ]);
+});
+
+test("action in handler registry", async () => {
+    await makeMockEnv();
+    actionHandlersRegistry.add("ir.action_in_handler_registry", ({ action }) =>
+        expect.step(action.type)
+    );
+    await getService("action").doAction({
+        tag: "this_is_a_tag",
+        target: "current",
+        type: "ir.action_in_handler_registry",
+    });
+    expect.verifySteps(["ir.action_in_handler_registry"]);
+});
+
+test("properly handle case when action id does not exist", async () => {
+    expect.errors(1);
+    await mountWithCleanup(WebClient);
+    getService("action").doAction(4448);
+    await animationFrame();
+    expect.verifyErrors(["RPC_ERROR"]);
+    expect(`.modal .o_error_dialog`).toHaveCount(1);
+    expect(".o_error_dialog .modal-body").toHaveText("The action 4448 does not exist");
+});
+
+test("properly handle case when action path does not exist", async () => {
+    expect.errors(1);
+    await mountWithCleanup(WebClient);
+    getService("action").doAction("plop");
+    await animationFrame();
+    expect.verifyErrors(["RPC_ERROR"]);
+    expect(`.modal .o_error_dialog`).toHaveCount(1);
+    expect(".o_error_dialog .modal-body").toHaveText('The action "plop" does not exist');
+});
+
+test("properly handle case when action xmlId does not exist", async () => {
+    expect.errors(1);
+    await mountWithCleanup(WebClient);
+    getService("action").doAction("not.found.action");
+    await animationFrame();
+    expect.verifyErrors(["RPC_ERROR"]);
+    expect(`.modal .o_error_dialog`).toHaveCount(1);
+    expect(".o_error_dialog .modal-body").toHaveText(
+        'The action "not.found.action" does not exist'
+    );
+});
+
+test("actions can be cached", async () => {
+    onRpc("/web/action/load", async (request) => {
+        const { params } = await request.json();
+        expect.step(params.context);
+    });
+
+    await makeMockEnv();
+
+    // With no additional params
+    await getService("action").loadAction(3);
+    await getService("action").loadAction(3);
+
+    // With specific context
+    await getService("action").loadAction(3, { configuratorMode: "add" });
+    await getService("action").loadAction(3, { configuratorMode: "edit" });
+
+    // With same active_id
+    await getService("action").loadAction(3, { active_id: 1 });
+    await getService("action").loadAction(3, { active_id: 1 });
+
+    // With active_id change
+    await getService("action").loadAction(3, { active_id: 2 });
+
+    // With same active_ids
+    await getService("action").loadAction(3, { active_ids: [1, 2] });
+    await getService("action").loadAction(3, { active_ids: [1, 2] });
+
+    // With active_ids change
+    await getService("action").loadAction(3, { active_ids: [1, 2, 3] });
+
+    // With same active_model
+    await getService("action").loadAction(3, { active_model: "a" });
+    await getService("action").loadAction(3, { active_model: "a" });
+
+    // With active_model change
+    await getService("action").loadAction(3, { active_model: "b" });
+
+    // should load from server once per active_id/active_ids/active_model change, nothing else
+    const baseCtx = {
+        lang: "en",
+        tz: "taht",
+        uid: 7,
+        allowed_company_ids: [1],
+    };
+    expect.verifySteps([
+        { ...baseCtx },
+        { ...baseCtx, configuratorMode: "add" },
+        { ...baseCtx, configuratorMode: "edit" },
+        { ...baseCtx, active_id: 1 },
+        { ...baseCtx, active_id: 2 },
+        { ...baseCtx, active_ids: [1, 2] },
+        { ...baseCtx, active_ids: [1, 2, 3] },
+        { ...baseCtx, active_model: "a" },
+        { ...baseCtx, active_model: "b" },
+    ]);
+});
+
+test("action cache: additionalContext is used on the key", async () => {
+    onRpc("/web/action/load", () => {
+        expect.step("server loaded");
+    });
+
+    await makeMockEnv();
+    const actionParams = {
+        additionalContext: {
+            some: { deep: { nested: "Robert" } },
+        },
+    };
+
+    let action = await getService("action").loadAction(3, actionParams);
+    expect.verifySteps(["server loaded"]);
+    expect(action.context).toEqual(actionParams);
+
+    // Modify the action in place
+    action.context.additionalContext.some.deep.nested = "Nesta";
+
+    // Change additionalContext and reload
+    actionParams.additionalContext.some.deep.nested = "Marley";
+    action = await getService("action").loadAction(3, actionParams);
+    expect.verifySteps(["server loaded"]);
+    expect(action.context).toEqual(actionParams);
+});
+
+test.tags("desktop");
+test('action with "no_breadcrumbs" set to true', async () => {
+    defineActions([
+        {
+            id: 42,
+            res_model: "partner",
+            type: "ir.actions.act_window",
+            views: [
+                [1, "kanban"],
+                [false, "list"],
+            ],
+            context: { no_breadcrumbs: true },
+        },
+    ]);
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(3);
+    expect(".o_breadcrumb").toHaveCount(1);
+    // push another action flagged with 'no_breadcrumbs=true'
+    await getService("action").doAction(42);
+    await waitFor(".o_kanban_view");
+    expect(".o_breadcrumb").toHaveCount(0);
+    await contains(".o_switch_view.o_list").click();
+    await waitFor(".o_list_view");
+    expect(".o_breadcrumb").toHaveCount(0);
+});
+
+test("document's title is updated when an action is executed", async () => {
+    await mountWithCleanup(WebClient);
+    await animationFrame();
+    let currentTitle = getService("title").getParts();
+    expect(currentTitle).toEqual({});
+    let currentState = router.current;
+    await getService("action").doAction(4);
+    await animationFrame();
+    currentTitle = getService("title").getParts();
+    expect(currentTitle).toEqual({ action: "Partners Action 4" });
+    currentState = router.current;
+    expect(currentState).toEqual({
+        action: 4,
+        actionStack: [
+            {
+                action: 4,
+                displayName: "Partners Action 4",
+                view_type: "kanban",
+            },
+        ],
+    });
+
+    await getService("action").doAction(8);
+    await animationFrame();
+    currentTitle = getService("title").getParts();
+    expect(currentTitle).toEqual({ action: "Favorite Ponies" });
+    currentState = router.current;
+    expect(currentState).toEqual({
+        action: 8,
+        actionStack: [
+            {
+                action: 4,
+                displayName: "Partners Action 4",
+                view_type: "kanban",
+            },
+            {
+                action: 8,
+                displayName: "Favorite Ponies",
+                view_type: "list",
+            },
+        ],
+    });
+
+    await contains(".o_data_row .o_data_cell").click();
+    await animationFrame();
+    currentTitle = getService("title").getParts();
+    expect(currentTitle).toEqual({ action: "Twilight Sparkle" });
+    currentState = router.current;
+    expect(currentState).toEqual({
+        action: 8,
+        resId: 4,
+        actionStack: [
+            {
+                action: 4,
+                displayName: "Partners Action 4",
+                view_type: "kanban",
+            },
+            {
+                action: 8,
+                displayName: "Favorite Ponies",
+                view_type: "list",
+            },
+            {
+                action: 8,
+                resId: 4,
+                displayName: "Twilight Sparkle",
+                view_type: "form",
+            },
+        ],
+    });
+});
+
+test.tags("desktop");
+test('handles "history_back" event', async () => {
+    let list;
+    patchWithCleanup(listView.Controller.prototype, {
+        setup() {
+            super.setup(...arguments);
+            list = this;
+        },
+    });
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(4);
+    await getService("action").doAction(3);
+    expect("ol.breadcrumb").toHaveCount(1);
+    expect(".o_breadcrumb span").toHaveCount(1);
+    list.env.config.historyBack();
+    await animationFrame();
+    expect(".o_breadcrumb span").toHaveCount(1);
+    expect(".o_breadcrumb").toHaveText("Partners Action 4", {
+        message: "breadcrumbs should display the display_name of the action",
+    });
+});
+
+test.tags("desktop");
+test("stores and restores scroll position (in kanban)", async () => {
+    defineActions([
+        {
+            id: 10,
+            name: "Partners",
+            res_model: "partner",
+            views: [[false, "kanban"]],
+        },
+    ]);
+    for (let i = 0; i < 60; i++) {
+        Partner._records.push({ id: 100 + i, display_name: `Record ${i}` });
+    }
+    const container = document.createElement("div");
+    container.classList.add("o_web_client");
+    container.style.height = "250px";
+    getFixture().appendChild(container);
+    await mountWithCleanup(WebClient, { target: container });
+    // execute a first action
+    await getService("action").doAction(10);
+    expect(".o_content").toHaveProperty("scrollTop", 0);
+    // simulate a scroll
+    await scroll(".o_content", { top: 100 });
+    // execute a second action (in which we don't scroll)
+    await getService("action").doAction(4);
+    expect(".o_content").toHaveProperty("scrollTop", 0);
+    // go back using the breadcrumbs
+    await contains(".o_control_panel .breadcrumb a").click();
+    expect(".o_content").toHaveProperty("scrollTop", 100);
+});
+
+test.tags("desktop");
+test("stores and restores scroll position (in list)", async () => {
+    for (let i = 0; i < 60; i++) {
+        Partner._records.push({ id: 100 + i, display_name: `Record ${i}` });
+    }
+    const container = document.createElement("div");
+    container.classList.add("o_web_client");
+    container.style.height = "250px";
+    getFixture().appendChild(container);
+    await mountWithCleanup(WebClient, { target: container });
+    // execute a first action
+    await getService("action").doAction(3);
+    expect(".o_content").toHaveProperty("scrollTop", 0);
+    expect(queryOne(".o_list_renderer").scrollTop).toBe(0);
+    // simulate a scroll
+    queryOne(".o_list_renderer").scrollTop = 100;
+    // execute a second action (in which we don't scroll)
+    await getService("action").doAction(4);
+    expect(".o_content").toHaveProperty("scrollTop", 0);
+    // go back using the breadcrumbs
+    await contains(".o_control_panel .breadcrumb a").click();
+    expect(".o_content").toHaveProperty("scrollTop", 0);
+    expect(queryOne(".o_list_renderer").scrollTop).toBe(100);
+});
+
+test.tags("desktop");
+test('executing an action with target != "new" closes all dialogs', async () => {
+    Partner._views["form"] = `
+        <form>
+            <field name="o2m">
+                <list><field name="display_name"/></list>
+                <form><field name="display_name"/></form>
+            </field>
+        </form>`;
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(3);
+    expect(".o_list_view").toHaveCount(1);
+    await contains(".o_list_view .o_data_row .o_list_char").click();
+    expect(".o_form_view").toHaveCount(1);
+    await contains(".o_form_view .o_data_row .o_data_cell").click();
+    expect(".modal .o_form_view").toHaveCount(1);
+    await getService("action").doAction(1); // target != 'new'
+    await animationFrame(); // wait for the dialog to be closed
+    expect(".modal").toHaveCount(0);
+});
+
+test.tags("desktop");
+test('executing an action with target "new" does not close dialogs', async () => {
+    Partner._views["form"] = `
+        <form>
+            <field name="o2m">
+                <list><field name="display_name"/></list>
+                <form><field name="display_name"/></form>
+            </field>
+        </form>`;
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(3);
+    expect(".o_list_view").toHaveCount(1);
+    await contains(".o_list_view .o_data_row .o_data_cell").click();
+    expect(".o_form_view").toHaveCount(1);
+    await contains(".o_form_view .o_data_row .o_data_cell").click();
+    expect(".modal .o_form_view").toHaveCount(1);
+    await getService("action").doAction(5); // target 'new'
+    expect(".modal .o_form_view").toHaveCount(2);
+});
+
+test.tags("desktop");
+test("search defaults are removed from context when switching view", async () => {
+    expect.assertions(1);
+    const context = {
+        search_default_x: true,
+        searchpanel_default_y: true,
+    };
+    patchWithCleanup(PivotModel.prototype, {
+        load(searchParams) {
+            expect(searchParams.context).toEqual({
+                allowed_company_ids: [1],
+                lang: "en",
+                tz: "taht",
+                uid: 7,
+            });
+            return super.load(...arguments);
+        },
+    });
+
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction({
+        res_model: "partner",
+        type: "ir.actions.act_window",
+        views: [
+            [false, "list"],
+            [false, "pivot"],
+        ],
+        context,
+    });
+    // list view is loaded, switch to pivot view
+    await switchView("pivot");
+});
+
+test("retrieving a stored action should remove 'allowed_company_ids' from its context (model)", async () => {
+    // Prepare a multi company scenario
+    serverState.companies = [
+        { id: 3, name: "Hermit", sequence: 1 },
+        { id: 2, name: "Herman's", sequence: 2 },
+        { id: 1, name: "Heroes TM", sequence: 3 },
+    ];
+
+    // Prepare a stored action
+    browser.sessionStorage.setItem(
+        "current_action",
+        JSON.stringify({
+            id: 1,
+            name: "Partners Action 1",
+            res_model: "partner",
+            type: "ir.actions.act_window",
+            views: [[1, "kanban"]],
+            context: {
+                someKey: 44,
+                allowed_company_ids: [1, 2],
+                lang: "not_en",
+                tz: "not_taht",
+                uid: 42,
+            },
+        })
+    );
+
+    // Prepare the URL hash to make sure the stored action will get executed.
+    Object.assign(browser.location, { search: "?model=partner&view_type=kanban" });
+
+    // Create the web client. It should execute the stored action.
+    await mountWithCleanup(WebClient);
+    await animationFrame(); // blank action
+
+    // Check the current action context
+    expect(getService("action").currentController.action.context).toEqual({
+        // action context
+        someKey: 44,
+        lang: "not_en",
+        tz: "not_taht",
+        uid: 42,
+        // note there is no 'allowed_company_ids' in the action context
+    });
+});
+
+test("retrieving a stored action should remove 'allowed_company_ids' from its context (action)", async () => {
+    // Prepare a multi company scenario
+    serverState.companies = [
+        { id: 3, name: "Hermit", sequence: 1 },
+        { id: 2, name: "Herman's", sequence: 2 },
+        { id: 1, name: "Heroes TM", sequence: 3 },
+    ];
+
+    // Prepare a stored action
+    browser.sessionStorage.setItem(
+        "current_action",
+        JSON.stringify({
+            id: 1,
+            name: "Partners Action 1",
+            res_model: "partner",
+            type: "ir.actions.act_window",
+            views: [[1, "kanban"]],
+            context: {
+                someKey: 44,
+                allowed_company_ids: [1, 2],
+                lang: "not_en",
+                tz: "not_taht",
+                uid: 42,
+            },
+        })
+    );
+
+    // Prepare the URL hash to make sure the stored action will get executed.
+    // Object.assign(browser.location, { search: "?model=partner&view_type=kanban" });
+    redirect("/odoo/action-1?view_type=kanban");
+
+    // Create the web client. It should execute the stored action.
+    await mountWithCleanup(WebClient);
+    await animationFrame(); // blank action
+
+    // Check the current action context
+    expect(getService("action").currentController.action.context).toEqual({
+        // action context
+        someKey: 44,
+        lang: "not_en",
+        tz: "not_taht",
+        uid: 42,
+        // note there is no 'allowed_company_ids' in the action context
+    });
+});
+test.tags("desktop");
+test("action is removed while waiting for another action with selectMenu", async () => {
+    let def;
+    class SlowClientAction extends Component {
+        static template = xml`<div>My client action</div>`;
+        static props = ["*"];
+
+        setup() {
+            onWillStart(() => def);
+        }
+    }
+    actionRegistry.add("slow_client_action", SlowClientAction);
+    defineActions([
+        {
+            id: 1001,
+            tag: "slow_client_action",
+            target: "main",
+            type: "ir.actions.client",
+            params: { description: "Id 1" },
+        },
+    ]);
+    defineMenus([
+        {
+            id: 1,
+            name: "App1",
+            actionID: 1001,
+            xmlid: "menu_1",
+        },
+    ]);
+
+    await mountWithCleanup(WebClient);
+    // starting point: a kanban view
+    await getService("action").doAction(4);
+    expect(".o_kanban_view").toHaveCount(1);
+
+    // select app in navbar menu
+    def = new Deferred();
+    await contains(".o_navbar_apps_menu .dropdown-toggle").click();
+    const appsMenu = getDropdownMenu(".o_navbar_apps_menu");
+    await contains(".o_app:contains(App1)", { root: appsMenu }).click();
+
+    // check that the action manager is empty, even though client action is loading
+    expect(".o_action_manager").toHaveText("");
+
+    // resolve onwillstart so client action is ready
+    def.resolve();
+    await animationFrame();
+    expect(".o_action_manager").toHaveText("My client action");
+});

odoo-bringout-oca-ocb-web/web/static/tests/webclient/actions/misc_tests.js

@@ -1,660 +0,0 @@
-/** @odoo-module **/
-
-import { browser } from "@web/core/browser/browser";
-import { registry } from "@web/core/registry";
-import { session } from "@web/session";
-import AbstractAction from "web.AbstractAction";
-import core from "web.core";
-import testUtils from "web.test_utils";
-import Widget from "web.Widget";
-import { makeTestEnv } from "../../helpers/mock_env";
-import {
-    click,
-    getFixture,
-    hushConsole,
-    legacyExtraNextTick,
-    nextTick,
-    patchWithCleanup,
-} from "../../helpers/utils";
-import {
-    createWebClient,
-    doAction,
-    getActionManagerServerData,
-    setupWebClientRegistries,
-} from "./../helpers";
-import * as cpHelpers from "@web/../tests/search/helpers";
-import { listView } from "@web/views/list/list_view";
-import { companyService } from "@web/webclient/company_service";
-import { GraphModel } from "@web/views/graph/graph_model";
-import { fakeCookieService } from "../../helpers/mock_services";
-
-let serverData;
-let target;
-// legacy stuff
-const actionRegistry = registry.category("actions");
-const actionHandlersRegistry = registry.category("action_handlers");
-
-QUnit.module("ActionManager", (hooks) => {
-    hooks.beforeEach(() => {
-        serverData = getActionManagerServerData();
-        target = getFixture();
-    });
-
-    QUnit.module("Misc");
-
-    QUnit.test("can execute actions from id, xmlid and tag", async (assert) => {
-        assert.expect(6);
-        serverData.actions[1] = {
-            tag: "client_action_by_db_id",
-            target: "main",
-            type: "ir.actions.client",
-        };
-        serverData.actions["wowl.some_action"] = {
-            tag: "client_action_by_xml_id",
-            target: "main",
-            type: "ir.actions.client",
-        };
-        actionRegistry
-            .add("client_action_by_db_id", () => assert.step("client_action_db_id"))
-            .add("client_action_by_xml_id", () => assert.step("client_action_xml_id"))
-            .add("client_action_by_object", () => assert.step("client_action_object"));
-        setupWebClientRegistries();
-        const env = await makeTestEnv({ serverData });
-        await doAction(env, 1);
-        assert.verifySteps(["client_action_db_id"]);
-        await doAction(env, "wowl.some_action");
-        assert.verifySteps(["client_action_xml_id"]);
-        await doAction(env, {
-            tag: "client_action_by_object",
-            target: "current",
-            type: "ir.actions.client",
-        });
-        assert.verifySteps(["client_action_object"]);
-    });
-
-    QUnit.test("action doesn't exists", async (assert) => {
-        assert.expect(1);
-        setupWebClientRegistries();
-        const env = await makeTestEnv({ serverData });
-        try {
-            await doAction(env, {
-                tag: "this_is_a_tag",
-                target: "current",
-                type: "ir.not_action.error",
-            });
-        } catch (e) {
-            assert.strictEqual(
-                e.message,
-                "The ActionManager service can't handle actions of type ir.not_action.error"
-            );
-        }
-    });
-
-    QUnit.test("action in handler registry", async (assert) => {
-        assert.expect(2);
-        setupWebClientRegistries();
-        const env = await makeTestEnv({ serverData });
-        actionHandlersRegistry.add("ir.action_in_handler_registry", ({ action }) =>
-            assert.step(action.type)
-        );
-        await doAction(env, {
-            tag: "this_is_a_tag",
-            target: "current",
-            type: "ir.action_in_handler_registry",
-        });
-        assert.verifySteps(["ir.action_in_handler_registry"]);
-    });
-
-    QUnit.test("properly handle case when action id does not exist", async (assert) => {
-        assert.expect(2);
-        const webClient = await createWebClient({ serverData });
-        patchWithCleanup(window, { console: hushConsole }, { pure: true });
-        patchWithCleanup(webClient.env.services.notification, {
-            add(message) {
-                assert.strictEqual(message, "No action with id '4448' could be found");
-            },
-        });
-        await doAction(webClient, 4448);
-        assert.containsOnce(target, "div.o_invalid_action");
-    });
-
-    QUnit.test("actions can be cached", async function (assert) {
-        assert.expect(8);
-
-        const mockRPC = async (route, args) => {
-            if (route === "/web/action/load") {
-                assert.step(JSON.stringify(args));
-            }
-        };
-
-        setupWebClientRegistries();
-        const env = await makeTestEnv({ serverData, mockRPC });
-
-        const loadAction = env.services.action.loadAction;
-
-        // With no additional params
-        await loadAction(3);
-        await loadAction(3);
-
-        // With specific additionalContext
-        await loadAction(3, { additionalContext: { configuratorMode: "add" } });
-        await loadAction(3, { additionalContext: { configuratorMode: "edit" } });
-
-        // With same active_id
-        await loadAction(3, { active_id: 1 });
-        await loadAction(3, { active_id: 1 });
-
-        // With active_id change
-        await loadAction(3, { active_id: 2 });
-
-        // With same active_ids
-        await loadAction(3, { active_ids: [1, 2] });
-        await loadAction(3, { active_ids: [1, 2] });
-
-        // With active_ids change
-        await loadAction(3, { active_ids: [1, 2, 3] });
-
-        // With same active_model
-        await loadAction(3, { active_model: "a" });
-        await loadAction(3, { active_model: "a" });
-
-        // With active_model change
-        await loadAction(3, { active_model: "b" });
-
-        assert.verifySteps(
-            [
-                '{"action_id":3,"additional_context":{}}',
-                '{"action_id":3,"additional_context":{"active_id":1}}',
-                '{"action_id":3,"additional_context":{"active_id":2}}',
-                '{"action_id":3,"additional_context":{"active_ids":[1,2]}}',
-                '{"action_id":3,"additional_context":{"active_ids":[1,2,3]}}',
-                '{"action_id":3,"additional_context":{"active_model":"a"}}',
-                '{"action_id":3,"additional_context":{"active_model":"b"}}',
-            ],
-            "should load from server once per active_id/active_ids/active_model change, nothing else"
-        );
-    });
-
-    QUnit.test("action cache: additionalContext is respected", async function (assert) {
-        assert.expect(5);
-
-        const mockRPC = async (route) => {
-            if (route === "/web/action/load") {
-                assert.step("server loaded");
-            }
-        };
-
-        setupWebClientRegistries();
-        const env = await makeTestEnv({ serverData, mockRPC });
-        const { loadAction } = env.services.action;
-        const actionParams = {
-            additionalContext: {
-                some: { deep: { nested: "Robert" } },
-            },
-        };
-
-        let action = await loadAction(3, actionParams);
-        assert.verifySteps(["server loaded"]);
-        assert.deepEqual(action.context, actionParams);
-
-        // Modify the action in place
-        action.context.additionalContext.some.deep.nested = "Nesta";
-
-        // Change additionalContext and reload from cache
-        actionParams.additionalContext.some.deep.nested = "Marley";
-        action = await loadAction(3, actionParams);
-        assert.verifySteps([], "loaded from cache");
-        assert.deepEqual(action.context, actionParams);
-    });
-
-    QUnit.test("no widget memory leaks when doing some action stuff", async function (assert) {
-        assert.expect(1);
-        let delta = 0;
-        testUtils.mock.patch(Widget, {
-            init: function () {
-                delta++;
-                this._super.apply(this, arguments);
-            },
-            destroy: function () {
-                delta--;
-                this._super.apply(this, arguments);
-            },
-        });
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, 8);
-        const n = delta;
-        await doAction(webClient, 4);
-        // kanban view is loaded, switch to list view
-        await cpHelpers.switchView(target, "list");
-        await legacyExtraNextTick();
-        // open a record in form view
-        await testUtils.dom.click(target.querySelector(".o_list_view .o_data_row"));
-        await legacyExtraNextTick();
-        // go back to action 7 in breadcrumbs
-        await testUtils.dom.click(target.querySelector(".o_control_panel .breadcrumb a"));
-        await legacyExtraNextTick();
-        assert.strictEqual(delta, n, "should have properly destroyed all other widgets");
-        testUtils.mock.unpatch(Widget);
-    });
-
-    QUnit.test("no widget memory leaks when executing actions in dialog", async function (assert) {
-        assert.expect(1);
-        let delta = 0;
-        testUtils.mock.patch(Widget, {
-            init: function () {
-                delta++;
-                this._super.apply(this, arguments);
-            },
-            destroy: function () {
-                if (!this.isDestroyed()) {
-                    delta--;
-                }
-                this._super.apply(this, arguments);
-            },
-        });
-        const webClient = await createWebClient({ serverData });
-        const n = delta;
-        await doAction(webClient, 5);
-        await doAction(webClient, { type: "ir.actions.act_window_close" });
-        assert.strictEqual(delta, n, "should have properly destroyed all widgets");
-        testUtils.mock.unpatch(Widget);
-    });
-
-    QUnit.test(
-        "no memory leaks when executing an action while switching view",
-        async function (assert) {
-            assert.expect(1);
-            let def;
-            let delta = 0;
-            testUtils.mock.patch(Widget, {
-                init: function () {
-                    delta += 1;
-                    this._super.apply(this, arguments);
-                },
-                destroy: function () {
-                    delta -= 1;
-                    this._super.apply(this, arguments);
-                },
-            });
-            const mockRPC = async function (route, args) {
-                if (args && args.method === "read") {
-                    await Promise.resolve(def);
-                }
-            };
-            const webClient = await createWebClient({ serverData, mockRPC });
-            await doAction(webClient, 4);
-            const n = delta;
-            await doAction(webClient, 3, { clearBreadcrumbs: true });
-            // switch to the form view (this request is blocked)
-            def = testUtils.makeTestPromise();
-            await testUtils.dom.click(target.querySelector(".o_list_view .o_data_row"));
-            // execute another action meanwhile (don't block this request)
-            await doAction(webClient, 4, { clearBreadcrumbs: true });
-            // unblock the switch to the form view in action 3
-            def.resolve();
-            await testUtils.nextTick();
-            assert.strictEqual(n, delta, "all widgets of action 3 should have been destroyed");
-            testUtils.mock.unpatch(Widget);
-        }
-    );
-
-    QUnit.test(
-        "no memory leaks when executing an action while loading views",
-        async function (assert) {
-            assert.expect(1);
-            let def;
-            let delta = 0;
-            testUtils.mock.patch(Widget, {
-                init: function () {
-                    delta += 1;
-                    this._super.apply(this, arguments);
-                },
-                destroy: function () {
-                    delta -= 1;
-                    this._super.apply(this, arguments);
-                },
-            });
-            const mockRPC = async function (route, args) {
-                if (args && args.method === "get_views") {
-                    await Promise.resolve(def);
-                }
-            };
-            const webClient = await createWebClient({ serverData, mockRPC });
-            // execute action 4 to know the number of widgets it instantiates
-            await doAction(webClient, 4);
-            const n = delta;
-            // execute a first action (its 'get_views' RPC is blocked)
-            def = testUtils.makeTestPromise();
-            doAction(webClient, 3, { clearBreadcrumbs: true });
-            await testUtils.nextTick();
-            await legacyExtraNextTick();
-            // execute another action meanwhile (and unlock the RPC)
-            doAction(webClient, 4, { clearBreadcrumbs: true });
-            def.resolve();
-            await testUtils.nextTick();
-            await legacyExtraNextTick();
-            assert.strictEqual(n, delta, "all widgets of action 3 should have been destroyed");
-            testUtils.mock.unpatch(Widget);
-        }
-    );
-
-    QUnit.test(
-        "no memory leaks when executing an action while loading data of default view",
-        async function (assert) {
-            assert.expect(1);
-            let def;
-            let delta = 0;
-            testUtils.mock.patch(Widget, {
-                init: function () {
-                    delta += 1;
-                    this._super.apply(this, arguments);
-                },
-                destroy: function () {
-                    delta -= 1;
-                    this._super.apply(this, arguments);
-                },
-            });
-            const mockRPC = async function (route) {
-                if (route === "/web/dataset/search_read") {
-                    await Promise.resolve(def);
-                }
-            };
-            const webClient = await createWebClient({ serverData, mockRPC });
-            // execute action 4 to know the number of widgets it instantiates
-            await doAction(webClient, 4);
-            const n = delta;
-            // execute a first action (its 'search_read' RPC is blocked)
-            def = testUtils.makeTestPromise();
-            doAction(webClient, 3, { clearBreadcrumbs: true });
-            await testUtils.nextTick();
-            await legacyExtraNextTick();
-            // execute another action meanwhile (and unlock the RPC)
-            doAction(webClient, 4, { clearBreadcrumbs: true });
-            def.resolve();
-            await testUtils.nextTick();
-            await legacyExtraNextTick();
-            assert.strictEqual(n, delta, "all widgets of action 3 should have been destroyed");
-            testUtils.mock.unpatch(Widget);
-        }
-    );
-
-    QUnit.test('action with "no_breadcrumbs" set to true', async function (assert) {
-        serverData.actions[4].context = { no_breadcrumbs: true };
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, 3);
-        assert.containsOnce(target, ".o_control_panel .breadcrumb-item");
-        // push another action flagged with 'no_breadcrumbs=true'
-        await doAction(webClient, 4);
-        assert.containsNone(target, ".o_control_panel .breadcrumb-item");
-    });
-
-    QUnit.test("document's title is updated when an action is executed", async function (assert) {
-        const defaultTitle = { zopenerp: "Odoo" };
-        const webClient = await createWebClient({ serverData });
-        let currentTitle = webClient.env.services.title.getParts();
-        assert.deepEqual(currentTitle, defaultTitle);
-        let currentHash = webClient.env.services.router.current.hash;
-        assert.deepEqual(currentHash, {});
-        await doAction(webClient, 4);
-        currentTitle = webClient.env.services.title.getParts();
-        assert.deepEqual(currentTitle, {
-            ...defaultTitle,
-            action: "Partners Action 4",
-        });
-        currentHash = webClient.env.services.router.current.hash;
-        assert.deepEqual(currentHash, { action: 4, model: "partner", view_type: "kanban" });
-        await doAction(webClient, 8);
-        currentTitle = webClient.env.services.title.getParts();
-        assert.deepEqual(currentTitle, {
-            ...defaultTitle,
-            action: "Favorite Ponies",
-        });
-        currentHash = webClient.env.services.router.current.hash;
-        assert.deepEqual(currentHash, { action: 8, model: "pony", view_type: "list" });
-        await click(target.querySelector(".o_data_row .o_data_cell"));
-        await nextTick();
-        currentTitle = webClient.env.services.title.getParts();
-        assert.deepEqual(currentTitle, {
-            ...defaultTitle,
-            action: "Twilight Sparkle",
-        });
-        currentHash = webClient.env.services.router.current.hash;
-        assert.deepEqual(currentHash, { action: 8, id: 4, model: "pony", view_type: "form" });
-    });
-
-    QUnit.test(
-        "on_reverse_breadcrumb handler is correctly called (legacy)",
-        async function (assert) {
-            // This test can be removed as soon as we no longer support legacy actions as the new
-            // ActionManager doesn't support this option. Indeed, it is used to reload the previous
-            // action when coming back, but we won't need such an artefact to that with Wowl, as the
-            // controller will be re-instantiated with an (exported) state given in props.
-            assert.expect(5);
-            const ClientAction = AbstractAction.extend({
-                events: {
-                    "click button": "_onClick",
-                },
-                start() {
-                    this.$el.html('<button class="my_button">Execute another action</button>');
-                },
-                _onClick() {
-                    this.do_action(4, {
-                        on_reverse_breadcrumb: () => assert.step("on_reverse_breadcrumb"),
-                    });
-                },
-            });
-            core.action_registry.add("ClientAction", ClientAction);
-            const webClient = await createWebClient({ serverData });
-            await doAction(webClient, "ClientAction");
-            assert.containsOnce(target, ".my_button");
-            await testUtils.dom.click(target.querySelector(".my_button"));
-            await legacyExtraNextTick();
-            assert.containsOnce(target, ".o_kanban_view");
-            await testUtils.dom.click($(target).find(".o_control_panel .breadcrumb a:first"));
-            await legacyExtraNextTick();
-            assert.containsOnce(target, ".my_button");
-            assert.verifySteps(["on_reverse_breadcrumb"]);
-            delete core.action_registry.map.ClientAction;
-        }
-    );
-
-    QUnit.test('handles "history_back" event', async function (assert) {
-        assert.expect(3);
-        let list;
-        patchWithCleanup(listView.Controller.prototype, {
-            setup() {
-                this._super(...arguments);
-                list = this;
-            },
-        });
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, 4);
-        await doAction(webClient, 3);
-        assert.containsN(target, ".o_control_panel .breadcrumb-item", 2);
-        list.env.config.historyBack();
-        await testUtils.nextTick();
-        await legacyExtraNextTick();
-        assert.containsOnce(target, ".o_control_panel .breadcrumb-item");
-        assert.strictEqual(
-            $(target).find(".o_control_panel .breadcrumb-item").text(),
-            "Partners Action 4",
-            "breadcrumbs should display the display_name of the action"
-        );
-    });
-
-    QUnit.test("stores and restores scroll position (in kanban)", async function (assert) {
-        serverData.actions[3].views = [[false, "kanban"]];
-        assert.expect(3);
-        for (let i = 0; i < 60; i++) {
-            serverData.models.partner.records.push({ id: 100 + i, foo: `Record ${i}` });
-        }
-        const container = document.createElement("div");
-        container.classList.add("o_web_client");
-        container.style.height = "250px";
-        target.appendChild(container);
-        const webClient = await createWebClient({ target: container, serverData });
-        // execute a first action
-        await doAction(webClient, 3);
-        assert.strictEqual(target.querySelector(".o_content").scrollTop, 0);
-        // simulate a scroll
-        target.querySelector(".o_content").scrollTop = 100;
-        // execute a second action (in which we don't scroll)
-        await doAction(webClient, 4);
-        assert.strictEqual(target.querySelector(".o_content").scrollTop, 0);
-        // go back using the breadcrumbs
-        await click(target.querySelector(".o_control_panel .breadcrumb a"));
-        assert.strictEqual(target.querySelector(".o_content").scrollTop, 100);
-    });
-
-    QUnit.test("stores and restores scroll position (in list)", async function (assert) {
-        for (let i = 0; i < 60; i++) {
-            serverData.models.partner.records.push({ id: 100 + i, foo: `Record ${i}` });
-        }
-        const container = document.createElement("div");
-        container.classList.add("o_web_client");
-        container.style.height = "250px";
-        target.appendChild(container);
-        const webClient = await createWebClient({ target: container, serverData });
-        // execute a first action
-        await doAction(webClient, 3);
-        assert.strictEqual(target.querySelector(".o_content").scrollTop, 0);
-        assert.strictEqual(target.querySelector(".o_list_renderer").scrollTop, 0);
-        // simulate a scroll
-        target.querySelector(".o_list_renderer").scrollTop = 100;
-        await nextTick();
-        // execute a second action (in which we don't scroll)
-        await doAction(webClient, 4);
-        assert.strictEqual(target.querySelector(".o_content").scrollTop, 0);
-        // go back using the breadcrumbs
-        await click(target.querySelector(".o_control_panel .breadcrumb a"));
-        assert.strictEqual(target.querySelector(".o_content").scrollTop, 0);
-        assert.strictEqual(target.querySelector(".o_list_renderer").scrollTop, 100);
-    });
-
-    QUnit.test(
-        'executing an action with target != "new" closes all dialogs',
-        async function (assert) {
-            serverData.views["partner,false,form"] = `
-                <form>
-                    <field name="o2m">
-                    <tree><field name="foo"/></tree>
-                    <form><field name="foo"/></form>
-                    </field>
-                </form>
-                `;
-            const webClient = await createWebClient({ serverData });
-            await doAction(webClient, 3);
-            assert.containsOnce(target, ".o_list_view");
-            await click(target.querySelector(".o_list_view .o_data_row .o_list_char"));
-            assert.containsOnce(target, ".o_form_view");
-            await click(target.querySelector(".o_form_view .o_data_row .o_data_cell"));
-            assert.containsOnce(document.body, ".modal .o_form_view");
-            await doAction(webClient, 1); // target != 'new'
-            assert.containsNone(document.body, ".modal");
-        }
-    );
-
-    QUnit.test(
-        'executing an action with target "new" does not close dialogs',
-        async function (assert) {
-            assert.expect(4);
-            serverData.views["partner,false,form"] = `
-                <form>
-                    <field name="o2m">
-                    <tree><field name="foo"/></tree>
-                    <form><field name="foo"/></form>
-                    </field>
-                </form>
-                `;
-            const webClient = await createWebClient({ serverData });
-            await doAction(webClient, 3);
-            assert.containsOnce(target, ".o_list_view");
-            await click(target.querySelector(".o_list_view .o_data_row .o_data_cell"));
-            assert.containsOnce(target, ".o_form_view");
-            await click(target.querySelector(".o_form_view .o_data_row .o_data_cell"));
-            assert.containsOnce(document.body, ".modal .o_form_view");
-            await doAction(webClient, 5); // target 'new'
-            assert.containsN(document.body, ".modal .o_form_view", 2);
-        }
-    );
-
-    QUnit.test(
-        "search defaults are removed from context when switching view",
-        async function (assert) {
-            assert.expect(1);
-            serverData.views["partner,false,graph"] = `<graph/>`;
-            serverData.views["partner,false,list"] = `<list/>`;
-            const context = {
-                search_default_x: true,
-                searchpanel_default_y: true,
-            };
-            registry.category("services").add("cookie", fakeCookieService);
-            patchWithCleanup(GraphModel.prototype, {
-                load(searchParams) {
-                    assert.deepEqual(searchParams.context, { lang: "en", tz: "taht", uid: 7 });
-                    return this._super.apply(this, arguments);
-                },
-            });
-
-            const webClient = await createWebClient({ serverData });
-            await doAction(webClient, {
-                res_model: "partner",
-                type: "ir.actions.act_window",
-                views: [
-                    [false, "list"],
-                    [false, "graph"],
-                ],
-                context,
-            });
-            // list view is loaded, switch to graph view
-            await cpHelpers.switchView(target, "graph");
-        }
-    );
-
-    QUnit.test(
-        "retrieving a stored action should remove 'allowed_company_ids' from its context",
-        async function (assert) {
-            // Prepare a multi company scenario
-            session.user_companies = {
-                allowed_companies: {
-                    3: { id: 3, name: "Hermit", sequence: 1 },
-                    2: { id: 2, name: "Herman's", sequence: 2 },
-                    1: { id: 1, name: "Heroes TM", sequence: 3 },
-                },
-                current_company: 3,
-            };
-            registry.category("services").add("company", companyService);
-
-            // Prepare a stored action
-            browser.sessionStorage.setItem(
-                "current_action",
-                JSON.stringify({
-                    ...serverData.actions[1],
-                    context: {
-                        someKey: 44,
-                        allowed_company_ids: [1, 2],
-                        lang: "not_en",
-                        tz: "not_taht",
-                        uid: 42,
-                    },
-                })
-            );
-
-            // Prepare the URL hash to make sure the stored action will get executed.
-            browser.location.hash = "#model=partner&view_type=kanban";
-
-            // Create the web client. It should execute the stored action.
-            const webClient = await createWebClient({ serverData });
-
-            // Check the current action context
-            assert.deepEqual(webClient.env.services.action.currentController.action.context, {
-                // action context
-                someKey: 44,
-                lang: "not_en",
-                tz: "not_taht",
-                uid: 42,
-                // note there is no 'allowed_company_ids' in the action context
-            });
-        }
-    );
-});

odoo-bringout-oca-ocb-web/web/static/tests/webclient/actions/multi_company_action.test.js

@@ -0,0 +1,158 @@
+import { beforeEach, expect, test } from "@odoo/hoot";
+import { cookie } from "@web/core/browser/cookie";
+import { redirect } from "@web/core/utils/urls";
+import {
+    contains,
+    defineModels,
+    fields,
+    getService,
+    makeServerError,
+    models,
+    mountWebClient,
+    onRpc,
+    patchWithCleanup,
+    serverState,
+} from "@web/../tests/web_test_helpers";
+import { animationFrame } from "@odoo/hoot-dom";
+import { browser } from "@web/core/browser/browser";
+import { FormViewDialog } from "@web/views/view_dialogs/form_view_dialog";
+
+class Partner extends models.Model {
+    _name = "res.partner";
+
+    name = fields.Char();
+
+    _records = [{ id: 1, name: "First record" }];
+    _views = {
+        form: `
+            <form>
+                <group>
+                    <field name="name"/>
+                </group>
+            </form>
+        `,
+    };
+}
+
+defineModels([Partner]);
+
+beforeEach(() => {
+    serverState.companies = [
+        { id: 1, name: "Company 1", sequence: 1, parent_id: false, child_ids: [] },
+        { id: 2, name: "Company 2", sequence: 2, parent_id: false, child_ids: [] },
+        { id: 3, name: "Company 3", sequence: 3, parent_id: false, child_ids: [] },
+    ];
+    patchWithCleanup(browser.location, {
+        reload() {
+            expect.step("reload");
+        },
+    });
+    patchWithCleanup(browser.location, {
+        origin: "http://example.com",
+    });
+});
+
+test("open record withtout the correct company (load state)", async () => {
+    cookie.set("cids", "1");
+    onRpc("web_read", () => {
+        throw makeServerError({
+            type: "AccessError",
+            message: "Wrong Company",
+            context: { suggested_company: { id: 2, display_name: "Company 2" } },
+        });
+    });
+
+    redirect("/odoo/res.partner/1");
+    await mountWebClient();
+    expect(cookie.get("cids")).toBe("1-2");
+    expect.verifySteps(["reload"]);
+    expect(browser.location.href).toBe("http://example.com/odoo/res.partner/1", {
+        message: "url did not change",
+    });
+});
+
+test("open record withtout the correct company (doAction)", async () => {
+    cookie.set("cids", "1");
+    onRpc("web_read", () => {
+        throw makeServerError({
+            type: "AccessError",
+            message: "Wrong Company",
+            context: { suggested_company: { id: 2, display_name: "Company 2" } },
+        });
+    });
+
+    await mountWebClient();
+    getService("action").doAction({
+        type: "ir.actions.act_window",
+        res_id: 1,
+        res_model: "res.partner",
+        views: [[false, "form"]],
+    });
+    await animationFrame();
+    expect(cookie.get("cids")).toBe("1-2");
+    expect.verifySteps(["reload"]);
+    expect(browser.location.href).toBe("http://example.com/odoo/res.partner/1", {
+        message: "url should contain the information of the doAction",
+    });
+});
+
+test("create/modify a record with a non-connected company", async () => {
+    cookie.set("cids", "1");
+    onRpc("web_save", ({ kwargs }) => {
+        expect.step(kwargs.context.allowed_company_ids);
+        if (
+            kwargs.context.allowed_company_ids.length === 1 &&
+            kwargs.context.allowed_company_ids[0] === 1
+        ) {
+            throw makeServerError({
+                type: "AccessError",
+                message: "Wrong Company",
+                context: { suggested_company: { id: 2, display_name: "Company 2" } },
+            });
+        }
+    });
+
+    await mountWebClient();
+    await getService("action").doAction({
+        type: "ir.actions.act_window",
+        res_model: "res.partner",
+        views: [[false, "form"]],
+    });
+    await contains(`.o_field_widget[name=name] input`).edit("some foo value");
+    await contains(`.o_form_button_save`).click();
+    await animationFrame();
+    expect.verifySteps([[1], [1, 2]]);
+    expect(cookie.get("cids")).toBe("1-2");
+    expect(`.o_field_widget[name=name] input`).toHaveValue("some foo value");
+});
+
+test.tags("desktop");
+test("form view in dialog shows wrong company error", async () => {
+    expect.errors(1);
+    cookie.set("cids", "1");
+
+    onRpc("web_read", () => {
+        throw makeServerError({
+            type: "AccessError",
+            message: "Wrong Company",
+            context: { suggested_company: { id: 2, display_name: "Company 2" } },
+        });
+    });
+    onRpc("has_group", () => true);
+    Partner._views.list = /* xml */ `
+        <list>
+            <field name="display_name" />
+        </list>
+    `;
+
+    await mountWebClient();
+
+    getService("dialog").add(FormViewDialog, {
+        resModel: "res.partner",
+        resId: 1,
+    });
+    await animationFrame();
+    expect.verifyErrors(['Error: The following error occurred in onWillStart: "Wrong Company"']);
+    expect(cookie.get("cids")).toBe("1"); // cookies were not modified
+    expect.verifySteps([]); // don't reload
+});

odoo-bringout-oca-ocb-web/web/static/tests/webclient/actions/new_window_action.test.js

@@ -0,0 +1,174 @@
+import { beforeEach, expect, test } from "@odoo/hoot";
+import { browser } from "@web/core/browser/browser";
+import { WebClient } from "@web/webclient/webclient";
+import {
+    defineActions,
+    defineModels,
+    fields,
+    getService,
+    models,
+    mountWithCleanup,
+    patchWithCleanup,
+} from "@web/../tests/web_test_helpers";
+import { Component, xml } from "@odoo/owl";
+import { registry } from "@web/core/registry";
+
+class TestClientAction extends Component {
+    static template = xml`
+        <div class="test_client_action">
+            ClientAction
+        </div>`;
+    static props = ["*"];
+}
+
+class Partner extends models.Model {
+    display_name = fields.Char();
+
+    _records = [
+        { id: 1, display_name: "First record" },
+        { id: 2, display_name: "Second record" },
+        { id: 3, display_name: "Third record" },
+        { id: 4, display_name: "Fourth record" },
+        { id: 5, display_name: "Fifth record" },
+    ];
+    _views = {
+        form: /* xml */ `
+            <form>
+                <group>
+                    <field name="display_name"/>
+                </group>
+            </form>`,
+        kanban: /* xml */ `
+            <kanban>
+                <templates>
+                    <t t-name="card">
+                        <field name="display_name"/>
+                    </t>
+                </templates>
+            </kanban>`,
+    };
+}
+
+class User extends models.Model {
+    _name = "res.users";
+    has_group() {
+        return true;
+    }
+}
+
+defineModels([Partner, User]);
+
+defineActions([
+    {
+        id: 1,
+        xml_id: "action_1",
+        name: "Partners Action 1",
+        res_model: "partner",
+        type: "ir.actions.act_window",
+        views: [[false, "kanban"]],
+    },
+]);
+
+beforeEach(() => {
+    patchWithCleanup(browser, {
+        open: (url) => expect.step("open: " + url),
+    });
+});
+
+test("can execute act_window actions from db ID in a new window", async () => {
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(1, { newWindow: true });
+    expect.verifySteps(["open: /odoo/action-1"]);
+});
+
+test("'CLEAR-UNCOMMITTED-CHANGES' is not triggered for window action", async () => {
+    const webClient = await mountWithCleanup(WebClient);
+    webClient.env.bus.addEventListener("CLEAR-UNCOMMITTED-CHANGES", () => {
+        expect.step("CLEAR-UNCOMMITTED-CHANGES");
+    });
+
+    await getService("action").doAction(1, { newWindow: true });
+    expect.verifySteps(["open: /odoo/action-1"]);
+});
+
+test("'CLEAR-UNCOMMITTED-CHANGES' is not triggered for client actions", async () => {
+    class ClientAction extends Component {
+        static template = xml`<div class="o_client_action_test">Hello World</div>`;
+        static props = ["*"];
+    }
+    registry.category("actions").add("my_action", ClientAction);
+
+    const webClient = await mountWithCleanup(WebClient);
+    webClient.env.bus.addEventListener("CLEAR-UNCOMMITTED-CHANGES", () => {
+        expect.step("CLEAR-UNCOMMITTED-CHANGES");
+    });
+
+    await getService("action").doAction("my_action", { newWindow: true });
+    expect.verifySteps(["open: /odoo/my_action"]);
+});
+
+test("'CLEAR-UNCOMMITTED-CHANGES' is not triggered for switchView", async () => {
+    const webClient = await mountWithCleanup(WebClient);
+    webClient.env.bus.addEventListener("CLEAR-UNCOMMITTED-CHANGES", () => {
+        expect.step("CLEAR-UNCOMMITTED-CHANGES");
+    });
+
+    await getService("action").doAction(1);
+    await getService("action").switchView("kanban", {}, { newWindow: true });
+    expect.verifySteps([
+        "CLEAR-UNCOMMITTED-CHANGES", // The first do action clear uncommitted changes as expected. The second one doesn't
+        "open: /odoo/action-1",
+    ]);
+});
+
+test("can execute dynamic act_window actions in a new window", async () => {
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(
+        {
+            name: "Partners",
+            res_model: "partner",
+            type: "ir.actions.act_window",
+            res_id: 22,
+            views: [[false, "form"]],
+        },
+        {
+            newWindow: true,
+        }
+    );
+    expect.verifySteps(["open: /odoo/m-partner/22"]);
+});
+
+test("can execute an actions in a new window and preserve the breadcrumb", async () => {
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(1);
+    await getService("action").doAction(
+        {
+            name: "Partners",
+            res_model: "partner",
+            type: "ir.actions.act_window",
+            res_id: 22,
+            views: [[false, "form"]],
+        },
+        {
+            newWindow: true,
+        }
+    );
+    expect.verifySteps(["open: /odoo/action-1/m-partner/22"]);
+});
+
+test("can execute client actions in a new window", async () => {
+    registry.category("actions").add("__test__client__action__", TestClientAction);
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(
+        {
+            name: "Dialog Test",
+            target: "current",
+            tag: "__test__client__action__",
+            type: "ir.actions.client",
+        },
+        {
+            newWindow: true,
+        }
+    );
+    expect.verifySteps(["open: /odoo/__test__client__action__"]);
+});

odoo-bringout-oca-ocb-web/web/static/tests/webclient/actions/push_state.test.js

@@ -0,0 +1,673 @@
+import { beforeEach, describe, expect, test } from "@odoo/hoot";
+import { queryAllTexts } from "@odoo/hoot-dom";
+import { Deferred, animationFrame } from "@odoo/hoot-mock";
+import { Component, onMounted, xml } from "@odoo/owl";
+import {
+    contains,
+    defineActions,
+    defineMenus,
+    defineModels,
+    editSearch,
+    fields,
+    getService,
+    models,
+    mountWithCleanup,
+    onRpc,
+    patchWithCleanup,
+    validateSearch,
+} from "@web/../tests/web_test_helpers";
+
+import { browser } from "@web/core/browser/browser";
+import { router } from "@web/core/browser/router";
+import { registry } from "@web/core/registry";
+import { redirect } from "@web/core/utils/urls";
+import { WebClient } from "@web/webclient/webclient";
+
+describe.current.tags("desktop");
+
+const actionRegistry = registry.category("actions");
+
+defineActions([
+    {
+        id: 3,
+        xml_id: "action_3",
+        name: "Partners",
+        res_model: "partner",
+        views: [
+            [false, "list"],
+            [1, "kanban"],
+            [false, "form"],
+        ],
+    },
+    {
+        id: 4,
+        xml_id: "action_4",
+        name: "Partners Action 4",
+        res_model: "partner",
+        views: [
+            [1, "kanban"],
+            [2, "list"],
+            [false, "form"],
+        ],
+    },
+    {
+        id: 8,
+        xml_id: "action_8",
+        name: "Favorite Ponies",
+        res_model: "pony",
+        views: [
+            [false, "list"],
+            [false, "form"],
+        ],
+    },
+    {
+        id: 1001,
+        tag: "__test__client__action__",
+        target: "main",
+        type: "ir.actions.client",
+        params: { description: "Id 1" },
+    },
+    {
+        id: 1002,
+        tag: "__test__client__action__",
+        target: "main",
+        type: "ir.actions.client",
+        params: { description: "Id 2" },
+    },
+]);
+
+defineMenus([
+    { id: 0 }, // prevents auto-loading the first action
+    { id: 1, actionID: 1001 },
+    { id: 2, actionID: 1002 },
+]);
+
+class Partner extends models.Model {
+    name = fields.Char();
+    foo = fields.Char();
+    parent_id = fields.Many2one({ relation: "partner" });
+    child_ids = fields.One2many({ relation: "partner", relation_field: "parent_id" });
+
+    _records = [
+        { id: 1, name: "First record", foo: "yop" },
+        { id: 2, name: "Second record", foo: "blip" },
+        { id: 3, name: "Third record", foo: "gnap" },
+        { id: 4, name: "Fourth record", foo: "plop" },
+        { id: 5, name: "Fifth record", foo: "zoup" },
+    ];
+    _views = {
+        "kanban,1": /* xml */ `
+            <kanban>
+                <templates>
+                    <t t-name="card">
+                        <field name="foo"/>
+                    </t>
+                </templates>
+            </kanban>
+        `,
+        "list,2": /* xml */ `
+            <list>
+                <field name="foo" />
+            </list>
+        `,
+        form: /* xml */ `
+            <form>
+                <header>
+                    <button name="object" string="Call method" type="object"/>
+                    <button name="4" string="Execute action" type="action"/>
+                </header>
+                <group>
+                    <field name="display_name"/>
+                    <field name="foo"/>
+                </group>
+            </form>
+        `,
+        search: /* xml */ `
+            <search>
+                <field name="foo" string="Foo" />
+            </search>
+        `,
+    };
+}
+
+class Pony extends models.Model {
+    name = fields.Char();
+
+    _records = [
+        { id: 4, name: "Twilight Sparkle" },
+        { id: 6, name: "Applejack" },
+        { id: 9, name: "Fluttershy" },
+    ];
+    _views = {
+        list: `<list><field name="name"/></list>`,
+        form: `<form><field name="name"/></form>`,
+    };
+}
+
+class User extends models.Model {
+    _name = "res.users";
+    has_group() {
+        return true;
+    }
+}
+
+defineModels([Partner, Pony, User]);
+
+class TestClientAction extends Component {
+    static template = xml`
+        <div class="test_client_action">
+            ClientAction_<t t-esc="props.action.params?.description"/>
+        </div>
+    `;
+    static props = ["*"];
+
+    setup() {
+        onMounted(() => {
+            this.env.config.setDisplayName(`Client action ${this.props.action.id}`);
+        });
+    }
+}
+
+onRpc("has_group", () => true);
+
+beforeEach(() => {
+    actionRegistry.add("__test__client__action__", TestClientAction);
+    patchWithCleanup(browser.location, {
+        origin: "http://example.com",
+    });
+    redirect("/odoo");
+});
+
+test(`basic action as App`, async () => {
+    await mountWithCleanup(WebClient);
+    expect(browser.location.href).toBe("http://example.com/odoo");
+    expect(router.current).toEqual({});
+
+    await contains(`.o_navbar_apps_menu button`).click();
+    await contains(`.o-dropdown-item:eq(2)`).click();
+    await animationFrame();
+    await animationFrame();
+    expect(router.current.action).toBe(1002);
+    expect(browser.location.href).toBe("http://example.com/odoo/action-1002");
+    expect(`.test_client_action`).toHaveText("ClientAction_Id 2");
+    expect(`.o_menu_brand`).toHaveText("App2");
+});
+
+test(`do action keeps menu in url`, async () => {
+    await mountWithCleanup(WebClient);
+    expect(browser.location.href).toBe("http://example.com/odoo");
+    expect(router.current).toEqual({});
+
+    await contains(`.o_navbar_apps_menu button`).click();
+    await contains(`.o-dropdown-item:eq(2)`).click();
+    await animationFrame();
+    await animationFrame();
+    expect(browser.location.href).toBe("http://example.com/odoo/action-1002");
+    expect(router.current.action).toBe(1002);
+    expect(`.test_client_action`).toHaveText("ClientAction_Id 2");
+    expect(`.o_menu_brand`).toHaveText("App2");
+
+    await getService("action").doAction(1001, { clearBreadcrumbs: true });
+    await animationFrame();
+    expect(browser.location.href).toBe("http://example.com/odoo/action-1001");
+    expect(router.current.action).toBe(1001);
+    expect(`.test_client_action`).toHaveText("ClientAction_Id 1");
+    expect(`.o_menu_brand`).toHaveText("App2");
+});
+
+test(`actions can push state`, async () => {
+    class ClientActionPushes extends Component {
+        static template = xml`
+            <div class="test_client_action" t-on-click="_actionPushState">
+                ClientAction_<t t-esc="props.params and props.params.description"/>
+            </div>
+        `;
+        static props = ["*"];
+
+        _actionPushState() {
+            router.pushState({ arbitrary: "actionPushed" });
+        }
+    }
+    actionRegistry.add("client_action_pushes", ClientActionPushes);
+
+    await mountWithCleanup(WebClient);
+    expect(browser.location.href).toBe("http://example.com/odoo");
+    expect(browser.history.length).toBe(1);
+    expect(router.current).toEqual({});
+
+    await getService("action").doAction("client_action_pushes");
+    await animationFrame();
+    expect(browser.location.href).toBe("http://example.com/odoo/client_action_pushes");
+    expect(browser.history.length).toBe(2);
+    expect(router.current.action).toBe("client_action_pushes");
+    expect(router.current.menu_id).toBe(undefined);
+
+    await contains(`.test_client_action`).click();
+    await animationFrame();
+    expect(browser.location.href).toBe(
+        "http://example.com/odoo/client_action_pushes?arbitrary=actionPushed"
+    );
+    expect(browser.history.length).toBe(3);
+    expect(router.current.action).toBe("client_action_pushes");
+    expect(router.current.arbitrary).toBe("actionPushed");
+});
+
+test(`actions override previous state`, async () => {
+    class ClientActionPushes extends Component {
+        static template = xml`
+            <div class="test_client_action" t-on-click="_actionPushState">
+                ClientAction_<t t-esc="props.params and props.params.description"/>
+            </div>
+        `;
+        static props = ["*"];
+
+        _actionPushState() {
+            router.pushState({ arbitrary: "actionPushed" });
+        }
+    }
+    actionRegistry.add("client_action_pushes", ClientActionPushes);
+
+    await mountWithCleanup(WebClient);
+    expect(browser.location.href).toBe("http://example.com/odoo");
+    expect(browser.history.length).toBe(1);
+    expect(router.current).toEqual({});
+
+    await getService("action").doAction("client_action_pushes");
+    await animationFrame(); // wait for pushState because it's unrealistic to click before it
+    await contains(`.test_client_action`).click();
+    await animationFrame();
+    expect(browser.location.href).toBe(
+        "http://example.com/odoo/client_action_pushes?arbitrary=actionPushed"
+    );
+    expect(browser.history.length).toBe(3); // Two history entries
+    expect(router.current.action).toBe("client_action_pushes");
+    expect(router.current.arbitrary).toBe("actionPushed");
+
+    await getService("action").doAction(1001);
+    await animationFrame();
+    expect(browser.location.href).toBe("http://example.com/odoo/action-1001", {
+        message: "client_action_pushes removed from url because action 1001 is in target main",
+    });
+    expect(browser.history.length).toBe(4);
+    expect(router.current.action).toBe(1001);
+    expect(router.current.arbitrary).toBe(undefined);
+});
+
+test(`actions override previous state from menu click`, async () => {
+    class ClientActionPushes extends Component {
+        static template = xml`
+            <div class="test_client_action" t-on-click="_actionPushState">
+                ClientAction_<t t-esc="props.params and props.params.description"/>
+            </div>
+        `;
+        static props = ["*"];
+
+        _actionPushState() {
+            router.pushState({ arbitrary: "actionPushed" });
+        }
+    }
+    actionRegistry.add("client_action_pushes", ClientActionPushes);
+
+    await mountWithCleanup(WebClient);
+    expect(browser.location.href).toBe("http://example.com/odoo");
+    expect(router.current).toEqual({});
+
+    await getService("action").doAction("client_action_pushes");
+    await contains(`.test_client_action`).click();
+    await contains(`.o_navbar_apps_menu button`).click();
+    await contains(`.o-dropdown-item:eq(2)`).click();
+    await animationFrame();
+    await animationFrame();
+    expect(browser.location.href).toBe("http://example.com/odoo/action-1002");
+    expect(router.current.action).toBe(1002);
+});
+
+test(`action in target new do not push state`, async () => {
+    defineActions([
+        {
+            id: 2001,
+            tag: "__test__client__action__",
+            target: "new",
+            type: "ir.actions.client",
+            params: { description: "Id 1" },
+        },
+    ]);
+
+    patchWithCleanup(browser.history, {
+        pushState() {
+            throw new Error("should not push state");
+        },
+    });
+
+    await mountWithCleanup(WebClient);
+    expect(browser.location.href).toBe("http://example.com/odoo");
+    expect(browser.history.length).toBe(1);
+
+    await getService("action").doAction(2001);
+    expect(`.modal .test_client_action`).toHaveCount(1);
+
+    await animationFrame();
+    expect(browser.location.href).toBe("http://example.com/odoo", {
+        message: "url did not change",
+    });
+    expect(browser.history.length).toBe(1, { message: "did not create a history entry" });
+    expect(router.current).toEqual({});
+});
+
+test(`properly push state`, async () => {
+    await mountWithCleanup(WebClient);
+    expect(browser.location.href).toBe("http://example.com/odoo");
+    expect(browser.history.length).toBe(1);
+
+    await getService("action").doAction(4);
+    await animationFrame();
+    expect(browser.location.href).toBe("http://example.com/odoo/action-4");
+    expect(browser.history.length).toBe(2);
+    expect(router.current).toEqual({
+        action: 4,
+        actionStack: [
+            {
+                action: 4,
+                displayName: "Partners Action 4",
+                view_type: "kanban",
+            },
+        ],
+    });
+
+    await getService("action").doAction(8);
+    await animationFrame();
+    expect(browser.location.href).toBe("http://example.com/odoo/action-4/action-8");
+    expect(browser.history.length).toBe(3);
+    expect(router.current).toEqual({
+        action: 8,
+        actionStack: [
+            {
+                action: 4,
+                displayName: "Partners Action 4",
+                view_type: "kanban",
+            },
+            {
+                action: 8,
+                displayName: "Favorite Ponies",
+                view_type: "list",
+            },
+        ],
+    });
+
+    await contains(`tr .o_data_cell:first`).click();
+    await animationFrame();
+    expect(browser.location.href).toBe("http://example.com/odoo/action-4/action-8/4");
+    expect(browser.history.length).toBe(4);
+    expect(router.current).toEqual({
+        action: 8,
+        actionStack: [
+            {
+                action: 4,
+                displayName: "Partners Action 4",
+                view_type: "kanban",
+            },
+            {
+                action: 8,
+                displayName: "Favorite Ponies",
+                view_type: "list",
+            },
+            {
+                action: 8,
+                displayName: "Twilight Sparkle",
+                resId: 4,
+                view_type: "form",
+            },
+        ],
+        resId: 4,
+    });
+});
+
+test(`push state after action is loaded, not before`, async () => {
+    const def = new Deferred();
+    onRpc("get_views", () => def);
+
+    await mountWithCleanup(WebClient);
+    expect(browser.location.href).toBe("http://example.com/odoo");
+    expect(browser.history.length).toBe(1);
+
+    getService("action").doAction(4);
+    await animationFrame();
+    await animationFrame();
+
+    expect(browser.location.href).toBe("http://example.com/odoo");
+    expect(browser.history.length).toBe(1);
+    expect(router.current).toEqual({});
+
+    def.resolve();
+    await animationFrame();
+    await animationFrame();
+    expect(browser.location.href).toBe("http://example.com/odoo/action-4");
+    expect(browser.history.length).toBe(2);
+    expect(router.current).toEqual({
+        action: 4,
+        actionStack: [
+            {
+                action: 4,
+                displayName: "Partners Action 4",
+                view_type: "kanban",
+            },
+        ],
+    });
+});
+
+test(`do not push state when action fails`, async () => {
+    onRpc("read", () => Promise.reject());
+
+    await mountWithCleanup(WebClient);
+    expect(browser.location.href).toBe("http://example.com/odoo");
+    expect(browser.history.length).toBe(1);
+
+    await getService("action").doAction(8);
+    await animationFrame();
+    expect(browser.location.href).toBe("http://example.com/odoo/action-8");
+    expect(browser.history.length).toBe(2);
+    expect(router.current).toEqual({
+        action: 8,
+        actionStack: [
+            {
+                action: 8,
+                displayName: "Favorite Ponies",
+                view_type: "list",
+            },
+        ],
+    });
+
+    await contains(`tr.o_data_row:first`).click();
+    // we make sure here that the list view is still in the dom
+    expect(`.o_list_view`).toHaveCount(1, {
+        message: "there should still be a list view in dom",
+    });
+
+    await animationFrame(); // wait for possible debounced pushState
+    expect(browser.location.href).toBe("http://example.com/odoo/action-8");
+    expect(browser.history.length).toBe(2);
+    expect(router.current).toEqual({
+        action: 8,
+        actionStack: [
+            {
+                action: 8,
+                displayName: "Favorite Ponies",
+                view_type: "list",
+            },
+        ],
+    });
+});
+
+test(`view_type is in url when not the default one`, async () => {
+    await mountWithCleanup(WebClient);
+    expect(browser.location.href).toBe("http://example.com/odoo");
+    expect(browser.history.length).toBe(1);
+
+    await getService("action").doAction(3);
+    await animationFrame();
+    expect(browser.location.href).toBe("http://example.com/odoo/action-3");
+    expect(browser.history.length).toBe(2);
+    expect(router.current).toEqual({
+        action: 3,
+        actionStack: [
+            {
+                action: 3,
+                displayName: "Partners",
+                view_type: "list",
+            },
+        ],
+    });
+    expect(`.breadcrumb`).toHaveCount(0);
+
+    await getService("action").doAction(3, { viewType: "kanban" });
+    await animationFrame();
+    expect(browser.location.href).toBe("http://example.com/odoo/action-3?view_type=kanban");
+    expect(browser.history.length).toBe(3, { message: "created a history entry" });
+    expect(`.breadcrumb`).toHaveCount(1, {
+        message: "created a breadcrumb entry",
+    });
+    expect(router.current).toEqual({
+        action: 3,
+        view_type: "kanban", // view_type is on the state when it's not the default one
+        actionStack: [
+            {
+                action: 3,
+                displayName: "Partners",
+                view_type: "list",
+            },
+            {
+                action: 3,
+                displayName: "Partners",
+                view_type: "kanban",
+            },
+        ],
+    });
+});
+
+test(`switchView pushes the stat but doesn't add to the breadcrumbs`, async () => {
+    await mountWithCleanup(WebClient);
+    expect(browser.location.href).toBe("http://example.com/odoo");
+    expect(browser.history.length).toBe(1);
+
+    await getService("action").doAction(3);
+    await animationFrame();
+    expect(browser.location.href).toBe("http://example.com/odoo/action-3");
+    expect(browser.history.length).toBe(2);
+    expect(router.current).toEqual({
+        action: 3,
+        actionStack: [
+            {
+                action: 3,
+                displayName: "Partners",
+                view_type: "list",
+            },
+        ],
+    });
+    expect(`.breadcrumb`).toHaveCount(0);
+
+    await getService("action").switchView("kanban");
+    await animationFrame();
+    expect(browser.location.href).toBe("http://example.com/odoo/action-3?view_type=kanban");
+    expect(browser.history.length).toBe(3, { message: "created a history entry" });
+    expect(`.breadcrumb`).toHaveCount(0, { message: "didn't create a breadcrumb entry" });
+    expect(router.current).toEqual({
+        action: 3,
+        view_type: "kanban", // view_type is on the state when it's not the default one
+        actionStack: [
+            {
+                action: 3,
+                displayName: "Partners",
+                view_type: "kanban",
+            },
+        ],
+    });
+});
+
+test(`properly push globalState`, async () => {
+    await mountWithCleanup(WebClient);
+    expect(browser.location.href).toBe("http://example.com/odoo");
+    expect(browser.history.length).toBe(1);
+
+    await getService("action").doAction(4);
+    await animationFrame();
+    expect(browser.location.href).toBe("http://example.com/odoo/action-4");
+    expect(browser.history.length).toBe(2);
+    expect(router.current).toEqual({
+        action: 4,
+        actionStack: [
+            {
+                action: 4,
+                displayName: "Partners Action 4",
+                view_type: "kanban",
+            },
+        ],
+    });
+
+    // add element on the search Model
+    await editSearch("blip");
+    await validateSearch();
+    expect(queryAllTexts(".o_facet_value")).toEqual(["blip"]);
+
+    //open record
+    await contains(".o_kanban_record").click();
+
+    // Add the globalState on the state before leaving the kanban
+    expect(router.current).toEqual({
+        action: 4,
+        actionStack: [
+            {
+                action: 4,
+                displayName: "Partners Action 4",
+                view_type: "kanban",
+            },
+        ],
+        globalState: {
+            searchModel: `{"nextGroupId":2,"nextGroupNumber":1,"nextId":2,"query":[{"searchItemId":1,"autocompleteValue":{"label":"blip","operator":"ilike","value":"blip"}}],"searchItems":{"1":{"type":"field","fieldName":"foo","fieldType":"char","description":"Foo","groupId":1,"id":1}},"searchPanelInfo":{"className":"","viewTypes":["kanban","list"],"loaded":false,"shouldReload":true},"sections":[]}`,
+        },
+    });
+
+    // pushState is defered
+    await animationFrame();
+    expect(".o_form_view").toHaveCount(1);
+    expect(browser.location.href).toBe("http://example.com/odoo/action-4/2");
+    expect(router.current).toEqual({
+        action: 4,
+        actionStack: [
+            {
+                action: 4,
+                displayName: "Partners Action 4",
+                view_type: "kanban",
+            },
+            {
+                action: 4,
+                displayName: "Second record",
+                resId: 2,
+                view_type: "form",
+            },
+        ],
+        resId: 2,
+    });
+
+    // came back using the browser
+    browser.history.back(); // Click on back button
+    await animationFrame();
+
+    // The search Model should be restored
+    expect(queryAllTexts(".o_facet_value")).toEqual(["blip"]);
+    expect(browser.location.href).toBe("http://example.com/odoo/action-4");
+
+    // The global state is restored on the state
+    expect(router.current).toEqual({
+        action: 4,
+        actionStack: [
+            {
+                action: 4,
+                displayName: "Partners Action 4",
+                view_type: "kanban",
+            },
+        ],
+        globalState: {
+            searchModel: `{"nextGroupId":2,"nextGroupNumber":1,"nextId":2,"query":[{"searchItemId":1,"autocompleteValue":{"label":"blip","operator":"ilike","value":"blip"}}],"searchItems":{"1":{"type":"field","fieldName":"foo","fieldType":"char","description":"Foo","groupId":1,"id":1}},"searchPanelInfo":{"className":"","viewTypes":["kanban","list"],"loaded":false,"shouldReload":true},"sections":[]}`,
+        },
+    });
+});

odoo-bringout-oca-ocb-web/web/static/tests/webclient/actions/push_state_tests.js

@@ -1,251 +0,0 @@
-/** @odoo-module **/
-
-import { browser } from "@web/core/browser/browser";
-import { registry } from "@web/core/registry";
-import { useService } from "@web/core/utils/hooks";
-import testUtils from "web.test_utils";
-import {
-    click,
-    getFixture,
-    legacyExtraNextTick,
-    makeDeferred,
-    nextTick,
-    patchWithCleanup,
-} from "../../helpers/utils";
-import { createWebClient, doAction, getActionManagerServerData } from "./../helpers";
-
-import { Component, xml } from "@odoo/owl";
-
-let serverData;
-let target;
-const actionRegistry = registry.category("actions");
-
-QUnit.module("ActionManager", (hooks) => {
-    hooks.beforeEach(() => {
-        serverData = getActionManagerServerData();
-        target = getFixture();
-    });
-
-    QUnit.module("Push State");
-
-    QUnit.test("basic action as App", async (assert) => {
-        assert.expect(5);
-        const webClient = await createWebClient({ serverData });
-        let urlState = webClient.env.services.router.current;
-        assert.deepEqual(urlState.hash, {});
-        await click(target, ".o_navbar_apps_menu button");
-        await click(target, ".o_navbar_apps_menu .dropdown-item:nth-child(3)");
-        await nextTick();
-        await nextTick();
-        urlState = webClient.env.services.router.current;
-        assert.strictEqual(urlState.hash.action, 1002);
-        assert.strictEqual(urlState.hash.menu_id, 2);
-        assert.strictEqual(
-            target.querySelector(".test_client_action").textContent.trim(),
-            "ClientAction_Id 2"
-        );
-        assert.strictEqual(target.querySelector(".o_menu_brand").textContent, "App2");
-    });
-
-    QUnit.test("do action keeps menu in url", async (assert) => {
-        assert.expect(9);
-        const webClient = await createWebClient({ serverData });
-        let urlState = webClient.env.services.router.current;
-        assert.deepEqual(urlState.hash, {});
-        await click(target, ".o_navbar_apps_menu button");
-        await click(target, ".o_navbar_apps_menu .dropdown-item:nth-child(3)");
-        await nextTick();
-        await nextTick();
-        urlState = webClient.env.services.router.current;
-        assert.strictEqual(urlState.hash.action, 1002);
-        assert.strictEqual(urlState.hash.menu_id, 2);
-        assert.strictEqual(
-            target.querySelector(".test_client_action").textContent.trim(),
-            "ClientAction_Id 2"
-        );
-        assert.strictEqual(target.querySelector(".o_menu_brand").textContent, "App2");
-        await doAction(webClient, 1001, { clearBreadcrumbs: true });
-        urlState = webClient.env.services.router.current;
-        assert.strictEqual(urlState.hash.action, 1001);
-        assert.strictEqual(urlState.hash.menu_id, 2);
-        assert.strictEqual(
-            target.querySelector(".test_client_action").textContent.trim(),
-            "ClientAction_Id 1"
-        );
-        assert.strictEqual(target.querySelector(".o_menu_brand").textContent, "App2");
-    });
-
-    QUnit.test("actions can push state", async (assert) => {
-        assert.expect(5);
-        class ClientActionPushes extends Component {
-            setup() {
-                this.router = useService("router");
-            }
-            _actionPushState() {
-                this.router.pushState({ arbitrary: "actionPushed" });
-            }
-        }
-        ClientActionPushes.template = xml`
-      <div class="test_client_action" t-on-click="_actionPushState">
-        ClientAction_<t t-esc="props.params and props.params.description" />
-      </div>`;
-        actionRegistry.add("client_action_pushes", ClientActionPushes);
-        const webClient = await createWebClient({ serverData });
-        let urlState = webClient.env.services.router.current;
-        assert.deepEqual(urlState.hash, {});
-        await doAction(webClient, "client_action_pushes");
-        urlState = webClient.env.services.router.current;
-        assert.strictEqual(urlState.hash.action, "client_action_pushes");
-        assert.strictEqual(urlState.hash.menu_id, undefined);
-        await click(target, ".test_client_action");
-        urlState = webClient.env.services.router.current;
-        assert.strictEqual(urlState.hash.action, "client_action_pushes");
-        assert.strictEqual(urlState.hash.arbitrary, "actionPushed");
-    });
-
-    QUnit.test("actions override previous state", async (assert) => {
-        assert.expect(5);
-        class ClientActionPushes extends Component {
-            setup() {
-                this.router = useService("router");
-            }
-            _actionPushState() {
-                this.router.pushState({ arbitrary: "actionPushed" });
-            }
-        }
-        ClientActionPushes.template = xml`
-      <div class="test_client_action" t-on-click="_actionPushState">
-        ClientAction_<t t-esc="props.params and props.params.description" />
-      </div>`;
-        actionRegistry.add("client_action_pushes", ClientActionPushes);
-        const webClient = await createWebClient({ serverData });
-        let urlState = webClient.env.services.router.current;
-        assert.deepEqual(urlState.hash, {});
-        await doAction(webClient, "client_action_pushes");
-        await click(target, ".test_client_action");
-        urlState = webClient.env.services.router.current;
-        assert.strictEqual(urlState.hash.action, "client_action_pushes");
-        assert.strictEqual(urlState.hash.arbitrary, "actionPushed");
-        await doAction(webClient, 1001);
-        urlState = webClient.env.services.router.current;
-        assert.strictEqual(urlState.hash.action, 1001);
-        assert.strictEqual(urlState.hash.arbitrary, undefined);
-    });
-
-    QUnit.test("actions override previous state from menu click", async (assert) => {
-        assert.expect(3);
-        class ClientActionPushes extends Component {
-            setup() {
-                this.router = useService("router");
-            }
-            _actionPushState() {
-                this.router.pushState({ arbitrary: "actionPushed" });
-            }
-        }
-        ClientActionPushes.template = xml`
-      <div class="test_client_action" t-on-click="_actionPushState">
-        ClientAction_<t t-esc="props.params and props.params.description" />
-      </div>`;
-        actionRegistry.add("client_action_pushes", ClientActionPushes);
-        const webClient = await createWebClient({ serverData });
-        let urlState = webClient.env.services.router.current;
-        assert.deepEqual(urlState.hash, {});
-        await doAction(webClient, "client_action_pushes");
-        await click(target, ".test_client_action");
-        await click(target, ".o_navbar_apps_menu button");
-        await click(target, ".o_navbar_apps_menu .dropdown-item:nth-child(3)");
-        await nextTick();
-        await nextTick();
-        urlState = webClient.env.services.router.current;
-        assert.strictEqual(urlState.hash.action, 1002);
-        assert.strictEqual(urlState.hash.menu_id, 2);
-    });
-
-    QUnit.test("action in target new do not push state", async (assert) => {
-        assert.expect(1);
-        serverData.actions[1001].target = "new";
-        patchWithCleanup(browser, {
-            history: Object.assign({}, browser.history, {
-                pushState() {
-                    throw new Error("should not push state");
-                },
-            }),
-        });
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, 1001);
-        assert.containsOnce(target, ".modal .test_client_action");
-    });
-
-    QUnit.test("properly push state", async function (assert) {
-        assert.expect(3);
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, 4);
-        assert.deepEqual(webClient.env.services.router.current.hash, {
-            action: 4,
-            model: "partner",
-            view_type: "kanban",
-        });
-        await doAction(webClient, 8);
-        assert.deepEqual(webClient.env.services.router.current.hash, {
-            action: 8,
-            model: "pony",
-            view_type: "list",
-        });
-        await testUtils.dom.click($(target).find("tr .o_data_cell:first"));
-        await nextTick();
-        assert.deepEqual(webClient.env.services.router.current.hash, {
-            action: 8,
-            model: "pony",
-            view_type: "form",
-            id: 4,
-        });
-    });
-
-    QUnit.test("push state after action is loaded, not before", async function (assert) {
-        assert.expect(2);
-        const def = makeDeferred();
-        const mockRPC = async function (route, args) {
-            if (args.method === "web_search_read") {
-                await def;
-            }
-        };
-        const webClient = await createWebClient({ serverData, mockRPC });
-        doAction(webClient, 4);
-        await nextTick();
-        await nextTick();
-        assert.deepEqual(webClient.env.services.router.current.hash, {});
-        def.resolve();
-        await nextTick();
-        await nextTick();
-        assert.deepEqual(webClient.env.services.router.current.hash, {
-            action: 4,
-            model: "partner",
-            view_type: "kanban",
-        });
-    });
-
-    QUnit.test("do not push state when action fails", async function (assert) {
-        assert.expect(3);
-        const mockRPC = async function (route, args) {
-            if (args && args.method === "read") {
-                return Promise.reject();
-            }
-        };
-        const webClient = await createWebClient({ serverData, mockRPC });
-        await doAction(webClient, 8);
-        assert.deepEqual(webClient.env.services.router.current.hash, {
-            action: 8,
-            model: "pony",
-            view_type: "list",
-        });
-        await testUtils.dom.click($(target).find("tr.o_data_row:first"));
-        await legacyExtraNextTick();
-        // we make sure here that the list view is still in the dom
-        assert.containsOnce(target, ".o_list_view", "there should still be a list view in dom");
-        assert.deepEqual(webClient.env.services.router.current.hash, {
-            action: 8,
-            model: "pony",
-            view_type: "list",
-        });
-    });
-});

odoo-bringout-oca-ocb-web/web/static/tests/webclient/actions/report_action.test.js

@@ -0,0 +1,420 @@
+import { afterEach, expect, test } from "@odoo/hoot";
+import { animationFrame, runAllTimers } from "@odoo/hoot-mock";
+import {
+    contains,
+    defineActions,
+    defineModels,
+    getService,
+    mockService,
+    models,
+    mountWithCleanup,
+    onRpc,
+    patchWithCleanup,
+    serverState,
+    stepAllNetworkCalls,
+} from "@web/../tests/web_test_helpers";
+
+import { router } from "@web/core/browser/router";
+import { download } from "@web/core/network/download";
+import { rpc } from "@web/core/network/rpc";
+import { registry } from "@web/core/registry";
+import { ReportAction } from "@web/webclient/actions/reports/report_action";
+import { downloadReport } from "@web/webclient/actions/reports/utils";
+import { WebClient } from "@web/webclient/webclient";
+
+class Partner extends models.Model {
+    _rec_name = "display_name";
+
+    _records = [
+        { id: 1, display_name: "First record" },
+        { id: 2, display_name: "Second record" },
+    ];
+    _views = {
+        form: `
+            <form>
+                <header>
+                    <button name="object" string="Call method" type="object"/>
+                </header>
+                <group>
+                    <field name="display_name"/>
+                </group>
+            </form>`,
+        "kanban,1": `
+            <kanban>
+                <templates>
+                    <t t-name="card">
+                        <field name="display_name"/>
+                    </t>
+                </templates>
+            </kanban>`,
+        list: `<list><field name="display_name"/></list>`,
+    };
+}
+
+defineModels([Partner]);
+
+defineActions([
+    {
+        id: 7,
+        xml_id: "action_7",
+        name: "Some Report",
+        report_name: "some_report",
+        report_type: "qweb-pdf",
+        type: "ir.actions.report",
+    },
+    {
+        id: 11,
+        xml_id: "action_11",
+        name: "Another Report",
+        report_name: "another_report",
+        report_type: "qweb-pdf",
+        type: "ir.actions.report",
+        close_on_report_download: true,
+    },
+    {
+        id: 12,
+        xml_id: "action_12",
+        name: "Some HTML Report",
+        report_name: "some_report",
+        report_type: "qweb-html",
+        type: "ir.actions.report",
+    },
+]);
+
+afterEach(() => {
+    // In the prod environment, we keep a promise with the wkhtmlstatus (e.g. broken, upgrade...).
+    // This ensures the request to be done only once. In the test environment, we mock this request
+    // to simulate the different status, so we want to erase the promise at the end of each test,
+    // otherwise all tests but the first one would use the status in cache.
+    delete downloadReport.wkhtmltopdfStatusProm;
+});
+
+test("can execute report actions from db ID", async () => {
+    patchWithCleanup(download, {
+        _download: (options) => {
+            expect.step(options.url);
+            return Promise.resolve();
+        },
+    });
+    onRpc("/report/check_wkhtmltopdf", () => "ok");
+    stepAllNetworkCalls();
+
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(7, { onClose: () => expect.step("on_close") });
+    expect.verifySteps([
+        "/web/webclient/translations",
+        "/web/webclient/load_menus",
+        "/web/action/load",
+        "/report/check_wkhtmltopdf",
+        "/report/download",
+        "on_close",
+    ]);
+});
+
+test("report actions can close modals and reload views", async () => {
+    defineActions([
+        {
+            id: 5,
+            name: "Create a Partner",
+            res_model: "partner",
+            target: "new",
+            views: [[false, "form"]],
+        },
+    ]);
+    patchWithCleanup(download, {
+        _download: (options) => {
+            expect.step(options.url);
+            return Promise.resolve();
+        },
+    });
+
+    onRpc("/report/check_wkhtmltopdf", () => "ok");
+
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(5, { onClose: () => expect.step("on_close") });
+    expect(".o_technical_modal .o_form_view").toHaveCount(1, {
+        message: "should have rendered a form view in a modal",
+    });
+
+    await getService("action").doAction(7, { onClose: () => expect.step("on_printed") });
+    expect(".o_technical_modal .o_form_view").toHaveCount(1, {
+        message: "The modal should still exist",
+    });
+
+    await getService("action").doAction(11);
+    await animationFrame();
+    expect(".o_technical_modal .o_form_view").toHaveCount(0, {
+        message: "the modal should have been closed after the action report",
+    });
+    expect.verifySteps(["/report/download", "on_printed", "/report/download", "on_close"]);
+});
+
+test("should trigger a notification if wkhtmltopdf is to upgrade", async () => {
+    patchWithCleanup(download, {
+        _download: (options) => {
+            expect.step(options.url);
+            return Promise.resolve();
+        },
+    });
+    mockService("notification", {
+        add: () => expect.step("notify"),
+    });
+
+    onRpc("/report/check_wkhtmltopdf", () => "upgrade");
+    stepAllNetworkCalls();
+
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(7);
+    expect.verifySteps([
+        "/web/webclient/translations",
+        "/web/webclient/load_menus",
+        "/web/action/load",
+        "/report/check_wkhtmltopdf",
+        "/report/download",
+        "notify",
+    ]);
+});
+
+test("should open the report client action if wkhtmltopdf is broken", async () => {
+    // patch the report client action to override its iframe's url so that
+    // it doesn't trigger an RPC when it is appended to the DOM
+    patchWithCleanup(ReportAction.prototype, {
+        setup() {
+            super.setup(...arguments);
+            rpc(this.reportUrl);
+            this.reportUrl = "about:blank";
+        },
+    });
+    patchWithCleanup(download, {
+        _download: () => {
+            expect.step("download"); // should not be called
+            return Promise.resolve();
+        },
+    });
+    mockService("notification", {
+        add: () => expect.step("notify"),
+    });
+
+    onRpc("/report/check_wkhtmltopdf", () => "broken");
+    onRpc("/report/html/some_report", async (request) => {
+        const search = decodeURIComponent(new URL(request.url).search);
+        expect(search).toBe(`?context={"lang":"en","tz":"taht","uid":7,"allowed_company_ids":[1]}`);
+        return true;
+    });
+    stepAllNetworkCalls();
+
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(7);
+    expect(".o_content iframe").toHaveCount(1, {
+        message: "should have opened the report client action",
+    });
+    // the control panel has the content twice and a d-none class is toggled depending the screen size
+    expect(":not(.d-none) > button[title='Print']").toHaveCount(1, {
+        message: "should have a print button",
+    });
+    expect.verifySteps([
+        "/web/webclient/translations",
+        "/web/webclient/load_menus",
+        "/web/action/load",
+        "/report/check_wkhtmltopdf",
+        "notify",
+        "/report/html/some_report",
+    ]);
+});
+
+test("send context in case of html report", async () => {
+    serverState.userContext = { some_key: 2 };
+    // patch the report client action to override its iframe's url so that
+    // it doesn't trigger an RPC when it is appended to the DOM
+    patchWithCleanup(ReportAction.prototype, {
+        setup() {
+            super.setup(...arguments);
+            rpc(this.reportUrl);
+            this.reportUrl = "about:blank";
+        },
+    });
+    patchWithCleanup(download, {
+        _download: () => {
+            expect.step("download"); // should not be called
+            return Promise.resolve();
+        },
+    });
+    mockService("notification", {
+        add(message, options) {
+            expect.step(options.type || "notification");
+        },
+    });
+
+    onRpc("/report/html/some_report", async (request) => {
+        const search = decodeURIComponent(new URL(request.url).search);
+        expect(search).toBe(
+            `?context={"some_key":2,"lang":"en","tz":"taht","uid":7,"allowed_company_ids":[1]}`
+        );
+        return true;
+    });
+    stepAllNetworkCalls();
+
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(12);
+    expect(".o_content iframe").toHaveCount(1, { message: "should have opened the client action" });
+    expect.verifySteps([
+        "/web/webclient/translations",
+        "/web/webclient/load_menus",
+        "/web/action/load",
+        "/report/html/some_report",
+    ]);
+});
+
+test("UI unblocks after downloading the report even if it threw an error", async () => {
+    let timesDownloasServiceHasBeenCalled = 0;
+    patchWithCleanup(download, {
+        _download: () => {
+            if (timesDownloasServiceHasBeenCalled === 0) {
+                expect.step("successful download");
+                timesDownloasServiceHasBeenCalled++;
+                return Promise.resolve();
+            }
+            if (timesDownloasServiceHasBeenCalled === 1) {
+                expect.step("failed download");
+                return Promise.reject();
+            }
+        },
+    });
+
+    onRpc("/report/check_wkhtmltopdf", () => "ok");
+
+    await mountWithCleanup(WebClient);
+    const onBlock = () => {
+        expect.step("block");
+    };
+    const onUnblock = () => {
+        expect.step("unblock");
+    };
+    getService("ui").bus.addEventListener("BLOCK", onBlock);
+    getService("ui").bus.addEventListener("UNBLOCK", onUnblock);
+
+    await getService("action").doAction(7);
+    try {
+        await getService("action").doAction(7);
+    } catch {
+        expect.step("error caught");
+    }
+    expect.verifySteps([
+        "block",
+        "successful download",
+        "unblock",
+        "block",
+        "failed download",
+        "unblock",
+        "error caught",
+    ]);
+    getService("ui").bus.removeEventListener("BLOCK", onBlock);
+    getService("ui").bus.removeEventListener("UNBLOCK", onUnblock);
+});
+
+test("can use custom handlers for report actions", async () => {
+    patchWithCleanup(download, {
+        _download: (options) => {
+            expect.step(options.url);
+            return Promise.resolve();
+        },
+    });
+
+    onRpc("/report/check_wkhtmltopdf", () => "ok");
+    stepAllNetworkCalls();
+
+    await mountWithCleanup(WebClient);
+    let customHandlerCalled = false;
+    registry.category("ir.actions.report handlers").add("custom_handler", async (action) => {
+        if (action.id === 7 && !customHandlerCalled) {
+            customHandlerCalled = true;
+            expect.step("calling custom handler");
+            return true;
+        }
+        expect.step("falling through to default handler");
+    });
+    await getService("action").doAction(7);
+    expect.step("first doAction finished");
+
+    await getService("action").doAction(7);
+    expect.verifySteps([
+        "/web/webclient/translations",
+        "/web/webclient/load_menus",
+        "/web/action/load",
+        "calling custom handler",
+        "first doAction finished",
+        "falling through to default handler",
+        "/report/check_wkhtmltopdf",
+        "/report/download",
+    ]);
+});
+
+test.tags("desktop");
+test("context is correctly passed to the client action report", async (assert) => {
+    patchWithCleanup(download, {
+        _download: (options) => {
+            expect.step(options.url);
+            expect(options.data.context).toBe(
+                `{"lang":"en","tz":"taht","uid":7,"allowed_company_ids":[1],"rabbia":"E Tarantella","active_ids":[99]}`
+            );
+            expect(JSON.parse(options.data.data)).toEqual([
+                "/report/pdf/ennio.morricone/99",
+                "qweb-pdf",
+            ]);
+            return Promise.resolve();
+        },
+    });
+    patchWithCleanup(ReportAction.prototype, {
+        setup() {
+            super.setup(...arguments);
+            rpc(this.reportUrl);
+            this.reportUrl = "about:blank";
+        },
+    });
+
+    onRpc("/report/check_wkhtmltopdf", () => "ok");
+    onRpc("/report/html", async (request) => {
+        const search = decodeURIComponent(new URL(request.url).search);
+        expect(search).toBe(`?context={"lang":"en","tz":"taht","uid":7,"allowed_company_ids":[1]}`);
+        return true;
+    });
+    stepAllNetworkCalls();
+
+    await mountWithCleanup(WebClient);
+
+    const action = {
+        context: {
+            rabbia: "E Tarantella",
+            active_ids: [99],
+        },
+        data: null,
+        name: "Ennio Morricone",
+        report_name: "ennio.morricone",
+        report_type: "qweb-html",
+        type: "ir.actions.report",
+    };
+    expect.verifySteps(["/web/webclient/translations", "/web/webclient/load_menus"]);
+
+    await getService("action").doAction(action);
+    expect.verifySteps(["/report/html/ennio.morricone/99"]);
+
+    await contains(".o_control_panel_main_buttons button[title='Print']").click();
+    expect.verifySteps(["/report/check_wkhtmltopdf", "/report/download"]);
+});
+
+test("url is valid", async (assert) => {
+    patchWithCleanup(ReportAction.prototype, {
+        init() {
+            super.init(...arguments);
+            this.reportUrl = "about:blank";
+        },
+    });
+
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(12); // 12 is a html report action
+    await runAllTimers();
+    const urlState = router.current;
+    // used to put report.client_action in the url
+    expect(urlState.action === "report.client_action").toBe(false);
+    expect(urlState.action).toBe(12);
+});

odoo-bringout-oca-ocb-web/web/static/tests/webclient/actions/reports/report_action_tests.js

@@ -1,380 +0,0 @@
-/** @odoo-module **/
-
-import { registry } from "@web/core/registry";
-import { uiService } from "@web/core/ui/ui_service";
-import { session } from "@web/session";
-import { ReportAction } from "@web/webclient/actions/reports/report_action";
-import { clearRegistryWithCleanup } from "@web/../tests/helpers/mock_env";
-import { makeFakeNotificationService } from "@web/../tests/helpers/mock_services";
-import { mockDownload, patchWithCleanup, getFixture, click } from "@web/../tests/helpers/utils";
-import {
-    createWebClient,
-    doAction,
-    getActionManagerServerData,
-} from "@web/../tests/webclient/helpers";
-
-let serverData;
-let target;
-
-const serviceRegistry = registry.category("services");
-
-QUnit.module("ActionManager", (hooks) => {
-    hooks.beforeEach(() => {
-        serverData = getActionManagerServerData();
-        target = getFixture();
-        clearRegistryWithCleanup(registry.category("main_components"));
-    });
-
-    QUnit.module("Report actions");
-
-    QUnit.test("can execute report actions from db ID", async function (assert) {
-        assert.expect(6);
-        mockDownload((options) => {
-            assert.step(options.url);
-            return Promise.resolve();
-        });
-        const mockRPC = async (route, args) => {
-            assert.step((args && args.method) || route);
-            if (route === "/report/check_wkhtmltopdf") {
-                return Promise.resolve("ok");
-            }
-        };
-        const webClient = await createWebClient({ serverData, mockRPC });
-        await doAction(webClient, 7, { onClose: () => assert.step("on_close") });
-        assert.verifySteps([
-            "/web/webclient/load_menus",
-            "/web/action/load",
-            "/report/check_wkhtmltopdf",
-            "/report/download",
-            "on_close",
-        ]);
-    });
-
-    QUnit.test("report actions can close modals and reload views", async function (assert) {
-        assert.expect(8);
-        mockDownload((options) => {
-            assert.step(options.url);
-            return Promise.resolve();
-        });
-        const mockRPC = async (route) => {
-            if (route === "/report/check_wkhtmltopdf") {
-                return Promise.resolve("ok");
-            }
-        };
-        const webClient = await createWebClient({ serverData, mockRPC });
-        await doAction(webClient, 5, { onClose: () => assert.step("on_close") });
-        assert.containsOnce(
-            document.body,
-            ".o_technical_modal .o_form_view",
-            "should have rendered a form view in a modal"
-        );
-        await doAction(webClient, 7, { onClose: () => assert.step("on_printed") });
-        assert.containsOnce(
-            document.body,
-            ".o_technical_modal .o_form_view",
-            "The modal should still exist"
-        );
-        await doAction(webClient, 11);
-        assert.containsNone(
-            document.body,
-            ".o_technical_modal .o_form_view",
-            "the modal should have been closed after the action report"
-        );
-        assert.verifySteps(["/report/download", "on_printed", "/report/download", "on_close"]);
-    });
-
-    QUnit.test(
-        "should trigger a notification if wkhtmltopdf is to upgrade",
-        async function (assert) {
-            serviceRegistry.add(
-                "notification",
-                makeFakeNotificationService(
-                    () => {
-                        assert.step("notify");
-                    },
-                    () => {}
-                )
-            );
-            mockDownload((options) => {
-                assert.step(options.url);
-                return Promise.resolve();
-            });
-            const mockRPC = async (route, args) => {
-                assert.step((args && args.method) || route);
-                if (route === "/report/check_wkhtmltopdf") {
-                    return Promise.resolve("upgrade");
-                }
-            };
-            const webClient = await createWebClient({ serverData, mockRPC });
-            await doAction(webClient, 7);
-            assert.verifySteps([
-                "/web/webclient/load_menus",
-                "/web/action/load",
-                "/report/check_wkhtmltopdf",
-                "notify",
-                "/report/download",
-            ]);
-        }
-    );
-
-    QUnit.test(
-        "should open the report client action if wkhtmltopdf is broken",
-        async function (assert) {
-            mockDownload(() => {
-                assert.step("download"); // should not be called
-                return Promise.resolve();
-            });
-            serviceRegistry.add(
-                "notification",
-                makeFakeNotificationService(
-                    () => {
-                        assert.step("notify");
-                    },
-                    () => {}
-                )
-            );
-            const mockRPC = async (route, args) => {
-                assert.step(args.method || route);
-                if (route === "/report/check_wkhtmltopdf") {
-                    return Promise.resolve("broken");
-                }
-                if (route.includes("/report/html/some_report")) {
-                    return Promise.resolve(true);
-                }
-            };
-            // patch the report client action to override its iframe's url so that
-            // it doesn't trigger an RPC when it is appended to the DOM (for this
-            // usecase, using removeSRCAttribute doesn't work as the RPC is
-            // triggered as soon as the iframe is in the DOM, even if its src
-            // attribute is removed right after)
-            patchWithCleanup(ReportAction.prototype, {
-                setup() {
-                    this._super(...arguments);
-                    this.env.services.rpc(this.reportUrl);
-                    this.reportUrl = "about:blank";
-                },
-            });
-            const webClient = await createWebClient({ serverData, mockRPC });
-            await doAction(webClient, 7);
-            assert.containsOnce(
-                target,
-                ".o_content iframe",
-                "should have opened the report client action"
-            );
-            assert.containsOnce(target, "button[title='Print']", "should have a print button");
-            assert.verifySteps([
-                "/web/webclient/load_menus",
-                "/web/action/load",
-                "/report/check_wkhtmltopdf",
-                "notify",
-                // context={"lang":'en',"uid":7,"tz":'taht'}
-                "/report/html/some_report?context=%7B%22lang%22%3A%22en%22%2C%22uid%22%3A7%2C%22tz%22%3A%22taht%22%7D",
-            ]);
-        }
-    );
-
-    QUnit.test("send context in case of html report", async function (assert) {
-        assert.expect(5);
-        mockDownload(() => {
-            assert.step("download"); // should not be called
-            return Promise.resolve();
-        });
-        serviceRegistry.add(
-            "notification",
-            makeFakeNotificationService(
-                (message, options) => {
-                    assert.step(options.type || "notification");
-                },
-                () => {}
-            )
-        );
-        patchWithCleanup(session.user_context, { some_key: 2 });
-        const mockRPC = async (route, args) => {
-            assert.step(args.method || route);
-            if (route.includes("/report/html/some_report")) {
-                return Promise.resolve(true);
-            }
-        };
-        // patch the report client action to override its iframe's url so that
-        // it doesn't trigger an RPC when it is appended to the DOM (for this
-        // usecase, using removeSRCAttribute doesn't work as the RPC is
-        // triggered as soon as the iframe is in the DOM, even if its src
-        // attribute is removed right after)
-        patchWithCleanup(ReportAction.prototype, {
-            setup() {
-                this._super(...arguments);
-                this.env.services.rpc(this.reportUrl);
-                this.reportUrl = "about:blank";
-            },
-        });
-        const webClient = await createWebClient({ serverData, mockRPC });
-        await doAction(webClient, 12);
-        assert.containsOnce(target, ".o_content iframe", "should have opened the client action");
-        assert.verifySteps([
-            "/web/webclient/load_menus",
-            "/web/action/load",
-            // context={"lang":'en',"uid":7,"tz":'taht',"some_key":2}
-            "/report/html/some_report?context=%7B%22lang%22%3A%22en%22%2C%22uid%22%3A7%2C%22tz%22%3A%22taht%22%2C%22some_key%22%3A2%7D",
-        ]);
-    });
-
-    QUnit.test(
-        "UI unblocks after downloading the report even if it threw an error",
-        async function (assert) {
-            assert.expect(8);
-            let timesDownloasServiceHasBeenCalled = 0;
-            mockDownload(() => {
-                if (timesDownloasServiceHasBeenCalled === 0) {
-                    assert.step("successful download");
-                    timesDownloasServiceHasBeenCalled++;
-                    return Promise.resolve();
-                }
-                if (timesDownloasServiceHasBeenCalled === 1) {
-                    assert.step("failed download");
-                    return Promise.reject();
-                }
-            });
-            serviceRegistry.add("ui", uiService);
-            const mockRPC = async (route) => {
-                if (route === "/report/check_wkhtmltopdf") {
-                    return Promise.resolve("ok");
-                }
-            };
-            const webClient = await createWebClient({ serverData, mockRPC });
-            const ui = webClient.env.services.ui;
-            const onBlock = () => {
-                assert.step("block");
-            };
-            const onUnblock = () => {
-                assert.step("unblock");
-            };
-            ui.bus.addEventListener("BLOCK", onBlock);
-            ui.bus.addEventListener("UNBLOCK", onUnblock);
-            await doAction(webClient, 7);
-            try {
-                await doAction(webClient, 7);
-            } catch (_e) {
-                assert.step("error caught");
-            }
-            assert.verifySteps([
-                "block",
-                "successful download",
-                "unblock",
-                "block",
-                "failed download",
-                "unblock",
-                "error caught",
-            ]);
-            ui.bus.removeEventListener("BLOCK", onBlock);
-            ui.bus.removeEventListener("UNBLOCK", onUnblock);
-        }
-    );
-
-    QUnit.test("can use custom handlers for report actions", async function (assert) {
-        assert.expect(8);
-        mockDownload((options) => {
-            assert.step(options.url);
-            return Promise.resolve();
-        });
-        const mockRPC = async (route, args) => {
-            assert.step((args && args.method) || route);
-            if (route === "/report/check_wkhtmltopdf") {
-                return "ok";
-            }
-        };
-        const webClient = await createWebClient({ serverData, mockRPC });
-        let customHandlerCalled = false;
-        registry.category("ir.actions.report handlers").add("custom_handler", async (action) => {
-            if (action.id === 7 && !customHandlerCalled) {
-                customHandlerCalled = true;
-                assert.step("calling custom handler");
-                return true;
-            }
-            assert.step("falling through to default handler");
-        });
-        await doAction(webClient, 7);
-        assert.step("first doAction finished");
-        await doAction(webClient, 7);
-
-        assert.verifySteps([
-            "/web/webclient/load_menus",
-            "/web/action/load",
-            "calling custom handler",
-            "first doAction finished",
-            "falling through to default handler",
-            "/report/check_wkhtmltopdf",
-            "/report/download",
-        ]);
-    });
-
-    QUnit.test("context is correctly passed to the client action report", async (assert) => {
-        assert.expect(8);
-
-        mockDownload((options) => {
-            assert.step(options.url);
-            assert.deepEqual(JSON.parse(options.data.data), [
-                "/report/pdf/ennio.morricone/99",
-                "qweb-pdf",
-            ]);
-            return Promise.resolve();
-        });
-        const mockRPC = async (route, args) => {
-            assert.step((args && args.method) || route);
-            if (route === "/report/check_wkhtmltopdf") {
-                return "ok";
-            }
-            if (route.includes("/report/html")) {
-                return true;
-            }
-        };
-
-        patchWithCleanup(ReportAction.prototype, {
-            setup() {
-                this._super(...arguments);
-                this.env.services.rpc(this.reportUrl);
-                this.reportUrl = "about:blank";
-            },
-        });
-        const webClient = await createWebClient({ serverData, mockRPC });
-
-        const action = {
-            context: {
-                rabbia: "E Tarantella",
-                active_ids: [99],
-            },
-            data: null,
-            name: "Ennio Morricone",
-            report_name: "ennio.morricone",
-            report_type: "qweb-html",
-            type: "ir.actions.report",
-        };
-        assert.verifySteps(["/web/webclient/load_menus"]);
-
-        await doAction(webClient, action);
-        assert.verifySteps([
-            "/report/html/ennio.morricone/99?context=%7B%22lang%22%3A%22en%22%2C%22uid%22%3A7%2C%22tz%22%3A%22taht%22%7D",
-        ]);
-        await click(target.querySelector("button[title='Print']"));
-        assert.verifySteps(["/report/check_wkhtmltopdf", "/report/download"]);
-    });
-
-    QUnit.test("url is valid", async (assert) => {
-        assert.expect(2);
-
-        patchWithCleanup(ReportAction.prototype, {
-            init() {
-                this._super(...arguments);
-                this.reportUrl = "about:blank";
-            },
-        });
-
-        const webClient = await createWebClient({ serverData });
-
-        await doAction(webClient, 12); // 12 is a html report action in serverData
-
-        const hash = webClient.router.current.hash;
-        // used to put report.client_action in the url
-        assert.strictEqual(hash.action === "report.client_action", false);
-        assert.strictEqual(hash.action === 12, true);
-    });
-});

odoo-bringout-oca-ocb-web/web/static/tests/webclient/actions/server_action.test.js

@@ -0,0 +1,151 @@
+import { expect, test } from "@odoo/hoot";
+import { animationFrame } from "@odoo/hoot-mock";
+import {
+    defineActions,
+    defineModels,
+    getService,
+    models,
+    mountWithCleanup,
+    onRpc,
+    stepAllNetworkCalls,
+} from "@web/../tests/web_test_helpers";
+
+import { WebClient } from "@web/webclient/webclient";
+
+class Partner extends models.Model {
+    _rec_name = "display_name";
+
+    _records = [
+        { id: 1, display_name: "First record" },
+        { id: 2, display_name: "Second record" },
+    ];
+    _views = {
+        form: `
+        <form>
+            <header>
+                <button name="object" string="Call method" type="object"/>
+                <button name="4" string="Execute action" type="action"/>
+            </header>
+            <group>
+                <field name="display_name"/>
+            </group>
+        </form>`,
+        "kanban,1": `
+            <kanban>
+                <templates>
+                    <t t-name="card">
+                        <field name="display_name"/>
+                    </t>
+                </templates>
+            </kanban>`,
+    };
+}
+
+class User extends models.Model {
+    _name = "res.users";
+    has_group() {
+        return true;
+    }
+}
+
+defineModels([Partner, User]);
+
+test("can execute server actions from db ID", async () => {
+    defineActions([
+        {
+            id: 2,
+            type: "ir.actions.server",
+        },
+        {
+            id: 1,
+            xml_id: "action_1",
+            name: "Partners Action 1",
+            res_model: "partner",
+            views: [[1, "kanban"]],
+        },
+    ]);
+    onRpc(
+        "/web/action/run",
+        async () => 1 // execute action 1
+    );
+    stepAllNetworkCalls();
+
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(2, { additionalContext: { someKey: 44 } });
+    expect(".o_control_panel").toHaveCount(1, { message: "should have rendered a control panel" });
+    expect(".o_kanban_view").toHaveCount(1, { message: "should have rendered a kanban view" });
+    expect.verifySteps([
+        "/web/webclient/translations",
+        "/web/webclient/load_menus",
+        "/web/action/load",
+        "/web/action/run",
+        "/web/action/load",
+        "get_views",
+        "web_search_read",
+        "has_group",
+    ]);
+});
+
+test("handle server actions returning false", async function (assert) {
+    defineActions([
+        {
+            id: 2,
+            type: "ir.actions.server",
+        },
+        {
+            id: 5,
+            xml_id: "action_5",
+            name: "Create a Partner",
+            res_model: "partner",
+            target: "new",
+            views: [[false, "form"]],
+        },
+    ]);
+    onRpc("/web/action/run", async () => false);
+    stepAllNetworkCalls();
+    await mountWithCleanup(WebClient);
+    // execute an action in target="new"
+    function onClose() {
+        expect.step("close handler");
+    }
+    await getService("action").doAction(5, { onClose });
+    expect(".o_technical_modal .o_form_view").toHaveCount(1, {
+        message: "should have rendered a form view in a modal",
+    });
+
+    // execute a server action that returns false
+    await getService("action").doAction(2);
+    await animationFrame();
+    expect(".o_technical_modal").toHaveCount(0, { message: "should have closed the modal" });
+    expect.verifySteps([
+        "/web/webclient/translations",
+        "/web/webclient/load_menus",
+        "/web/action/load",
+        "get_views",
+        "onchange",
+        "/web/action/load",
+        "/web/action/run",
+        "close handler",
+    ]);
+});
+
+test("action with html help returned by a server action", async () => {
+    defineActions([
+        {
+            id: 2,
+            type: "ir.actions.server",
+        },
+    ]);
+    onRpc("/web/action/run", async () => ({
+        res_model: "partner",
+        type: "ir.actions.act_window",
+        views: [[false, "kanban"]],
+        help: "<p>I am not a helper</p>",
+        domain: [[0, "=", 1]],
+    }));
+
+    await mountWithCleanup(WebClient);
+    await getService("action").doAction(2);
+
+    expect(".o_kanban_view .o_nocontent_help p").toHaveText("I am not a helper");
+});

odoo-bringout-oca-ocb-web/web/static/tests/webclient/actions/server_action_tests.js

@@ -1,115 +0,0 @@
-/** @odoo-module **/
-
-import { createWebClient, doAction, getActionManagerServerData } from "./../helpers";
-import { getFixture } from "../../helpers/utils";
-
-let serverData;
-let target;
-
-QUnit.module("ActionManager", (hooks) => {
-    hooks.beforeEach(() => {
-        serverData = getActionManagerServerData();
-        target = getFixture();
-    });
-
-    QUnit.module("Server actions");
-
-    QUnit.test("can execute server actions from db ID", async function (assert) {
-        assert.expect(10);
-        const mockRPC = async (route, args) => {
-            assert.step((args && args.method) || route);
-            if (route === "/web/action/run") {
-                assert.strictEqual(args.action_id, 2, "should call the correct server action");
-                return Promise.resolve(1); // execute action 1
-            }
-        };
-        const webClient = await createWebClient({ serverData, mockRPC });
-        await doAction(webClient, 2);
-        assert.containsOnce(target, ".o_control_panel", "should have rendered a control panel");
-        assert.containsOnce(target, ".o_kanban_view", "should have rendered a kanban view");
-        assert.verifySteps([
-            "/web/webclient/load_menus",
-            "/web/action/load",
-            "/web/action/run",
-            "/web/action/load",
-            "get_views",
-            "web_search_read",
-        ]);
-    });
-
-    QUnit.test("handle server actions returning false", async function (assert) {
-        assert.expect(10);
-        const mockRPC = async (route, args) => {
-            assert.step((args && args.method) || route);
-            if (route === "/web/action/run") {
-                return Promise.resolve(false);
-            }
-        };
-        const webClient = await createWebClient({ serverData, mockRPC });
-        // execute an action in target="new"
-        function onClose() {
-            assert.step("close handler");
-        }
-        await doAction(webClient, 5, { onClose });
-        assert.containsOnce(
-            document.body,
-            ".o_technical_modal .o_form_view",
-            "should have rendered a form view in a modal"
-        );
-        // execute a server action that returns false
-        await doAction(webClient, 2);
-        assert.containsNone(document.body, ".o_technical_modal", "should have closed the modal");
-        assert.verifySteps([
-            "/web/webclient/load_menus",
-            "/web/action/load",
-            "get_views",
-            "onchange",
-            "/web/action/load",
-            "/web/action/run",
-            "close handler",
-        ]);
-    });
-
-    QUnit.test("send correct context when executing a server action", async function (assert) {
-        assert.expect(1);
-
-        serverData.actions[2].context = { someKey: 44 };
-        const mockRPC = async (route, args) => {
-            if (route === "/web/action/run") {
-                assert.deepEqual(args.context, {
-                    // user context
-                    lang: "en",
-                    tz: "taht",
-                    uid: 7,
-                    // action context
-                    someKey: 44,
-                });
-                return Promise.resolve(1); // execute action 1
-            }
-        };
-        const webClient = await createWebClient({ serverData, mockRPC });
-        await doAction(webClient, 2);
-    });
-
-    QUnit.test("action with html help returned by a server action", async function (assert) {
-        serverData.actions[2].context = { someKey: 44 };
-        const mockRPC = async (route, args) => {
-            if (route === "/web/action/run") {
-                return Promise.resolve({
-                    res_model: "partner",
-                    type: "ir.actions.act_window",
-                    views: [[false, "list"]],
-                    help: "<p>I am not a helper</p>",
-                    domain: [[0, "=", 1]],
-                });
-            }
-        };
-        const webClient = await createWebClient({ serverData, mockRPC });
-        await doAction(webClient, 2);
-
-        assert.strictEqual(
-            target.querySelector(".o_list_view .o_nocontent_help p").innerText,
-            "I am not a helper"
-        );
-    });
-});

odoo-bringout-oca-ocb-web/web/static/tests/webclient/actions/target.test.js

@@ -0,0 +1,770 @@
+import { describe, expect, test } from "@odoo/hoot";
+import { queryAll, queryAllTexts, queryText } from "@odoo/hoot-dom";
+import { animationFrame, Deferred } from "@odoo/hoot-mock";
+import { Component, onMounted, xml } from "@odoo/owl";
+import {
+    contains,
+    defineActions,
+    defineMenus,
+    defineModels,
+    getService,
+    mockService,
+    models,
+    mountWithCleanup,
+    onRpc,
+    patchWithCleanup,
+    stepAllNetworkCalls,
+    webModels,
+} from "@web/../tests/web_test_helpers";
+
+import { ClientErrorDialog } from "@web/core/errors/error_dialogs";
+import { registry } from "@web/core/registry";
+import { useService } from "@web/core/utils/hooks";
+import { WebClient } from "@web/webclient/webclient";
+
+const { ResCompany, ResPartner, ResUsers } = webModels;
+
+class Partner extends models.Model {
+    _rec_name = "display_name";
+
+    _records = [
+        { id: 1, display_name: "First record" },
+        { id: 2, display_name: "Second record" },
+    ];
+    _views = {
+        form: `
+            <form>
+                <header>
+                    <button name="object" string="Call method" type="object"/>
+                    <button name="4" string="Execute action" type="action"/>
+                </header>
+                <group>
+                    <field name="display_name"/>
+                </group>
+            </form>`,
+        "kanban,1": `
+            <kanban>
+                <templates>
+                    <t t-name="card">
+                        <field name="display_name"/>
+                    </t>
+                </templates>
+            </kanban>`,
+        list: `<list><field name="display_name"/></list>`,
+        "list,2": `<list limit="3"><field name="display_name"/></list>`,
+    };
+}
+
+defineModels([Partner, ResCompany, ResPartner, ResUsers]);
+
+defineActions([
+    {
+        id: 1,
+        xml_id: "action_1",
+        name: "Partners Action 1",
+        res_model: "partner",
+        views: [[1, "kanban"]],
+    },
+    {
+        id: 4,
+        xml_id: "action_4",
+        name: "Partners Action 4",
+        res_model: "partner",
+        views: [
+            [1, "kanban"],
+            [2, "list"],
+            [false, "form"],
+        ],
+    },
+    {
+        id: 5,
+        xml_id: "action_5",
+        name: "Create a Partner",
+        res_model: "partner",
+        target: "new",
+        views: [[false, "form"]],
+    },
+    {
+        id: 15,
+        name: "Partners Action Fullscreen",
+        res_model: "partner",
+        target: "fullscreen",
+        views: [[1, "kanban"]],
+    },
+]);
+
+describe("new", () => {
+    test('can execute act_window actions in target="new"', async () => {
+        stepAllNetworkCalls();
+
+        await mountWithCleanup(WebClient);
+        await getService("action").doAction(5);
+        expect(".o_technical_modal .o_form_view").toHaveCount(1, {
+            message: "should have rendered a form view in a modal",
+        });
+        expect(".o_technical_modal .modal-body").toHaveClass("o_act_window", {
+            message: "dialog main element should have classname 'o_act_window'",
+        });
+        expect(".o_technical_modal .o_form_view .o_form_editable").toHaveCount(1, {
+            message: "form view should be in edit mode",
+        });
+        expect.verifySteps([
+            "/web/webclient/translations",
+            "/web/webclient/load_menus",
+            "/web/action/load",
+            "get_views",
+            "onchange",
+        ]);
+    });
+
+    test("chained action on_close", async () => {
+        function onClose(closeInfo) {
+            expect(closeInfo).toBe("smallCandle");
+            expect.step("Close Action");
+        }
+        await mountWithCleanup(WebClient);
+        await getService("action").doAction(5, { onClose });
+        // a target=new action shouldn't activate the on_close
+        await getService("action").doAction(5);
+        expect.verifySteps([]);
+        // An act_window_close should trigger the on_close
+        await getService("action").doAction({
+            type: "ir.actions.act_window_close",
+            infos: "smallCandle",
+        });
+        expect.verifySteps(["Close Action"]);
+    });
+
+    test("footer buttons are moved to the dialog footer", async () => {
+        Partner._views["form"] = `
+            <form>
+                <field name="display_name"/>
+                <footer>
+                    <button string="Create" type="object" class="infooter"/>
+                </footer>
+            </form>`;
+
+        await mountWithCleanup(WebClient);
+        await getService("action").doAction(5);
+        expect(".o_technical_modal .modal-body button.infooter").toHaveCount(0, {
+            message: "the button should not be in the body",
+        });
+        expect(".o_technical_modal .modal-footer button.infooter").toHaveCount(1, {
+            message: "the button should be in the footer",
+        });
+        expect(".modal-footer button:visible").toHaveCount(1, {
+            message: "the modal footer should only contain one visible button",
+        });
+    });
+
+    test.tags("desktop");
+    test("Button with `close` attribute closes dialog on desktop", async () => {
+        Partner._views = {
+            form: `
+                <form>
+                    <header>
+                        <button string="Open dialog" name="5" type="action"/>
+                    </header>
+                </form>`,
+            "form,17": `
+                <form>
+                    <footer>
+                        <button string="I close the dialog" name="some_method" type="object" close="1"/>
+                    </footer>
+                </form>`,
+        };
+        defineActions(
+            [
+                {
+                    id: 4,
+                    name: "Partners Action 4",
+                    res_model: "partner",
+                    views: [[false, "form"]],
+                },
+                {
+                    id: 5,
+                    name: "Create a Partner",
+                    res_model: "partner",
+                    target: "new",
+                    views: [[17, "form"]],
+                },
+            ],
+            { mode: "replace" }
+        );
+
+        onRpc("/web/dataset/call_button/*", async (request) => {
+            const { params } = await request.json();
+            if (params.method === "some_method") {
+                return {
+                    tag: "display_notification",
+                    type: "ir.actions.client",
+                };
+            }
+        });
+        stepAllNetworkCalls();
+
+        await mountWithCleanup(WebClient);
+        expect.verifySteps(["/web/webclient/translations", "/web/webclient/load_menus"]);
+        await getService("action").doAction(4);
+        expect.verifySteps(["/web/action/load", "get_views", "onchange"]);
+        await contains(`button[name="5"]`).click();
+        expect.verifySteps(["web_save", "/web/action/load", "get_views", "onchange"]);
+        expect(".modal").toHaveCount(1);
+        await contains(`button[name=some_method]`).click();
+        expect.verifySteps(["web_save", "some_method", "web_read"]);
+        expect(".modal").toHaveCount(0);
+    });
+
+    test.tags("mobile");
+    test("Button with `close` attribute closes dialog on mobile", async () => {
+        Partner._views = {
+            form: `
+                <form>
+                    <header>
+                        <button string="Open dialog" name="5" type="action"/>
+                    </header>
+                </form>`,
+            "form,17": `
+                <form>
+                    <footer>
+                        <button string="I close the dialog" name="some_method" type="object" close="1"/>
+                    </footer>
+                </form>`,
+        };
+        defineActions(
+            [
+                {
+                    id: 4,
+                    name: "Partners Action 4",
+                    res_model: "partner",
+                    views: [[false, "form"]],
+                },
+                {
+                    id: 5,
+                    name: "Create a Partner",
+                    res_model: "partner",
+                    target: "new",
+                    views: [[17, "form"]],
+                },
+            ],
+            { mode: "replace" }
+        );
+
+        onRpc("/web/dataset/call_button/*", async (request) => {
+            const { params } = await request.json();
+            if (params.method === "some_method") {
+                return {
+                    tag: "display_notification",
+                    type: "ir.actions.client",
+                };
+            }
+        });
+        stepAllNetworkCalls();
+
+        await mountWithCleanup(WebClient);
+        expect.verifySteps(["/web/webclient/translations", "/web/webclient/load_menus"]);
+        await getService("action").doAction(4);
+        expect.verifySteps(["/web/action/load", "get_views", "onchange"]);
+        await contains(`.o_cp_action_menus button:has(.fa-cog)`).click();
+        await contains(`button[name="5"]`).click();
+        expect.verifySteps(["web_save", "/web/action/load", "get_views", "onchange"]);
+        expect(".modal").toHaveCount(1);
+        await contains(`button[name=some_method]`).click();
+        expect.verifySteps(["web_save", "some_method", "web_read"]);
+        expect(".modal").toHaveCount(0);
+    });
+
+    test('footer buttons are updated when having another action in target "new"', async () => {
+        defineActions([
+            {
+                id: 25,
+                name: "Create a Partner",
+                res_model: "partner",
+                target: "new",
+                views: [[3, "form"]],
+            },
+        ]);
+        Partner._views = {
+            form: `
+                <form>
+                    <field name="display_name"/>
+                    <footer>
+                        <button string="Create" type="object" class="infooter"/>
+                    </footer>
+                </form>`,
+            "form,3": `
+                <form>
+                    <footer>
+                        <button class="btn-primary" string="Save" special="save"/>
+                    </footer>
+                </form>`,
+        };
+
+        await mountWithCleanup(WebClient);
+        await getService("action").doAction(5);
+        expect('.o_technical_modal .modal-body button[special="save"]').toHaveCount(0);
+        expect(".o_technical_modal .modal-body button.infooter").toHaveCount(0);
+        expect(".o_technical_modal .modal-footer button.infooter").toHaveCount(1);
+        expect(".o_technical_modal .modal-footer button:visible").toHaveCount(1);
+        await getService("action").doAction(25);
+        expect(".o_technical_modal .modal-body button.infooter").toHaveCount(0);
+        expect(".o_technical_modal .modal-footer button.infooter").toHaveCount(0);
+        expect('.o_technical_modal .modal-body button[special="save"]').toHaveCount(0);
+        expect('.o_technical_modal .modal-footer button[special="save"]').toHaveCount(1);
+        expect(".o_technical_modal .modal-footer button:visible").toHaveCount(1);
+    });
+
+    test('button with confirm attribute in act_window action in target="new"', async () => {
+        defineActions([
+            {
+                id: 999,
+                name: "A window action",
+                res_model: "partner",
+                target: "new",
+                views: [[999, "form"]],
+            },
+        ]);
+        Partner._views["form,999"] = `
+            <form>
+                <button name="method" string="Call method" type="object" confirm="Are you sure?"/>
+            </form>`;
+        Partner._views["form,1000"] = `<form>Another action</form>`;
+
+        onRpc("method", () => ({
+            id: 1000,
+            name: "Another window action",
+            res_model: "partner",
+            target: "new",
+            type: "ir.actions.act_window",
+            views: [[1000, "form"]],
+        }));
+
+        await mountWithCleanup(WebClient);
+        await getService("action").doAction(999);
+        expect(".modal button[name=method]").toHaveCount(1);
+
+        await contains(".modal button[name=method]").click();
+        expect(".modal").toHaveCount(2);
+        expect(".modal:last .modal-body").toHaveText("Are you sure?");
+
+        await contains(".modal:last .modal-footer .btn-primary").click();
+        // needs two renderings to close the ConfirmationDialog:
+        //  - 1 to open the next dialog (the action in target="new")
+        //  - 1 to close the ConfirmationDialog, once the next action is executed
+        await animationFrame();
+        expect(".modal").toHaveCount(1);
+        expect(".modal main .o_content").toHaveText("Another action");
+    });
+
+    test('actions in target="new" do not update page title', async () => {
+        mockService("title", {
+            setParts({ action }) {
+                if (action) {
+                    expect.step(action);
+                }
+            },
+        });
+
+        await mountWithCleanup(WebClient);
+
+        // sanity check: execute an action in target="current"
+        await getService("action").doAction(1);
+        expect.verifySteps(["Partners Action 1"]);
+
+        // execute an action in target="new"
+        await getService("action").doAction(5);
+        expect.verifySteps([]);
+    });
+
+    test("do not commit a dialog in error", async () => {
+        expect.assertions(7);
+        expect.errors(1);
+
+        class ErrorClientAction extends Component {
+            static template = xml`<div/>`;
+            static props = ["*"];
+            setup() {
+                throw new Error("my error");
+            }
+        }
+        registry.category("actions").add("failing", ErrorClientAction);
+
+        class ClientActionTargetNew extends Component {
+            static template = xml`<div class="my_action_new" />`;
+            static props = ["*"];
+        }
+        registry.category("actions").add("clientActionNew", ClientActionTargetNew);
+
+        class ClientAction extends Component {
+            static template = xml`
+                <div class="my_action" t-on-click="onClick">
+                    My Action
+                </div>`;
+            static props = ["*"];
+            setup() {
+                this.action = useService("action");
+            }
+            async onClick() {
+                try {
+                    await this.action.doAction(
+                        { type: "ir.actions.client", tag: "failing", target: "new" },
+                        { onClose: () => expect.step("failing dialog closed") }
+                    );
+                } catch (e) {
+                    expect(e.cause.message).toBe("my error");
+                    throw e;
+                }
+            }
+        }
+        registry.category("actions").add("clientAction", ClientAction);
+
+        const errorDialogOpened = new Deferred();
+        patchWithCleanup(ClientErrorDialog.prototype, {
+            setup() {
+                super.setup(...arguments);
+                onMounted(() => errorDialogOpened.resolve());
+            },
+        });
+
+        await mountWithCleanup(WebClient);
+        await getService("action").doAction({ type: "ir.actions.client", tag: "clientAction" });
+        await contains(".my_action").click();
+        await errorDialogOpened;
+        expect(".modal").toHaveCount(1);
+
+        await contains(".modal-body button.btn-link").click();
+        expect(queryText(".modal-body .o_error_detail")).toInclude("my error");
+        expect.verifyErrors(["my error"]);
+
+        await contains(".modal-footer .btn-primary").click();
+        expect(".modal").toHaveCount(0);
+
+        await getService("action").doAction({
+            type: "ir.actions.client",
+            tag: "clientActionNew",
+            target: "new",
+        });
+        expect(".modal .my_action_new").toHaveCount(1);
+
+        expect.verifySteps([]);
+    });
+
+    test('breadcrumbs of actions in target="new"', async () => {
+        await mountWithCleanup(WebClient);
+
+        // execute an action in target="current"
+        await getService("action").doAction(1);
+        expect(queryAllTexts(".o_breadcrumb span")).toEqual(["Partners Action 1"]);
+
+        // execute an action in target="new" and a list view (s.t. there is a control panel)
+        await getService("action").doAction({
+            xml_id: "action_5",
+            name: "Create a Partner",
+            res_model: "partner",
+            target: "new",
+            type: "ir.actions.act_window",
+            views: [[false, "list"]],
+        });
+        expect(".modal .o_breadcrumb").toHaveCount(0);
+    });
+
+    test('call switchView in an action in target="new"', async () => {
+        await mountWithCleanup(WebClient);
+
+        // execute an action in target="current"
+        await getService("action").doAction(4);
+        expect(".o_kanban_view").toHaveCount(1);
+
+        // execute an action in target="new" and a list view (s.t. we can call switchView)
+        await getService("action").doAction({
+            xml_id: "action_5",
+            name: "Create a Partner",
+            res_model: "partner",
+            target: "new",
+            type: "ir.actions.act_window",
+            views: [[false, "list"]],
+        });
+        expect(".modal .o_list_view").toHaveCount(1);
+        expect(".o_kanban_view").toHaveCount(1);
+
+        // click on a record in the dialog -> should do nothing as we can't switch view
+        // in the dialog, and we don't want to switch view behind the dialog
+        await contains(".modal .o_data_row .o_data_cell").click();
+        expect(".modal .o_list_view").toHaveCount(1);
+        expect(".o_kanban_view").toHaveCount(1);
+    });
+
+    test("action with 'dialog_size' key in context", async () => {
+        const action = {
+            name: "Some Action",
+            res_model: "partner",
+            type: "ir.actions.act_window",
+            target: "new",
+            views: [[false, "form"]],
+        };
+        await mountWithCleanup(WebClient);
+
+        await getService("action").doAction(action);
+        expect(".o_dialog .modal-dialog").toHaveClass("modal-lg");
+
+        await getService("action").doAction({ ...action, context: { dialog_size: "small" } });
+        expect(".o_dialog .modal-dialog").toHaveClass("modal-sm");
+
+        await getService("action").doAction({ ...action, context: { dialog_size: "medium" } });
+        expect(".o_dialog .modal-dialog").toHaveClass("modal-md");
+
+        await getService("action").doAction({ ...action, context: { dialog_size: "large" } });
+        expect(".o_dialog .modal-dialog").toHaveClass("modal-lg");
+
+        await getService("action").doAction({ ...action, context: { dialog_size: "extra-large" } });
+        expect(".o_dialog .modal-dialog").toHaveClass("modal-xl");
+    });
+
+    test('click on record in list view action in target="new"', async () => {
+        await mountWithCleanup(WebClient);
+        await getService("action").doAction({
+            name: "My Partners",
+            res_model: "partner",
+            type: "ir.actions.act_window",
+            target: "new",
+            views: [
+                [false, "list"],
+                [false, "form"],
+            ],
+        });
+
+        // The list view has been opened in a dialog
+        expect(".o_dialog .modal-dialog .o_list_view").toHaveCount(1);
+
+        // click on a record in the dialog -> should do nothing as we can't switch view in the dialog
+        await contains(".modal .o_data_row .o_data_cell").click();
+        expect(".o_dialog .modal-dialog .o_list_view").toHaveCount(1);
+        expect(".o_form_view").toHaveCount(0);
+    });
+});
+
+describe("fullscreen", () => {
+    test('correctly execute act_window actions in target="fullscreen"', async () => {
+        await mountWithCleanup(WebClient);
+        await getService("action").doAction(15);
+        await animationFrame(); // wait for the webclient template to be re-rendered
+        expect(".o_control_panel").toHaveCount(1, {
+            message: "should have rendered a control panel",
+        });
+        expect(".o_kanban_view").toHaveCount(1, { message: "should have rendered a kanban view" });
+        expect(".o_main_navbar").toHaveCount(0);
+    });
+
+    test('action after another in target="fullscreen" is not displayed in fullscreen mode', async () => {
+        await mountWithCleanup(WebClient);
+        await getService("action").doAction(15);
+        await animationFrame(); // wait for the webclient template to be re-rendered
+        expect(".o_main_navbar").toHaveCount(0);
+        await getService("action").doAction(1);
+        await animationFrame(); // wait for the webclient template to be re-rendered
+        // The navbar should be displayed again
+        expect(".o_main_navbar").toHaveCount(1);
+    });
+
+    test.tags("desktop");
+    test('fullscreen on action change: back to a "current" action', async () => {
+        defineActions([
+            {
+                id: 6,
+                xml_id: "action_6",
+                name: "Partner",
+                res_id: 2,
+                res_model: "partner",
+                target: "current",
+                views: [[false, "form"]],
+            },
+        ]);
+        Partner._views["form"] = `
+            <form>
+                <button name="15" type="action" class="oe_stat_button" />
+            </form>`;
+
+        await mountWithCleanup(WebClient);
+        await getService("action").doAction(6);
+        expect(".o_main_navbar").toHaveCount(1);
+
+        await contains("button[name='15']").click();
+        await animationFrame(); // wait for the webclient template to be re-rendered
+        expect(".o_main_navbar").toHaveCount(0);
+
+        await contains(".breadcrumb li a").click();
+        await animationFrame(); // wait for the webclient template to be re-rendered
+        expect(".o_main_navbar").toHaveCount(1);
+    });
+
+    test.tags("desktop");
+    test('fullscreen on action change: all "fullscreen" actions', async () => {
+        defineActions([
+            {
+                id: 6,
+                xml_id: "action_6",
+                name: "Partner",
+                res_id: 2,
+                res_model: "partner",
+                target: "fullscreen",
+                views: [[false, "form"]],
+            },
+        ]);
+        Partner._views["form"] = `
+            <form>
+                <button name="15" type="action" class="oe_stat_button" />
+            </form>`;
+
+        await mountWithCleanup(WebClient);
+        await getService("action").doAction(6);
+        await animationFrame(); // for the webclient to react and remove the navbar
+        expect(".o_main_navbar").not.toHaveCount();
+
+        await contains("button[name='15']").click();
+        await animationFrame();
+        expect(".o_main_navbar").not.toHaveCount();
+
+        await contains(".breadcrumb li a").click();
+        await animationFrame();
+        expect(".o_main_navbar").not.toHaveCount();
+    });
+
+    test.tags("desktop");
+    test('fullscreen on action change: back to another "current" action', async () => {
+        defineActions([
+            {
+                id: 6,
+                name: "Partner",
+                res_id: 2,
+                res_model: "partner",
+                target: "current",
+                views: [[false, "form"]],
+            },
+            {
+                id: 24,
+                name: "Partner",
+                res_id: 2,
+                res_model: "partner",
+                views: [[666, "form"]],
+            },
+        ]);
+        defineMenus([
+            {
+                id: 1,
+                name: "MAIN APP",
+                actionID: 6,
+            },
+        ]);
+        Partner._views["form"] = `
+            <form>
+                <button name="24" type="action" string="Execute action 24" class="oe_stat_button"/>
+            </form>`;
+        Partner._views["form,666"] = `
+            <form>
+                <button type="action" name="15" icon="fa-star" context="{'default_partner': id}" class="oe_stat_button"/>
+            </form>`;
+
+        await mountWithCleanup(WebClient);
+        await animationFrame(); // wait for the load state (default app)
+        await animationFrame(); // wait for the action to be mounted
+        expect("nav .o_menu_brand").toHaveCount(1);
+        expect("nav .o_menu_brand").toHaveText("MAIN APP");
+
+        await contains("button[name='24']").click();
+        await animationFrame(); // wait for the webclient template to be re-rendered
+        expect("nav .o_menu_brand").toHaveCount(1);
+
+        await contains("button[name='15']").click();
+        await animationFrame(); // wait for the webclient template to be re-rendered
+        expect("nav.o_main_navbar").toHaveCount(0);
+
+        await contains(queryAll(".breadcrumb li a")[1]).click();
+        await animationFrame(); // wait for the webclient template to be re-rendered
+        expect("nav .o_menu_brand").toHaveCount(1);
+        expect("nav .o_menu_brand").toHaveText("MAIN APP");
+    });
+});
+
+describe("main", () => {
+    test.tags("desktop");
+    test('can execute act_window actions in target="main"', async () => {
+        await mountWithCleanup(WebClient);
+        await getService("action").doAction(1);
+        expect(".o_kanban_view").toHaveCount(1);
+        expect(".o_breadcrumb span").toHaveCount(1);
+        expect(".o_control_panel .o_breadcrumb").toHaveText("Partners Action 1");
+
+        await getService("action").doAction({
+            name: "Another Partner Action",
+            res_model: "partner",
+            type: "ir.actions.act_window",
+            views: [[false, "list"]],
+            target: "main",
+        });
+        expect(".o_list_view").toHaveCount(1);
+        expect(".o_breadcrumb span").toHaveCount(1);
+        expect(".o_control_panel .o_breadcrumb").toHaveText("Another Partner Action");
+    });
+
+    test.tags("desktop");
+    test('can switch view in an action in target="main"', async () => {
+        await mountWithCleanup(WebClient);
+        await getService("action").doAction({
+            name: "Partner Action",
+            res_model: "partner",
+            type: "ir.actions.act_window",
+            views: [
+                [false, "list"],
+                [false, "form"],
+            ],
+            target: "main",
+        });
+        expect(".o_list_view").toHaveCount(1);
+        expect(".o_breadcrumb span").toHaveCount(1);
+        expect(".o_control_panel .o_breadcrumb").toHaveText("Partner Action");
+
+        // open first record
+        await contains(".o_data_row .o_data_cell").click();
+        expect(".o_form_view").toHaveCount(1);
+        expect("ol.breadcrumb").toHaveCount(1);
+        expect(".o_breadcrumb span").toHaveCount(1);
+        expect(".o_control_panel .o_breadcrumb").toHaveText("Partner Action\nFirst record");
+    });
+
+    test.tags("desktop");
+    test('can restore an action in target="main"', async () => {
+        await mountWithCleanup(WebClient);
+        await getService("action").doAction({
+            name: "Partner Action",
+            res_model: "partner",
+            type: "ir.actions.act_window",
+            views: [
+                [false, "list"],
+                [false, "form"],
+            ],
+            target: "main",
+        });
+        expect(".o_list_view").toHaveCount(1);
+        expect(".o_breadcrumb span").toHaveCount(1);
+        expect(".o_control_panel .o_breadcrumb").toHaveText("Partner Action");
+
+        // open first record
+        await contains(".o_data_row .o_data_cell").click();
+        expect(".o_form_view").toHaveCount(1);
+        expect("ol.breadcrumb").toHaveCount(1);
+        expect(".o_breadcrumb span").toHaveCount(1);
+        expect(".o_control_panel .o_breadcrumb").toHaveText("Partner Action\nFirst record");
+
+        await getService("action").doAction(1);
+        expect(".o_kanban_view").toHaveCount(1);
+        expect("ol.breadcrumb").toHaveCount(1);
+        expect(".o_breadcrumb span").toHaveCount(1);
+
+        // go back to form view
+        await contains("ol.breadcrumb .o_back_button").click();
+        expect(".o_form_view").toHaveCount(1);
+        expect("ol.breadcrumb").toHaveCount(1);
+        expect(".o_breadcrumb span").toHaveCount(1);
+        expect(".o_control_panel .o_breadcrumb").toHaveText("Partner Action\nFirst record");
+    });
+});

odoo-bringout-oca-ocb-web/web/static/tests/webclient/actions/target_tests.js

@@ -1,673 +0,0 @@
-/** @odoo-module **/
-
-import testUtils from "web.test_utils";
-import core from "web.core";
-import AbstractAction from "web.AbstractAction";
-import { registry } from "@web/core/registry";
-import { click, getFixture, patchWithCleanup, makeDeferred, nextTick } from "../../helpers/utils";
-import { createWebClient, doAction, getActionManagerServerData } from "./../helpers";
-import { registerCleanup } from "../../helpers/cleanup";
-import { errorService } from "@web/core/errors/error_service";
-import { useService } from "@web/core/utils/hooks";
-import { ClientErrorDialog } from "@web/core/errors/error_dialogs";
-
-import { Component, onMounted, xml } from "@odoo/owl";
-
-let serverData;
-let target;
-
-QUnit.module("ActionManager", (hooks) => {
-    hooks.beforeEach(() => {
-        serverData = getActionManagerServerData();
-        target = getFixture();
-    });
-
-    QUnit.module('Actions in target="new"');
-
-    QUnit.test('can execute act_window actions in target="new"', async function (assert) {
-        assert.expect(8);
-        const mockRPC = async (route, args) => {
-            assert.step((args && args.method) || route);
-        };
-        const webClient = await createWebClient({ serverData, mockRPC });
-        await doAction(webClient, 5);
-        assert.containsOnce(
-            document.body,
-            ".o_technical_modal .o_form_view",
-            "should have rendered a form view in a modal"
-        );
-        assert.hasClass(
-            $(".o_technical_modal .modal-body")[0],
-            "o_act_window",
-            "dialog main element should have classname 'o_act_window'"
-        );
-        assert.containsOnce(
-            document.body,
-            ".o_technical_modal .o_form_view .o_form_editable",
-            "form view should be in edit mode"
-        );
-        assert.verifySteps([
-            "/web/webclient/load_menus",
-            "/web/action/load",
-            "get_views",
-            "onchange",
-        ]);
-    });
-
-    QUnit.test("chained action on_close", async function (assert) {
-        assert.expect(4);
-        function onClose(closeInfo) {
-            assert.strictEqual(closeInfo, "smallCandle");
-            assert.step("Close Action");
-        }
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, 5, { onClose });
-        // a target=new action shouldn't activate the on_close
-        await doAction(webClient, 5);
-        assert.verifySteps([]);
-        // An act_window_close should trigger the on_close
-        await doAction(webClient, { type: "ir.actions.act_window_close", infos: "smallCandle" });
-        assert.verifySteps(["Close Action"]);
-    });
-
-    QUnit.test("footer buttons are moved to the dialog footer", async function (assert) {
-        assert.expect(3);
-        serverData.views["partner,false,form"] = `
-            <form>
-                <field name="display_name"/>
-                <footer>
-                    <button string="Create" type="object" class="infooter"/>
-                </footer>
-            </form>
-        `;
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, 5);
-        assert.containsNone(
-            $(".o_technical_modal .modal-body")[0],
-            "button.infooter",
-            "the button should not be in the body"
-        );
-        assert.containsOnce(
-            $(".o_technical_modal .modal-footer")[0],
-            "button.infooter",
-            "the button should be in the footer"
-        );
-        assert.containsOnce(
-            target,
-            ".modal-footer button:not(.d-none)",
-            "the modal footer should only contain one visible button"
-        );
-    });
-
-    QUnit.test("Button with `close` attribute closes dialog", async function (assert) {
-        serverData.views = {
-            "partner,false,form": `
-                <form>
-                    <header>
-                        <button string="Open dialog" name="5" type="action"/>
-                    </header>
-                </form>`,
-            "partner,view_ref,form": `
-                <form>
-                    <footer>
-                        <button string="I close the dialog" name="some_method" type="object" close="1"/>
-                    </footer>
-                </form>`,
-            "partner,false,search": "<search></search>",
-        };
-        serverData.actions[4] = {
-            id: 4,
-            name: "Partners Action 4",
-            res_model: "partner",
-            type: "ir.actions.act_window",
-            views: [[false, "form"]],
-        };
-        serverData.actions[5] = {
-            id: 5,
-            name: "Create a Partner",
-            res_model: "partner",
-            target: "new",
-            type: "ir.actions.act_window",
-            views: [["view_ref", "form"]],
-        };
-        const mockRPC = async (route, args) => {
-            assert.step(route);
-            if (route === "/web/dataset/call_button" && args.method === "some_method") {
-                return {
-                    tag: "display_notification",
-                    type: "ir.actions.client",
-                };
-            }
-        };
-        const webClient = await createWebClient({ serverData, mockRPC });
-        assert.verifySteps(["/web/webclient/load_menus"]);
-        await doAction(webClient, 4);
-        assert.verifySteps([
-            "/web/action/load",
-            "/web/dataset/call_kw/partner/get_views",
-            "/web/dataset/call_kw/partner/onchange",
-        ]);
-        await testUtils.dom.click(`button[name="5"]`);
-        assert.verifySteps([
-            "/web/dataset/call_kw/partner/create",
-            "/web/dataset/call_kw/partner/read",
-            "/web/action/load",
-            "/web/dataset/call_kw/partner/get_views",
-            "/web/dataset/call_kw/partner/onchange",
-        ]);
-        assert.containsOnce(document.body, ".modal");
-        await testUtils.dom.click(`button[name="some_method"]`);
-        assert.verifySteps([
-            "/web/dataset/call_kw/partner/create",
-            "/web/dataset/call_kw/partner/read",
-            "/web/dataset/call_button",
-            "/web/dataset/call_kw/partner/read",
-        ]);
-        assert.containsNone(document.body, ".modal");
-    });
-
-    QUnit.test('on_attach_callback is called for actions in target="new"', async function (assert) {
-        assert.expect(3);
-        const ClientAction = AbstractAction.extend({
-            on_attach_callback: function () {
-                assert.step("on_attach_callback");
-                assert.containsOnce(
-                    document.body,
-                    ".modal .o_test",
-                    "should have rendered the client action in a dialog"
-                );
-            },
-            start: function () {
-                this.$el.addClass("o_test");
-            },
-        });
-        core.action_registry.add("test", ClientAction);
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, {
-            tag: "test",
-            target: "new",
-            type: "ir.actions.client",
-        });
-        assert.verifySteps(["on_attach_callback"]);
-        delete core.action_registry.map.test;
-    });
-
-    QUnit.test(
-        'footer buttons are updated when having another action in target "new"',
-        async function (assert) {
-            serverData.views["partner,false,form"] = `
-                <form>
-                    <field name="display_name"/>
-                    <footer>
-                        <button string="Create" type="object" class="infooter"/>
-                    </footer>
-                </form>
-            `;
-            const webClient = await createWebClient({ serverData });
-            await doAction(webClient, 5);
-            assert.containsNone(target, '.o_technical_modal .modal-body button[special="save"]');
-            assert.containsNone(target, ".o_technical_modal .modal-body button.infooter");
-            assert.containsOnce(target, ".o_technical_modal .modal-footer button.infooter");
-            assert.containsOnce(target, ".o_technical_modal .modal-footer button:not(.d-none)");
-            await doAction(webClient, 25);
-            assert.containsNone(target, ".o_technical_modal .modal-body button.infooter");
-            assert.containsNone(target, ".o_technical_modal .modal-footer button.infooter");
-            assert.containsNone(target, '.o_technical_modal .modal-body button[special="save"]');
-            assert.containsOnce(target, '.o_technical_modal .modal-footer button[special="save"]');
-            assert.containsOnce(target, ".o_technical_modal .modal-footer button:not(.d-none)");
-        }
-    );
-
-    QUnit.test(
-        'buttons of client action in target="new" and transition to MVC action',
-        async function (assert) {
-            const ClientAction = AbstractAction.extend({
-                renderButtons($target) {
-                    const button = document.createElement("button");
-                    button.setAttribute("class", "o_stagger_lee");
-                    $target[0].appendChild(button);
-                },
-            });
-            core.action_registry.add("test", ClientAction);
-            const webClient = await createWebClient({ serverData });
-            await doAction(webClient, {
-                tag: "test",
-                target: "new",
-                type: "ir.actions.client",
-            });
-            assert.containsOnce(target, ".modal footer button.o_stagger_lee");
-            assert.containsNone(target, '.modal footer button[special="save"]');
-            await doAction(webClient, 25);
-            assert.containsNone(target, ".modal footer button.o_stagger_lee");
-            assert.containsOnce(target, '.modal footer button[special="save"]');
-            delete core.action_registry.map.test;
-        }
-    );
-
-    QUnit.test(
-        'button with confirm attribute in act_window action in target="new"',
-        async function (assert) {
-            serverData.actions[999] = {
-                id: 999,
-                name: "A window action",
-                res_model: "partner",
-                target: "new",
-                type: "ir.actions.act_window",
-                views: [[999, "form"]],
-            };
-            serverData.views["partner,999,form"] = `
-            <form>
-                <button name="method" string="Call method" type="object" confirm="Are you sure?"/>
-            </form>`;
-            serverData.views["partner,1000,form"] = `<form>Another action</form>`;
-
-            const mockRPC = (route, args) => {
-                if (args.method === "method") {
-                    return Promise.resolve({
-                        id: 1000,
-                        name: "Another window action",
-                        res_model: "partner",
-                        target: "new",
-                        type: "ir.actions.act_window",
-                        views: [[1000, "form"]],
-                    });
-                }
-            };
-            const webClient = await createWebClient({ serverData, mockRPC });
-
-            await doAction(webClient, 999);
-
-            assert.containsOnce(document.body, ".modal button[name=method]");
-
-            await testUtils.dom.click($(".modal button[name=method]"));
-
-            assert.containsN(document.body, ".modal", 2);
-            assert.strictEqual($(".modal:last .modal-body").text(), "Are you sure?");
-
-            await testUtils.dom.click($(".modal:last .modal-footer .btn-primary"));
-            // needs two renderings to close the ConfirmationDialog:
-            //  - 1 to open the next dialog (the action in target="new")
-            //  - 1 to close the ConfirmationDialog, once the next action is executed
-            await nextTick();
-            assert.containsOnce(document.body, ".modal");
-            assert.strictEqual(
-                target.querySelector(".modal main .o_content").innerText.trim(),
-                "Another action"
-            );
-        }
-    );
-
-    QUnit.test('actions in target="new" do not update page title', async function (assert) {
-        const mockedTitleService = {
-            start() {
-                return {
-                    setParts({ action }) {
-                        if (action) {
-                            assert.step(action);
-                        }
-                    },
-                };
-            },
-        };
-        registry.category("services").add("title", mockedTitleService);
-        const webClient = await createWebClient({ serverData });
-
-        // sanity check: execute an action in target="current"
-        await doAction(webClient, 1);
-        assert.verifySteps(["Partners Action 1"]);
-
-        // execute an action in target="new"
-        await doAction(webClient, 5);
-        assert.verifySteps([]);
-    });
-
-    QUnit.test("do not commit a dialog in error", async (assert) => {
-        assert.expect(6);
-
-        const handler = (ev) => {
-            // need to preventDefault to remove error from console (so python test pass)
-            ev.preventDefault();
-        };
-        window.addEventListener("unhandledrejection", handler);
-        registerCleanup(() => window.removeEventListener("unhandledrejection", handler));
-
-        patchWithCleanup(QUnit, {
-            onUnhandledRejection: () => {},
-        });
-
-        class ErrorClientAction extends Component {
-            setup() {
-                throw new Error("my error");
-            }
-        }
-        ErrorClientAction.template = xml`<div/>`;
-        registry.category("actions").add("failing", ErrorClientAction);
-
-        class ClientActionTargetNew extends Component {}
-        ClientActionTargetNew.template = xml`<div class="my_action_new" />`;
-        registry.category("actions").add("clientActionNew", ClientActionTargetNew);
-
-        class ClientAction extends Component {
-            setup() {
-                this.action = useService("action");
-            }
-            async onClick() {
-                try {
-                    await this.action.doAction(
-                        { type: "ir.actions.client", tag: "failing", target: "new" },
-                        { onClose: () => assert.step("failing dialog closed") }
-                    );
-                } catch (e) {
-                    assert.strictEqual(e.cause.message, "my error");
-                }
-            }
-        }
-        ClientAction.template = xml`
-            <div class="my_action" t-on-click="onClick">
-                My Action
-            </div>`;
-        registry.category("actions").add("clientAction", ClientAction);
-
-        const errorDialogOpened = makeDeferred();
-        patchWithCleanup(ClientErrorDialog.prototype, {
-            setup() {
-                this._super(...arguments);
-                onMounted(() => errorDialogOpened.resolve());
-            },
-        });
-
-        registry.category("services").add("error", errorService);
-        const webClient = await createWebClient({});
-
-        await doAction(webClient, { type: "ir.actions.client", tag: "clientAction" });
-        await click(target, ".my_action");
-        await errorDialogOpened;
-
-        assert.containsOnce(target, ".modal");
-        await click(target, ".modal-body button.btn-link");
-        assert.ok(
-            target.querySelector(".modal-body .o_error_detail").textContent.includes("my error")
-        );
-
-        await click(target, ".modal-footer button");
-        assert.containsNone(target, ".modal");
-
-        await doAction(webClient, {
-            type: "ir.actions.client",
-            tag: "clientActionNew",
-            target: "new",
-        });
-        assert.containsOnce(target, ".modal .my_action_new");
-
-        assert.verifySteps([]);
-    });
-
-    QUnit.test('breadcrumbs of actions in target="new"', async function (assert) {
-        const webClient = await createWebClient({ serverData });
-
-        // execute an action in target="current"
-        await doAction(webClient, 1);
-        assert.deepEqual(
-            [...target.querySelectorAll(".breadcrumb-item")].map((i) => i.innerText),
-            ["Partners Action 1"]
-        );
-
-        // execute an action in target="new" and a list view (s.t. there is a control panel)
-        await doAction(webClient, {
-            xml_id: "action_5",
-            name: "Create a Partner",
-            res_model: "partner",
-            target: "new",
-            type: "ir.actions.act_window",
-            views: [[false, "list"]],
-        });
-        assert.containsNone(target, ".modal .breadcrumb");
-    });
-
-    QUnit.test('call switchView in an action in target="new"', async function (assert) {
-        const webClient = await createWebClient({ serverData });
-
-        // execute an action in target="current"
-        await doAction(webClient, 4);
-        assert.containsOnce(target, ".o_kanban_view");
-
-        // execute an action in target="new" and a list view (s.t. we can call switchView)
-        await doAction(webClient, {
-            xml_id: "action_5",
-            name: "Create a Partner",
-            res_model: "partner",
-            target: "new",
-            type: "ir.actions.act_window",
-            views: [[false, "list"]],
-        });
-        assert.containsOnce(target, ".modal .o_list_view");
-        assert.containsOnce(target, ".o_kanban_view");
-
-        // click on a record in the dialog -> should do nothing as we can't switch view
-        // in the dialog, and we don't want to switch view behind the dialog
-        await click(target.querySelector(".modal .o_data_row .o_data_cell"));
-        assert.containsOnce(target, ".modal .o_list_view");
-        assert.containsOnce(target, ".o_kanban_view");
-    });
-
-    QUnit.test("action with 'dialog_size' key in context", async function (assert) {
-        const action = {
-            name: "Some Action",
-            res_model: "partner",
-            type: "ir.actions.act_window",
-            target: "new",
-            views: [[false, "form"]],
-        };
-        const webClient = await createWebClient({ serverData });
-
-        await doAction(webClient, action);
-        assert.hasClass(target.querySelector(".o_dialog .modal-dialog"), "modal-lg");
-
-        await doAction(webClient, { ...action, context: { dialog_size: "small" } });
-        assert.hasClass(target.querySelector(".o_dialog .modal-dialog"), "modal-sm");
-
-        await doAction(webClient, { ...action, context: { dialog_size: "medium" } });
-        assert.hasClass(target.querySelector(".o_dialog .modal-dialog"), "modal-md");
-
-        await doAction(webClient, { ...action, context: { dialog_size: "large" } });
-        assert.hasClass(target.querySelector(".o_dialog .modal-dialog"), "modal-lg");
-
-        await doAction(webClient, { ...action, context: { dialog_size: "extra-large" } });
-        assert.hasClass(target.querySelector(".o_dialog .modal-dialog"), "modal-xl");
-    });
-
-    QUnit.test('click on record in list view action in target="new"', async function (assert) {
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, 1001);
-        await doAction(webClient, {
-            name: "Favorite Ponies",
-            res_model: "pony",
-            type: "ir.actions.act_window",
-            target: "new",
-            views: [[false, "list"], [false, "form"]],
-        });
-
-        // The list view has been opened in a dialog
-        assert.containsOnce(target, ".o_dialog .modal-dialog .o_list_view");
-
-        // click on a record in the dialog -> should do nothing as we can't switch view in the dialog
-        await click(target.querySelector(".modal .o_data_row .o_data_cell"));
-        assert.containsOnce(target, ".o_dialog .modal-dialog .o_list_view");
-        assert.containsNone(target, ".o_form_view");
-    });
-
-    QUnit.module('Actions in target="fullscreen"');
-
-    QUnit.test(
-        'correctly execute act_window actions in target="fullscreen"',
-        async function (assert) {
-            serverData.actions[1].target = "fullscreen";
-            const webClient = await createWebClient({ serverData });
-            await doAction(webClient, 1);
-            await nextTick(); // wait for the webclient template to be re-rendered
-            assert.containsOnce(target, ".o_control_panel", "should have rendered a control panel");
-            assert.containsOnce(target, ".o_kanban_view", "should have rendered a kanban view");
-            assert.containsNone(target, ".o_main_navbar");
-        }
-    );
-
-    QUnit.test('fullscreen on action change: back to a "current" action', async function (assert) {
-        serverData.actions[1].target = "fullscreen";
-        serverData.views[
-            "partner,false,form"
-        ] = `<form><button name="1" type="action" class="oe_stat_button" /></form>`;
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, 6);
-        assert.containsOnce(target, ".o_main_navbar");
-        await click(target.querySelector("button[name='1']"));
-        await nextTick(); // wait for the webclient template to be re-rendered
-        assert.containsNone(target, ".o_main_navbar");
-        await click(target.querySelector(".breadcrumb li a"));
-        await nextTick(); // wait for the webclient template to be re-rendered
-        assert.containsOnce(target, ".o_main_navbar");
-    });
-
-    QUnit.test('fullscreen on action change: all "fullscreen" actions', async function (assert) {
-        serverData.actions[6].target = "fullscreen";
-        serverData.views[
-            "partner,false,form"
-        ] = `<form><button name="1" type="action" class="oe_stat_button" /></form>`;
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, 6);
-        assert.isNotVisible(target.querySelector(".o_main_navbar"));
-        await click(target.querySelector("button[name='1']"));
-        assert.isNotVisible(target.querySelector(".o_main_navbar"));
-        await click(target.querySelector(".breadcrumb li a"));
-        assert.isNotVisible(target.querySelector(".o_main_navbar"));
-    });
-
-    QUnit.test(
-        'fullscreen on action change: back to another "current" action',
-        async function (assert) {
-            serverData.menus = {
-                root: { id: "root", children: [1], name: "root", appID: "root" },
-                1: { id: 1, children: [], name: "MAIN APP", appID: 1, actionID: 6 },
-            };
-            serverData.actions[1].target = "fullscreen";
-            serverData.views["partner,false,form"] =
-                '<form><button name="24" type="action" class="oe_stat_button"/></form>';
-            await createWebClient({ serverData });
-            await nextTick(); // wait for the load state (default app)
-            assert.containsOnce(target, "nav .o_menu_brand");
-            assert.strictEqual(target.querySelector("nav .o_menu_brand").innerText, "MAIN APP");
-            await click(target.querySelector("button[name='24']"));
-            await nextTick(); // wait for the webclient template to be re-rendered
-            assert.containsOnce(target, "nav .o_menu_brand");
-            await click(target.querySelector("button[name='1']"));
-            await nextTick(); // wait for the webclient template to be re-rendered
-            assert.containsNone(target, "nav.o_main_navbar");
-            await click(target.querySelectorAll(".breadcrumb li a")[1]);
-            await nextTick(); // wait for the webclient template to be re-rendered
-            assert.containsOnce(target, "nav .o_menu_brand");
-            assert.strictEqual(target.querySelector("nav .o_menu_brand").innerText, "MAIN APP");
-        }
-    );
-
-    QUnit.module('Actions in target="main"');
-
-    QUnit.test('can execute act_window actions in target="main"', async function (assert) {
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, 1);
-
-        assert.containsOnce(target, ".o_kanban_view");
-        assert.containsOnce(target, ".breadcrumb-item");
-        assert.strictEqual(
-            target.querySelector(".o_control_panel .breadcrumb").textContent,
-            "Partners Action 1"
-        );
-
-        await doAction(webClient, {
-            name: "Another Partner Action",
-            res_model: "partner",
-            type: "ir.actions.act_window",
-            views: [[false, "list"]],
-            target: "main",
-        });
-
-        assert.containsOnce(target, ".o_list_view");
-        assert.containsOnce(target, ".breadcrumb-item");
-        assert.strictEqual(
-            target.querySelector(".o_control_panel .breadcrumb").textContent,
-            "Another Partner Action"
-        );
-    });
-
-    QUnit.test('can switch view in an action in target="main"', async function (assert) {
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, {
-            name: "Partner Action",
-            res_model: "partner",
-            type: "ir.actions.act_window",
-            views: [
-                [false, "list"],
-                [false, "form"],
-            ],
-            target: "main",
-        });
-
-        assert.containsOnce(target, ".o_list_view");
-        assert.containsOnce(target, ".breadcrumb-item");
-        assert.strictEqual(
-            target.querySelector(".o_control_panel .breadcrumb").textContent,
-            "Partner Action"
-        );
-
-        // open first record
-        await click(target.querySelector(".o_data_row .o_data_cell"));
-
-        assert.containsOnce(target, ".o_form_view");
-        assert.containsN(target, ".breadcrumb-item", 2);
-        assert.strictEqual(
-            target.querySelector(".o_control_panel .breadcrumb").textContent,
-            "Partner ActionFirst record"
-        );
-    });
-
-    QUnit.test('can restore an action in target="main"', async function (assert) {
-        const webClient = await createWebClient({ serverData });
-        await doAction(webClient, {
-            name: "Partner Action",
-            res_model: "partner",
-            type: "ir.actions.act_window",
-            views: [
-                [false, "list"],
-                [false, "form"],
-            ],
-            target: "main",
-        });
-
-        assert.containsOnce(target, ".o_list_view");
-        assert.containsOnce(target, ".breadcrumb-item");
-        assert.strictEqual(
-            target.querySelector(".o_control_panel .breadcrumb").textContent,
-            "Partner Action"
-        );
-
-        // open first record
-        await click(target.querySelector(".o_data_row .o_data_cell"));
-        assert.containsOnce(target, ".o_form_view");
-        assert.containsN(target, ".breadcrumb-item", 2);
-        assert.strictEqual(
-            target.querySelector(".o_control_panel .breadcrumb").textContent,
-            "Partner ActionFirst record"
-        );
-
-        await doAction(webClient, 1);
-        assert.containsOnce(target, ".o_kanban_view");
-        assert.containsN(target, ".breadcrumb-item", 3);
-
-        // go back to form view
-        await click(target.querySelectorAll(".breadcrumb-item")[1]);
-        assert.containsOnce(target, ".o_form_view");
-        assert.containsN(target, ".breadcrumb-item", 2);
-        assert.strictEqual(
-            target.querySelector(".o_control_panel .breadcrumb").textContent,
-            "Partner ActionFirst record"
-        );
-    });
-});

odoo-bringout-oca-ocb-web/web/static/tests/webclient/actions/url_action.test.js

@@ -0,0 +1,61 @@
+import { expect, test } from "@odoo/hoot";
+import { getService, makeMockEnv, patchWithCleanup } from "@web/../tests/web_test_helpers";
+import { browser } from "@web/core/browser/browser";
+
+test("execute an 'ir.actions.act_url' action with target 'self'", async () => {
+    patchWithCleanup(browser.location, {
+        assign: (url) => {
+            expect.step(url);
+        },
+    });
+    await makeMockEnv();
+    await getService("action").doAction({
+        type: "ir.actions.act_url",
+        target: "self",
+        url: "/my/test/url",
+    });
+    expect.verifySteps(["/my/test/url"]);
+});
+
+test("execute an 'ir.actions.act_url' action with onClose option", async () => {
+    patchWithCleanup(browser, {
+        open: () => expect.step("browser open"),
+    });
+    await makeMockEnv();
+    const options = {
+        onClose: () => expect.step("onClose"),
+    };
+    await getService("action").doAction({ type: "ir.actions.act_url" }, options);
+    expect.verifySteps(["browser open", "onClose"]);
+});
+
+test("execute an 'ir.actions.act_url' action with url javascript:", async () => {
+    patchWithCleanup(browser.location, {
+        assign: (url) => {
+            expect.step(url);
+        },
+    });
+    await makeMockEnv();
+    await getService("action").doAction({
+        type: "ir.actions.act_url",
+        target: "self",
+        url: "javascript:alert()",
+    });
+    expect.verifySteps(["/javascript:alert()"]);
+});
+
+test("execute an 'ir.actions.act_url' action with target 'download'", async () => {
+    patchWithCleanup(browser, {
+        open: (url) => {
+            expect.step(url);
+        },
+    });
+    await makeMockEnv();
+    await getService("action").doAction({
+        type: "ir.actions.act_url",
+        target: "download",
+        url: "/my/test/url",
+    });
+    expect(".o_blockUI").toHaveCount(0);
+    expect.verifySteps(["/my/test/url"]);
+});

odoo-bringout-oca-ocb-web/web/static/tests/webclient/actions/url_action_tests.js

@@ -1,70 +0,0 @@
-/** @odoo-module **/
-
-import { registry } from "@web/core/registry";
-import { makeTestEnv } from "../../helpers/mock_env";
-import { makeFakeRouterService } from "../../helpers/mock_services";
-import { setupWebClientRegistries, doAction, getActionManagerServerData } from "./../helpers";
-import { patchWithCleanup } from "@web/../tests/helpers/utils";
-import { browser } from "@web/core/browser/browser";
-
-let serverData;
-const serviceRegistry = registry.category("services");
-
-QUnit.module("ActionManager", (hooks) => {
-    hooks.beforeEach(() => {
-        serverData = getActionManagerServerData();
-    });
-
-    QUnit.module("URL actions");
-
-    QUnit.test("execute an 'ir.actions.act_url' action with target 'self'", async (assert) => {
-        serviceRegistry.add(
-            "router",
-            makeFakeRouterService({
-                onRedirect(url) {
-                    assert.step(url);
-                },
-            })
-        );
-        setupWebClientRegistries();
-        const env = await makeTestEnv({ serverData });
-        await doAction(env, {
-            type: "ir.actions.act_url",
-            target: "self",
-            url: "/my/test/url",
-        });
-        assert.verifySteps(["/my/test/url"]);
-    });
-
-    QUnit.test("execute an 'ir.actions.act_url' action with onClose option", async (assert) => {
-        setupWebClientRegistries();
-        patchWithCleanup(browser, {
-            open: () => assert.step("browser open"),
-        });
-        const env = await makeTestEnv({ serverData });
-        const options = {
-            onClose: () => assert.step("onClose"),
-        };
-        await doAction(env, { type: "ir.actions.act_url" }, options);
-        assert.verifySteps(["browser open", "onClose"]);
-    });
-    
-    QUnit.test("execute an 'ir.actions.act_url' action with url javascript:", async (assert) => {
-        assert.expect(1);
-        serviceRegistry.add(
-            "router",
-            makeFakeRouterService({
-                onRedirect(url) {
-                    assert.strictEqual(url, "/javascript:alert()");
-                },
-            })
-        );
-        setupWebClientRegistries();
-        const env = await makeTestEnv({ serverData });
-        await doAction(env, {
-            type: "ir.actions.act_url",
-            target: "self",
-            url: "javascript:alert()",
-        });
-    });
-});