350 lines
12 KiB
JavaScript
350 lines
12 KiB
JavaScript
$(document).ready(function () {
|
|
var $fix = $('#qunit-fixture');
|
|
|
|
var instance;
|
|
var baseSetup = function () {
|
|
instance = openerp.testing.instanceFor('list_editable');
|
|
|
|
openerp.testing.loadTemplate(instance);
|
|
|
|
openerp.testing.mockifyRPC(instance);
|
|
};
|
|
|
|
|
|
/**
|
|
*
|
|
* @param {String} name
|
|
* @param {Object} [attrs]
|
|
* @param {String} [attrs.type="char"]
|
|
* @param {Boolean} [attrs.required]
|
|
* @param {Boolean} [attrs.invisible]
|
|
* @param {Boolean} [attrs.readonly]
|
|
* @return {Object}
|
|
*/
|
|
function field(name, attrs) {
|
|
attrs = attrs || {};
|
|
attrs.name = name;
|
|
return _.defaults(attrs, {
|
|
type: 'char'
|
|
});
|
|
}
|
|
|
|
/**
|
|
* @param {Array} fields
|
|
* @return {Object}
|
|
*/
|
|
function makeFormView(fields) {
|
|
var fobj = {};
|
|
_(fields).each(function (field) {
|
|
fobj[field.name] = {
|
|
type: field.type,
|
|
string: field.string
|
|
};
|
|
});
|
|
var children = _(fields).map(function (field) {
|
|
return {
|
|
tag: 'field',
|
|
attrs: {
|
|
name: field.name,
|
|
modifiers: JSON.stringify({
|
|
required: field.required,
|
|
invisible: field.invisible,
|
|
readonly: field.readonly
|
|
})
|
|
}
|
|
}
|
|
});
|
|
return {
|
|
arch: {
|
|
tag: 'form',
|
|
attrs: {
|
|
version: '7.0',
|
|
'class': 'oe_form_container'
|
|
},
|
|
children: children
|
|
},
|
|
fields: fobj
|
|
};
|
|
}
|
|
|
|
module('editor', {
|
|
setup: baseSetup
|
|
});
|
|
asyncTest('base-state', 2, function () {
|
|
var e = new instance.web.list.Editor({
|
|
dataset: {ids: []},
|
|
edition_view: function () {
|
|
return makeFormView();
|
|
}
|
|
});
|
|
e.appendTo($fix)
|
|
.always(start)
|
|
.fail(function (error) { ok(false, error && error.message); })
|
|
.done(function () {
|
|
ok(!e.is_editing(), "should not be editing");
|
|
ok(e.form instanceof instance.web.FormView,
|
|
"should use default form type");
|
|
});
|
|
});
|
|
asyncTest('toggle-edition-save', 4, function () {
|
|
instance.session.responses['/web/dataset/call_kw:create'] = function () {
|
|
return { result: 42 };
|
|
};
|
|
instance.session.responses['/web/dataset/call_kw:read'] = function () {
|
|
return { result: [{
|
|
id: 42,
|
|
a: false,
|
|
b: false,
|
|
c: false
|
|
}]};
|
|
};
|
|
var e = new instance.web.list.Editor({
|
|
dataset: new instance.web.DataSetSearch(),
|
|
prepends_on_create: function () { return false; },
|
|
edition_view: function () {
|
|
return makeFormView([ field('a'), field('b'), field('c') ]);
|
|
}
|
|
});
|
|
var counter = 0;
|
|
e.appendTo($fix)
|
|
.pipe(function () {
|
|
return e.edit({}, function () {
|
|
++counter;
|
|
});
|
|
})
|
|
.pipe(function (form) {
|
|
ok(e.is_editing(), "should be editing");
|
|
equal(counter, 3, "should have configured all fields");
|
|
return e.save();
|
|
})
|
|
.always(start)
|
|
.fail(function (error) { ok(false, error && error.message); })
|
|
.done(function (record) {
|
|
ok(!e.is_editing(), "should have stopped editing");
|
|
equal(record.id, 42, "should have newly created id");
|
|
})
|
|
});
|
|
asyncTest('toggle-edition-cancel', 2, function () {
|
|
instance.session.responses['/web/dataset/call_kw:create'] = function () {
|
|
return { result: 42 };
|
|
};
|
|
var e = new instance.web.list.Editor({
|
|
dataset: new instance.web.DataSetSearch(),
|
|
prepends_on_create: function () { return false; },
|
|
edition_view: function () {
|
|
return makeFormView([ field('a'), field('b'), field('c') ]);
|
|
}
|
|
});
|
|
var counter = 0;
|
|
e.appendTo($fix)
|
|
.pipe(function () {
|
|
return e.edit({}, function () {
|
|
++counter;
|
|
});
|
|
})
|
|
.pipe(function (form) {
|
|
return e.cancel();
|
|
})
|
|
.always(start)
|
|
.fail(function (error) { ok(false, error && error.message); })
|
|
.done(function (record) {
|
|
ok(!e.is_editing(), "should have stopped editing");
|
|
ok(!record.id, "should have no id");
|
|
})
|
|
});
|
|
asyncTest('toggle-save-required', 2, function () {
|
|
instance.session.responses['/web/dataset/call_kw:create'] = function () {
|
|
return { result: 42 };
|
|
};
|
|
var e = new instance.web.list.Editor({
|
|
do_warn: function () {
|
|
warnings++;
|
|
},
|
|
dataset: new instance.web.DataSetSearch(),
|
|
prepends_on_create: function () { return false; },
|
|
edition_view: function () {
|
|
return makeFormView([
|
|
field('a', {required: true}), field('b'), field('c') ]);
|
|
}
|
|
});
|
|
var counter = 0;
|
|
var warnings = 0;
|
|
e.appendTo($fix)
|
|
.pipe(function () {
|
|
return e.edit({}, function () {
|
|
++counter;
|
|
});
|
|
})
|
|
.pipe(function (form) {
|
|
return e.save();
|
|
})
|
|
.always(start)
|
|
.done(function () { ok(false, "cancel should not succeed"); })
|
|
.fail(function () {
|
|
equal(warnings, 1, "should have been warned");
|
|
ok(e.is_editing(), "should have kept editing");
|
|
})
|
|
});
|
|
|
|
module('list-edition', {
|
|
setup: function () {
|
|
baseSetup();
|
|
|
|
var records = {};
|
|
_.extend(instance.session.responses, {
|
|
'/web/listview/load': function () {
|
|
return {result: {
|
|
type: 'tree',
|
|
fields: {
|
|
a: {type: 'char', string: "A"},
|
|
b: {type: 'char', string: "B"},
|
|
c: {type: 'char', string: "C"}
|
|
},
|
|
arch: {
|
|
tag: 'tree',
|
|
attrs: {},
|
|
children: [
|
|
{tag: 'field', attrs: {name: 'a'}},
|
|
{tag: 'field', attrs: {name: 'b'}},
|
|
{tag: 'field', attrs: {name: 'c'}}
|
|
]
|
|
}
|
|
}};
|
|
},
|
|
'/web/dataset/call_kw:create': function (params) {
|
|
records[42] = _.extend({}, params.params.args[0]);
|
|
return {result: 42};
|
|
},
|
|
'/web/dataset/call_kw:read': function (params) {
|
|
var id = params.params.args[0][0];
|
|
if (id in records) {
|
|
return {result: [records[id]]};
|
|
}
|
|
return {result: []};
|
|
}
|
|
})
|
|
}
|
|
});
|
|
asyncTest('newrecord', 6, function () {
|
|
var got_defaults = false;
|
|
instance.session.responses['/web/dataset/call_kw:default_get'] = function (params) {
|
|
var fields = params.params.args[0];
|
|
deepEqual(
|
|
fields, ['a', 'b', 'c'],
|
|
"should ask defaults for all fields");
|
|
got_defaults = true;
|
|
return {result: {
|
|
a: "qux",
|
|
b: "quux"
|
|
}};
|
|
};
|
|
|
|
var ds = new instance.web.DataSetStatic(null, 'demo', null, [1]);
|
|
var l = new instance.web.ListView({}, ds, false, {editable: 'top'});
|
|
|
|
l.appendTo($fix)
|
|
.pipe(l.proxy('reload_content'))
|
|
.pipe(function () {
|
|
return l.start_edition();
|
|
})
|
|
.always(start)
|
|
.pipe(function () {
|
|
ok(got_defaults, "should have fetched default values for form");
|
|
return l.save_edition();
|
|
})
|
|
.pipe(function (result) {
|
|
ok(result.created, "should yield newly created record");
|
|
equal(result.record.get('a'), "qux",
|
|
"should have used default values");
|
|
equal(result.record.get('b'), "quux",
|
|
"should have used default values");
|
|
ok(!result.record.get('c'),
|
|
"should have no value if there was no default");
|
|
})
|
|
.fail(function (e) { ok(false, e && e.message || e); });
|
|
});
|
|
|
|
module('list-edition-events', {
|
|
setup: function () {
|
|
baseSetup();
|
|
_.extend(instance.session.responses, {
|
|
'/web/listview/load': function () {
|
|
return {result: {
|
|
type: 'tree',
|
|
fields: {
|
|
a: {type: 'char', string: "A"},
|
|
b: {type: 'char', string: "B"},
|
|
c: {type: 'char', string: "C"}
|
|
},
|
|
arch: {
|
|
tag: 'tree',
|
|
attrs: {},
|
|
children: [
|
|
{tag: 'field', attrs: {name: 'a'}},
|
|
{tag: 'field', attrs: {name: 'b'}},
|
|
{tag: 'field', attrs: {name: 'c'}}
|
|
]
|
|
}
|
|
}};
|
|
},
|
|
'/web/dataset/call_kw:read': function (params) {
|
|
return {result: [{
|
|
id: 1,
|
|
a: 'foo',
|
|
b: 'bar',
|
|
c: 'baz'
|
|
}]};
|
|
}
|
|
});
|
|
}
|
|
});
|
|
asyncTest('edition events', 4, function () {
|
|
var ds = new instance.web.DataSetStatic(null, 'demo', null, [1]);
|
|
var o = {
|
|
counter: 0,
|
|
onEvent: function (e) { this.counter++; }
|
|
};
|
|
var l = new instance.web.ListView({}, ds, false, {editable: 'top'});
|
|
l.on('edit:before edit:after', o, o.onEvent);
|
|
l.appendTo($fix)
|
|
.pipe(l.proxy('reload_content'))
|
|
.always(start)
|
|
.pipe(function () {
|
|
ok(l.options.editable, "should be editable");
|
|
equal(o.counter, 0, "should have seen no event yet");
|
|
return l.start_edition(l.records.get(1));
|
|
})
|
|
.pipe(function () {
|
|
ok(l.editor.is_editing(), "should be editing");
|
|
equal(o.counter, 2, "should have seen two edition events");
|
|
})
|
|
.fail(function (e) { ok(false, e && e.message); });
|
|
});
|
|
|
|
asyncTest('edition events: cancelling', 3, function () {
|
|
var edit_after = false;
|
|
var ds = new instance.web.DataSetStatic(null, 'demo', null, [1]);
|
|
var l = new instance.web.ListView({}, ds, false, {editable: 'top'});
|
|
l.on('edit:before', {}, function (e) {
|
|
e.cancel = true;
|
|
});
|
|
l.on('edit:after', {}, function () {
|
|
edit_after = true;
|
|
});
|
|
l.appendTo($fix)
|
|
.pipe(l.proxy('reload_content'))
|
|
.always(start)
|
|
.pipe(function () {
|
|
ok(l.options.editable, "should be editable");
|
|
return l.start_edition();
|
|
})
|
|
// cancelling an event rejects the deferred
|
|
.pipe($.Deferred().reject(), function () {
|
|
ok(!l.editor.is_editing(), "should not be editing");
|
|
ok(!edit_after, "should not have fired the edit:after event");
|
|
return $.when();
|
|
})
|
|
.fail(function (e) { ok(false, e && e.message || e); });
|
|
});
|
|
});
|