401 lines
15 KiB
JavaScript
401 lines
15 KiB
JavaScript
/** @odoo-module **/
|
|
|
|
import { browser } from "@web/core/browser/browser";
|
|
import { registry } from "@web/core/registry";
|
|
import testUtils from "@web/../tests/legacy/helpers/test_utils";
|
|
import { click, getFixture, nextTick, patchWithCleanup } from "../../helpers/utils";
|
|
import { createWebClient, doAction, getActionManagerServerData } from "./../helpers";
|
|
|
|
import { Component, onMounted, 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", 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("ClientAction receives breadcrumbs and exports title", 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");
|
|
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(".o_breadcrumb").textContent,
|
|
"Favorite PoniesnewOwlTitlePartners"
|
|
);
|
|
});
|
|
|
|
QUnit.test("ClientAction receives arbitrary props from doAction", 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("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,
|
|
},
|
|
});
|
|
await nextTick(); // wait for the notification to be displayed
|
|
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",
|
|
},
|
|
],
|
|
},
|
|
});
|
|
await nextTick(); // wait for the notification to be displayed
|
|
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",
|
|
},
|
|
],
|
|
},
|
|
});
|
|
await nextTick(); // wait for the notification to be displayed
|
|
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
|
|
);
|
|
await nextTick(); // wait for the notification to be displayed
|
|
const notificationSelector = ".o_notification_manager .o_notification";
|
|
assert.containsOnce(
|
|
document.body,
|
|
notificationSelector,
|
|
"a notification should be present"
|
|
);
|
|
assert.verifySteps(["onClose"]);
|
|
});
|
|
|
|
QUnit.test("test reload client action", async function (assert) {
|
|
patchWithCleanup(browser.location, {
|
|
assign: (url) => {
|
|
assert.step(url);
|
|
},
|
|
origin: "",
|
|
hash: "#test=42",
|
|
});
|
|
|
|
const webClient = await createWebClient({ serverData });
|
|
|
|
await doAction(webClient, {
|
|
type: "ir.actions.client",
|
|
tag: "reload",
|
|
});
|
|
await doAction(webClient, {
|
|
type: "ir.actions.client",
|
|
tag: "reload",
|
|
params: {
|
|
action_id: 2,
|
|
},
|
|
});
|
|
await doAction(webClient, {
|
|
type: "ir.actions.client",
|
|
tag: "reload",
|
|
params: {
|
|
menu_id: 1,
|
|
},
|
|
});
|
|
await doAction(webClient, {
|
|
type: "ir.actions.client",
|
|
tag: "reload",
|
|
params: {
|
|
action_id: 1,
|
|
menu_id: 2,
|
|
},
|
|
});
|
|
assert.verifySteps([
|
|
"/web/tests?reload=true#test=42",
|
|
"/web/tests?reload=true#action=2",
|
|
"/web/tests?reload=true#menu_id=1",
|
|
"/web/tests?reload=true#menu_id=2&action=1",
|
|
]);
|
|
});
|
|
});
|