Michael (mcm)
77e825cab2
This commit converts almost all odoo module by native module. The goal is to deprecate odoo.define in favor of native module and then simplify boot.js by removing the regexp that finds module dependencies. task id: 3162300 closes odoo/odoo#117456 Signed-off-by: Géry Debongnie <ged@odoo.com>
564 lines
17 KiB
JavaScript
564 lines
17 KiB
JavaScript
/** @odoo-module **/
|
|
|
|
import MockServer from "web.MockServer";
|
|
|
|
QUnit.module("Legacy MockServer", {
|
|
beforeEach() {
|
|
this.data = {
|
|
"res.partner": {
|
|
fields: {
|
|
name: {
|
|
string: "Name",
|
|
type: "string",
|
|
},
|
|
email: {
|
|
string: "Email",
|
|
type: "string",
|
|
},
|
|
active: {
|
|
string: "Active",
|
|
type: "bool",
|
|
default: true,
|
|
},
|
|
},
|
|
records: [
|
|
{ id: 1, name: "Jean-Michel", email: "jean.michel@example.com" },
|
|
{ id: 2, name: "Raoul", email: "raoul@example.com", active: false },
|
|
],
|
|
},
|
|
bar: {
|
|
fields: {
|
|
foo: {
|
|
string: "Foo",
|
|
type: "integer",
|
|
searchable: true,
|
|
group_operator: "sum",
|
|
},
|
|
date: { string: "Date", type: "date", store: true, sortable: true },
|
|
datetime: {
|
|
string: "DateTime",
|
|
type: "datetime",
|
|
store: true,
|
|
sortable: true,
|
|
},
|
|
partners: { string: "Buddies", type: "many2many", relation: "res.partner" },
|
|
},
|
|
records: [
|
|
{
|
|
id: 1,
|
|
foo: 12,
|
|
date: "2016-12-14",
|
|
datetime: "2016-12-14 12:34:56",
|
|
partners: [1, 2],
|
|
},
|
|
{
|
|
id: 2,
|
|
foo: 1,
|
|
date: "2016-10-26",
|
|
datetime: "2016-10-26 12:34:56",
|
|
partners: [1],
|
|
},
|
|
{
|
|
id: 3,
|
|
foo: 17,
|
|
date: "2016-12-15",
|
|
datetime: "2016-12-15 12:34:56",
|
|
partners: [2],
|
|
},
|
|
{ id: 4, foo: 2, date: "2016-04-11", datetime: "2016-04-11 12:34:56" },
|
|
{ id: 5, foo: 0, date: "2016-12-15", datetime: "2016-12-15 12:34:56" },
|
|
{ id: 6, foo: 42, date: "2019-12-30", datetime: "2019-12-30 12:34:56" },
|
|
],
|
|
},
|
|
};
|
|
},
|
|
}, function () {
|
|
QUnit.test("performRpc: search_read with an empty array of fields", async function (assert) {
|
|
assert.expect(1);
|
|
const server = new MockServer(this.data, {});
|
|
const result = await server.performRpc("", {
|
|
model: "res.partner",
|
|
method: "search_read",
|
|
args: [],
|
|
kwargs: {
|
|
fields: [],
|
|
},
|
|
});
|
|
const expectedFields = ["id", "email", "name", "display_name"];
|
|
assert.strictEqual(_.difference(expectedFields, Object.keys(result[0])).length, 0,
|
|
"should contains all the fields");
|
|
});
|
|
|
|
QUnit.test("performRpc: search_read without fields", async function (assert) {
|
|
assert.expect(1);
|
|
const server = new MockServer(this.data, {});
|
|
const result = await server.performRpc("", {
|
|
model: "res.partner",
|
|
method: "search_read",
|
|
args: [],
|
|
kwargs: {},
|
|
});
|
|
const expectedFields = ["id", "email", "name", "display_name"];
|
|
assert.strictEqual(_.difference(expectedFields, Object.keys(result[0])).length, 0,
|
|
"should contains all the fields");
|
|
});
|
|
|
|
QUnit.test("performRpc: name_get with no args", async function (assert) {
|
|
assert.expect(2);
|
|
const server = new MockServer(this.data, {});
|
|
try {
|
|
await server.performRpc("", {
|
|
model: "res.partner",
|
|
method: "name_get",
|
|
args: [],
|
|
kwargs: {},
|
|
});
|
|
} catch {
|
|
assert.step("name_get failed")
|
|
}
|
|
assert.verifySteps(["name_get failed"])
|
|
});
|
|
|
|
QUnit.test("performRpc: name_get with undefined arg", async function (assert) {
|
|
assert.expect(1);
|
|
const server = new MockServer(this.data, {});
|
|
const result = await server.performRpc("", {
|
|
model: "res.partner",
|
|
method: "name_get",
|
|
args: [undefined],
|
|
kwargs: {},
|
|
});
|
|
assert.deepEqual(result, [])
|
|
});
|
|
|
|
QUnit.test("performRpc: name_get with a single id", async function (assert) {
|
|
assert.expect(1);
|
|
const server = new MockServer(this.data, {});
|
|
const result = await server.performRpc("", {
|
|
model: "res.partner",
|
|
method: "name_get",
|
|
args: [1],
|
|
kwargs: {},
|
|
});
|
|
assert.deepEqual(result, [[1, "Jean-Michel"]]);
|
|
});
|
|
|
|
QUnit.test("performRpc: name_get with array of ids", async function (assert) {
|
|
assert.expect(1);
|
|
const server = new MockServer(this.data, {});
|
|
const result = await server.performRpc("", {
|
|
model: "res.partner",
|
|
method: "name_get",
|
|
args: [[1]],
|
|
kwargs: {},
|
|
});
|
|
assert.deepEqual(result, [[1, "Jean-Michel"]]);
|
|
});
|
|
|
|
QUnit.test("performRpc: name_get with invalid id", async function (assert) {
|
|
assert.expect(2);
|
|
const server = new MockServer(this.data, {});
|
|
try {
|
|
await server.performRpc("", {
|
|
model: "res.partner",
|
|
method: "name_get",
|
|
args: [11111],
|
|
kwargs: {},
|
|
});
|
|
} catch {
|
|
assert.step("name_get failed")
|
|
}
|
|
assert.verifySteps(["name_get failed"])
|
|
});
|
|
|
|
QUnit.test("performRpc: name_get with id and undefined id", async function (assert) {
|
|
assert.expect(1);
|
|
const server = new MockServer(this.data, {});
|
|
const result = await server.performRpc("", {
|
|
model: "res.partner",
|
|
method: "name_get",
|
|
args: [[undefined, 1]],
|
|
kwargs: {},
|
|
});
|
|
assert.deepEqual(result, [[null, ""], [1, "Jean-Michel"]]);
|
|
});
|
|
|
|
QUnit.test("performRpc: name_get with single id 0", async function (assert) {
|
|
assert.expect(1);
|
|
const server = new MockServer(this.data, {});
|
|
const result = await server.performRpc("", {
|
|
model: "res.partner",
|
|
method: "name_get",
|
|
args: [0],
|
|
kwargs: {},
|
|
});
|
|
assert.deepEqual(result, []);
|
|
});
|
|
|
|
QUnit.test("performRpc: name_get with array of id 0", async function (assert) {
|
|
assert.expect(1);
|
|
const server = new MockServer(this.data, {});
|
|
const result = await server.performRpc("", {
|
|
model: "res.partner",
|
|
method: "name_get",
|
|
args: [[0]],
|
|
kwargs: {},
|
|
});
|
|
assert.deepEqual(result, [[null, ""]]);
|
|
});
|
|
|
|
QUnit.test("performRpc: search with active_test=false", async function (assert) {
|
|
assert.expect(1);
|
|
const server = new MockServer(this.data, {});
|
|
const result = await server.performRpc("", {
|
|
model: "res.partner",
|
|
method: "search",
|
|
args: [[]],
|
|
kwargs: {
|
|
context: { active_test: false },
|
|
},
|
|
});
|
|
assert.deepEqual(result, [1, 2]);
|
|
});
|
|
|
|
QUnit.test("performRpc: search with active_test=true", async function (assert) {
|
|
assert.expect(1);
|
|
const server = new MockServer(this.data, {});
|
|
const result = await server.performRpc("", {
|
|
model: "res.partner",
|
|
method: "search",
|
|
args: [[]],
|
|
kwargs: {
|
|
context: { active_test: true },
|
|
},
|
|
});
|
|
assert.deepEqual(result, [1]);
|
|
});
|
|
|
|
QUnit.test("performRpc: search_read with active_test=false", async function (assert) {
|
|
assert.expect(1);
|
|
const server = new MockServer(this.data, {});
|
|
const result = await server.performRpc("", {
|
|
model: "res.partner",
|
|
method: "search_read",
|
|
args: [[]],
|
|
kwargs: {
|
|
fields: ["name"],
|
|
context: { active_test: false },
|
|
},
|
|
});
|
|
assert.deepEqual(result, [{id: 1, name: "Jean-Michel"}, {id: 2, name: "Raoul"}]);
|
|
});
|
|
|
|
QUnit.test("performRpc: search_read with active_test=true", async function (assert) {
|
|
assert.expect(1);
|
|
const server = new MockServer(this.data, {});
|
|
const result = await server.performRpc("", {
|
|
model: "res.partner",
|
|
method: "search_read",
|
|
args: [[]],
|
|
kwargs: {
|
|
fields: ["name"],
|
|
context: { active_test: true },
|
|
},
|
|
});
|
|
assert.deepEqual(result, [{id: 1, name: "Jean-Michel"}]);
|
|
});
|
|
|
|
QUnit.test("performRpc: read_group, group by date", async function (assert) {
|
|
assert.expect(10);
|
|
const server = new MockServer(this.data, {});
|
|
let result = await server.performRpc("", {
|
|
model: "bar",
|
|
method: "read_group",
|
|
args: [[]],
|
|
kwargs: {
|
|
fields: ["foo"],
|
|
domain: [],
|
|
groupby: ["date"], //Month by default
|
|
},
|
|
});
|
|
assert.deepEqual(
|
|
result.map((x) => x.date),
|
|
["December 2016", "October 2016", "April 2016", "December 2019"]
|
|
);
|
|
assert.deepEqual(
|
|
result.map((x) => x.date_count),
|
|
[3, 1, 1, 1]
|
|
);
|
|
|
|
result = await server.performRpc("", {
|
|
model: "bar",
|
|
method: "read_group",
|
|
args: [[]],
|
|
kwargs: {
|
|
fields: ["foo"],
|
|
domain: [],
|
|
groupby: ["date:day"],
|
|
},
|
|
});
|
|
assert.deepEqual(
|
|
result.map((x) => x["date:day"]),
|
|
["2016-12-14", "2016-10-26", "2016-12-15", "2016-04-11", "2019-12-30"]
|
|
);
|
|
assert.deepEqual(
|
|
result.map((x) => x.date_count),
|
|
[1, 1, 2, 1, 1]
|
|
);
|
|
|
|
result = await server.performRpc("", {
|
|
model: "bar",
|
|
method: "read_group",
|
|
args: [[]],
|
|
kwargs: {
|
|
fields: ["foo"],
|
|
domain: [],
|
|
groupby: ["date:week"],
|
|
},
|
|
});
|
|
assert.deepEqual(
|
|
result.map((x) => x["date:week"]),
|
|
["W50 2016", "W43 2016", "W15 2016", "W01 2020"]
|
|
);
|
|
assert.deepEqual(
|
|
result.map((x) => x.date_count),
|
|
[3, 1, 1, 1]
|
|
);
|
|
|
|
result = await server.performRpc("", {
|
|
model: "bar",
|
|
method: "read_group",
|
|
args: [[]],
|
|
kwargs: {
|
|
fields: ["foo"],
|
|
domain: [],
|
|
groupby: ["date:quarter"],
|
|
},
|
|
});
|
|
assert.deepEqual(
|
|
result.map((x) => x["date:quarter"]),
|
|
["Q4 2016", "Q2 2016", "Q4 2019"]
|
|
);
|
|
assert.deepEqual(
|
|
result.map((x) => x.date_count),
|
|
[4, 1, 1]
|
|
);
|
|
|
|
result = await server.performRpc("", {
|
|
model: "bar",
|
|
method: "read_group",
|
|
args: [[]],
|
|
kwargs: {
|
|
fields: ["foo"],
|
|
domain: [],
|
|
groupby: ["date:year"],
|
|
},
|
|
});
|
|
assert.deepEqual(
|
|
result.map((x) => x["date:year"]),
|
|
["2016", "2019"]
|
|
);
|
|
assert.deepEqual(
|
|
result.map((x) => x.date_count),
|
|
[5, 1]
|
|
);
|
|
});
|
|
|
|
QUnit.test("performRpc: read_group, group by datetime", async function (assert) {
|
|
const server = new MockServer(this.data, {});
|
|
let result = await server.performRpc("", {
|
|
model: "bar",
|
|
method: "read_group",
|
|
args: [[]],
|
|
kwargs: {
|
|
fields: ["foo"],
|
|
domain: [],
|
|
groupby: ["datetime"], //Month by default
|
|
},
|
|
});
|
|
assert.deepEqual(
|
|
result.map((x) => x.datetime),
|
|
["December 2016", "October 2016", "April 2016", "December 2019"]
|
|
);
|
|
assert.deepEqual(
|
|
result.map((x) => x.datetime_count),
|
|
[3, 1, 1, 1]
|
|
);
|
|
|
|
result = await server.performRpc("", {
|
|
model: "bar",
|
|
method: "read_group",
|
|
args: [[]],
|
|
kwargs: {
|
|
fields: ["foo"],
|
|
domain: [],
|
|
groupby: ["datetime:hour"],
|
|
},
|
|
});
|
|
assert.deepEqual(
|
|
result.map((x) => x["datetime:hour"]),
|
|
["12:00 14 Dec", "12:00 26 Oct", "12:00 15 Dec", "12:00 11 Apr", "12:00 30 Dec"]
|
|
);
|
|
assert.deepEqual(
|
|
result.map((x) => x.datetime_count),
|
|
[1, 1, 2, 1, 1]
|
|
);
|
|
|
|
result = await server.performRpc("", {
|
|
model: "bar",
|
|
method: "read_group",
|
|
args: [[]],
|
|
kwargs: {
|
|
fields: ["foo"],
|
|
domain: [],
|
|
groupby: ["datetime:day"],
|
|
},
|
|
});
|
|
assert.deepEqual(
|
|
result.map((x) => x["datetime:day"]),
|
|
["2016-12-14", "2016-10-26", "2016-12-15", "2016-04-11", "2019-12-30"]
|
|
);
|
|
assert.deepEqual(
|
|
result.map((x) => x.datetime_count),
|
|
[1, 1, 2, 1, 1]
|
|
);
|
|
|
|
result = await server.performRpc("", {
|
|
model: "bar",
|
|
method: "read_group",
|
|
args: [[]],
|
|
kwargs: {
|
|
fields: ["foo"],
|
|
domain: [],
|
|
groupby: ["datetime:week"],
|
|
},
|
|
});
|
|
assert.deepEqual(
|
|
result.map((x) => x["datetime:week"]),
|
|
["W50 2016", "W43 2016", "W15 2016", "W01 2020"]
|
|
);
|
|
assert.deepEqual(
|
|
result.map((x) => x.datetime_count),
|
|
[3, 1, 1, 1]
|
|
);
|
|
|
|
result = await server.performRpc("", {
|
|
model: "bar",
|
|
method: "read_group",
|
|
args: [[]],
|
|
kwargs: {
|
|
fields: ["foo"],
|
|
domain: [],
|
|
groupby: ["datetime:quarter"],
|
|
},
|
|
});
|
|
assert.deepEqual(
|
|
result.map((x) => x["datetime:quarter"]),
|
|
["Q4 2016", "Q2 2016", "Q4 2019"]
|
|
);
|
|
assert.deepEqual(
|
|
result.map((x) => x.datetime_count),
|
|
[4, 1, 1]
|
|
);
|
|
|
|
result = await server.performRpc("", {
|
|
model: "bar",
|
|
method: "read_group",
|
|
args: [[]],
|
|
kwargs: {
|
|
fields: ["foo"],
|
|
domain: [],
|
|
groupby: ["datetime:year"],
|
|
},
|
|
});
|
|
assert.deepEqual(
|
|
result.map((x) => x["datetime:year"]),
|
|
["2016", "2019"]
|
|
);
|
|
assert.deepEqual(
|
|
result.map((x) => x.datetime_count),
|
|
[5, 1]
|
|
);
|
|
});
|
|
|
|
QUnit.test("performRpc: read_group, group by m2m", async function (assert) {
|
|
const server = new MockServer(this.data, {});
|
|
const result = await server.performRpc("", {
|
|
model: "bar",
|
|
method: "read_group",
|
|
args: [[]],
|
|
kwargs: {
|
|
fields: ["partners"],
|
|
domain: [],
|
|
groupby: ["partners"],
|
|
},
|
|
});
|
|
assert.deepEqual(
|
|
result,
|
|
[
|
|
{
|
|
__domain: [["partners", "=", 1]],
|
|
partners: [1, "Jean-Michel"],
|
|
partners_count: 2,
|
|
},
|
|
{
|
|
__domain: [["partners", "=", 2]],
|
|
partners: [2, "Raoul"],
|
|
partners_count: 2,
|
|
},
|
|
{
|
|
__domain: [["partners", "=", false]],
|
|
partners: false,
|
|
partners_count: 3,
|
|
},
|
|
]
|
|
);
|
|
});
|
|
|
|
QUnit.test("performRpc: read_group, group by integer", async function (assert) {
|
|
const server = new MockServer(this.data, {});
|
|
const result = await server.performRpc("", {
|
|
model: "bar",
|
|
method: "read_group",
|
|
args: [[]],
|
|
kwargs: {
|
|
fields: ["foo"],
|
|
domain: [],
|
|
groupby: ["foo"],
|
|
},
|
|
});
|
|
assert.deepEqual(result, [
|
|
{
|
|
__domain: [["foo", "=", 12]],
|
|
foo: 12,
|
|
foo_count: 1,
|
|
},
|
|
{
|
|
__domain: [["foo", "=", 1]],
|
|
foo: 1,
|
|
foo_count: 1,
|
|
},
|
|
{
|
|
__domain: [["foo", "=", 17]],
|
|
foo: 17,
|
|
foo_count: 1,
|
|
},
|
|
{
|
|
__domain: [["foo", "=", 2]],
|
|
foo: 2,
|
|
foo_count: 1,
|
|
},
|
|
{
|
|
__domain: [["foo", "=", 0]],
|
|
foo: 0,
|
|
foo_count: 1,
|
|
},
|
|
{
|
|
__domain: [["foo", "=", 42]],
|
|
foo: 42,
|
|
foo_count: 1,
|
|
},
|
|
]);
|
|
});
|
|
});
|