fix directive unit tests

src/directive.js

@@ -13,9 +13,13 @@ var expParser = require('./parsers/expression')
  * @param {Node} el
  * @param {Vue} vm
  * @param {Object} descriptor
+ *                 - {String} name
+ *                 - {Object} def
  *                 - {String} expression
- *                 - {String} [arg]
  *                 - {Array<Object>} [filters]
+ *                 - {Boolean} literal
+ *                 - {String} attr
+ *                 - {String} raw
  * @param {Object} def - directive definition object
  * @param {Vue} [host] - transclusion host component
  * @param {Object} [scope] - v-for scope

test/unit/specs/directive_spec.js

@@ -30,23 +30,24 @@ describe('Directive', function () {
   })
 
   it('normal', function (done) {
-    var d = new Directive('test', el, vm, {
+    var d = new Directive({
+      name: 'test',
+      def: def,
       expression: 'a',
-      arg: 'someArg',
-      filters: [{name: 'test'}]
-    }, def)
+      literal: false,
+      filters: [{ name: 'test' }]
+    }, vm, el)
     d._bind()
     // properties
     expect(d.el).toBe(el)
     expect(d.name).toBe('test')
     expect(d.vm).toBe(vm)
-    expect(d.arg).toBe('someArg')
     expect(d.expression).toBe('a')
+    expect(d.literal).toBe(false)
     // init calls
     expect(def.bind).toHaveBeenCalled()
     expect(def.update).toHaveBeenCalledWith(2)
     expect(d._bound).toBe(true)
-    // update
     vm.a = 2
     nextTick(function () {
       expect(def.update).toHaveBeenCalledWith(4, 2)
@@ -59,47 +60,19 @@ describe('Directive', function () {
     })
   })
 
-  it('static literal', function () {
-    def.isLiteral = true
-    var d = new Directive('test', el, vm, {
-      expression: 'a'
-    }, def)
+  it('literal', function () {
+    var d = new Directive({
+      name: 'test',
+      expression: 'a',
+      raw: 'a',
+      def: def,
+      literal: true
+    }, vm, el)
     d._bind()
     expect(d._watcher).toBeUndefined()
     expect(d.expression).toBe('a')
     expect(d.bind).toHaveBeenCalled()
-    expect(d.update).not.toHaveBeenCalled()
-  })
-
-  it('static literal, interpolate with no update', function () {
-    def.isLiteral = true
-    delete def.update
-    var d = new Directive('test', el, vm, {
-      expression: '{{a}}'
-    }, def)
-    d._bind()
-    expect(d._watcher).toBeUndefined()
-    expect(d.expression).toBe(1)
-    expect(d.bind).toHaveBeenCalled()
-  })
-
-  it('dynamic literal', function (done) {
-    vm.a = '' // #468 dynamic literals with falsy initial
-              // should still create the watcher.
-    def.isLiteral = true
-    var d = new Directive('test', el, vm, {
-      expression: '{{a}}'
-    }, def)
-    d._bind()
-    expect(d._watcher).toBeDefined()
-    expect(d.expression).toBe('')
-    expect(def.bind).toHaveBeenCalled()
-    expect(def.update).toHaveBeenCalledWith('')
-    vm.a = 'aa'
-    nextTick(function () {
-      expect(def.update).toHaveBeenCalledWith('aa', '')
-      done()
-    })
+    expect(d.update).toHaveBeenCalledWith('a')
   })
 
   it('inline statement', function () {
@@ -113,10 +86,12 @@ describe('Directive', function () {
         fn()
       }
     }
-    var d = new Directive('test', el, vm, {
+    var d = new Directive({
+      name: 'test',
       expression: 'a++',
-      filters: [{name: 'test'}]
-    }, def)
+      filters: [{name: 'test'}],
+      def: def
+    }, vm, el)
     d._bind()
     expect(d._watcher).toBeUndefined()
     expect(d.bind).toHaveBeenCalled()
@@ -134,10 +109,12 @@ describe('Directive', function () {
         return v * 3
       }
     }
-    var d = new Directive('test', el, vm, {
+    var d = new Directive({
+      name: 'test',
       expression: 'a',
-      filters: [{name: 'test'}]
-    }, def)
+      filters: [{name: 'test'}],
+      def: def
+    }, vm, el)
     d._bind()
     d.set(2)
     expect(vm.a).toBe(6)
@@ -150,9 +127,11 @@ describe('Directive', function () {
 
   it('deep', function (done) {
     def.deep = true
-    var d = new Directive('test', el, vm, {
-      expression: 'b'
-    }, def)
+    var d = new Directive({
+      name: 'test',
+      expression: 'b',
+      def: def
+    }, vm, el)
     d._bind()
     vm.b.c.d = 3
     nextTick(function () {
@@ -162,19 +141,13 @@ describe('Directive', function () {
   })
 
   it('function def', function () {
-    var d = new Directive('test', el, vm, {
-      expression: 'a'
-    }, def.update)
+    var d = new Directive({
+      name: 'test',
+      expression: 'a',
+      def: def.update
+    }, vm, el)
     d._bind()
     expect(d.update).toBe(def.update)
     expect(def.update).toHaveBeenCalled()
   })
-
-  it('literal (new syntax)', function () {
-    var d = new Directive('test', el, vm, {
-      raw: 'a'
-    }, def.update, null, null, null, null, true)
-    d._bind()
-    expect(def.update).toHaveBeenCalledWith('a')
-  })
 })