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");
|
||
|
|
});
|
||
|
|
|
||
|
|
});
|
||
|
|
|