extlib/leaflet/spec/suites/core/ClassSpec.js

   1 describe("Class", function() {
   2
   3         describe("#extend", function() {
   4                 var Klass,
   5                         constructor,
   6                         method;
   7
   8                 beforeEach(function() {
   9                         constructor = jasmine.createSpy(),
  10                         method = jasmine.createSpy();
  11
  12                         Klass = L.Class.extend({
  13                                 statics: {bla: 1},
  14                                 includes: {mixin: true},
  15
  16                                 initialize: constructor,
  17                                 foo: 5,
  18                                 bar: method
  19                         });
  20                 });
  21
  22                 it("should create a class with the given constructor & properties", function() {
  23                         var a = new Klass();
  24
  25                         expect(constructor).toHaveBeenCalled();
  26                         expect(a.foo).toEqual(5);
  27
  28                         a.bar();
  29
  30                         expect(method).toHaveBeenCalled();
  31                 });
  32
  33                 it("should inherit parent classes' constructor & properties", function() {
  34                         var Klass2 = Klass.extend({baz: 2});
  35
  36                         var b = new Klass2();
  37
  38                         expect(b instanceof Klass).toBeTruthy();
  39                         expect(b instanceof Klass2).toBeTruthy();
  40
  41                         expect(constructor).toHaveBeenCalled();
  42                         expect(b.baz).toEqual(2);
  43
  44                         b.bar();
  45
  46                         expect(method).toHaveBeenCalled();
  47                 });
  48
  49                 it("should grant the ability to call parent methods, including constructor", function() {
  50                         var Klass2 = Klass.extend({
  51                                 initialize: function() {},
  52                                 bar: function() {}
  53                         });
  54
  55                         var b = new Klass2();
  56
  57                         expect(constructor).not.toHaveBeenCalled();
  58                         b.superclass.initialize.call(this);
  59                         expect(constructor).toHaveBeenCalled();
  60
  61                         b.superclass.bar.call(this);
  62                         expect(method).toHaveBeenCalled();
  63                 });
  64
  65                 it("should support static properties", function() {
  66                         expect(Klass.bla).toEqual(1);
  67                 });
  68
  69                 it("should inherit parent static properties", function() {
  70                         var Klass2 = Klass.extend({});
  71
  72                         expect(Klass2.bla).toEqual(1);
  73                 });
  74
  75                 it("should include the given mixin", function() {
  76                         var a = new Klass();
  77                         expect(a.mixin).toBeTruthy();
  78                 });
  79
  80                 it("should be able to include multiple mixins", function() {
  81                         var Klass2 = L.Class.extend({
  82                                 includes: [{mixin: true}, {mixin2: true}]
  83                         });
  84                         var a = new Klass2();
  85
  86                         expect(a.mixin).toBeTruthy();
  87                         expect(a.mixin2).toBeTruthy();
  88                 });
  89
  90                 it("should grant the ability to include the given mixin", function() {
  91                         Klass.include({mixin2: true});
  92
  93                         var a = new Klass();
  94                         expect(a.mixin2).toBeTruthy();
  95                 });
  96
  97                 it("should merge options instead of replacing them", function() {
  98                         var KlassWithOptions1 = L.Class.extend({
  99                                 options: {
 100                                         foo1: 1,
 101                                         foo2: 2
 102                                 }
 103                         });
 104                         var KlassWithOptions2 = KlassWithOptions1.extend({
 105                                 options: {
 106                                         foo2: 3,
 107                                         foo3: 4
 108                                 }
 109                         });
 110
 111                         var a = new KlassWithOptions2();
 112
 113                         expect(a.options).toEqual({
 114                                 foo1: 1,
 115                                 foo2: 3,
 116                                 foo3: 4
 117                         });
 118                 });
 119         });
 120 });