566 lines
18 KiB
JavaScript
566 lines
18 KiB
JavaScript
odoo.define('web.mockserver_tests', function (require) {
|
|
"use strict";
|
|
|
|
const MockServer = require("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 (_error) {
|
|
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 (_error) {
|
|
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,
|
|
},
|
|
]);
|
|
});
|
|
});
|
|
});
|