Géry Debongnie
b960f8ad52
The test suite needs to be adapted to the modules. Also, the update of qunit changes the API, so the tests needs to be changed as well.
473 lines
15 KiB
JavaScript
473 lines
15 KiB
JavaScript
odoo.define_section('list.events', ['web.list_common'], function (test) {
|
|
|
|
test('Simple event triggering', function (assert, list_common) {
|
|
var e = Object.create(list_common.Events),
|
|
passed = false;
|
|
|
|
e.bind('foo', function () { passed = true; });
|
|
e.trigger('foo');
|
|
|
|
assert.ok(passed);
|
|
});
|
|
|
|
test('Bind all', function (assert, list_common) {
|
|
var e = Object.create(list_common.Events),
|
|
event = null;
|
|
e.bind(null, function (ev) { event = ev; });
|
|
e.trigger('foo');
|
|
|
|
assert.strictEqual(event, 'foo');
|
|
});
|
|
|
|
test('Propagate trigger params', function (assert, list_common) {
|
|
var e = Object.create(list_common.Events),
|
|
p = false;
|
|
|
|
e.bind(null, function (_, param) { p = param; });
|
|
e.trigger('foo', true);
|
|
|
|
assert.strictEqual(p, true);
|
|
});
|
|
|
|
test('Bind multiple callbacks', function (assert, list_common) {
|
|
var e = Object.create(list_common.Events),
|
|
count;
|
|
|
|
e.bind('foo', function () { count++; })
|
|
.bind('bar', function () { count++; })
|
|
.bind(null, function () { count++; })
|
|
.bind('foo', function () { count++; })
|
|
.bind(null, function () { count++; })
|
|
.bind(null, function () { count++; });
|
|
|
|
count = 0;
|
|
e.trigger('foo');
|
|
assert.strictEqual(count, 5);
|
|
|
|
count = 0;
|
|
e.trigger('bar');
|
|
assert.strictEqual(count, 4);
|
|
|
|
count = 0;
|
|
e.trigger('baz');
|
|
assert.strictEqual(count, 3);
|
|
});
|
|
|
|
test('Mixin events', ['web.Class'], function (assert, list_common, Class) {
|
|
var cls = Class.extend({
|
|
method: function () { this.trigger('e'); }
|
|
});
|
|
cls.include(list_common.Events);
|
|
|
|
var i = new cls(),
|
|
triggered = false;
|
|
|
|
i.bind('e', function () { triggered = true; });
|
|
i.method();
|
|
|
|
assert.ok(triggered);
|
|
});
|
|
|
|
test('Unbind all handlers', function (assert, list_common) {
|
|
var e = Object.create(list_common.Events),
|
|
passed = 0;
|
|
|
|
e.bind('foo', function () { passed++; });
|
|
e.trigger('foo');
|
|
assert.strictEqual(passed, 1);
|
|
|
|
e.unbind('foo');
|
|
e.trigger('foo');
|
|
assert.strictEqual(passed, 1);
|
|
});
|
|
|
|
test('Unbind one handler', function (assert, list_common) {
|
|
var e = Object.create(list_common.Events),
|
|
p1 = 0,
|
|
p2 = 0,
|
|
h1 = function () { p1++; },
|
|
h2 = function () { p2++; };
|
|
|
|
e.bind('foo', h1);
|
|
e.bind('foo', h2);
|
|
e.trigger('foo');
|
|
assert.strictEqual(p1, 1);
|
|
assert.strictEqual(p2, 1);
|
|
|
|
e.unbind('foo', h1);
|
|
e.trigger('foo');
|
|
assert.strictEqual(p1, 1);
|
|
assert.strictEqual(p2, 2);
|
|
});
|
|
});
|
|
|
|
odoo.define_section('list.records', ['web.list_common'], function (test) {
|
|
|
|
test('Basic record initialization', function (assert, list_common) {
|
|
var r = new list_common.Record({qux: 3});
|
|
r.set('foo', 1);
|
|
r.set('bar', 2);
|
|
|
|
assert.strictEqual(r.get('foo'), 1);
|
|
assert.strictEqual(r.get('bar'), 2);
|
|
assert.strictEqual(r.get('qux'), 3);
|
|
});
|
|
|
|
test('Change all the things', function (assert, list_common) {
|
|
var r = new list_common.Record(),
|
|
changed = false,
|
|
field;
|
|
|
|
r.bind('change', function () { changed = true; });
|
|
r.bind(null, function (e) { field = field || e.split(':')[1]; });
|
|
r.set('foo', 1);
|
|
|
|
assert.strictEqual(r.get('foo'), 1);
|
|
assert.ok(changed);
|
|
assert.strictEqual(field, 'foo');
|
|
});
|
|
|
|
test('Change single field', function (assert, list_common) {
|
|
var r = new list_common.Record(),
|
|
changed = 0;
|
|
|
|
r.bind('change:foo', function () { changed++; });
|
|
r.set('foo', 1);
|
|
r.set('bar', 1);
|
|
|
|
assert.strictEqual(r.get('foo'), 1);
|
|
assert.strictEqual(r.get('bar'), 1);
|
|
assert.strictEqual(changed, 1);
|
|
});
|
|
});
|
|
|
|
odoo.define_section('list.Collection', ['web.list_common'], function (test) {
|
|
test('degenerate-fetch', function (assert, list_common) {
|
|
var c = new list_common.Collection();
|
|
assert.strictEqual(c.length, 0);
|
|
|
|
c.add({id: 1, value: 2});
|
|
c.add({id: 2, value: 3});
|
|
c.add({id: 3, value: 5});
|
|
c.add({id: 4, value: 7});
|
|
assert.strictEqual(c.length, 4);
|
|
|
|
var r = c.at(2),
|
|
r2 = c.get(1);
|
|
|
|
assert.ok(r instanceof list_common.Record);
|
|
assert.strictEqual(r.get('id'), 3);
|
|
assert.strictEqual(r.get('value'), 5);
|
|
|
|
assert.ok(r2 instanceof list_common.Record);
|
|
assert.strictEqual(r2.get('id'), 1);
|
|
assert.strictEqual(r2.get('value'), 2);
|
|
});
|
|
|
|
test('degenerate-indexed-add', function (assert, list_common) {
|
|
var c = new list_common.Collection([
|
|
{id: 1, value: 5},
|
|
{id: 2, value: 10},
|
|
{id: 3, value: 20}
|
|
]);
|
|
|
|
assert.strictEqual(c.at(1).get('value'), 10);
|
|
assert.equal(c.at(3), undefined);
|
|
|
|
c.add({id:4, value: 55}, {at: 1});
|
|
|
|
assert.strictEqual(c.at(1).get('value'), 55);
|
|
assert.strictEqual(c.at(3).get('value'), 20);
|
|
});
|
|
|
|
test('degenerate-remove', function (assert, list_common) {
|
|
var c = new list_common.Collection([
|
|
{id: 1, value: 5},
|
|
{id: 2, value: 10},
|
|
{id: 3, value: 20}
|
|
]);
|
|
|
|
var record = c.get(2);
|
|
assert.strictEqual(c.length, 3);
|
|
|
|
c.remove(record);
|
|
assert.strictEqual(c.length, 2);
|
|
assert.equal(c.get(2), undefined);
|
|
assert.strictEqual(c.at(1).get('value'), 20);
|
|
});
|
|
|
|
test('degenerate-remove-bound', function (assert, list_common) {
|
|
var changed = false,
|
|
c = new list_common.Collection([ {id: 1, value: 5} ]);
|
|
|
|
c.bind('change', function () { changed = true; });
|
|
var record = c.get(1);
|
|
c.remove(record);
|
|
record.set('value', 42);
|
|
|
|
assert.ok(!changed, 'removed records should not trigger events in their ' +
|
|
'parent collection');
|
|
});
|
|
|
|
test('degenerate-reset', function (assert, list_common) {
|
|
var event,
|
|
obj,
|
|
c = new list_common.Collection([
|
|
{id: 1, value: 5},
|
|
{id: 2, value: 10},
|
|
{id: 3, value: 20}
|
|
]);
|
|
|
|
c.bind(null, function (e, instance) { event = e; obj = instance; });
|
|
c.reset();
|
|
|
|
assert.strictEqual(c.length, 0);
|
|
assert.strictEqual(event, 'reset');
|
|
assert.strictEqual(obj, c);
|
|
|
|
c.add([
|
|
{id: 1, value: 5},
|
|
{id: 2, value: 10},
|
|
{id: 3, value: 20}
|
|
]);
|
|
c.reset([{id: 42, value: 55}]);
|
|
|
|
assert.strictEqual(c.length, 1);
|
|
assert.strictEqual(c.get(42).get('value'), 55);
|
|
});
|
|
|
|
test('degenerate-reset-bound', function (assert, list_common) {
|
|
var changed = false,
|
|
c = new list_common.Collection([ {id: 1, value: 5} ]);
|
|
|
|
c.bind('change', function () { changed = true; });
|
|
var record = c.get(1);
|
|
c.reset();
|
|
record.set('value', 42);
|
|
|
|
assert.ok(!changed, 'removed records should not trigger events in their ' +
|
|
'parent collection');
|
|
});
|
|
|
|
test('degenerate-propagations', function (assert, list_common) {
|
|
var values = [];
|
|
var c = new list_common.Collection([
|
|
{id: 1, value: 5},
|
|
{id: 2, value: 10},
|
|
{id: 3, value: 20}
|
|
]);
|
|
c.bind('change:value', function (e, record, value) {
|
|
values.push(value);
|
|
});
|
|
c.get(1).set('value', 6);
|
|
c.get(2).set('value', 11);
|
|
c.get(3).set('value', 21);
|
|
|
|
assert.deepEqual(values, [6, 11, 21]);
|
|
});
|
|
|
|
test('BTree', function (assert, list_common) {
|
|
var root = new list_common.Collection(),
|
|
c = root.proxy('admin'),
|
|
total = 0;
|
|
|
|
c.add({id: 1, name: "Administrator", login: 'admin'});
|
|
c.add({id: 3, name: "Demo", login: 'demo'});
|
|
root.bind('change:wealth', function () {
|
|
total = (root.get(1).get('wealth') || 0) + (root.get(3).get('wealth') || 0);
|
|
});
|
|
|
|
assert.strictEqual(total, 0);
|
|
|
|
c.at(0).set('wealth', 42);
|
|
assert.strictEqual(total, 42);
|
|
|
|
c.at(1).set('wealth', 5);
|
|
assert.strictEqual(total, 47);
|
|
});
|
|
|
|
test('degenerate-successor', function (assert, list_common) {
|
|
var root = new list_common.Collection([
|
|
{id: 1, value: 1},
|
|
{id: 2, value: 2},
|
|
{id: 3, value: 3},
|
|
{id: 4, value: 5},
|
|
{id: 5, value: 8}
|
|
]);
|
|
|
|
assert.deepEqual(root.succ(root.at(2)).attributes,
|
|
root.at(3).attributes,
|
|
"should return the record at (index + 1) from the pivot");
|
|
assert.equal(root.succ(root.at(4)), null,
|
|
"should return null as successor to last record");
|
|
assert.deepEqual(root.succ(root.at(4), {wraparound: true}).attributes,
|
|
root.at(0).attributes,
|
|
"should return index 0 as successor to last record if" +
|
|
" wraparound is set");
|
|
assert.deepEqual(root.succ(root.at(2), {wraparound: true}).attributes,
|
|
root.at(3).attributes,
|
|
"wraparound should have no effect if not succ(last_record)");
|
|
});
|
|
|
|
test('successor', function (assert, list_common) {
|
|
var root = new list_common.Collection();
|
|
root.proxy('first').add([{id: 1, value: 1}, {id: 2, value: 2}]);
|
|
root.proxy('second').add([{id: 3, value: 3}, {id: 4, value: 5}]);
|
|
root.proxy('third').add([{id: 5, value: 8}, {id: 6, value: 13}]);
|
|
|
|
assert.deepEqual(root.succ(root.get(3)).attributes,
|
|
root.get(4).attributes,
|
|
"should get successor");
|
|
assert.equal(root.succ(root.get(4)),
|
|
null,
|
|
"successors do not cross collections");
|
|
assert.deepEqual(root.succ(root.get(4), {wraparound: true}).attributes,
|
|
root.get(3).attributes,
|
|
"should wraparound within a collection");
|
|
});
|
|
|
|
test('degenerate-predecessor', function (assert, list_common) {
|
|
var root = new list_common.Collection([
|
|
{id: 1, value: 1},
|
|
{id: 2, value: 2},
|
|
{id: 3, value: 3},
|
|
{id: 4, value: 5},
|
|
{id: 5, value: 8}
|
|
]);
|
|
|
|
assert.deepEqual(root.pred(root.at(2)).attributes,
|
|
root.at(1).attributes,
|
|
"should return the record at (index - 1) from the pivot");
|
|
assert.equal(root.pred(root.at(0)), null,
|
|
"should return null as predecessor to first record");
|
|
assert.deepEqual(root.pred(root.at(0), {wraparound: true}).attributes,
|
|
root.at(4).attributes,
|
|
"should return last record as predecessor to first record" +
|
|
" if wraparound is set");
|
|
assert.deepEqual(root.pred(root.at(1), {wraparound: true}).attributes,
|
|
root.at(0).attributes,
|
|
"wraparound should have no effect if not pred(first_record)");
|
|
});
|
|
|
|
test('predecessor', function (assert, list_common) {
|
|
var root = new list_common.Collection();
|
|
root.proxy('first').add([{id: 1, value: 1}, {id: 2, value: 2}]);
|
|
root.proxy('second').add([{id: 3, value: 3}, {id: 4, value: 5}]);
|
|
root.proxy('third').add([{id: 5, value: 8}, {id: 6, value: 13}]);
|
|
|
|
assert.deepEqual(root.pred(root.get(4)).attributes,
|
|
root.get(3).attributes,
|
|
"should get predecessor");
|
|
assert.equal(root.pred(root.get(3)),
|
|
null,
|
|
"predecessor do not cross collections");
|
|
assert.deepEqual(root.pred(root.get(3), {wraparound: true}).attributes,
|
|
root.get(4).attributes,
|
|
"should wraparound within a collection");
|
|
});
|
|
|
|
});
|
|
|
|
|
|
odoo.define_section('list.collections.higherordermethods', ['web.list_common'], function (test) {
|
|
|
|
test('each, degenerate', function (assert, list_common) {
|
|
var c = new list_common.Collection([
|
|
{id: 1, value: 5},
|
|
{id: 2, value: 10},
|
|
{id: 3, value: 20}
|
|
]), ids = [];
|
|
|
|
c.each(function (record) {
|
|
ids.push(record.get('id'));
|
|
});
|
|
assert.deepEqual(
|
|
ids, [1, 2, 3],
|
|
'degenerate collections should be iterated in record order');
|
|
});
|
|
|
|
test('each, deep', function (assert, list_common) {
|
|
var root = new list_common.Collection(),
|
|
ids = [];
|
|
|
|
root.proxy('foo').add([
|
|
{id: 1, value: 5},
|
|
{id: 2, value: 10},
|
|
{id: 3, value: 20}]);
|
|
root.proxy('bar').add([
|
|
{id: 10, value: 5},
|
|
{id: 20, value: 10},
|
|
{id: 30, value: 20}]);
|
|
root.each(function (record) {
|
|
ids.push(record.get('id'));
|
|
});
|
|
|
|
// No contract on sub-collection iteration order (for now anyway)
|
|
ids.sort(function (a, b) { return a - b; });
|
|
|
|
assert.deepEqual(
|
|
ids, [1, 2, 3, 10, 20, 30],
|
|
'tree collections should be deeply iterated');
|
|
});
|
|
|
|
test('map, degenerate', function (assert, list_common) {
|
|
var c = new list_common.Collection([
|
|
{id: 1, value: 5},
|
|
{id: 2, value: 10},
|
|
{id: 3, value: 20}
|
|
]);
|
|
var ids = c.map(function (record) {
|
|
return record.get('id');
|
|
});
|
|
|
|
assert.deepEqual(
|
|
ids, [1, 2, 3],
|
|
'degenerate collections should be iterated in record order');
|
|
});
|
|
|
|
test('map, deep', function (assert, list_common) {
|
|
var root = new list_common.Collection();
|
|
root.proxy('foo').add([
|
|
{id: 1, value: 5},
|
|
{id: 2, value: 10},
|
|
{id: 3, value: 20}]);
|
|
root.proxy('bar').add([
|
|
{id: 10, value: 5},
|
|
{id: 20, value: 10},
|
|
{id: 30, value: 20}]);
|
|
var ids = root.map(function (record) {
|
|
return record.get('id');
|
|
});
|
|
|
|
// No contract on sub-collection iteration order (for now anyway)
|
|
ids.sort(function (a, b) { return a - b; });
|
|
assert.deepEqual(
|
|
ids, [1, 2, 3, 10, 20, 30],
|
|
'tree collections should be deeply iterated');
|
|
});
|
|
});
|
|
|
|
odoo.define_section('list.collections.weirdoes', ['web.list_common'], function (test) {
|
|
test('set-from-noid', function (assert, list_common) {
|
|
var root = new list_common.Collection();
|
|
root.add({v: 3});
|
|
root.at(0).set('id', 42);
|
|
var record = root.get(42);
|
|
|
|
assert.equal(root.length, 1);
|
|
assert.equal(record.get('v'), 3, "should have fetched the original record");
|
|
});
|
|
|
|
test('set-from-previd', function (assert, list_common) {
|
|
var root = new list_common.Collection();
|
|
root.add({id: 1, v: 2});
|
|
root.get(1).set('id', 42);
|
|
var record = root.get(42);
|
|
|
|
assert.equal(root.length, 1);
|
|
assert.equal(record.get('v'), 2, "should have fetched the original record");
|
|
});
|
|
|
|
});
|
|
|