github.com/insionng/yougam@v0.0.0-20170714101924-2bc18d833463/themes/wind/static/libs/vue-1.0.24/test/unit/specs/directive_spec.js (about)

     1  var Vue = require('src')
     2  var Directive = require('src/directive')
     3  var nextTick = Vue.nextTick
     4  
     5  describe('Directive', function () {
     6    var el, vm, def
     7    beforeEach(function () {
     8      el = document.createElement('div')
     9      def = {
    10        params: ['foo', 'keBab'],
    11        paramWatchers: {
    12          foo: jasmine.createSpy('foo')
    13        },
    14        bind: jasmine.createSpy('bind'),
    15        update: jasmine.createSpy('update'),
    16        unbind: jasmine.createSpy('unbind')
    17      }
    18      vm = new Vue({
    19        data: {
    20          a: 1,
    21          b: { c: { d: 2 }}
    22        },
    23        filters: {
    24          test: function (v) {
    25            return v * 2
    26          }
    27        },
    28        directives: {
    29          test: def
    30        }
    31      })
    32    })
    33  
    34    it('normal', function (done) {
    35      var d = new Directive({
    36        name: 'test',
    37        def: def,
    38        expression: 'a',
    39        modifiers: {
    40          literal: false
    41        },
    42        filters: [{ name: 'test' }]
    43      }, vm, el)
    44      d._bind()
    45      // properties
    46      expect(d.el).toBe(el)
    47      expect(d.name).toBe('test')
    48      expect(d.vm).toBe(vm)
    49      expect(d.expression).toBe('a')
    50      expect(d.literal).toBe(false)
    51      // init calls
    52      expect(def.bind).toHaveBeenCalled()
    53      expect(def.update).toHaveBeenCalledWith(2)
    54      expect(d._bound).toBe(true)
    55      vm.a = 2
    56      nextTick(function () {
    57        expect(def.update).toHaveBeenCalledWith(4, 2)
    58        // teardown
    59        d._teardown()
    60        expect(def.unbind).toHaveBeenCalled()
    61        expect(d._bound).toBe(false)
    62        expect(d._watcher).toBe(null)
    63        done()
    64      })
    65    })
    66  
    67    it('literal', function () {
    68      var d = new Directive({
    69        name: 'test',
    70        expression: 'a',
    71        raw: 'a',
    72        def: def,
    73        modifiers: {
    74          literal: true
    75        }
    76      }, vm, el)
    77      d._bind()
    78      expect(d._watcher).toBeUndefined()
    79      expect(d.expression).toBe('a')
    80      expect(d.bind).toHaveBeenCalled()
    81      expect(d.update).toHaveBeenCalledWith('a')
    82    })
    83  
    84    it('inline statement', function () {
    85      def.acceptStatement = true
    86      var spy = jasmine.createSpy()
    87      vm.$options.filters.test = function (fn) {
    88        spy()
    89        return function () {
    90          // call it twice
    91          fn()
    92          fn()
    93        }
    94      }
    95      var d = new Directive({
    96        name: 'test',
    97        expression: 'a++',
    98        filters: [{name: 'test'}],
    99        def: def
   100      }, vm, el)
   101      d._bind()
   102      expect(d._watcher).toBeUndefined()
   103      expect(d.bind).toHaveBeenCalled()
   104      var wrappedFn = d.update.calls.argsFor(0)[0]
   105      expect(typeof wrappedFn).toBe('function')
   106      // test invoke the wrapped fn
   107      wrappedFn()
   108      expect(vm.a).toBe(3)
   109    })
   110  
   111    it('two-way', function (done) {
   112      def.twoWay = true
   113      vm.$options.filters.test = {
   114        write: function (v) {
   115          return v * 3
   116        }
   117      }
   118      var d = new Directive({
   119        name: 'test',
   120        expression: 'a',
   121        filters: [{name: 'test'}],
   122        def: def
   123      }, vm, el)
   124      d._bind()
   125      d.set(2)
   126      expect(vm.a).toBe(6)
   127      nextTick(function () {
   128        // should have no update calls
   129        expect(def.update.calls.count()).toBe(1)
   130        done()
   131      })
   132    })
   133  
   134    it('deep', function (done) {
   135      def.deep = true
   136      var d = new Directive({
   137        name: 'test',
   138        expression: 'b',
   139        def: def
   140      }, vm, el)
   141      d._bind()
   142      vm.b.c.d = 3
   143      nextTick(function () {
   144        expect(def.update.calls.count()).toBe(2)
   145        done()
   146      })
   147    })
   148  
   149    it('function def', function () {
   150      var d = new Directive({
   151        name: 'test',
   152        expression: 'a',
   153        def: def.update
   154      }, vm, el)
   155      d._bind()
   156      expect(d.update).toBe(def.update)
   157      expect(def.update).toHaveBeenCalled()
   158    })
   159  
   160    it('static params', function () {
   161      el.setAttribute('foo', 'hello')
   162      el.setAttribute('ke-bab', 'yo')
   163      var d = new Directive({
   164        name: 'test',
   165        def: def,
   166        expression: 'a'
   167      }, vm, el)
   168      d._bind()
   169      expect(d.params.foo).toBe('hello')
   170      expect(d.params.keBab).toBe('yo')
   171    })
   172  
   173    it('dynamic params', function (done) {
   174      el.setAttribute(':foo', 'a')
   175      el.setAttribute(':ke-bab', '123')
   176      var d = new Directive({
   177        name: 'test',
   178        def: def,
   179        expression: 'a'
   180      }, vm, el)
   181      d._bind()
   182      expect(d.params.foo).toBe(vm.a)
   183      expect(d.params.keBab).toBe(123)
   184      vm.a = 2
   185      nextTick(function () {
   186        expect(def.paramWatchers.foo).toHaveBeenCalledWith(2, 1)
   187        expect(d.params.foo).toBe(vm.a)
   188        done()
   189      })
   190    })
   191  })