addons/web/static/test/class.js

   1 openerp.testing.section('class', {
   2     dependencies: ['web.corelib']
   3 }, function (test) {
   4     test('Basic class creation', function (instance) {
   5         var C = instance.web.Class.extend({
   6             foo: function () {
   7                 return this.somevar;
   8             }
   9         });
  10         var i = new C();
  11         i.somevar = 3;
  12
  13         ok(i instanceof C);
  14         strictEqual(i.foo(), 3);
  15     });
  16     test('Class initialization', function (instance) {
  17         var C1 = instance.web.Class.extend({
  18             init: function () {
  19                 this.foo = 3;
  20             }
  21         });
  22         var C2 = instance.web.Class.extend({
  23             init: function (arg) {
  24                 this.foo = arg;
  25             }
  26         });
  27
  28         var i1 = new C1(),
  29             i2 = new C2(42);
  30
  31         strictEqual(i1.foo, 3);
  32         strictEqual(i2.foo, 42);
  33     });
  34     test('Inheritance', function (instance) {
  35         var C0 = instance.web.Class.extend({
  36             foo: function () {
  37                 return 1;
  38             }
  39         });
  40         var C1 = C0.extend({
  41             foo: function () {
  42                 return 1 + this._super();
  43             }
  44         });
  45         var C2 = C1.extend({
  46             foo: function () {
  47                 return 1 + this._super();
  48             }
  49         });
  50
  51         strictEqual(new C0().foo(), 1);
  52         strictEqual(new C1().foo(), 2);
  53         strictEqual(new C2().foo(), 3);
  54     });
  55     test('In-place extension', function (instance) {
  56         var C0 = instance.web.Class.extend({
  57             foo: function () {
  58                 return 3;
  59             },
  60             qux: function () {
  61                 return 3;
  62             },
  63             bar: 3
  64         });
  65         C0.include({
  66             foo: function () {
  67                 return 5;
  68             },
  69             qux: function () {
  70                 return 2 + this._super();
  71             },
  72             bar: 5,
  73             baz: 5
  74         });
  75
  76         strictEqual(new C0().bar, 5);
  77         strictEqual(new C0().baz, 5);
  78         strictEqual(new C0().foo(), 5);
  79         strictEqual(new C0().qux(), 5);
  80     });
  81     test('In-place extension and inheritance', function (instance) {
  82         var C0 = instance.web.Class.extend({
  83             foo: function () { return 1; },
  84             bar: function () { return 1; }
  85         });
  86         var C1 = C0.extend({
  87             foo: function () { return 1 + this._super(); }
  88         });
  89         strictEqual(new C1().foo(), 2);
  90         strictEqual(new C1().bar(), 1);
  91
  92         C1.include({
  93             foo: function () { return 2 + this._super(); },
  94             bar: function () { return 1 + this._super(); }
  95         });
  96         strictEqual(new C1().foo(), 4);
  97         strictEqual(new C1().bar(), 2);
  98     });
  99     test('In-place extensions alter existing instances', function (instance) {
 100         var C0 = instance.web.Class.extend({
 101             foo: function () { return 1; },
 102             bar: function () { return 1; }
 103         });
 104         var i = new C0();
 105         strictEqual(i.foo(), 1);
 106         strictEqual(i.bar(), 1);
 107
 108         C0.include({
 109             foo: function () { return 2; },
 110             bar: function () { return 2 + this._super(); }
 111         });
 112         strictEqual(i.foo(), 2);
 113         strictEqual(i.bar(), 3);
 114     });
 115     test('In-place extension of subclassed types', function (instance) {
 116         var C0 = instance.web.Class.extend({
 117             foo: function () { return 1; },
 118             bar: function () { return 1; }
 119         });
 120         var C1 = C0.extend({
 121             foo: function () { return 1 + this._super(); },
 122             bar: function () { return 1 + this._super(); }
 123         });
 124         var i = new C1();
 125         strictEqual(i.foo(), 2);
 126         C0.include({
 127             foo: function () { return 2; },
 128             bar: function () { return 2 + this._super(); }
 129         });
 130         strictEqual(i.foo(), 3);
 131         strictEqual(i.bar(), 4);
 132     });
 133 });