github.com/insionng/yougam@v0.0.0-20170714101924-2bc18d833463/public/libs/vue-1.0.24/test/unit/specs/util/options_spec.js (about)

     1  var _ = require('src/util')
     2  var Vue = require('src')
     3  var merge = _.mergeOptions
     4  var resolveAsset = _.resolveAsset
     5  
     6  describe('Util - Option merging', function () {
     7    it('default strat', function () {
     8      // child undefined
     9      var res = merge({replace: true}, {}).replace
    10      expect(res).toBe(true)
    11      // child overwrite
    12      res = merge({replace: true}, {replace: false}).replace
    13      expect(res).toBe(false)
    14    })
    15  
    16    it('hooks', function () {
    17      var fn1 = function () {}
    18      var fn2 = function () {}
    19      var res
    20      // parent undefined
    21      res = merge({}, {created: fn1}).created
    22      expect(Array.isArray(res)).toBe(true)
    23      expect(res.length).toBe(1)
    24      expect(res[0]).toBe(fn1)
    25      // child undefined
    26      res = merge({created: [fn1]}, {}).created
    27      expect(Array.isArray(res)).toBe(true)
    28      expect(res.length).toBe(1)
    29      expect(res[0]).toBe(fn1)
    30      // both defined
    31      res = merge({created: [fn1]}, {created: fn2}).created
    32      expect(Array.isArray(res)).toBe(true)
    33      expect(res.length).toBe(2)
    34      expect(res[0]).toBe(fn1)
    35      expect(res[1]).toBe(fn2)
    36    })
    37  
    38    it('events', function () {
    39      // no parent
    40      res = merge({}, {events: 1})
    41      expect(res.events).toBe(1)
    42      // no child
    43      res = merge({events: 1}, {})
    44      expect(res.events).toBe(1)
    45  
    46      var fn1 = function () {}
    47      var fn2 = function () {}
    48      var fn3 = function () {}
    49      var parent = {
    50        events: {
    51          'fn1': [fn1, fn2],
    52          'fn2': fn2
    53        }
    54      }
    55      var child = {
    56        events: {
    57          'fn1': fn3,
    58          'fn2': fn3,
    59          'fn3': fn3
    60        }
    61      }
    62      var res = merge(parent, child).events
    63      assertRes(res.fn1, [fn1, fn2, fn3])
    64      assertRes(res.fn2, [fn2, fn3])
    65      assertRes(res.fn3, [fn3])
    66  
    67      function assertRes (res, expected) {
    68        expect(Array.isArray(res)).toBe(true)
    69        expect(res.length).toBe(expected.length)
    70        var i = expected.length
    71        while (i--) {
    72          expect(res[i]).toBe(expected[i])
    73        }
    74      }
    75    })
    76  
    77    it('normal object hashes', function () {
    78      var fn1 = function () {}
    79      var fn2 = function () {}
    80      var res
    81      // parent undefined
    82      res = merge({}, {methods: {test: fn1}}).methods
    83      expect(res.test).toBe(fn1)
    84      // child undefined
    85      res = merge({methods: {test: fn1}}, {}).methods
    86      expect(res.test).toBe(fn1)
    87      // both defined
    88      var parent = {methods: {test: fn1}}
    89      res = merge(parent, {methods: {test2: fn2}}).methods
    90      expect(res.test).toBe(fn1)
    91      expect(res.test2).toBe(fn2)
    92    })
    93  
    94    it('assets', function () {
    95      var asset1 = {}
    96      var asset2 = {}
    97      var res = merge(
    98        { directives: { a: asset1 }},
    99        { directives: { b: asset2 }}
   100      ).directives
   101      expect(res.a).toBe(asset1)
   102      expect(res.b).toBe(asset2)
   103    })
   104  
   105    it('props', function () {
   106      var res = merge({
   107        props: {
   108          a: null,
   109          d: null
   110        }
   111      }, {
   112        props: {
   113          a: { required: true },
   114          b: Boolean,
   115          c: { type: Array }
   116        }
   117      })
   118      expect(typeof res.props.a).toBe('object')
   119      expect(res.props.a.required).toBe(true)
   120      expect(typeof res.props.b).toBe('object')
   121      expect(res.props.b.type).toBe(Boolean)
   122      expect(typeof res.props.c).toBe('object')
   123      expect(res.props.c.type).toBe(Array)
   124      expect(res.props.d).toBe(null)
   125  
   126      // check array syntax
   127      res = merge({
   128        props: {
   129          b: null
   130        }
   131      }, {
   132        props: ['a']
   133      })
   134      expect(res.props.a).toBe(null)
   135      expect(res.props.b).toBe(null)
   136    })
   137  
   138    it('guard components', function () {
   139      var res = merge({
   140        components: null
   141      }, {
   142        components: {
   143          test: { template: 'foo' }
   144        }
   145      })
   146      expect(typeof res.components.test).toBe('function')
   147      expect(res.components.test.super).toBe(Vue)
   148    })
   149  
   150    it('guard components warn built-in elements', function () {
   151      merge({
   152        components: null
   153      }, {
   154        components: {
   155          a: { template: 'foo' }
   156        }
   157      })
   158      expect('Do not use built-in or reserved HTML elements as component id: a').toHaveBeenWarned()
   159      merge({
   160        components: null
   161      }, {
   162        components: {
   163          slot: { template: 'foo' }
   164        }
   165      })
   166      expect('Do not use built-in or reserved HTML elements as component id: slot').toHaveBeenWarned()
   167    })
   168  
   169    it('should ignore non-function el & data in class merge', function () {
   170      var res = merge({}, {el: 1, data: 2})
   171      expect(res.el).toBeUndefined()
   172      expect(res.data).toBeUndefined()
   173    })
   174  
   175    it('class el merge', function () {
   176      function fn1 () {}
   177      function fn2 () {}
   178      var res = merge({ el: fn1 }, { el: fn2 })
   179      expect(res.el).toBe(fn2)
   180    })
   181  
   182    it('class data merge', function () {
   183      function fn1 () {
   184        return { a: 1, c: 4, d: { e: 1 }}
   185      }
   186      function fn2 () {
   187        return { a: 2, b: 3, d: { f: 2 }}
   188      }
   189      // both present
   190      var res = merge({ data: fn1 }, { data: fn2 }).data()
   191      expect(res.a).toBe(2)
   192      expect(res.b).toBe(3)
   193      expect(res.c).toBe(4)
   194      expect(res.d.e).toBe(1)
   195      expect(res.d.f).toBe(2)
   196      // only parent
   197      res = merge({ data: fn1 }, {}).data()
   198      expect(res.a).toBe(1)
   199      expect(res.b).toBeUndefined()
   200      expect(res.c).toBe(4)
   201      expect(res.d.e).toBe(1)
   202      expect(res.d.f).toBeUndefined()
   203    })
   204  
   205    it('instanace el merge', function () {
   206      var vm = {} // mock vm presence
   207      function fn1 () {
   208        expect(this).toBe(vm)
   209        return 1
   210      }
   211      function fn2 () {
   212        expect(this).toBe(vm)
   213        return 2
   214      }
   215      // both functions
   216      var res = merge({ el: fn1 }, { el: fn2 }, vm)
   217      expect(res.el).toBe(2)
   218      // direct instance el
   219      res = merge({ el: fn1 }, { el: 2 }, vm)
   220      expect(res.el).toBe(2)
   221      // no parent
   222      res = merge({}, { el: 2 }, vm)
   223      expect(res.el).toBe(2)
   224      // no child
   225      res = merge({ el: fn1 }, {}, vm)
   226      expect(res.el).toBe(1)
   227    })
   228  
   229    it('instance data merge with no instance data', function () {
   230      var res = merge(
   231        {data: function () {
   232          return { a: 1}
   233        }},
   234        {}, // no instance data
   235        {} // mock vm presence
   236      )
   237      expect(res.data().a).toBe(1)
   238    })
   239  
   240    it('instance data merge with default data function', function () {
   241      var vm = {} // mock vm presence
   242      var res = merge(
   243        // component default
   244        { data: function () {
   245          expect(this).toBe(vm)
   246          return {
   247            a: 1,
   248            b: 2
   249          }
   250        }},
   251        { data: { a: 2 }}, // instance data
   252        vm
   253      )
   254      var data = res.data()
   255      expect(data.a).toBe(2)
   256      expect(data.b).toBe(2)
   257    })
   258  
   259    it('already observed instance data merge with default data', function () {
   260      var observe = require('src/observer').observe
   261      var instanceData = { a: 123 }
   262      // observe it
   263      observe(instanceData)
   264      var res = merge(
   265        {
   266          data: function () {
   267            return { b: 234 }
   268          }
   269        },
   270        {
   271          data: instanceData
   272        },
   273        {}
   274      )
   275      var data = res.data()
   276      expect(data.a).toBe(123)
   277      expect(data.b).toBe(234)
   278      expect(Object.getOwnPropertyDescriptor(data, 'b').get).toBeTruthy()
   279    })
   280  
   281    it('extends', function () {
   282      var f1 = function () {}
   283      var f2 = function () {}
   284      var f3 = function () {}
   285      var componentA = Vue.extend({ template: 'foo', methods: { f1: f1, f2: function () {} }})
   286      var componentB = { extends: componentA, methods: { f2: f2 }}
   287      var componentC = { extends: componentB, template: 'bar', methods: { f3: f3 }}
   288      var res = merge({}, componentC)
   289      expect(res.template).toBe('bar')
   290      expect(res.methods.f1).toBe(f1)
   291      expect(res.methods.f2).toBe(f2)
   292      expect(res.methods.f3).toBe(f3)
   293    })
   294  
   295    it('mixins', function () {
   296      var a = {}
   297      var b = {}
   298      var c = {}
   299      var d = {}
   300      var f1 = function () {}
   301      var f2 = function () {}
   302      var f3 = function () {}
   303      var f4 = function () {}
   304      var mixinA = { a: 1, directives: { a: a }, created: f2 }
   305      var mixinB = { b: 1, directives: { b: b }, created: f3 }
   306      var res = merge(
   307        { a: 2, directives: { c: c }, created: [f1] },
   308        { directives: { d: d }, mixins: [mixinA, mixinB], created: f4 }
   309      )
   310      expect(res.a).toBe(1)
   311      expect(res.b).toBe(1)
   312      expect(res.directives.a).toBe(a)
   313      expect(res.directives.b).toBe(b)
   314      expect(res.directives.c).toBe(c)
   315      expect(res.directives.d).toBe(d)
   316      expect(res.created[0]).toBe(f1)
   317      expect(res.created[1]).toBe(f2)
   318      expect(res.created[2]).toBe(f3)
   319      expect(res.created[3]).toBe(f4)
   320    })
   321  
   322    it('Array assets', function () {
   323      var a = {
   324        components: {
   325          a: Vue.extend({})
   326        }
   327      }
   328      var b = {
   329        components: [{ name: 'b' }]
   330      }
   331      var res = merge(a, b)
   332      expect(res.components.a).toBe(a.components.a)
   333      // b.components is guarded and converted to object hash
   334      expect(res.components.b).toBeTruthy()
   335      expect(res.components.b).toBe(b.components.b)
   336    })
   337  
   338    it('warn Array assets without id', function () {
   339      var a = {
   340        components: {
   341          a: Vue.extend({})
   342        }
   343      }
   344      var b = {
   345        components: [{}]
   346      }
   347      merge(a, b)
   348      expect('must provide a "name" or "id" field').toHaveBeenWarned()
   349    })
   350  
   351    it('warn Array async component without id', function () {
   352      var a = {
   353        components: {
   354          a: Vue.extend({})
   355        }
   356      }
   357      var b = {
   358        components: [function () {}]
   359      }
   360      merge(a, b)
   361      expect('must provide a "name" or "id" field').toHaveBeenWarned()
   362    })
   363  })
   364  
   365  describe('Util - Option resolveAsset', function () {
   366    var vm
   367    beforeEach(function () {
   368      vm = new Vue({
   369        data: {},
   370        components: {
   371          'hyphenated-component': {
   372            template: 'foo'
   373          },
   374          camelCasedComponent: {
   375            template: 'bar'
   376          },
   377          PascalCasedComponent: {
   378            template: 'baz'
   379          }
   380        }
   381      })
   382    })
   383  
   384    it('resolves', function () {
   385      expect(resolveAsset(vm.$options, 'components', 'hyphenated-component')).toBeTruthy()
   386      expect(resolveAsset(vm.$options, 'components', 'camel-cased-component')).toBeTruthy()
   387      expect(resolveAsset(vm.$options, 'components', 'pascal-cased-component')).toBeTruthy()
   388    })
   389  })