782 lines
28 KiB
JavaScript
782 lines
28 KiB
JavaScript
import { defineMailModels } from "@mail/../tests/mail_test_helpers";
|
|
import { beforeEach, describe, expect, test } from "@odoo/hoot";
|
|
import { queryAllTexts, queryOne } from "@odoo/hoot-dom";
|
|
import {
|
|
contains,
|
|
defineModels,
|
|
fields,
|
|
mockService,
|
|
models,
|
|
mountView,
|
|
onRpc,
|
|
serverState,
|
|
} from "@web/../tests/web_test_helpers";
|
|
import { BoardAction } from "@board/board_action";
|
|
|
|
class Board extends models.Model {}
|
|
|
|
class Partner extends models.Model {
|
|
name = fields.Char({ string: "Displayed name", searchable: true });
|
|
foo = fields.Char({
|
|
string: "Foo",
|
|
default: "My little Foo Value",
|
|
searchable: true,
|
|
});
|
|
bar = fields.Boolean({ string: "Bar" });
|
|
int_field = fields.Integer({
|
|
string: "Integer field",
|
|
aggregator: "sum",
|
|
});
|
|
|
|
_records = [
|
|
{
|
|
id: 1,
|
|
name: "first record",
|
|
foo: "yop",
|
|
int_field: 3,
|
|
},
|
|
{
|
|
id: 2,
|
|
name: "second record",
|
|
foo: "lalala",
|
|
int_field: 5,
|
|
},
|
|
{
|
|
id: 4,
|
|
name: "aaa",
|
|
foo: "abc",
|
|
int_field: 2,
|
|
},
|
|
];
|
|
|
|
_views = {
|
|
"form,100000001": "<form/>",
|
|
"search,100000002": "<search/>",
|
|
"list,4": '<list string="Partner"><field name="foo"/></list>',
|
|
};
|
|
}
|
|
|
|
defineModels([Board, Partner]);
|
|
defineMailModels();
|
|
|
|
beforeEach(() => {
|
|
BoardAction.cache = {};
|
|
});
|
|
|
|
describe.tags("desktop");
|
|
describe("board_desktop", () => {
|
|
test("display the no content helper", async () => {
|
|
await mountView({
|
|
type: "form",
|
|
resModel: "board",
|
|
arch: `
|
|
<form string="My Dashboard" js_class="board">
|
|
<board style="2-1">
|
|
<column></column>
|
|
</board>
|
|
</form>`,
|
|
});
|
|
expect(".o_view_nocontent").toHaveCount(1);
|
|
});
|
|
|
|
test("basic functionality, with one sub action", async () => {
|
|
expect.assertions(19);
|
|
onRpc("/web/action/load", () => {
|
|
expect.step("load action");
|
|
return {
|
|
res_model: "partner",
|
|
views: [[4, "list"]],
|
|
};
|
|
});
|
|
onRpc("web_search_read", (args) => {
|
|
expect(args.kwargs.domain).toEqual([["foo", "!=", "False"]], {
|
|
message: "the domain should be passed",
|
|
});
|
|
expect(args.kwargs.context.orderedBy).toEqual(
|
|
[
|
|
{
|
|
name: "foo",
|
|
asc: true,
|
|
},
|
|
],
|
|
{
|
|
message:
|
|
"orderedBy is present in the search read when specified on the custom action",
|
|
}
|
|
);
|
|
});
|
|
onRpc("/web/view/edit_custom", () => {
|
|
expect.step("edit custom");
|
|
return true;
|
|
});
|
|
onRpc("partner", "get_views", (args) => {
|
|
expect(args.kwargs.views.find((v) => v[1] === "list")).toEqual([4, "list"]);
|
|
});
|
|
await mountView({
|
|
type: "form",
|
|
resModel: "board",
|
|
arch: `
|
|
<form string="My Dashboard" js_class="board">
|
|
<board style="2-1">
|
|
<column>
|
|
<action context="{"orderedBy": [{"name": "foo", "asc": True}]}" view_mode="list" string="ABC" name="51" domain="[['foo', '!=', 'False']]"></action>
|
|
</column>
|
|
</board>
|
|
</form>`,
|
|
});
|
|
|
|
expect(".o-dashboard-header").toHaveCount(1, { message: "should have rendered a header" });
|
|
expect("div.o-dashboard-layout-2-1").toHaveCount(1, {
|
|
message: "should have rendered a div with layout",
|
|
});
|
|
expect("td.o_list_record_selector").toHaveCount(0, {
|
|
message: "td should not have a list selector",
|
|
});
|
|
expect("h3 span:contains(ABC)").toHaveCount(1, {
|
|
message: "should have rendered a header with action string",
|
|
});
|
|
expect("tr.o_data_row").toHaveCount(3, { message: "should have rendered 3 data rows" });
|
|
|
|
expect(".o-dashboard-action .o_list_view").toHaveCount(1);
|
|
|
|
await contains("h3 i.fa-window-minimize").click();
|
|
|
|
expect(".o-dashboard-action .o_list_view").toHaveCount(0);
|
|
|
|
await contains("h3 i.fa-window-maximize").click();
|
|
|
|
// content is visible again
|
|
expect(".o-dashboard-action .o_list_view").toHaveCount(1);
|
|
expect.verifySteps(["load action", "edit custom", "edit custom"]);
|
|
|
|
// header should have dropdown with correct image
|
|
expect(
|
|
".o-dashboard-header .dropdown img[data-src='/board/static/img/layout_2-1.png']"
|
|
).toHaveCount(1);
|
|
|
|
// change layout to 1-1
|
|
await contains(".o-dashboard-header .dropdown img").click();
|
|
await contains(".dropdown-item:nth-child(2)").click();
|
|
expect(
|
|
".o-dashboard-header .dropdown img[data-src='/board/static/img/layout_1-1.png']"
|
|
).toHaveCount(1);
|
|
expect("div.o-dashboard-layout-1-1").toHaveCount(1, {
|
|
message: "should have rendered a div with layout",
|
|
});
|
|
|
|
expect.verifySteps(["edit custom"]);
|
|
});
|
|
|
|
test("views in the dashboard do not have a control panel", async () => {
|
|
onRpc("/web/action/load", () => {
|
|
return {
|
|
res_model: "partner",
|
|
views: [
|
|
[4, "list"],
|
|
[5, "form"],
|
|
],
|
|
};
|
|
});
|
|
await mountView({
|
|
type: "form",
|
|
resModel: "board",
|
|
arch: `
|
|
<form string="My Dashboard" js_class="board">
|
|
<board style="2-1">
|
|
<column>
|
|
<action context="{"orderedBy": [{"name": "foo", "asc": True}]}" view_mode="list" string="ABC" name="51" domain="[['foo', '!=', 'False']]"></action>
|
|
</column>
|
|
</board>
|
|
</form>`,
|
|
});
|
|
|
|
expect(".o-dashboard-action .o_list_view").toHaveCount(1);
|
|
expect(".o-dashboard-action .o_control_panel").toHaveCount(0);
|
|
});
|
|
|
|
test("can render an action without view_mode attribute", async () => {
|
|
// The view_mode attribute is automatically set to the 'action' nodes when
|
|
// the action is added to the dashboard using the 'Add to dashboard' button
|
|
// in the searchview. However, other dashboard views can be written by hand
|
|
// (see openacademy tutorial), and in this case, we don't want hardcode
|
|
// action's params (like context or domain), as the dashboard can directly
|
|
// retrieve them from the action. Same applies for the view_type, as the
|
|
// first view of the action can be used, by default.
|
|
onRpc("/web/action/load", () => {
|
|
return {
|
|
res_model: "partner",
|
|
views: [
|
|
[4, "list"],
|
|
[false, "form"],
|
|
],
|
|
};
|
|
});
|
|
|
|
await mountView({
|
|
type: "form",
|
|
resModel: "board",
|
|
arch: `
|
|
<form string="My Dashboard" js_class="board">
|
|
<board style="2-1">
|
|
<column>
|
|
<action context="{"orderedBy": [{"name": "foo", "asc": True}]}" string="ABC" name="51" domain="[['foo', '!=', 'False']]"></action>
|
|
</column>
|
|
</board>
|
|
</form>`,
|
|
});
|
|
|
|
expect(".o-dashboard-action .o_list_view").toHaveCount(1);
|
|
});
|
|
|
|
test("can sort a sub list", async () => {
|
|
onRpc("/web/action/load", () => {
|
|
return {
|
|
res_model: "partner",
|
|
views: [[4, "list"]],
|
|
};
|
|
});
|
|
await mountView({
|
|
type: "form",
|
|
resModel: "board",
|
|
arch: `
|
|
<form string="My Dashboard" js_class="board">
|
|
<board style="2-1">
|
|
<column>
|
|
<action context="{"orderedBy": [{"name": "foo", "asc": True}]}" string="ABC" name="51" domain="[['foo', '!=', 'False']]"></action>
|
|
</column>
|
|
</board>
|
|
</form>`,
|
|
});
|
|
|
|
expect(queryAllTexts("tr.o_data_row")).toEqual(["yop", "lalala", "abc"], {
|
|
message: "should have correct initial data",
|
|
});
|
|
|
|
await contains("th.o_column_sortable:contains(Foo)").click();
|
|
expect(queryAllTexts("tr.o_data_row")).toEqual(["abc", "lalala", "yop"], {
|
|
message: "data should have been sorted",
|
|
});
|
|
});
|
|
|
|
test("can open a record", async () => {
|
|
expect.assertions(1);
|
|
mockService("action", {
|
|
doAction(action) {
|
|
expect(action).toEqual({
|
|
res_id: 1,
|
|
res_model: "partner",
|
|
type: "ir.actions.act_window",
|
|
views: [[false, "form"]],
|
|
});
|
|
return true;
|
|
},
|
|
});
|
|
onRpc("/web/action/load", () => {
|
|
return {
|
|
res_model: "partner",
|
|
views: [[4, "list"]],
|
|
};
|
|
});
|
|
await mountView({
|
|
type: "form",
|
|
resModel: "board",
|
|
arch: `
|
|
<form string="My Dashboard" js_class="board">
|
|
<board style="2-1">
|
|
<column>
|
|
<action context="{"orderedBy": [{"name": "foo", "asc": True}]}" string="ABC" name="51" domain="[['foo', '!=', 'False']]"></action>
|
|
</column>
|
|
</board>
|
|
</form>`,
|
|
});
|
|
|
|
await contains("tr.o_data_row td:contains(yop)").click();
|
|
});
|
|
|
|
test("can open record using action form view", async () => {
|
|
expect.assertions(1);
|
|
Partner._views["form,5"] = '<form string="Partner"><field name="name"/></form>';
|
|
mockService("action", {
|
|
doAction(action) {
|
|
expect(action).toEqual({
|
|
res_id: 1,
|
|
res_model: "partner",
|
|
type: "ir.actions.act_window",
|
|
views: [[5, "form"]],
|
|
});
|
|
return true;
|
|
},
|
|
});
|
|
|
|
onRpc("/web/action/load", () => {
|
|
return {
|
|
res_model: "partner",
|
|
views: [
|
|
[4, "list"],
|
|
[5, "form"],
|
|
],
|
|
};
|
|
});
|
|
|
|
await mountView({
|
|
type: "form",
|
|
resModel: "board",
|
|
arch: `
|
|
<form string="My Dashboard" js_class="board">
|
|
<board style="2-1">
|
|
<column>
|
|
<action context="{"orderedBy": [{"name": "foo", "asc": True}]}" string="ABC" name="51" domain="[['foo', '!=', 'False']]"></action>
|
|
</column>
|
|
</board>
|
|
</form>`,
|
|
});
|
|
|
|
await contains("tr.o_data_row td:contains(yop)").click();
|
|
});
|
|
|
|
test("can drag and drop a view", async () => {
|
|
onRpc("/web/action/load", () => {
|
|
return {
|
|
res_model: "partner",
|
|
views: [[4, "list"]],
|
|
};
|
|
});
|
|
onRpc("/web/view/edit_custom", () => {
|
|
expect.step("edit custom");
|
|
return true;
|
|
});
|
|
await mountView({
|
|
type: "form",
|
|
resModel: "board",
|
|
arch: `
|
|
<form string="My Dashboard" js_class="board">
|
|
<board style="2-1">
|
|
<column>
|
|
<action context="{"orderedBy": [{"name": "foo", "asc": True}]}" view_mode="list" string="ABC" name="51" domain="[['foo', '!=', 'False']]"></action>
|
|
</column>
|
|
</board>
|
|
</form>`,
|
|
});
|
|
|
|
expect('.o-dashboard-column[data-idx="0"] .o-dashboard-action').toHaveCount(1);
|
|
expect('.o-dashboard-column[data-idx="1"] .o-dashboard-action').toHaveCount(0);
|
|
|
|
await contains('.o-dashboard-column[data-idx="0"] .o-dashboard-action-header').dragAndDrop(
|
|
'.o-dashboard-column[data-idx="1"]'
|
|
);
|
|
|
|
expect('.o-dashboard-column[data-idx="0"] .o-dashboard-action').toHaveCount(0);
|
|
expect('.o-dashboard-column[data-idx="1"] .o-dashboard-action').toHaveCount(1);
|
|
expect.verifySteps(["edit custom"]);
|
|
});
|
|
|
|
test("twice the same action in a dashboard", async () => {
|
|
Partner._views["kanban,5"] = `
|
|
<kanban>
|
|
<templates>
|
|
<t t-name="card">
|
|
<field name="foo"/>
|
|
</t>
|
|
</templates>
|
|
</kanban>`;
|
|
onRpc("/web/action/load", () => {
|
|
return {
|
|
res_model: "partner",
|
|
views: [
|
|
[4, "list"],
|
|
[5, "kanban"],
|
|
],
|
|
};
|
|
});
|
|
onRpc("/web/view/edit_custom", () => {
|
|
expect.step("edit custom");
|
|
return true;
|
|
});
|
|
await mountView({
|
|
type: "form",
|
|
resModel: "board",
|
|
arch: `
|
|
<form string="My Dashboard" js_class="board">
|
|
<board style="2-1">
|
|
<column>
|
|
<action context="{}" view_mode="list" string="ABC" name="51" domain="[]"></action>
|
|
<action context="{}" view_mode="kanban" string="DEF" name="51" domain="[]"></action>
|
|
</column>
|
|
</board>
|
|
</form>`,
|
|
});
|
|
|
|
expect(".o-dashboard-action:eq(0) .o_list_view").toHaveCount(1);
|
|
expect(".o-dashboard-action:eq(1) .o_kanban_view").toHaveCount(1);
|
|
});
|
|
|
|
test("non-existing action in a dashboard", async () => {
|
|
onRpc("/web/action/load", () => {
|
|
// server answer if the action doesn't exist anymore
|
|
return false;
|
|
});
|
|
await mountView({
|
|
type: "form",
|
|
resModel: "board",
|
|
arch: `
|
|
<form string="My Dashboard" js_class="board">
|
|
<board style="2-1">
|
|
<column>
|
|
<action context="{"orderedBy": [{"name": "foo", "asc": True}]}" view_mode="list" string="ABC" name="51" domain="[['foo', '!=', 'False']]"></action>
|
|
</column>
|
|
</board>
|
|
</form>`,
|
|
});
|
|
|
|
expect("h3 span:contains(ABC)").toHaveCount(1);
|
|
expect(".o-dashboard-action div:contains(Invalid action)").toHaveCount(1);
|
|
});
|
|
|
|
test(`clicking on a kanban's button should trigger the action`, async () => {
|
|
expect.assertions(4);
|
|
Partner._views.kanban = `
|
|
<kanban>
|
|
<templates>
|
|
<t t-name="card">
|
|
<field name="foo"/>
|
|
<button name="sitting_on_a_park_bench" type="object">Eying little girls with bad intent</button>
|
|
</t>
|
|
</templates>
|
|
</kanban>`;
|
|
mockService("action", {
|
|
doActionButton(params) {
|
|
expect(params.resModel).toBe("partner");
|
|
expect(params.resId).toBe(1);
|
|
expect(params.name).toBe("sitting_on_a_park_bench");
|
|
expect(params.type).toBe("object");
|
|
},
|
|
});
|
|
onRpc("/web/action/load", () => {
|
|
return {
|
|
res_model: "partner",
|
|
view_mode: "kanban",
|
|
views: [[false, "kanban"]],
|
|
};
|
|
});
|
|
await mountView({
|
|
type: "form",
|
|
resModel: "board",
|
|
arch: `
|
|
<form string="My Dashboard" js_class="board">
|
|
<board style="2-1">
|
|
<column>
|
|
<action name="149" string="Partner" view_mode="kanban" id="action_0_1"></action>
|
|
</column>
|
|
</board>
|
|
</form>`,
|
|
});
|
|
|
|
await contains(".btn.oe_kanban_action").click();
|
|
});
|
|
|
|
test("Views should be loaded in the user's language", async () => {
|
|
expect.assertions(2);
|
|
serverState.lang = "fr_FR";
|
|
onRpc("/web/action/load", () => {
|
|
return {
|
|
res_model: "partner",
|
|
views: [[4, "list"]],
|
|
};
|
|
});
|
|
onRpc("get_views", (args) => {
|
|
expect(args.kwargs.context.lang).toBe("fr_FR");
|
|
});
|
|
await mountView({
|
|
type: "form",
|
|
resModel: "board",
|
|
arch: `
|
|
<form string="My Dashboard" js_class="board">
|
|
<board style="2-1">
|
|
<column>
|
|
<action context="{'lang': 'en_US'}" view_mode="list" string="ABC" name="51" domain="[]"></action>
|
|
</column>
|
|
</board>
|
|
</form>`,
|
|
});
|
|
});
|
|
|
|
test("Dashboard should use correct groupby", async () => {
|
|
expect.assertions(1);
|
|
onRpc("/web/action/load", () => {
|
|
return {
|
|
res_model: "partner",
|
|
views: [[4, "list"]],
|
|
};
|
|
});
|
|
onRpc("web_read_group", (args) => {
|
|
expect(args.kwargs.groupby).toEqual(["bar"]);
|
|
});
|
|
await mountView({
|
|
type: "form",
|
|
resModel: "board",
|
|
arch: `
|
|
<form string="My Dashboard" js_class="board">
|
|
<board style="2-1">
|
|
<column>
|
|
<action context="{'group_by': ['bar']}" string="ABC" name="51"></action>
|
|
</column>
|
|
</board>
|
|
</form>`,
|
|
});
|
|
});
|
|
|
|
test("Dashboard should read comparison from context", async () => {
|
|
expect.assertions(2);
|
|
Partner._views["pivot,4"] = '<pivot><field name="int_field" type="measure"/></pivot>';
|
|
onRpc("/web/action/load", () => {
|
|
return {
|
|
res_model: "partner",
|
|
views: [[4, "pivot"]],
|
|
};
|
|
});
|
|
await mountView({
|
|
type: "form",
|
|
resModel: "board",
|
|
arch: `
|
|
<form string="My Dashboard" js_class="board">
|
|
<board style="2-1">
|
|
<column>
|
|
<action
|
|
name="356"
|
|
string="Sales Analysis pivot"
|
|
view_mode="pivot"
|
|
context="{
|
|
'comparison': {
|
|
'fieldName': 'date',
|
|
'domains': [
|
|
{
|
|
'arrayRepr': [],
|
|
'description': 'February 2023',
|
|
},
|
|
{
|
|
'arrayRepr': [],
|
|
'description': 'January 2023',
|
|
},
|
|
]
|
|
},
|
|
}"
|
|
/>
|
|
</column>
|
|
</board>
|
|
</form>`,
|
|
});
|
|
expect(".o_pivot_origin_row:eq(0)").toHaveText("January 2023");
|
|
expect(".o_pivot_origin_row:eq(1)").toHaveText("February 2023");
|
|
});
|
|
|
|
test("Dashboard should use correct groupby when defined as a string of one field", async () => {
|
|
expect.assertions(1);
|
|
onRpc("/web/action/load", () => {
|
|
return {
|
|
res_model: "partner",
|
|
views: [[4, "list"]],
|
|
};
|
|
});
|
|
onRpc("web_read_group", ({ kwargs }) => {
|
|
expect(kwargs.groupby).toEqual(["bar"]);
|
|
});
|
|
await mountView({
|
|
type: "form",
|
|
resModel: "board",
|
|
arch: `
|
|
<form string="My Dashboard" js_class="board">
|
|
<board style="2-1">
|
|
<column>
|
|
<action context="{'group_by': 'bar'}" string="ABC" name="51"></action>
|
|
</column>
|
|
</board>
|
|
</form>`,
|
|
});
|
|
});
|
|
|
|
test("click on a cell of pivot view inside dashboard", async () => {
|
|
Partner._views["pivot,4"] = '<pivot><field name="int_field" type="measure"/></pivot>';
|
|
mockService("action", {
|
|
doAction(action) {
|
|
expect.step("do action");
|
|
expect(action.views).toEqual([
|
|
[false, "list"],
|
|
[false, "form"],
|
|
]);
|
|
},
|
|
});
|
|
|
|
onRpc("/web/action/load", () => {
|
|
return {
|
|
res_model: "partner",
|
|
views: [[4, "pivot"]],
|
|
};
|
|
});
|
|
onRpc("web_read_group", (args) => {
|
|
expect(args.kwargs.groupby).toEqual(["bar"]);
|
|
});
|
|
|
|
await mountView({
|
|
type: "form",
|
|
resModel: "board",
|
|
arch: `
|
|
<form string="My Dashboard" js_class="board">
|
|
<board style="2-1">
|
|
<column>
|
|
<action view_mode="pivot" string="ABC" name="51"></action>
|
|
</column>
|
|
</board>
|
|
</form>`,
|
|
});
|
|
|
|
expect.verifySteps([]);
|
|
|
|
await contains(".o_pivot_view .o_pivot_cell_value").click();
|
|
|
|
expect.verifySteps(["do action"]);
|
|
});
|
|
|
|
test("graphs in dashboard aren't squashed", async () => {
|
|
Partner._views["graph,4"] = '<graph><field name="int_field" type="measure"/></graph>';
|
|
onRpc("/web/action/load", () => {
|
|
return {
|
|
res_model: "partner",
|
|
views: [[4, "graph"]],
|
|
};
|
|
});
|
|
await mountView({
|
|
type: "form",
|
|
resModel: "board",
|
|
arch: `
|
|
<form string="My Dashboard" js_class="board">
|
|
<board style="2-1">
|
|
<column>
|
|
<action string="ABC" name="51"></action>
|
|
</column>
|
|
</board>
|
|
</form>`,
|
|
});
|
|
|
|
expect(".o-dashboard-action .o_graph_renderer").toHaveCount(1);
|
|
expect(queryOne(".o-dashboard-action .o_graph_renderer canvas").offsetHeight).toBe(300);
|
|
});
|
|
|
|
test("pivot view with property in pivot_column_groupby", async function () {
|
|
Partner._views["pivot,false"] = `<pivot/>`;
|
|
Partner._fields.properties_definition = fields.PropertiesDefinition();
|
|
Partner._fields.properties_definition = fields.PropertiesDefinition();
|
|
Partner._fields.parent_id = fields.Many2one({ relation: "partner" });
|
|
Partner._fields.properties = fields.Properties({
|
|
definition_record: "parent_id",
|
|
definition_record_field: "properties_definition",
|
|
});
|
|
onRpc("/web/action/load", () => ({
|
|
res_model: "partner",
|
|
views: [[false, "pivot"]],
|
|
}));
|
|
onRpc(({ method, kwargs }) => {
|
|
if (method === "get_property_definition") {
|
|
return {};
|
|
} else if (method === "read_group" && kwargs.groupby?.includes("properties.my_char")) {
|
|
return [
|
|
{
|
|
"properties.my_char": false,
|
|
__domain: [["properties.my_char", "=", false]],
|
|
__count: 2,
|
|
},
|
|
{
|
|
"properties.my_char": "aaa",
|
|
__domain: [["properties.my_char", "=", "aaa"]],
|
|
__count: 1,
|
|
},
|
|
];
|
|
}
|
|
});
|
|
await mountView({
|
|
type: "form",
|
|
resModel: "board",
|
|
arch: `
|
|
<form js_class="board">
|
|
<board style="2-1">
|
|
<column>
|
|
<action context="{'pivot_column_groupby':['properties.my_char']}"/>
|
|
</column>
|
|
</board>
|
|
</form>`,
|
|
});
|
|
expect(queryAllTexts(".o_pivot_cell_value div")).toEqual(["2", "1", "3"]);
|
|
});
|
|
});
|
|
|
|
describe.tags("mobile");
|
|
describe("board_mobile", () => {
|
|
test("can't switch views in the dashboard", async () => {
|
|
Partner._views["list,4"] = '<list string="Partner"><field name="foo"/></list>';
|
|
|
|
onRpc("/web/action/load", () => {
|
|
return {
|
|
res_model: "partner",
|
|
views: [[4, "list"]],
|
|
};
|
|
});
|
|
await mountView({
|
|
type: "form",
|
|
resModel: "board",
|
|
arch: `
|
|
<form string="My Dashboard" js_class="board">
|
|
<board style="2-1">
|
|
<column>
|
|
<action context="{"orderedBy": [{"name": "foo", "asc": True}]}" view_mode="list" string="ABC" name="51" domain="[['foo', '!=', 'False']]"></action>
|
|
</column>
|
|
</board>
|
|
</form>`,
|
|
});
|
|
|
|
expect(".o-dashboard-header").toHaveCount(0, {
|
|
message: "Couldn't allow user to Change layout",
|
|
});
|
|
expect(".o-dashboard-layout-1").toHaveCount(1, {
|
|
message: "The display layout is force to 1",
|
|
});
|
|
expect(".o-dashboard-action .o_control_panel").not.toBeVisible();
|
|
expect(".o-dashboard-action-header .fa-close").toHaveCount(0, {
|
|
message: "Should not have a close action button",
|
|
});
|
|
});
|
|
|
|
test("Correctly soft switch to '1' layout on small screen", async () => {
|
|
Partner._views["list,4"] = '<list string="Partner"><field name="foo"/></list>';
|
|
|
|
onRpc("/web/action/load", () => {
|
|
return {
|
|
res_model: "partner",
|
|
views: [[4, "list"]],
|
|
};
|
|
});
|
|
await mountView({
|
|
type: "form",
|
|
resModel: "board",
|
|
arch: `
|
|
<form string="My Dashboard" js_class="board">
|
|
<board style="2-1">
|
|
<column>
|
|
<action context="{"orderedBy": [{"name": "foo", "asc": True}]}" view_mode="list" string="ABC" name="51" domain="[['foo', '!=', 'False']]"></action>
|
|
</column>
|
|
<column>
|
|
<action context="{"orderedBy": [{"name": "foo", "asc": True}]}" view_mode="list" string="ABC" name="51" domain="[['foo', '!=', 'False']]"></action>
|
|
</column>
|
|
</board>
|
|
</form>`,
|
|
});
|
|
expect(".o-dashboard-layout-1").toHaveCount(1, {
|
|
message: "The display layout is force to 1",
|
|
});
|
|
expect(".o-dashboard-column").toHaveCount(1, {
|
|
message: "The display layout is force to 1 column",
|
|
});
|
|
expect(".o-dashboard-action").toHaveCount(2, {
|
|
message: "The display should contains the 2 actions",
|
|
});
|
|
});
|
|
});
|