Aaron Bohy
034c075e7e
Before this rev., it crashed when trying to create records of the res.users model. This is due to commitad1cceb. The 'default_get' of 'res.users' always returns a value for field 'groups_id', whereas the docstring of 'default_get' states that it only returns default values for fields given in arguments. Rev.ad1ccebchanged a bit the way the result of 'default_get' was processed, by iterating over the values instead of over the fields in the view. So, beforead1cceb, 'groups_id' was simply ignored, and after, the BasicModel tried to process it and it crashed when it attempted to retrieve its fieldsInfo, as this field isn't in the view. This rev. restores the previous behavior. Fixes #23303 Fixes #23305
2215 lines
80 KiB
JavaScript
2215 lines
80 KiB
JavaScript
odoo.define('web.basic_model_tests', function (require) {
|
|
"use strict";
|
|
|
|
var BasicModel = require('web.BasicModel');
|
|
var testUtils = require('web.test_utils');
|
|
|
|
var createModel = testUtils.createModel;
|
|
|
|
QUnit.module('Views', {
|
|
beforeEach: function () {
|
|
this.data = {
|
|
partner: {
|
|
fields: {
|
|
display_name: {string: "STRING", type: 'char'},
|
|
total: {string: "Total", type: 'integer'},
|
|
foo: {string: "Foo", type: 'char'},
|
|
bar: {string: "Bar", type: 'integer'},
|
|
qux: {string: "Qux", type: 'many2one', relation: 'partner'},
|
|
product_id: {string: "Favorite product", type: 'many2one', relation: 'product'},
|
|
product_ids: {string: "Favorite products", type: 'one2many', relation: 'product'},
|
|
category: {string: "Category M2M", type: 'many2many', relation: 'partner_type'},
|
|
date: {string: "Date Field", type: 'date'},
|
|
reference: {string: "Reference Field", type: 'reference', selection: [["product", "Product"], ["partner_type", "Partner Type"], ["partner", "Partner"]]},
|
|
},
|
|
records: [
|
|
{id: 1, foo: 'blip', bar: 1, product_id: 37, category: [12], display_name: "first partner", date: "2017-01-25"},
|
|
{id: 2, foo: 'gnap', bar: 2, product_id: 41, display_name: "second partner"},
|
|
],
|
|
onchanges: {},
|
|
},
|
|
product: {
|
|
fields: {
|
|
name: {string: "Product Name", type: "char"}
|
|
},
|
|
records: [
|
|
{id: 37, display_name: "xphone"},
|
|
{id: 41, display_name: "xpad"}
|
|
]
|
|
},
|
|
partner_type: {
|
|
fields: {
|
|
display_name: {string: "Partner Type", type: "char"},
|
|
date: {string: "Date Field", type: 'date'},
|
|
},
|
|
records: [
|
|
{id: 12, display_name: "gold", date: "2017-01-25"},
|
|
{id: 14, display_name: "silver"},
|
|
{id: 15, display_name: "bronze"}
|
|
]
|
|
},
|
|
};
|
|
|
|
// add related fields to category.
|
|
this.data.partner.fields.category.relatedFields =
|
|
$.extend(true, {}, this.data.partner_type.fields);
|
|
this.params = {
|
|
res_id: 2,
|
|
modelName: 'partner',
|
|
fields: this.data.partner.fields,
|
|
};
|
|
}
|
|
}, function () {
|
|
QUnit.module('BasicModel');
|
|
|
|
QUnit.test('can load a record', function (assert) {
|
|
assert.expect(7);
|
|
|
|
this.params.fieldNames = ['foo'];
|
|
this.params.context = {active_field: 2};
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
assert.deepEqual(args.kwargs.context, {
|
|
active_field: 2,
|
|
bin_size: true,
|
|
someKey: 'some value',
|
|
}, "should have sent the correct context");
|
|
return this._super.apply(this, arguments);
|
|
},
|
|
session: {
|
|
user_context: {someKey: 'some value'},
|
|
}
|
|
});
|
|
|
|
assert.strictEqual(model.get(1), null, "should return null for non existing key");
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
// it is a string, because it is used as a key in an object
|
|
assert.strictEqual(typeof resultID, 'string', "result should be a valid id");
|
|
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.res_id, 2, "res_id read should be the same as asked");
|
|
assert.strictEqual(record.type, 'record', "should be of type 'record'");
|
|
assert.strictEqual(record.data.foo, "gnap", "should correctly read value");
|
|
assert.strictEqual(record.data.bar, undefined, "should not fetch the field 'bar'");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('rejects loading a record with invalid id', function (assert) {
|
|
assert.expect(1);
|
|
|
|
this.params.res_id = 99;
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
});
|
|
|
|
model.load(this.params).always(function (error) {
|
|
assert.strictEqual(this.state(), 'rejected',
|
|
"load should return a rejected deferred for an invalid id")
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('notify change with many2one', function (assert) {
|
|
assert.expect(2);
|
|
|
|
this.params.fieldNames = ['foo', 'qux'];
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.qux, false, "qux field should be false");
|
|
model.notifyChanges(resultID, {qux: {id: 1, display_name: "hello"}});
|
|
|
|
record = model.get(resultID);
|
|
assert.strictEqual(record.data.qux.data.id, 1, "qux field should be 1");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('notify change on many2one: unset and reset same value', function (assert) {
|
|
assert.expect(3);
|
|
|
|
this.data.partner.records[1].qux = 1;
|
|
|
|
this.params.fieldNames = ['qux'];
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.qux.data.id, 1, "qux value should be 1");
|
|
|
|
model.notifyChanges(resultID, {qux: false});
|
|
record = model.get(resultID);
|
|
assert.strictEqual(record.data.qux, false, "qux should be unset");
|
|
|
|
model.notifyChanges(resultID, {qux: {id: 1, display_name: 'second_partner'}});
|
|
record = model.get(resultID);
|
|
assert.strictEqual(record.data.qux.data.id, 1, "qux value should be 1 again");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('write on a many2one', function (assert) {
|
|
assert.expect(4);
|
|
var self = this;
|
|
|
|
this.params.fieldNames = ['product_id'];
|
|
|
|
var rpcCount = 0;
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
rpcCount++;
|
|
return this._super(route, args);
|
|
},
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.product_id.data.display_name, 'xpad',
|
|
"should be initialized with correct value");
|
|
|
|
model.notifyChanges(resultID, {product_id: {id: 37, display_name: 'xphone'}});
|
|
|
|
record = model.get(resultID);
|
|
assert.strictEqual(record.data.product_id.data.display_name, 'xphone',
|
|
"should be changed with correct value");
|
|
|
|
model.save(resultID);
|
|
|
|
assert.strictEqual(self.data.partner.records[1].product_id, 37,
|
|
"should have really saved the data");
|
|
assert.strictEqual(rpcCount, 3, "should have done 3 rpc: 1 read, 1 write, 1 read");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('basic onchange', function (assert) {
|
|
assert.expect(5);
|
|
|
|
this.data.partner.fields.foo.onChange = true;
|
|
this.data.partner.onchanges.foo = function (obj) {
|
|
obj.bar = obj.foo.length;
|
|
};
|
|
|
|
this.params.fieldNames = ['foo', 'bar'];
|
|
this.params.context = {hello: 'world'};
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
if (args.method === 'onchange') {
|
|
var context = args.args[4];
|
|
assert.deepEqual(context, {hello: 'world'},
|
|
"context should be sent by the onchange");
|
|
}
|
|
return this._super(route, args);
|
|
},
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.foo, 'gnap', "foo field is properly initialized");
|
|
assert.strictEqual(record.data.bar, 2, "bar field is properly initialized");
|
|
|
|
model.notifyChanges(resultID, {foo: 'mary poppins'});
|
|
|
|
record = model.get(resultID);
|
|
assert.strictEqual(record.data.foo, 'mary poppins', "onchange has been applied");
|
|
assert.strictEqual(record.data.bar, 12, "onchange has been applied");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('onchange with a many2one', function (assert) {
|
|
assert.expect(5);
|
|
|
|
this.data.partner.fields.product_id.onChange = true;
|
|
this.data.partner.onchanges.product_id = function (obj) {
|
|
if (obj.product_id === 37) {
|
|
obj.foo = "space lollipop";
|
|
}
|
|
};
|
|
|
|
this.params.fieldNames = ['foo', 'product_id'];
|
|
|
|
var rpcCount = 0;
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
if (args.method === 'onchange') {
|
|
assert.strictEqual(args.args[2], "product_id",
|
|
"should send the only changed field as a string, not a list");
|
|
}
|
|
rpcCount++;
|
|
return this._super(route, args);
|
|
},
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.foo, 'gnap', "foo field is properly initialized");
|
|
assert.strictEqual(record.data.product_id.data.id, 41, "product_id field is properly initialized");
|
|
|
|
model.notifyChanges(resultID, {product_id: {id: 37, display_name: 'xphone'}});
|
|
|
|
record = model.get(resultID);
|
|
assert.strictEqual(record.data.foo, 'space lollipop', "onchange has been applied");
|
|
assert.strictEqual(rpcCount, 2, "should have done 2 rpc: 1 read and 1 onchange");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('onchange on a one2many not in view (fieldNames)', function (assert) {
|
|
assert.expect(6);
|
|
|
|
this.data.partner.fields.foo.onChange = true;
|
|
this.data.partner.onchanges.foo = function (obj) {
|
|
obj.bar = obj.foo.length;
|
|
obj.product_ids = [];
|
|
};
|
|
|
|
this.params.fieldNames = ['foo'];
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.foo, 'gnap', "foo field is properly initialized");
|
|
assert.strictEqual(record.data.bar, undefined, "bar field is not loaded");
|
|
assert.strictEqual(record.data.product_ids, undefined, "product_ids field is not loaded");
|
|
|
|
model.notifyChanges(resultID, {foo: 'mary poppins'});
|
|
|
|
record = model.get(resultID);
|
|
assert.strictEqual(record.data.foo, 'mary poppins', "onchange has been applied");
|
|
assert.strictEqual(record.data.bar, 12, "onchange has been applied");
|
|
assert.strictEqual(record.data.product_ids, undefined,
|
|
"onchange on product_ids (one2many) has not been applied");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('notifyChange on a one2many', function (assert) {
|
|
assert.expect(9);
|
|
|
|
this.data.partner.records[1].product_ids = [37];
|
|
this.params.fieldNames = ['product_ids'];
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
if (args.method === 'name_get') {
|
|
assert.strictEqual(args.model, 'product');
|
|
}
|
|
return this._super(route, args);
|
|
},
|
|
});
|
|
|
|
var o2mParams = {
|
|
modelName: 'product',
|
|
fields: this.data.product.fields,
|
|
fieldNames: ['display_name'],
|
|
};
|
|
model.load(this.params).then(function (resultID) {
|
|
model.load(o2mParams).then(function (newRecordID) {
|
|
var record = model.get(resultID);
|
|
var x2mListID = record.data.product_ids.id;
|
|
|
|
assert.strictEqual(record.data.product_ids.count, 1,
|
|
"there should be one record in the relation");
|
|
|
|
// trigger a 'ADD' command
|
|
model.notifyChanges(resultID, {product_ids: {operation: 'ADD', id: newRecordID}});
|
|
|
|
assert.deepEqual(model.localData[x2mListID]._changes, [{
|
|
operation: 'ADD', id: newRecordID,
|
|
}], "_changes should be correct");
|
|
record = model.get(resultID);
|
|
assert.strictEqual(record.data.product_ids.count, 2,
|
|
"there should be two records in the relation");
|
|
|
|
// trigger a 'UPDATE' command
|
|
model.notifyChanges(resultID, {product_ids: {operation: 'UPDATE', id: newRecordID}});
|
|
|
|
assert.deepEqual(model.localData[x2mListID]._changes, [{
|
|
operation: 'ADD', id: newRecordID,
|
|
}, {
|
|
operation: 'UPDATE', id: newRecordID,
|
|
}], "_changes should be correct");
|
|
record = model.get(resultID);
|
|
assert.strictEqual(record.data.product_ids.count, 2,
|
|
"there should be two records in the relation");
|
|
|
|
// trigger a 'DELETE' command on the existing record
|
|
var existingRecordID = record.data.product_ids.data[0].id;
|
|
model.notifyChanges(resultID, {product_ids: {operation: 'DELETE', ids: [existingRecordID]}});
|
|
|
|
assert.deepEqual(model.localData[x2mListID]._changes, [{
|
|
operation: 'ADD', id: newRecordID,
|
|
}, {
|
|
operation: 'UPDATE', id: newRecordID,
|
|
}, {
|
|
operation: 'DELETE', id: existingRecordID,
|
|
}],
|
|
"_changes should be correct");
|
|
record = model.get(resultID);
|
|
assert.strictEqual(record.data.product_ids.count, 1,
|
|
"there should be one record in the relation");
|
|
|
|
// trigger a 'DELETE' command on the new record
|
|
model.notifyChanges(resultID, {product_ids: {operation: 'DELETE', ids: [newRecordID]}});
|
|
|
|
assert.deepEqual(model.localData[x2mListID]._changes, [{
|
|
operation: 'DELETE', id: existingRecordID,
|
|
}], "_changes should be correct");
|
|
record = model.get(resultID);
|
|
assert.strictEqual(record.data.product_ids.count, 0,
|
|
"there should be no record in the relation");
|
|
});
|
|
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('notifyChange on a many2one, without display_name', function (assert) {
|
|
assert.expect(3);
|
|
|
|
this.params.fieldNames = ['product_id'];
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
if (args.method === 'name_get') {
|
|
assert.strictEqual(args.model, 'product');
|
|
}
|
|
return this._super(route, args);
|
|
},
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.product_id.data.display_name, 'xpad',
|
|
"product_id field is set to xpad");
|
|
|
|
model.notifyChanges(resultID, {product_id: {id: 37}});
|
|
|
|
record = model.get(resultID);
|
|
assert.strictEqual(record.data.product_id.data.display_name, 'xphone',
|
|
"display_name should have been fetched");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('onchange on a char with an unchanged many2one', function (assert) {
|
|
assert.expect(2);
|
|
|
|
this.data.partner.fields.foo.onChange = true;
|
|
this.data.partner.onchanges.foo = function (obj) {
|
|
obj.foo = obj.foo + " alligator";
|
|
};
|
|
|
|
this.params.fieldNames = ['foo', 'product_id'];
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
if (args.method === 'onchange') {
|
|
assert.strictEqual(args.args[1].product_id, 41, "should send correct value");
|
|
}
|
|
return this._super(route, args);
|
|
},
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
model.notifyChanges(resultID, {foo: 'cookie'});
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.foo, 'cookie alligator', "onchange has been applied");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('onchange on a char with another many2one not set to a value', function (assert) {
|
|
assert.expect(2);
|
|
this.data.partner.records[0].product_id = false;
|
|
this.data.partner.fields.foo.onChange = true;
|
|
this.data.partner.onchanges.foo = function (obj) {
|
|
obj.foo = obj.foo + " alligator";
|
|
};
|
|
|
|
this.params.fieldNames = ['foo', 'product_id'];
|
|
this.params.res_id = 1;
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.product_id, false, "product_id is not set");
|
|
|
|
model.notifyChanges(resultID, {foo: 'cookie'});
|
|
record = model.get(resultID);
|
|
assert.strictEqual(record.data.foo, 'cookie alligator', "onchange has been applied");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('can get a many2many', function (assert) {
|
|
assert.expect(3);
|
|
|
|
this.params.res_id = 1;
|
|
this.params.fieldsInfo = {
|
|
default: {
|
|
category: {
|
|
fieldsInfo: {default: {display_name: {}}},
|
|
relatedFields: {display_name: {type: "char"}},
|
|
viewType: 'default',
|
|
},
|
|
},
|
|
};
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.category.data[0].res_id, 12,
|
|
"should have loaded many2many res_ids");
|
|
assert.strictEqual(record.data.category.data[0].data.display_name, "gold",
|
|
"should have loaded many2many display_name");
|
|
record = model.get(resultID, {raw: true});
|
|
assert.deepEqual(record.data.category, [12],
|
|
"with option raw, category should only return ids");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('can use command add and get many2many value with date field', function (assert) {
|
|
assert.expect(2);
|
|
|
|
this.params.fieldsInfo = {
|
|
default: {
|
|
category: {
|
|
fieldsInfo: {default: {date: {}}},
|
|
relatedFields: {date: {type: "date"}},
|
|
viewType: 'default',
|
|
},
|
|
},
|
|
};
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var changes = {
|
|
category: {operation: 'ADD_M2M', ids: [{id: 12}]}
|
|
};
|
|
model.notifyChanges(resultID, changes).then(function () {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.category.data.length, 1, "should have added one category");
|
|
assert.strictEqual(record.data.category.data[0].data.date instanceof moment,
|
|
true, "should have a date parsed in a moment object");
|
|
});
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('many2many with ADD_M2M command and context with parent key', function (assert) {
|
|
assert.expect(1);
|
|
|
|
this.data.partner_type.fields.some_char = {type: "char"};
|
|
this.params.fieldsInfo = {
|
|
default: {
|
|
category: {
|
|
fieldsInfo: {default: {some_char: { context: "{'a': parent.foo}"}}},
|
|
relatedFields: {some_char: {type: "char"}},
|
|
viewType: 'default',
|
|
},
|
|
foo: {},
|
|
},
|
|
};
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var changes = {
|
|
category: {operation: 'ADD_M2M', ids: [{id: 12}]}
|
|
};
|
|
model.notifyChanges(resultID, changes).then(function () {
|
|
var record = model.get(resultID);
|
|
var categoryRecord = record.data.category.data[0];
|
|
assert.deepEqual(categoryRecord.getContext({fieldName: 'some_char'}), {a:'gnap'},
|
|
"should properly evaluate context");
|
|
});
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('can fetch a list', function (assert) {
|
|
assert.expect(4);
|
|
|
|
this.params.fieldNames = ['foo'];
|
|
this.params.domain = [];
|
|
this.params.groupedBy = [];
|
|
this.params.res_id = undefined;
|
|
this.params.context = {active_field: 2};
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
assert.strictEqual(args.context.active_field, 2,
|
|
"should have sent the correct context");
|
|
return this._super(route, args);
|
|
},
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
|
|
assert.strictEqual(record.type, 'list', "record fetched should be a list");
|
|
assert.strictEqual(record.data.length, 2, "should have fetched 2 records");
|
|
assert.strictEqual(record.data[0].data.foo, 'blip', "first record should have 'blip' in foo field");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('fetch x2manys in list, with not too many rpcs', function (assert) {
|
|
assert.expect(3);
|
|
|
|
this.data.partner.records[0].category = [12, 15];
|
|
this.data.partner.records[1].category = [12, 14];
|
|
|
|
this.params.fieldNames = ['category'];
|
|
this.params.domain = [];
|
|
this.params.groupedBy = [];
|
|
this.params.res_id = undefined;
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
assert.step(route);
|
|
return this._super(route, args);
|
|
},
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
|
|
assert.strictEqual(record.data[0].data.category.data.length, 2,
|
|
"first record should have 2 categories loaded");
|
|
assert.verifySteps(["/web/dataset/search_read"],
|
|
"should have done 2 rpc (searchread and read category)");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('can make a default_record, no onchange', function (assert) {
|
|
assert.expect(5);
|
|
|
|
this.params.context = {};
|
|
this.params.fieldNames = ['product_id', 'category', 'product_ids'];
|
|
this.params.res_id = undefined;
|
|
this.params.type = 'record';
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
assert.step(args.method);
|
|
return this._super(route, args);
|
|
},
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.product_id, false, "m2o default value should be false");
|
|
assert.deepEqual(record.data.product_ids.data, [], "o2m default should be []");
|
|
assert.deepEqual(record.data.category.data, [], "m2m default should be []");
|
|
});
|
|
|
|
assert.verifySteps(['default_get'],
|
|
"there should be default_get");
|
|
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('default_get returning a non requested field', function (assert) {
|
|
// 'default_get' returns a default value for the fields given in
|
|
// arguments. It should not return a value for fields that have not be
|
|
// requested. However, it happens (e.g. res.users), and the webclient
|
|
// should not crash when this situation occurs (the field should simply
|
|
// be ignored).
|
|
assert.expect(2);
|
|
|
|
this.params.context = {};
|
|
this.params.fieldNames = ['category'];
|
|
this.params.res_id = undefined;
|
|
this.params.type = 'record';
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
var result = this._super(route, args);
|
|
if (args.method === 'default_get') {
|
|
result.product_ids = [[6, 0, [37, 41]]];
|
|
}
|
|
return result;
|
|
},
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.ok('category' in record.data,
|
|
"should have processed 'category'");
|
|
assert.notOk('product_ids' in record.data,
|
|
"should have ignored 'product_ids'");
|
|
});
|
|
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('can make a default_record with default relational values', function (assert) {
|
|
assert.expect(7);
|
|
|
|
this.data.partner.fields.product_id.default = 37;
|
|
this.data.partner.fields.product_ids.default = [
|
|
[0, false, {name: 'xmac'}],
|
|
[0, false, {name: 'xcloud'}]
|
|
];
|
|
this.data.partner.fields.category.default = [
|
|
[6, false, [12, 14]]
|
|
];
|
|
|
|
this.params.fieldNames = ['product_id', 'category', 'product_ids'];
|
|
this.params.res_id = undefined;
|
|
this.params.type = 'record';
|
|
this.params.fieldsInfo = {
|
|
form: {
|
|
category: {},
|
|
product_id: {},
|
|
product_ids: {
|
|
fieldsInfo: {
|
|
default: { name: {} },
|
|
},
|
|
relatedFields: this.data.product.fields,
|
|
viewType: 'default',
|
|
},
|
|
},
|
|
};
|
|
this.params.viewType = 'form';
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
assert.step(args.method);
|
|
return this._super(route, args);
|
|
},
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.deepEqual(record.data.product_id.data.display_name, 'xphone',
|
|
"m2o default should be xphone");
|
|
assert.deepEqual(record.data.product_ids.data.length,
|
|
2, "o2m default should have two records");
|
|
assert.deepEqual(record.data.product_ids.data[0].data.name,
|
|
'xmac', "first o2m default value should be xmac");
|
|
assert.deepEqual(record.data.category.res_ids, [12, 14],
|
|
"m2m default should be [12, 14]");
|
|
});
|
|
|
|
assert.verifySteps(['default_get', 'name_get'],
|
|
"there should be default_get and name_get");
|
|
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('default_record, with onchange on many2one', function (assert) {
|
|
assert.expect(1);
|
|
|
|
// the onchange is done by the mockRPC because we want to return a value
|
|
// of 'false', which does not work with the mockserver mockOnChange method.
|
|
this.data.partner.onchanges.product_id = true;
|
|
|
|
this.params.context = {};
|
|
this.params.fieldNames = ['product_id'];
|
|
this.params.res_id = undefined;
|
|
this.params.type = 'record';
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
if (args.method === 'onchange') {
|
|
return $.when({value: { product_id: false }});
|
|
}
|
|
return this._super(route, args);
|
|
},
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.product_id, false, "m2o default value should be false");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('default record: batch namegets on same model and res_id', function (assert) {
|
|
assert.expect(3);
|
|
|
|
var rpcCount = 0;
|
|
var fields = this.data.partner.fields;
|
|
fields.other_product_id = _.extend({}, fields.product_id);
|
|
fields.product_id.default = 37;
|
|
fields.other_product_id.default = 41;
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
rpcCount++;
|
|
return this._super(route, args);
|
|
},
|
|
});
|
|
|
|
var params = {
|
|
context: {},
|
|
fieldNames: ['other_product_id', 'product_id'],
|
|
fields: fields,
|
|
modelName: 'partner',
|
|
type: 'record',
|
|
};
|
|
|
|
model.load(params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.product_id.data.display_name, "xphone",
|
|
"should have fetched correct name");
|
|
assert.strictEqual(record.data.other_product_id.data.display_name, "xpad",
|
|
"should have fetched correct name");
|
|
assert.strictEqual(rpcCount, 2, "should have done 2 rpcs: default_get and 1 name_get");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('undoing a change makes the record not dirty', function (assert) {
|
|
assert.expect(4);
|
|
|
|
this.params.fieldNames = ['foo'];
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.foo, "gnap", "foo field should properly be set");
|
|
assert.ok(!model.isDirty(resultID), "record should not be dirty");
|
|
model.notifyChanges(resultID, {foo: "hello"});
|
|
assert.ok(model.isDirty(resultID), "record should be dirty");
|
|
model.notifyChanges(resultID, {foo: "gnap"});
|
|
assert.ok(!model.isDirty(resultID), "record should not be dirty");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('isDirty works correctly on list made empty', function (assert) {
|
|
assert.expect(3);
|
|
|
|
this.params.fieldNames = ['category'];
|
|
this.params.res_id = 1;
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
var category_value = record.data.category;
|
|
assert.ok(_.isObject(category_value), "category field should have been fetched");
|
|
assert.strictEqual(category_value.data.length, 1, "category field should contain one record");
|
|
model.notifyChanges(resultID, {category: {
|
|
operation: 'DELETE',
|
|
ids: [category_value.data[0].id],
|
|
}});
|
|
assert.ok(model.isDirty(resultID), "record should be considered dirty");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('can duplicate a record', function (assert) {
|
|
assert.expect(4);
|
|
|
|
this.params.fieldNames = ['foo'];
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.display_name, "second partner",
|
|
"record should have correct display name");
|
|
assert.strictEqual(record.data.foo, "gnap", "foo should be set to correct value");
|
|
model.duplicateRecord(resultID).then(function (duplicateID) {
|
|
var duplicate = model.get(duplicateID);
|
|
assert.strictEqual(duplicate.data.display_name, "second partner (copy)",
|
|
"record should have been duplicated");
|
|
assert.strictEqual(duplicate.data.foo, "gnap", "foo should be set to correct value");
|
|
});
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('record with many2one set to some value, then set it to none', function (assert) {
|
|
assert.expect(3);
|
|
|
|
this.params.fieldNames = ['product_id'];
|
|
|
|
var self = this;
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.product_id.data.display_name, 'xpad', "product_id should be set");
|
|
model.notifyChanges(resultID, {product_id: false});
|
|
|
|
record = model.get(resultID);
|
|
assert.strictEqual(record.data.product_id, false, "product_id should not be set");
|
|
|
|
model.save(resultID);
|
|
|
|
assert.strictEqual(self.data.partner.records[1].product_id, false,
|
|
"should have saved the new product_id value");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('internal state of groups remains when reloading', function (assert) {
|
|
assert.expect(10);
|
|
|
|
this.params.fieldNames = ['foo'];
|
|
this.params.domain = [];
|
|
this.params.limit = 80;
|
|
this.params.groupedBy = ['product_id'];
|
|
this.params.res_id = undefined;
|
|
|
|
var filterEnabled = false;
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
if (args.method === 'read_group' && filterEnabled) {
|
|
// as this is not yet supported by the MockServer, simulates
|
|
// a read_group that returns empty groups
|
|
// this is the case for several models (e.g. project.task
|
|
// grouped by stage_id)
|
|
return this._super.apply(this, arguments).then(function (result) {
|
|
// artificially filter out records of first group
|
|
result[0].product_id_count = 0;
|
|
return result;
|
|
});
|
|
}
|
|
return this._super.apply(this, arguments);
|
|
},
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.length, 2, "should have 2 groups");
|
|
var groupID = record.data[0].id;
|
|
assert.strictEqual(model.localData[groupID].parentID, resultID,
|
|
"parentID should be correctly set on groups");
|
|
|
|
model.toggleGroup(groupID);
|
|
|
|
record = model.get(resultID);
|
|
assert.ok(record.data[0].isOpen, "first group should be open");
|
|
assert.strictEqual(record.data[0].data.length, 1,
|
|
"first group should have one record");
|
|
assert.strictEqual(record.data[0].limit, 80,
|
|
"limit should be 80 by default");
|
|
|
|
// change the limit and offset of the first group
|
|
model.localData[record.data[0].id].limit = 10;
|
|
|
|
model.reload(resultID);
|
|
record = model.get(resultID);
|
|
assert.ok(record.data[0].isOpen, "first group should still be open");
|
|
assert.strictEqual(record.data[0].data.length, 1,
|
|
"first group should still have one record");
|
|
assert.strictEqual(record.data[0].limit, 10,
|
|
"new limit should have been kept");
|
|
|
|
// filter some records out: the open group should stay open but now
|
|
// be empty
|
|
filterEnabled = true;
|
|
model.reload(resultID);
|
|
record = model.get(resultID);
|
|
assert.strictEqual(record.data[0].count, 0,
|
|
"first group's count should be 0");
|
|
assert.strictEqual(record.data[0].data.length, 0,
|
|
"first group's data should be empty'");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('group on date field with magic grouping method', function (assert) {
|
|
assert.expect(1);
|
|
|
|
this.params.fieldNames = ['foo'];
|
|
this.params.groupedBy = ['date:month'];
|
|
this.params.res_id = undefined;
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
if (args.method === 'read_group') {
|
|
assert.deepEqual(args.kwargs.fields, ['foo', 'date'],
|
|
"should have correctly trimmed the magic grouping info from the field name");
|
|
}
|
|
return this._super.apply(this, arguments);
|
|
},
|
|
});
|
|
|
|
model.load(this.params);
|
|
model.destroy();
|
|
});
|
|
|
|
|
|
QUnit.test('read group when grouped by a selection field', function (assert) {
|
|
assert.expect(5);
|
|
|
|
this.data.partner.fields.selection = {
|
|
type: 'selection',
|
|
selection: [['a', 'A'], ['b', 'B']],
|
|
};
|
|
this.data.partner.records[0].selection = 'a';
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
});
|
|
var params = {
|
|
modelName: 'partner',
|
|
fields: this.data.partner.fields,
|
|
fieldNames: ['foo'],
|
|
groupedBy: ['selection'],
|
|
};
|
|
|
|
model.load(params).then(function (resultID) {
|
|
var dataPoint = model.get(resultID);
|
|
assert.strictEqual(dataPoint.data.length, 2, "should have two groups");
|
|
|
|
var groupFalse = _.findWhere(dataPoint.data, {value: false});
|
|
assert.ok(groupFalse, "should have a group for value false");
|
|
assert.deepEqual(groupFalse.domain, [['selection', '=', false]],
|
|
"group's domain should be correct");
|
|
|
|
var groupA = _.findWhere(dataPoint.data, {value: 'A'});
|
|
assert.ok(groupA, "should have a group for value 'a'");
|
|
assert.deepEqual(groupA.domain, [['selection', '=', 'a']],
|
|
"group's domain should be correct");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('create record, then save', function (assert) {
|
|
assert.expect(5);
|
|
|
|
this.params.fieldNames = ['product_ids'];
|
|
this.params.res_id = undefined;
|
|
this.params.type = 'record';
|
|
this.params.context = {active_field: 2};
|
|
|
|
var id;
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
if (args.method === 'create') {
|
|
// has to be done before the call to _super
|
|
assert.notOk('product_ids' in args.args[0], "should not have any value");
|
|
assert.notOk('category' in args.args[0], "should not have other fields");
|
|
|
|
assert.strictEqual(args.kwargs.context.active_field, 2,
|
|
"record's context should be correctly passed");
|
|
}
|
|
var result = this._super(route, args);
|
|
if (args.method === 'create') {
|
|
result.then(function (res) {
|
|
id = res;
|
|
});
|
|
}
|
|
return result;
|
|
},
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
model.save(record.id, {reload: false});
|
|
record = model.get(resultID);
|
|
assert.strictEqual(record.res_id, id, "should have correct id from server");
|
|
assert.strictEqual(record.data.id, id, "should have correct id from server");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('write commands on a one2many', function (assert) {
|
|
assert.expect(4);
|
|
|
|
this.data.partner.records[1].product_ids = [37];
|
|
|
|
this.params.fieldNames = ['product_ids'];
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
if (args.method === 'write') {
|
|
assert.deepEqual(args.args[0], [2], "should write on res_id = 2");
|
|
var commands = args.args[1].product_ids;
|
|
assert.deepEqual(commands[0], [4, 37, false], "first command should be a 4");
|
|
// TO DO: uncomment next line
|
|
// assert.strictEqual(commands[1], [0, false, {name: "toy"}], "second command should be a 0");
|
|
assert.strictEqual(commands[1][0], 0, "second command should be a 0");
|
|
}
|
|
return this._super(route, args);
|
|
},
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID, {raw: true});
|
|
assert.deepEqual(record.data.product_ids, [37], "should have correct initial value");
|
|
|
|
model.makeRecord('product', [{
|
|
name: 'name',
|
|
string: "Product Name",
|
|
type: "char",
|
|
value: "xpod"
|
|
}
|
|
]).then(function (relatedRecordID) {
|
|
model.notifyChanges(record.id, {
|
|
product_ids: {operation: "ADD", id: relatedRecordID}
|
|
});
|
|
model.save(record.id);
|
|
});
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('create commands on a one2many', function (assert) {
|
|
assert.expect(3);
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
return this._super(route, args);
|
|
},
|
|
});
|
|
|
|
this.params.fieldsInfo = {
|
|
default: {
|
|
product_ids: {
|
|
fieldsInfo: {
|
|
default: {
|
|
display_name: {type: 'string'},
|
|
}
|
|
},
|
|
viewType: 'default',
|
|
}
|
|
}
|
|
};
|
|
this.params.res_id = undefined;
|
|
this.params.type = 'record';
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.product_ids.data.length, 0,
|
|
"one2many should start with a list of length 0");
|
|
|
|
model.notifyChanges(record.id, {
|
|
product_ids: {
|
|
operation: "CREATE",
|
|
data: {
|
|
display_name: 'coucou',
|
|
},
|
|
},
|
|
});
|
|
record = model.get(resultID);
|
|
assert.strictEqual(record.data.product_ids.data.length, 1,
|
|
"one2many should be a list of length 1");
|
|
assert.strictEqual(record.data.product_ids.data[0].data.display_name, "coucou",
|
|
"one2many should have correct data");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('onchange with a one2many on a new record', function (assert) {
|
|
assert.expect(4);
|
|
|
|
this.data.partner.fields.total.default = 50;
|
|
this.data.partner.fields.product_ids.onChange = true;
|
|
this.data.partner.onchanges.product_ids = function (obj) {
|
|
obj.total += 100;
|
|
};
|
|
|
|
this.params.fieldNames = ['total', 'product_ids'];
|
|
this.params.res_id = undefined;
|
|
this.params.type = 'record';
|
|
this.params.fieldsInfo = {
|
|
form: {
|
|
product_ids: {
|
|
fieldsInfo: {
|
|
default: { name: {} },
|
|
},
|
|
relatedFields: this.data.product.fields,
|
|
viewType: 'default',
|
|
},
|
|
total: {},
|
|
},
|
|
};
|
|
this.params.viewType = 'form';
|
|
|
|
var o2mRecordParams = {
|
|
fields: this.data.product.fields,
|
|
fieldNames: ['name'],
|
|
modelName: 'product',
|
|
type: 'record',
|
|
};
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
if (args.method === 'onchange' && args.args[1].total === 150) {
|
|
assert.deepEqual(args.args[1].product_ids, [[0, args.args[1].product_ids[0][1], {name: "xpod"}]],
|
|
"Should have sent the create command in the onchange");
|
|
}
|
|
return this._super(route, args);
|
|
},
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.product_ids.data.length, 0,
|
|
"one2many should start with a list of length 0");
|
|
|
|
// make a default record for the related model
|
|
model.load(o2mRecordParams).then(function (relatedRecordID) {
|
|
// update the subrecord
|
|
model.notifyChanges(relatedRecordID, {name: 'xpod'});
|
|
// add the subrecord to the o2m of the main record
|
|
model.notifyChanges(resultID, {
|
|
product_ids: {operation: "ADD", id: relatedRecordID}
|
|
});
|
|
|
|
record = model.get(resultID);
|
|
assert.strictEqual(record.data.product_ids.data.length, 1,
|
|
"one2many should be a list of length 1");
|
|
assert.strictEqual(record.data.product_ids.data[0].data.name, "xpod",
|
|
"one2many should have correct data");
|
|
});
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('dates are properly loaded and parsed (record)', function (assert) {
|
|
assert.expect(2);
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
});
|
|
|
|
var params = {
|
|
fieldNames: ['date'],
|
|
fields: this.data.partner.fields,
|
|
modelName: 'partner',
|
|
res_id: 1,
|
|
};
|
|
|
|
model.load(params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.ok(record.data.date instanceof moment,
|
|
"fetched date field should have been formatted");
|
|
});
|
|
|
|
params.res_id = 2;
|
|
|
|
model.load(params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.date, false,
|
|
"unset date field should be false");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('dates are properly loaded and parsed (list)', function (assert) {
|
|
assert.expect(2);
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
});
|
|
|
|
var params = {
|
|
fieldNames: ['date'],
|
|
fields: this.data.partner.fields,
|
|
modelName: 'partner',
|
|
type: 'list',
|
|
};
|
|
|
|
model.load(params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
var firstRecord = record.data[0];
|
|
var secondRecord = record.data[1];
|
|
assert.ok(firstRecord.data.date instanceof moment,
|
|
"fetched date field should have been formatted");
|
|
assert.strictEqual(secondRecord.data.date, false,
|
|
"if date is not set, it should be false");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('dates are properly loaded and parsed (default_get)', function (assert) {
|
|
assert.expect(1);
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
});
|
|
|
|
var params = {
|
|
fieldNames: ['date'],
|
|
fields: this.data.partner.fields,
|
|
modelName: 'partner',
|
|
type: 'record',
|
|
};
|
|
|
|
model.load(params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.date, false, "date default value should be false");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('default_get on x2many may return a list of ids', function (assert) {
|
|
assert.expect(1);
|
|
|
|
this.data.partner.fields.category.default = [12, 14];
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
});
|
|
|
|
var params = {
|
|
fieldNames: ['category'],
|
|
fields: this.data.partner.fields,
|
|
modelName: 'partner',
|
|
type: 'record',
|
|
};
|
|
|
|
model.load(params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.ok(_.isEqual(record.data.category.res_ids, [12, 14]),
|
|
"category field should have correct default value");
|
|
});
|
|
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('default_get: fetch many2one with default (empty & not) inside x2manys', function (assert) {
|
|
assert.expect(4);
|
|
|
|
this.data.partner.fields.o2m = {
|
|
string: "O2M", type: 'one2many', relation: 'partner', default: [
|
|
[6, 0, []],
|
|
[0, 0, {category: false}],
|
|
[0, 0, {category: 12}],
|
|
],
|
|
};
|
|
this.data.partner.fields.category.type = 'many2one';
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
if (args.method === 'name_get' && args.model === 'partner_type') {
|
|
assert.deepEqual(args.args, [[12]], "should name_get on category 12");
|
|
}
|
|
return this._super(route, args);
|
|
},
|
|
});
|
|
|
|
var params = {
|
|
fieldNames: ['o2m'],
|
|
fields: this.data.partner.fields,
|
|
fieldsInfo: {
|
|
form: {
|
|
o2m: {
|
|
relatedFields: this.data.partner.fields,
|
|
fieldsInfo: {
|
|
list: {
|
|
category: {
|
|
relatedFields: { display_name: {} },
|
|
},
|
|
},
|
|
},
|
|
viewType: 'list',
|
|
},
|
|
},
|
|
},
|
|
modelName: 'partner',
|
|
type: 'record',
|
|
viewType: 'form',
|
|
};
|
|
|
|
model.load(params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.o2m.count, 2, "o2m field should contain 2 records");
|
|
assert.strictEqual(record.data.o2m.data[0].data.category, false,
|
|
"first category field should be empty");
|
|
assert.strictEqual(record.data.o2m.data[1].data.category.data.display_name, "gold",
|
|
"second category field should have been correctly fetched");
|
|
});
|
|
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('default_get: fetch x2manys inside x2manys', function (assert) {
|
|
assert.expect(3);
|
|
|
|
this.data.partner.fields.o2m = {
|
|
string: "O2M", type: 'one2many', relation: 'partner', default: [[6, 0, [1]]],
|
|
};
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
});
|
|
|
|
var params = {
|
|
fieldNames: ['o2m'],
|
|
fields: this.data.partner.fields,
|
|
fieldsInfo: {
|
|
form: {
|
|
o2m: {
|
|
relatedFields: this.data.partner.fields,
|
|
fieldsInfo: {
|
|
list: {
|
|
category: {
|
|
relatedFields: { display_name: {} },
|
|
},
|
|
},
|
|
},
|
|
viewType: 'list',
|
|
},
|
|
},
|
|
},
|
|
modelName: 'partner',
|
|
type: 'record',
|
|
viewType: 'form',
|
|
};
|
|
|
|
model.load(params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.o2m.count, 1, "o2m field should contain 1 record");
|
|
var categoryList = record.data.o2m.data[0].data.category;
|
|
assert.strictEqual(categoryList.count, 1,
|
|
"category field should contain 1 record");
|
|
assert.strictEqual(categoryList.data[0].data.display_name,
|
|
'gold', "category records should have been fetched");
|
|
});
|
|
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('contexts and domains can be properly fetched', function (assert) {
|
|
assert.expect(8);
|
|
|
|
this.data.partner.fields.product_id.context = "{'hello': 'world', 'test': foo}";
|
|
this.data.partner.fields.product_id.domain = "[['hello', 'like', 'world'], ['test', 'like', foo]]";
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
});
|
|
|
|
this.params.fieldNames = ['product_id', 'foo'];
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var recordPartner = model.get(resultID);
|
|
assert.strictEqual(typeof recordPartner.getContext, "function",
|
|
"partner record should have a getContext function");
|
|
assert.strictEqual(typeof recordPartner.getDomain, "function",
|
|
"partner record should have a getDomain function");
|
|
assert.deepEqual(recordPartner.getContext(), {},
|
|
"asking for a context without a field name should fetch the session/user/view context");
|
|
assert.deepEqual(recordPartner.getDomain(), [],
|
|
"asking for a domain without a field name should fetch the session/user/view domain");
|
|
assert.deepEqual(
|
|
recordPartner.getContext({fieldName: "product_id"}),
|
|
{hello: "world", test: "gnap"},
|
|
"asking for a context with a field name should fetch the field context (evaluated)");
|
|
assert.deepEqual(
|
|
recordPartner.getDomain({fieldName: "product_id"}),
|
|
[["hello", "like", "world"], ["test", "like", "gnap"]],
|
|
"asking for a domain with a field name should fetch the field domain (evaluated)");
|
|
});
|
|
model.destroy();
|
|
|
|
// Try again with xml override of field domain and context
|
|
model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
});
|
|
|
|
this.params.fieldsInfo = {
|
|
default: {
|
|
foo: {},
|
|
product_id: {
|
|
context: "{'hello2': 'world', 'test2': foo}",
|
|
domain: "[['hello2', 'like', 'world'], ['test2', 'like', foo]]",
|
|
},
|
|
}
|
|
};
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var recordPartner = model.get(resultID);
|
|
assert.deepEqual(
|
|
recordPartner.getContext({fieldName: "product_id"}),
|
|
{hello2: "world", test2: "gnap"},
|
|
"field context should have been overriden by xml attribute");
|
|
assert.deepEqual(
|
|
recordPartner.getDomain({fieldName: "product_id"}),
|
|
[["hello2", "like", "world"], ["test2", "like", "gnap"]],
|
|
"field domain should have been overriden by xml attribute");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('dont write on readonly fields (write and create)', function (assert) {
|
|
assert.expect(6);
|
|
|
|
this.params.fieldNames = ['foo', 'bar'];
|
|
this.data.partner.fields.foo.onChange = true;
|
|
this.data.partner.onchanges.foo = function (obj) {
|
|
obj.bar = obj.foo.length;
|
|
};
|
|
this.params.fieldsInfo = {
|
|
default: {
|
|
foo: {},
|
|
bar: {
|
|
modifiers: {
|
|
readonly: true,
|
|
},
|
|
},
|
|
}
|
|
};
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
if (args.method === 'write') {
|
|
assert.deepEqual(args.args[1], {foo: "verylongstring"},
|
|
"should only save foo field");
|
|
}
|
|
if (args.method === 'create') {
|
|
assert.deepEqual(args.args[0], {foo: "anotherverylongstring"},
|
|
"should only save foo field");
|
|
}
|
|
return this._super(route, args);
|
|
},
|
|
});
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.bar, 2,
|
|
"should be initialized with correct value");
|
|
|
|
model.notifyChanges(resultID, {foo: "verylongstring"});
|
|
|
|
record = model.get(resultID);
|
|
assert.strictEqual(record.data.bar, 14,
|
|
"should be changed with correct value");
|
|
|
|
model.save(resultID);
|
|
});
|
|
|
|
// start again, but with a new record
|
|
delete this.params.res_id;
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.bar, 0,
|
|
"should be initialized with correct value (0 as integer)");
|
|
|
|
model.notifyChanges(resultID, {foo: "anotherverylongstring"});
|
|
|
|
record = model.get(resultID);
|
|
assert.strictEqual(record.data.bar, 21,
|
|
"should be changed with correct value");
|
|
|
|
model.save(resultID);
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('dont write on readonly fields unless save attribute is set', function (assert) {
|
|
assert.expect(6);
|
|
|
|
this.params.fieldNames = ['foo', 'bar'];
|
|
this.data.partner.fields.foo.onChange = true;
|
|
this.data.partner.onchanges.foo = function (obj) {
|
|
obj.bar = obj.foo.length;
|
|
};
|
|
this.params.fieldsInfo = {
|
|
default: {
|
|
foo: {},
|
|
bar: {
|
|
modifiers: {
|
|
readonly: true,
|
|
},
|
|
force_save: true,
|
|
},
|
|
}
|
|
};
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
if (args.method === 'write') {
|
|
assert.deepEqual(args.args[1], {bar: 14, foo: "verylongstring"},
|
|
"should only save foo field");
|
|
}
|
|
if (args.method === 'create') {
|
|
assert.deepEqual(args.args[0], {bar: 21, foo: "anotherverylongstring"},
|
|
"should only save foo field");
|
|
}
|
|
return this._super(route, args);
|
|
},
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.bar, 2,
|
|
"should be initialized with correct value");
|
|
|
|
model.notifyChanges(resultID, {foo: "verylongstring"});
|
|
|
|
record = model.get(resultID);
|
|
assert.strictEqual(record.data.bar, 14,
|
|
"should be changed with correct value");
|
|
|
|
model.save(resultID);
|
|
});
|
|
|
|
// start again, but with a new record
|
|
delete this.params.res_id;
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.bar, 0,
|
|
"should be initialized with correct value (0 as integer)");
|
|
|
|
model.notifyChanges(resultID, {foo: "anotherverylongstring"});
|
|
|
|
record = model.get(resultID);
|
|
assert.strictEqual(record.data.bar, 21,
|
|
"should be changed with correct value");
|
|
|
|
model.save(resultID);
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('default_get with one2many values', function (assert) {
|
|
assert.expect(1);
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
if (args.method === 'default_get') {
|
|
return $.when({
|
|
product_ids: [[0, 0, {"name": "xdroid"}]]
|
|
});
|
|
}
|
|
return this._super(route, args);
|
|
},
|
|
});
|
|
var params = {
|
|
fieldNames: ['product_ids'],
|
|
fields: this.data.partner.fields,
|
|
modelName: 'partner',
|
|
type: 'record',
|
|
fieldsInfo: {
|
|
form: {
|
|
product_ids: {
|
|
fieldsInfo: {
|
|
default: { name: {} },
|
|
},
|
|
relatedFields: this.data.product.fields,
|
|
viewType: 'default',
|
|
},
|
|
},
|
|
},
|
|
viewType: 'form',
|
|
};
|
|
model.load(params).then(function (resultID) {
|
|
assert.strictEqual(typeof resultID, 'string', "result should be a valid id");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('call makeRecord with a pre-fetched many2one field', function (assert) {
|
|
assert.expect(3);
|
|
var rpcCount = 0;
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
rpcCount++;
|
|
return this._super(route, args);
|
|
},
|
|
});
|
|
|
|
model.makeRecord('coucou', [{
|
|
name: 'partner_id',
|
|
relation: 'partner',
|
|
type: 'many2one',
|
|
value: [1, 'first partner'],
|
|
}], {
|
|
partner_id: {
|
|
options: {
|
|
no_open: true,
|
|
},
|
|
},
|
|
}).then(function (recordID) {
|
|
var record = model.get(recordID);
|
|
assert.deepEqual(record.fieldsInfo.default.partner_id, {options: {no_open: true}},
|
|
"makeRecord should have generated the fieldsInfo");
|
|
assert.deepEqual(record.data.partner_id.data, {id: 1, display_name: 'first partner'},
|
|
"many2one should contain the partner with id 1");
|
|
assert.strictEqual(rpcCount, 0, "makeRecord should not have done any rpc");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('call makeRecord with a many2many field', function (assert) {
|
|
assert.expect(5);
|
|
var rpcCount = 0;
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
rpcCount++;
|
|
return this._super(route, args);
|
|
},
|
|
});
|
|
|
|
model.makeRecord('coucou', [{
|
|
name: 'partner_ids',
|
|
fields: [{
|
|
name: 'id',
|
|
type: 'integer',
|
|
}, {
|
|
name: 'display_name',
|
|
type: 'char',
|
|
}],
|
|
relation: 'partner',
|
|
type: 'many2many',
|
|
value: [1, 2],
|
|
}]).then(function (recordID) {
|
|
var record = model.get(recordID);
|
|
assert.deepEqual(record.fieldsInfo.default.partner_ids, {},
|
|
"makeRecord should have generated the fieldsInfo");
|
|
assert.strictEqual(record.data.partner_ids.count, 2,
|
|
"there should be 2 elements in the many2many");
|
|
assert.strictEqual(record.data.partner_ids.data.length, 2,
|
|
"many2many should be a list of length 2");
|
|
assert.deepEqual(record.data.partner_ids.data[0].data, {id: 1, display_name: 'first partner'},
|
|
"many2many should contain the partner with id 1");
|
|
assert.strictEqual(rpcCount, 1, "makeRecord should have done 1 rpc");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('call makeRecord with a pre-fetched many2many field', function (assert) {
|
|
assert.expect(5);
|
|
var rpcCount = 0;
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
rpcCount++;
|
|
return this._super(route, args);
|
|
},
|
|
});
|
|
|
|
model.makeRecord('coucou', [{
|
|
name: 'partner_ids',
|
|
fields: [{
|
|
name: 'id',
|
|
type: 'integer',
|
|
}, {
|
|
name: 'display_name',
|
|
type: 'char',
|
|
}],
|
|
relation: 'partner',
|
|
type: 'many2many',
|
|
value: [{
|
|
id: 1,
|
|
display_name: "first partner",
|
|
}, {
|
|
id: 2,
|
|
display_name: "second partner",
|
|
}],
|
|
}]).then(function (recordID) {
|
|
var record = model.get(recordID);
|
|
assert.deepEqual(record.fieldsInfo.default.partner_ids, {},
|
|
"makeRecord should have generated the fieldsInfo");
|
|
assert.strictEqual(record.data.partner_ids.count, 2,
|
|
"there should be 2 elements in the many2many");
|
|
assert.strictEqual(record.data.partner_ids.data.length, 2,
|
|
"many2many should be a list of length 2");
|
|
assert.deepEqual(record.data.partner_ids.data[0].data, {id: 1, display_name: 'first partner'},
|
|
"many2many should contain the partner with id 1");
|
|
assert.strictEqual(rpcCount, 0, "makeRecord should not have done any rpc");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('check id, active_id, active_ids, active_model values in record\'s context', function (assert) {
|
|
assert.expect(2);
|
|
|
|
this.data.partner.fields.product_id.context = "{'id': id, 'active_id': active_id, 'active_ids': active_ids, 'active_model': active_model}";
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
});
|
|
|
|
this.params.fieldNames = ['product_id'];
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var recordPartner = model.get(resultID);
|
|
assert.deepEqual(
|
|
recordPartner.getContext({fieldName: "product_id"}),
|
|
{id: 2, active_id: 2, active_ids: [2], active_model: "partner"},
|
|
"wrong values for id, active_id, active_ids or active_model");
|
|
});
|
|
|
|
// Try again without record
|
|
this.params.res_id = undefined;
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var recordPartner = model.get(resultID);
|
|
assert.deepEqual(
|
|
recordPartner.getContext({fieldName: "product_id"}),
|
|
{id: false, active_id: false, active_ids: [], active_model: "partner"},
|
|
"wrong values for id, active_id, active_ids or active_model. Have to be defined even if there is no record.");
|
|
});
|
|
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('load model with many2many field properly fetched', function (assert) {
|
|
assert.expect(2);
|
|
|
|
this.params.fieldNames = ['category'];
|
|
this.params.res_id = 1;
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
assert.step(args.method);
|
|
return this._super(route, args);
|
|
},
|
|
});
|
|
|
|
model.load(this.params);
|
|
assert.verifySteps(['read'],
|
|
"there should be only one read");
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('data should contain all fields in view, default being false', function (assert) {
|
|
assert.expect(1);
|
|
|
|
this.data.partner.fields.product_ids.default = [
|
|
[6, 0, []],
|
|
[0, 0, {name: 'new'}],
|
|
];
|
|
this.data.product.fields.date = { string: "Date", type: "date" };
|
|
|
|
var params = {
|
|
fieldNames: ['product_ids'],
|
|
modelName: 'partner',
|
|
fields: this.data.partner.fields,
|
|
fieldsInfo: {
|
|
form: {
|
|
product_ids: {
|
|
relatedFields: this.data.product.fields,
|
|
fieldsInfo: { list: { name: {}, date: {} } },
|
|
viewType: 'list',
|
|
}
|
|
},
|
|
},
|
|
res_id: undefined,
|
|
type: 'record',
|
|
viewType: 'form',
|
|
};
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
});
|
|
|
|
model.load(params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.product_ids.data[0].data.date, false,
|
|
"date value should be in data, and should be false");
|
|
});
|
|
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('changes are discarded when reloading from a new record', function (assert) {
|
|
// practical use case: click on 'Create' to open a form view in edit
|
|
// mode (new record), click on 'Discard', then open an existing record
|
|
assert.expect(2);
|
|
|
|
this.data.partner.fields.foo.default = 'default';
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
});
|
|
|
|
// load a new record (default_get)
|
|
var params = _.extend(this.params, {
|
|
res_id: undefined,
|
|
type: 'record',
|
|
fieldNames: ['foo'],
|
|
});
|
|
model.load(params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.foo, 'default',
|
|
"should be the default value");
|
|
|
|
// reload with id 2
|
|
model.reload(record.id, {currentId: 2}).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.strictEqual(record.data.foo, 'gnap',
|
|
"should be the value of record 2");
|
|
});
|
|
});
|
|
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('has a proper evaluation context', function (assert) {
|
|
assert.expect(1);
|
|
|
|
this.params.fieldNames = Object.keys(this.data.partner.fields);
|
|
this.params.res_id = 1;
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.deepEqual(record.evalContext, {
|
|
active_id: 1,
|
|
active_ids: [1],
|
|
active_model: "partner",
|
|
bar: 1,
|
|
category: [12],
|
|
current_date: moment().format('YYYY-MM-DD'),
|
|
date: "2017-01-25",
|
|
display_name: "first partner",
|
|
foo: "blip",
|
|
id: 1,
|
|
product_id: 37,
|
|
product_ids: [],
|
|
qux: false,
|
|
reference: false,
|
|
total: 0
|
|
}, "should use the proper eval context");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('x2manys in contexts and domains are correctly evaluated', function (assert) {
|
|
assert.expect(4);
|
|
|
|
this.data.partner.records[0].product_ids = [37, 41];
|
|
this.params.fieldNames = Object.keys(this.data.partner.fields);
|
|
this.params.fieldsInfo = {
|
|
form: {
|
|
qux: {
|
|
context: "{'category': category, 'product_ids': product_ids}",
|
|
domain: "[['id', 'in', category], ['id', 'in', product_ids]]",
|
|
relatedFields: this.data.partner.fields,
|
|
},
|
|
category: {
|
|
relatedFields: this.data.partner_type.fields,
|
|
},
|
|
product_ids: {
|
|
relatedFields: this.data.product.fields,
|
|
},
|
|
},
|
|
};
|
|
this.params.viewType = 'form';
|
|
this.params.res_id = 1;
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
var context = record.getContext({fieldName: 'qux'});
|
|
var domain = record.getDomain({fieldName: 'qux'});
|
|
|
|
assert.deepEqual(context, {
|
|
category: [12],
|
|
product_ids: [37, 41],
|
|
}, "x2many values in context manipulated client-side should be lists of ids");
|
|
assert.strictEqual(JSON.stringify(context),
|
|
"{\"category\":[[6,false,[12]]],\"product_ids\":[[4,37,false],[4,41,false]]}",
|
|
"x2many values in context sent to the server should be commands");
|
|
assert.deepEqual(domain, [
|
|
['id', 'in', [12]],
|
|
['id', 'in', [37, 41]],
|
|
], "x2many values in domains should be lists of ids");
|
|
assert.strictEqual(JSON.stringify(domain),
|
|
"[[\"id\",\"in\",[12]],[\"id\",\"in\",[37,41]]]",
|
|
"x2many values in domains should be lists of ids");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('fetch references in list, with not too many rpcs', function (assert) {
|
|
assert.expect(5);
|
|
|
|
this.data.partner.records[0].reference = 'product,37';
|
|
this.data.partner.records[1].reference = 'product,41';
|
|
|
|
this.params.fieldNames = ['reference'];
|
|
this.params.domain = [];
|
|
this.params.groupedBy = [];
|
|
this.params.res_id = undefined;
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
assert.step(route);
|
|
if (route === "/web/dataset/call_kw/product/name_get") {
|
|
assert.deepEqual(args.args, [[37, 41]],
|
|
"the name_get should contain the product ids");
|
|
}
|
|
return this._super(route, args);
|
|
},
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
|
|
assert.strictEqual(record.data[0].data.reference.data.display_name, "xphone",
|
|
"name_get should have been correctly fetched");
|
|
assert.verifySteps(["/web/dataset/search_read", "/web/dataset/call_kw/product/name_get"],
|
|
"should have done 2 rpc (searchread and name_get for product)");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('reload a new record', function (assert) {
|
|
assert.expect(6);
|
|
|
|
this.params.context = {};
|
|
this.params.fieldNames = ['product_id', 'category', 'product_ids'];
|
|
this.params.res_id = undefined;
|
|
this.params.type = 'record';
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route, args) {
|
|
assert.step(args.method);
|
|
return this._super(route, args);
|
|
},
|
|
});
|
|
|
|
model.load(this.params).then(function (recordID) {
|
|
model.reload(recordID).then(function (recordID) {
|
|
assert.verifySteps(['default_get', 'default_get'],
|
|
"two default_get RPCs should have been done");
|
|
var record = model.get(recordID);
|
|
assert.strictEqual(record.data.product_id, false,
|
|
"m2o default value should be false");
|
|
assert.deepEqual(record.data.product_ids.data, [],
|
|
"o2m default should be []");
|
|
assert.deepEqual(record.data.category.data, [],
|
|
"m2m default should be []");
|
|
});
|
|
});
|
|
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('default_get with value false for a one2many', function (assert) {
|
|
assert.expect(1);
|
|
|
|
this.data.partner.fields.product_ids.default = false;
|
|
this.params.fieldNames = ['product_ids'];
|
|
this.params.res_id = undefined;
|
|
this.params.type = 'record';
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
assert.deepEqual(record.data.product_ids.data, [], "o2m default should be []");
|
|
});
|
|
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('only x2many lists (static) should be sorted client-side', function (assert) {
|
|
assert.expect(1);
|
|
|
|
this.params.modelName = 'partner_type';
|
|
this.params.res_id = undefined;
|
|
this.params.orderedBy = [{name: 'display_name', asc: true}];
|
|
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
mockRPC: function (route) {
|
|
if (route === '/web/dataset/search_read') {
|
|
// simulate randomn sort form the server
|
|
return $.when({
|
|
length: 3,
|
|
records: [
|
|
{id: 12, display_name: "gold", date: "2017-01-25"},
|
|
{id: 15, display_name: "bronze"},
|
|
{id: 14, display_name: "silver"},
|
|
],
|
|
});
|
|
}
|
|
return this._super.apply(this, arguments);
|
|
},
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var list = model.get(resultID);
|
|
assert.deepEqual(_.map(list.data, 'res_id'), [12, 15, 14],
|
|
"should have kept the order from the server");
|
|
});
|
|
model.destroy();
|
|
});
|
|
|
|
QUnit.test('onchange on a boolean field', function (assert) {
|
|
assert.expect(2);
|
|
|
|
var newFields = {
|
|
foobool: {
|
|
type: 'boolean',
|
|
string: 'foobool',
|
|
},
|
|
foobool2: {
|
|
type: 'boolean',
|
|
string: 'foobool2',
|
|
},
|
|
};
|
|
_.extend(this.data.partner.fields, newFields);
|
|
|
|
this.data.partner.fields.foobool.onChange = true;
|
|
this.data.partner.onchanges.foobool = function (obj) {
|
|
if (obj.foobool) {
|
|
obj.foobool2 = true;
|
|
}
|
|
};
|
|
|
|
this.data.partner.records[0].foobool = false;
|
|
this.data.partner.records[0].foobool2 = true;
|
|
|
|
this.params.res_id = 1;
|
|
this.params.fieldNames = ['foobool', 'foobool2'];
|
|
this.params.fields = this.data.partner.fields;
|
|
var model = createModel({
|
|
Model: BasicModel,
|
|
data: this.data,
|
|
});
|
|
|
|
model.load(this.params).then(function (resultID) {
|
|
var record = model.get(resultID);
|
|
model.notifyChanges(resultID, {foobool2: false});
|
|
record = model.get(resultID);
|
|
assert.strictEqual(record.data.foobool2, false, "foobool2 field should be false");
|
|
model.notifyChanges(resultID, {foobool: true});
|
|
record = model.get(resultID);
|
|
assert.strictEqual(record.data.foobool2, true, "foobool2 field should be true");
|
|
});
|
|
model.destroy();
|
|
});
|
|
});});
|