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.
634 lines
20 KiB
JavaScript
634 lines
20 KiB
JavaScript
odoo.define_section('class', ['web.Class'], function (test) {
|
|
|
|
test('Basic class creation', function (assert, Class) {
|
|
var C = Class.extend({
|
|
foo: function () {
|
|
return this.somevar;
|
|
}
|
|
});
|
|
var i = new C();
|
|
i.somevar = 3;
|
|
|
|
assert.ok(i instanceof C);
|
|
assert.strictEqual(i.foo(), 3);
|
|
});
|
|
|
|
test('Class initialization', function (assert, Class) {
|
|
var C1 = Class.extend({
|
|
init: function () {
|
|
this.foo = 3;
|
|
}
|
|
});
|
|
var C2 = Class.extend({
|
|
init: function (arg) {
|
|
this.foo = arg;
|
|
}
|
|
});
|
|
|
|
var i1 = new C1(),
|
|
i2 = new C2(42);
|
|
|
|
assert.strictEqual(i1.foo, 3);
|
|
assert.strictEqual(i2.foo, 42);
|
|
});
|
|
|
|
test('Inheritance', function (assert, Class) {
|
|
var C0 = Class.extend({
|
|
foo: function () {
|
|
return 1;
|
|
}
|
|
});
|
|
var C1 = C0.extend({
|
|
foo: function () {
|
|
return 1 + this._super();
|
|
}
|
|
});
|
|
var C2 = C1.extend({
|
|
foo: function () {
|
|
return 1 + this._super();
|
|
}
|
|
});
|
|
|
|
assert.strictEqual(new C0().foo(), 1);
|
|
assert.strictEqual(new C1().foo(), 2);
|
|
assert.strictEqual(new C2().foo(), 3);
|
|
});
|
|
|
|
test('In-place extension', function (assert, Class) {
|
|
var C0 = Class.extend({
|
|
foo: function () {
|
|
return 3;
|
|
},
|
|
qux: function () {
|
|
return 3;
|
|
},
|
|
bar: 3
|
|
});
|
|
|
|
C0.include({
|
|
foo: function () {
|
|
return 5;
|
|
},
|
|
qux: function () {
|
|
return 2 + this._super();
|
|
},
|
|
bar: 5,
|
|
baz: 5
|
|
});
|
|
|
|
assert.strictEqual(new C0().bar, 5);
|
|
assert.strictEqual(new C0().baz, 5);
|
|
assert.strictEqual(new C0().foo(), 5);
|
|
assert.strictEqual(new C0().qux(), 5);
|
|
});
|
|
|
|
test('In-place extension and inheritance', function (assert, Class) {
|
|
var C0 = Class.extend({
|
|
foo: function () { return 1; },
|
|
bar: function () { return 1; }
|
|
});
|
|
var C1 = C0.extend({
|
|
foo: function () { return 1 + this._super(); }
|
|
});
|
|
assert.strictEqual(new C1().foo(), 2);
|
|
assert.strictEqual(new C1().bar(), 1);
|
|
|
|
C1.include({
|
|
foo: function () { return 2 + this._super(); },
|
|
bar: function () { return 1 + this._super(); }
|
|
});
|
|
assert.strictEqual(new C1().foo(), 4);
|
|
assert.strictEqual(new C1().bar(), 2);
|
|
});
|
|
|
|
test('In-place extensions alter existing instances', function (assert, Class) {
|
|
var C0 = Class.extend({
|
|
foo: function () { return 1; },
|
|
bar: function () { return 1; }
|
|
});
|
|
var i = new C0();
|
|
assert.strictEqual(i.foo(), 1);
|
|
assert.strictEqual(i.bar(), 1);
|
|
|
|
C0.include({
|
|
foo: function () { return 2; },
|
|
bar: function () { return 2 + this._super(); }
|
|
});
|
|
assert.strictEqual(i.foo(), 2);
|
|
assert.strictEqual(i.bar(), 3);
|
|
});
|
|
|
|
test('In-place extension of subclassed types', function (assert, Class) {
|
|
var C0 = Class.extend({
|
|
foo: function () { return 1; },
|
|
bar: function () { return 1; }
|
|
});
|
|
var C1 = C0.extend({
|
|
foo: function () { return 1 + this._super(); },
|
|
bar: function () { return 1 + this._super(); }
|
|
});
|
|
var i = new C1();
|
|
|
|
assert.strictEqual(i.foo(), 2);
|
|
|
|
C0.include({
|
|
foo: function () { return 2; },
|
|
bar: function () { return 2 + this._super(); }
|
|
});
|
|
|
|
assert.strictEqual(i.foo(), 3);
|
|
assert.strictEqual(i.bar(), 4);
|
|
});
|
|
});
|
|
|
|
odoo.define_section('Widget.proxy', ['web.Widget'], function (test) {
|
|
test('(String)', function (assert, Widget) {
|
|
var W = Widget.extend({
|
|
exec: function () {
|
|
this.executed = true;
|
|
}
|
|
});
|
|
var w = new W();
|
|
var fn = w.proxy('exec');
|
|
fn();
|
|
assert.ok(w.executed, 'should execute the named method in the right context');
|
|
});
|
|
|
|
test('(String)(*args)', function (assert, Widget) {
|
|
var W = Widget.extend({
|
|
exec: function (arg) {
|
|
this.executed = arg;
|
|
}
|
|
});
|
|
var w = new W();
|
|
var fn = w.proxy('exec');
|
|
fn(42);
|
|
assert.ok(w.executed, "should execute the named method in the right context");
|
|
assert.equal(w.executed, 42, "should be passed the proxy's arguments");
|
|
});
|
|
|
|
test('(String), include', function (assert, Widget) {
|
|
// the proxy function should handle methods being changed on the class
|
|
// and should always proxy "by name", to the most recent one
|
|
var W = Widget.extend({
|
|
exec: function () {
|
|
this.executed = 1;
|
|
}
|
|
});
|
|
var w = new W();
|
|
var fn = w.proxy('exec');
|
|
W.include({
|
|
exec: function () { this.executed = 2; }
|
|
});
|
|
|
|
fn();
|
|
assert.equal(w.executed, 2, "should be lazily resolved");
|
|
});
|
|
|
|
test('(Function)', function (assert, Widget) {
|
|
var w = new (Widget.extend({ }))();
|
|
|
|
var fn = w.proxy(function () { this.executed = true; });
|
|
fn();
|
|
assert.ok(w.executed, "should set the function's context (like Function#bind)");
|
|
});
|
|
|
|
test('(Function)(*args)', function (assert, Widget) {
|
|
var w = new (Widget.extend({ }))();
|
|
|
|
var fn = w.proxy(function (arg) { this.executed = arg; });
|
|
fn(42);
|
|
assert.equal(w.executed, 42, "should be passed the proxy's arguments");
|
|
});
|
|
|
|
});
|
|
|
|
odoo.define_section('Widget.renderElement', ['web.Widget'], function (test) {
|
|
|
|
test('no template, default', function (assert, Widget) {
|
|
var widget = new (Widget.extend({ }))();
|
|
|
|
var $original = widget.$el;
|
|
assert.ok($original, "should initially have a root element");
|
|
|
|
widget.renderElement();
|
|
|
|
assert.ok(widget.$el, "should have generated a root element");
|
|
assert.ok($original !== widget.$el, "should have generated a new root element");
|
|
assert.strictEqual(widget.$el, widget.$el, "should provide $el alias");
|
|
assert.ok(widget.$el.is(widget.el), "should provide raw DOM alias");
|
|
|
|
assert.equal(widget.el.nodeName, 'DIV', "should have generated the default element");
|
|
assert.equal(widget.el.attributes.length, 0, "should not have generated any attribute");
|
|
assert.ok(_.isEmpty(widget.$el.html(), "should not have generated any content"));
|
|
});
|
|
|
|
test('no template, custom tag', function (assert, Widget) {
|
|
|
|
var widget = new (Widget.extend({
|
|
tagName: 'ul'
|
|
}))();
|
|
widget.renderElement();
|
|
|
|
assert.equal(widget.el.nodeName, 'UL', "should have generated the custom element tag");
|
|
});
|
|
|
|
test('no template, @id', function (assert, Widget) {
|
|
var widget = new (Widget.extend({
|
|
id: 'foo'
|
|
}))();
|
|
widget.renderElement();
|
|
|
|
assert.equal(widget.el.attributes.length, 1, "should have one attribute");
|
|
assert.equal(widget.$el.attr('id'), 'foo', "should have generated the id attribute");
|
|
assert.equal(widget.el.id, 'foo', "should also be available via property");
|
|
});
|
|
|
|
test('no template, @className', function (assert, Widget) {
|
|
var widget = new (Widget.extend({
|
|
className: 'oe_some_class'
|
|
}))();
|
|
widget.renderElement();
|
|
|
|
assert.equal(widget.el.className, 'oe_some_class', "should have the right property");
|
|
assert.equal(widget.$el.attr('class'), 'oe_some_class', "should have the right attribute");
|
|
});
|
|
|
|
test('no template, bunch of attributes', function (assert, Widget) {
|
|
var widget = new (Widget.extend({
|
|
attributes: {
|
|
'id': 'some_id',
|
|
'class': 'some_class',
|
|
'data-foo': 'data attribute',
|
|
'clark': 'gable',
|
|
'spoiler': // don't read the next line if you care about Harry Potter...
|
|
'snape kills dumbledore'
|
|
}
|
|
}))();
|
|
widget.renderElement();
|
|
|
|
assert.equal(widget.el.attributes.length, 5, "should have all the specified attributes");
|
|
|
|
assert.equal(widget.el.id, 'some_id');
|
|
assert.equal(widget.$el.attr('id'), 'some_id');
|
|
|
|
assert.equal(widget.el.className, 'some_class');
|
|
assert.equal(widget.$el.attr('class'), 'some_class');
|
|
|
|
assert.equal(widget.$el.attr('data-foo'), 'data attribute');
|
|
assert.equal(widget.$el.data('foo'), 'data attribute');
|
|
|
|
assert.equal(widget.$el.attr('clark'), 'gable');
|
|
assert.equal(widget.$el.attr('spoiler'), 'snape kills dumbledore');
|
|
});
|
|
|
|
test('template', ['web.core'], function (assert, Widget, core) {
|
|
core.qweb.add_template(
|
|
'<no>' +
|
|
'<t t-name="test.widget.template">' +
|
|
'<ol>' +
|
|
'<li t-foreach="5" t-as="counter" ' +
|
|
't-attf-class="class-#{counter}">' +
|
|
'<input/>' +
|
|
'<t t-esc="counter"/>' +
|
|
'</li>' +
|
|
'</ol>' +
|
|
'</t>' +
|
|
'</no>'
|
|
);
|
|
|
|
var widget = new (Widget.extend({
|
|
template: 'test.widget.template'
|
|
}))();
|
|
widget.renderElement();
|
|
|
|
assert.equal(widget.el.nodeName, 'OL');
|
|
assert.equal(widget.$el.children().length, 5);
|
|
assert.equal(widget.el.textContent, '01234');
|
|
});
|
|
|
|
test('repeated', ['web.core'], function (assert, Widget, core) {
|
|
assert.expect(4);
|
|
var $fix = $( "#qunit-fixture");
|
|
|
|
core.qweb.add_template(
|
|
'<no>' +
|
|
'<t t-name="test.widget.template">' +
|
|
'<p><t t-esc="widget.value"/></p>' +
|
|
'</t>' +
|
|
'</no>'
|
|
);
|
|
var widget = new (Widget.extend({
|
|
template: 'test.widget.template'
|
|
}))();
|
|
widget.value = 42;
|
|
|
|
return widget.appendTo($fix)
|
|
.done(function () {
|
|
assert.equal($fix.find('p').text(), '42', "DOM fixture should contain initial value");
|
|
assert.equal(widget.$el.text(), '42', "should set initial value");
|
|
widget.value = 36;
|
|
widget.renderElement();
|
|
assert.equal($fix.find('p').text(), '36', "DOM fixture should use new value");
|
|
assert.equal(widget.$el.text(), '36', "should set new value");
|
|
});
|
|
});
|
|
|
|
});
|
|
|
|
odoo.define_section('Widget.$', ['web.Widget', 'web.core'], function (test) {
|
|
|
|
test('basic-alias', function (assert, Widget, core) {
|
|
core.qweb.add_template(
|
|
'<no>' +
|
|
'<t t-name="test.widget.template">' +
|
|
'<ol>' +
|
|
'<li t-foreach="5" t-as="counter" ' +
|
|
't-attf-class="class-#{counter}">' +
|
|
'<input/>' +
|
|
'<t t-esc="counter"/>' +
|
|
'</li>' +
|
|
'</ol>' +
|
|
'</t>' +
|
|
'</no>'
|
|
);
|
|
var widget = new (Widget.extend({
|
|
template: 'test.widget.template'
|
|
}))();
|
|
widget.renderElement();
|
|
|
|
assert.ok(widget.$('li:eq(3)').is(widget.$el.find('li:eq(3)')),
|
|
"should do the same thing as calling find on the widget root");
|
|
});
|
|
|
|
});
|
|
|
|
odoo.define_section('Widget.events', ['web.Widget', 'web.core'], function (test) {
|
|
function setup(qweb) {
|
|
qweb.add_template(
|
|
'<no>' +
|
|
'<t t-name="test.widget.template">' +
|
|
'<ol>' +
|
|
'<li t-foreach="5" t-as="counter" ' +
|
|
't-attf-class="class-#{counter}">' +
|
|
'<input/>' +
|
|
'<t t-esc="counter"/>' +
|
|
'</li>' +
|
|
'</ol>' +
|
|
'</t>' +
|
|
'</no>'
|
|
);
|
|
}
|
|
|
|
test('delegate', function (assert, Widget, core) {
|
|
setup(core.qweb);
|
|
|
|
var a = [];
|
|
var widget = new (Widget.extend({
|
|
template: 'test.widget.template',
|
|
events: {
|
|
'click': function () {
|
|
a[0] = true;
|
|
assert.strictEqual(this, widget, "should trigger events in widget");
|
|
},
|
|
'click li.class-3': 'class3',
|
|
'change input': function () { a[2] = true; }
|
|
},
|
|
class3: function () { a[1] = true; }
|
|
}))();
|
|
widget.renderElement();
|
|
|
|
widget.$el.click();
|
|
widget.$('li:eq(3)').click();
|
|
widget.$('input:last').val('foo').change();
|
|
|
|
for(var i=0; i<3; ++i) {
|
|
assert.ok(a[i], "should pass test " + i);
|
|
}
|
|
});
|
|
|
|
test('undelegate', function (assert, Widget, core) {
|
|
setup(core.qweb);
|
|
|
|
var clicked = false,
|
|
newclicked = false;
|
|
|
|
var widget = new (Widget.extend({
|
|
template: 'test.widget.template',
|
|
events: { 'click li': function () { clicked = true; } }
|
|
}))();
|
|
|
|
widget.renderElement();
|
|
widget.$el.on('click', 'li', function () { newclicked = true; });
|
|
|
|
widget.$('li').click();
|
|
assert.ok(clicked, "should trigger bound events");
|
|
assert.ok(newclicked, "should trigger bound events");
|
|
|
|
clicked = newclicked = false;
|
|
widget.undelegateEvents();
|
|
widget.$('li').click();
|
|
assert.ok(!clicked, "undelegate should unbind events delegated");
|
|
assert.ok(newclicked, "undelegate should only unbind events it created");
|
|
});
|
|
});
|
|
|
|
odoo.define_section('Widget.async', ['web.Widget'], function (test) {
|
|
test("alive(alive)", function (assert, Widget) {
|
|
assert.expect(1);
|
|
|
|
var widget = new (Widget.extend({}));
|
|
|
|
return $.async_when(widget.start())
|
|
.then(function () { return widget.alive($.async_when()) })
|
|
.then(function () { assert.ok(true); });
|
|
});
|
|
|
|
test("alive(dead)", function (assert, Widget) {
|
|
assert.expect(1);
|
|
var widget = new (Widget.extend({}));
|
|
|
|
return $.Deferred(function (d) {
|
|
$.async_when(widget.start())
|
|
.then(function () {
|
|
// destroy widget
|
|
widget.destroy();
|
|
var promise = $.async_when();
|
|
// leave time for alive() to do its stuff
|
|
promise.then(function () {
|
|
return $.async_when();
|
|
}).then(function () {
|
|
assert.ok(true);
|
|
d.resolve();
|
|
});
|
|
// ensure that widget.alive() refuses to resolve or reject
|
|
return widget.alive(promise);
|
|
}).always(function () {
|
|
d.reject();
|
|
assert.ok(false, "alive() should not terminate by default");
|
|
})
|
|
});
|
|
});
|
|
|
|
test("alive(alive, true)", function (assert, Widget) {
|
|
assert.expect(1);
|
|
var widget = new (Widget.extend({}));
|
|
return $.async_when(widget.start())
|
|
.then(function () { return widget.alive($.async_when(), true) })
|
|
.then(function () { assert.ok(true); });
|
|
});
|
|
|
|
test("alive(dead, true)", function (assert, Widget) {
|
|
assert.expect(1);
|
|
var done = assert.async();
|
|
|
|
var widget = new (Widget.extend({}));
|
|
|
|
$.async_when(widget.start())
|
|
.then(function () {
|
|
// destroy widget
|
|
widget.destroy();
|
|
console.log('destroyed');
|
|
return widget.alive($.async_when().done(function () { console.log('when'); }), true);
|
|
}).then(function () {
|
|
console.log('unfailed')
|
|
assert.ok(false, "alive(p, true) should fail its promise");
|
|
done();
|
|
}, function () {
|
|
console.log('failed')
|
|
assert.ok(true, "alive(p, true) should fail its promise");
|
|
done();
|
|
});
|
|
});
|
|
|
|
});
|
|
|
|
|
|
odoo.define_section('server-formats', ['web.time'], function (test) {
|
|
|
|
test('Parse server datetime', function (assert, time) {
|
|
var date = time.str_to_datetime("2009-05-04 12:34:23");
|
|
assert.deepEqual(
|
|
[date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(),
|
|
date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds()],
|
|
[2009, 5 - 1, 4, 12, 34, 23]);
|
|
assert.deepEqual(
|
|
[date.getFullYear(), date.getMonth(), date.getDate(),
|
|
date.getHours(), date.getMinutes(), date.getSeconds()],
|
|
[2009, 5 - 1, 4, 12 - (date.getTimezoneOffset() / 60), 34, 23]);
|
|
|
|
var date2 = time.str_to_datetime('2011-12-10 00:00:00');
|
|
assert.deepEqual(
|
|
[date2.getUTCFullYear(), date2.getUTCMonth(), date2.getUTCDate(),
|
|
date2.getUTCHours(), date2.getUTCMinutes(), date2.getUTCSeconds()],
|
|
[2011, 12 - 1, 10, 0, 0, 0]);
|
|
|
|
var date3 = time.str_to_datetime("2009-05-04 12:34:23.84565");
|
|
assert.deepEqual(
|
|
[date3.getUTCFullYear(), date3.getUTCMonth(), date3.getUTCDate(),
|
|
date3.getUTCHours(), date3.getUTCMinutes(), date3.getUTCSeconds(), date3.getUTCMilliseconds()],
|
|
[2009, 5 - 1, 4, 12, 34, 23, 845]);
|
|
});
|
|
|
|
test('Parse server datetime on 31', function (assert, time) {
|
|
var wDate = window.Date;
|
|
|
|
try {
|
|
window.Date = function (v) {
|
|
if (_.isUndefined(v)) {
|
|
v = '2013-10-31 12:34:56';
|
|
}
|
|
return new wDate(v);
|
|
};
|
|
var date = time.str_to_datetime('2013-11-11 02:45:21');
|
|
|
|
assert.deepEqual(
|
|
[date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(),
|
|
date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds()],
|
|
[2013, 11 - 1, 11, 2, 45, 21]);
|
|
}
|
|
finally {
|
|
window.Date = wDate;
|
|
}
|
|
});
|
|
|
|
test('Parse server date', function (assert, time) {
|
|
var date = time.str_to_date("2009-05-04");
|
|
assert.deepEqual(
|
|
[date.getFullYear(), date.getMonth(), date.getDate()],
|
|
[2009, 5 - 1, 4]);
|
|
});
|
|
|
|
test('Parse server date on 31', function (assert, time) {
|
|
var wDate = window.Date;
|
|
|
|
try {
|
|
window.Date = function (v) {
|
|
if (_.isUndefined(v)) {
|
|
v = '2013-10-31 12:34:56';
|
|
}
|
|
return new wDate(v);
|
|
};
|
|
var date = time.str_to_date('2013-11-21');
|
|
|
|
assert.deepEqual(
|
|
[date.getFullYear(), date.getMonth(), date.getDate()],
|
|
[2013, 11 - 1, 21]);
|
|
}
|
|
finally {
|
|
window.Date = wDate;
|
|
}
|
|
|
|
});
|
|
|
|
test('Parse server time', function (assert, time) {
|
|
var date = time.str_to_time("12:34:23");
|
|
assert.deepEqual(
|
|
[date.getHours(), date.getMinutes(), date.getSeconds()],
|
|
[12, 34, 23]);
|
|
|
|
date = time.str_to_time("12:34:23.5467");
|
|
assert.deepEqual(
|
|
[date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds()],
|
|
[12, 34, 23, 546]);
|
|
});
|
|
|
|
test('Format server datetime', function (assert, time) {
|
|
var date = new Date();
|
|
date.setUTCFullYear(2009);
|
|
date.setUTCMonth(5 - 1);
|
|
date.setUTCDate(4);
|
|
date.setUTCHours(12);
|
|
date.setUTCMinutes(34);
|
|
date.setUTCSeconds(23);
|
|
assert.equal(time.datetime_to_str(date), "2009-05-04 12:34:23");
|
|
});
|
|
|
|
test('Format server date', function (assert, time) {
|
|
var date = new Date();
|
|
date.setUTCFullYear(2009);
|
|
date.setUTCMonth(5 - 1);
|
|
date.setUTCDate(4);
|
|
date.setUTCHours(0);
|
|
date.setUTCMinutes(0);
|
|
date.setUTCSeconds(0);
|
|
assert.equal(time.date_to_str(date), "2009-05-04");
|
|
});
|
|
|
|
test('Format server time', function (assert, time) {
|
|
var date = new Date();
|
|
date.setUTCFullYear(1970);
|
|
date.setUTCMonth(1 - 1);
|
|
date.setUTCDate(1);
|
|
date.setUTCHours(0);
|
|
date.setUTCMinutes(0);
|
|
date.setUTCSeconds(0);
|
|
date.setHours(12);
|
|
date.setMinutes(34);
|
|
date.setSeconds(23);
|
|
assert.equal(time.time_to_str(date), "12:34:23");
|
|
});
|
|
|
|
});
|
|
|