| import chai from 'chai' |
| import sinon from 'sinon' |
| import sinonChai from 'sinon-chai' |
| const { expect } = chai |
| chai.use(sinonChai) |
| |
| import * as compiler from '../../../../frameworks/legacy/vm/compiler' |
| import * as directive from '../../../../frameworks/legacy/vm/directive' |
| import { initState } from '../../../../frameworks/legacy/core/state' |
| |
| describe.skip('generate workflow', () => { |
| let contentIndex = 0 |
| const vm = {} |
| Object.assign(vm, compiler, directive, { |
| _watchers: [], |
| _createBlock: function () { return { element: {}} }, |
| _mergeContext: function () { return this }, |
| _createBody: type => { return { type } }, |
| _createElement: type => { return { type } }, |
| _attachTarget: (element, dest) => element, |
| _bindElement: () => {}, |
| _setId: function () {}, |
| _bindSubVm: function () {}, |
| _bindSubVmAfterInitialized: function () {}, |
| _applyNaitveComponentOptions: function () {} |
| }) |
| |
| vm.constructor = function () { |
| contentIndex++ |
| this._content = { index: contentIndex } |
| this.$on = sinon.spy() |
| } |
| |
| beforeEach(() => { |
| contentIndex = 0 |
| sinon.spy(vm, '_compile') |
| sinon.spy(vm, '_compileNativeComponent') |
| sinon.spy(vm, '_createBody') |
| sinon.spy(vm, '_createElement') |
| sinon.spy(vm, '_bindElement') |
| sinon.spy(vm, '_attachTarget') |
| sinon.spy(vm, '_createBlock') |
| sinon.spy(vm, '_mergeContext') |
| sinon.spy(vm, 'constructor') |
| }) |
| |
| afterEach(() => { |
| vm._compile.restore() |
| vm._compileNativeComponent.restore() |
| vm._createBody.restore() |
| vm._createElement.restore() |
| vm._bindElement.restore() |
| vm._attachTarget.restore() |
| vm._createBlock.restore() |
| vm._mergeContext.restore() |
| vm.constructor.restore() |
| contentIndex = 0 |
| }) |
| |
| it('generate a body', (done) => { |
| const target = { |
| type: 'a' |
| } |
| const dest = { |
| ref: '_documentElement' |
| } |
| |
| function check () { |
| expect(vm._compile).callCount(1) |
| expect(vm._compile).calledWith(target, dest) |
| expect(vm._createBody).callCount(1) |
| expect(vm._bindElement).callCount(1) |
| expect(vm._createElement).callCount(0) |
| expect(vm._attachTarget).callCount(1) |
| expect(vm._createBlock).callCount(0) |
| expect(vm._mergeContext).callCount(0) |
| expect(vm.constructor).callCount(0) |
| done() |
| } |
| |
| vm._compile(target, dest) |
| check() |
| }) |
| |
| it('generate a single element', (done) => { |
| const target = { |
| type: 'a' |
| } |
| const dest = {} |
| |
| function check () { |
| expect(vm._compile).callCount(1) |
| expect(vm._compile).calledWith(target, dest) |
| expect(vm._createBody).callCount(0) |
| expect(vm._bindElement).callCount(1) |
| expect(vm._createElement).callCount(1) |
| expect(vm._attachTarget).callCount(1) |
| expect(vm._createBlock).callCount(0) |
| expect(vm._mergeContext).callCount(0) |
| expect(vm.constructor).callCount(0) |
| done() |
| } |
| |
| vm._compile(target, dest) |
| check() |
| }) |
| |
| it('generate some child nodes', (done) => { |
| const target = [{ |
| type: 'a' |
| }, { |
| type: 'b' |
| }] |
| const dest = {} |
| |
| function check () { |
| expect(vm._compile).callCount(3) |
| expect(vm._compile.args[0]).eql( |
| [target, dest]) |
| expect(vm._compile.args[1]).eql( |
| [target[0], { element: {}}, undefined]) |
| expect(vm._compile.args[2]).eql( |
| [target[1], { element: {}}, undefined]) |
| expect(vm._createBlock).callCount(1) |
| expect(vm._mergeContext).callCount(0) |
| expect(vm.constructor).callCount(0) |
| done() |
| } |
| |
| vm._compile(target, dest) |
| check() |
| }) |
| |
| it('generate content holder', (done) => { |
| const target = { |
| type: 'a', children: [ |
| { type: 'b' }, |
| { type: 'content' }, |
| { type: 'c' } |
| ] |
| } |
| const dest = {} |
| |
| function check () { |
| expect(vm._compile).callCount(4) |
| expect(vm._compile.args[0]).eql( |
| [target, dest]) |
| expect(vm._compile.args[1]).eql( |
| [target.children[0], { type: 'a' }]) |
| expect(vm._compile.args[2]).eql( |
| [target.children[1], { type: 'a' }]) |
| expect(vm._compile.args[3]).eql( |
| [target.children[2], { type: 'a' }]) |
| expect(vm._content).is.an.object |
| expect(vm._content).eql({ element: {}}) |
| expect(vm._createBlock).callCount(1) |
| expect(vm._mergeContext).callCount(0) |
| expect(vm.constructor).callCount(0) |
| done() |
| } |
| |
| vm._compile(target, dest) |
| check() |
| }) |
| |
| it('generate a repeat element', (done) => { |
| const target = { |
| type: 'a', |
| repeat: () => [1, 2, 3] |
| } |
| const dest = {} |
| |
| function checkRepeatVm (args, target, meta) { |
| expect(args[0]).eql(target) |
| expect(args[2]).eql(meta) |
| const vm = args[1] |
| expect(vm.element).eql({}) |
| expect(vm.data).eql([1, 2, 3]) |
| } |
| |
| function check () { |
| expect(vm._compile).callCount(4) |
| expect(vm._compile.args[0]).eql([target, dest]) |
| checkRepeatVm(vm._compile.args[1], target, { repeat: 1 }) |
| checkRepeatVm(vm._compile.args[2], target, { repeat: 2 }) |
| checkRepeatVm(vm._compile.args[3], target, { repeat: 3 }) |
| expect(vm._createBlock).callCount(1) |
| expect(vm._mergeContext).callCount(3) |
| expect(vm.constructor).callCount(0) |
| done() |
| } |
| |
| vm._compile(target, dest) |
| check() |
| }) |
| |
| it('can\'t not use repeat on root element', (done) => { |
| const target = { |
| type: 'a', |
| repeat: () => [1, 2, 3] |
| } |
| const dest = { |
| type: 'document' |
| } |
| |
| function check () { |
| expect(vm._compile).callCount(1) |
| expect(vm._createBody).callCount(0) |
| expect(vm._createBlock).callCount(0) |
| expect(vm._mergeContext).callCount(0) |
| expect(vm.constructor).callCount(0) |
| done() |
| } |
| |
| vm._compile(target, dest) |
| check() |
| }) |
| |
| it('generate a shown element', (done) => { |
| const target = { |
| type: 'a', |
| shown: () => true |
| } |
| const dest = {} |
| |
| function check () { |
| expect(vm._compile).callCount(2) |
| expect(vm._compile.args[0]).eql( |
| [target, dest]) |
| expect(vm._compile.args[1][0]).eql(target) |
| expect(vm._compile.args[1][1].display).eql(true) |
| expect(vm._compile.args[1][2]).eql({ shown: true }) |
| expect(vm._createBlock).callCount(1) |
| expect(vm._mergeContext).callCount(0) |
| expect(vm.constructor).callCount(0) |
| done() |
| } |
| |
| vm._compile(target, dest) |
| check() |
| }) |
| |
| it('can\'t not use shown on root element', (done) => { |
| const target = { |
| type: 'a', |
| shown: () => true |
| } |
| const dest = { |
| type: 'document' |
| } |
| |
| function check () { |
| expect(vm._compile).callCount(1) |
| expect(vm._createBody).callCount(0) |
| expect(vm._createBlock).callCount(0) |
| expect(vm._mergeContext).callCount(0) |
| expect(vm.constructor).callCount(0) |
| done() |
| } |
| |
| vm._compile(target, dest) |
| check() |
| }) |
| |
| it('generate a repeat shown element', (done) => { |
| let index = 0 |
| const target = { |
| type: 'a', |
| repeat: () => [1, 2, 3], |
| shown: () => { |
| index++ |
| return index % 2 |
| } |
| } |
| const dest = {} |
| |
| function checkRepeatVm (args, target, meta) { |
| expect(args[0]).eql(target) |
| expect(args[2]).eql(meta) |
| const vm = args[1] |
| expect(vm.element).eql({}) |
| expect(vm.data).eql([1, 2, 3]) |
| } |
| |
| function check () { |
| expect(vm._compile).callCount(6) |
| expect(vm._compile.args[0]).eql([target, dest]) |
| checkRepeatVm(vm._compile.args[1], target, { repeat: 1 }) |
| expect(vm._compile.args[2][0]).eql(target) |
| expect(vm._compile.args[2][1].display).eql(true) |
| expect(vm._compile.args[2][2]).eql({ repeat: 1, shown: true }) |
| checkRepeatVm(vm._compile.args[3], target, { repeat: 2 }) |
| checkRepeatVm(vm._compile.args[4], target, { repeat: 3 }) |
| expect(vm._compile.args[5][0]).eql(target) |
| expect(vm._compile.args[5][1].display).eql(true) |
| expect(vm._compile.args[5][2]).eql({ repeat: 3, shown: true }) |
| expect(vm._createBlock).callCount(4) |
| expect(vm._mergeContext).callCount(3) |
| expect(vm.constructor).callCount(0) |
| done() |
| } |
| |
| vm._compile(target, dest) |
| check() |
| }) |
| |
| it('generate an element with children', (done) => { |
| const target = { |
| type: 'a', |
| children: [{ type: 'b' }, { type: 'c' }] |
| } |
| const dest = {} |
| |
| function check () { |
| expect(vm._compile).callCount(3) |
| expect(vm._compile.args[0]).eql([target, dest]) |
| expect(vm._compile.args[1]).eql([target.children[0], { type: 'a' }]) |
| expect(vm._compile.args[2]).eql([target.children[1], { type: 'a' }]) |
| expect(vm._createBlock).callCount(0) |
| expect(vm._mergeContext).callCount(0) |
| expect(vm.constructor).callCount(0) |
| done() |
| } |
| |
| vm._compile(target, dest) |
| check() |
| }) |
| |
| it('generate an whole element with children', (done) => { |
| const target = { |
| type: 'a', |
| append: 'tree', |
| children: [{ type: 'b' }, { type: 'c' }] |
| } |
| const dest = {} |
| |
| function check () { |
| expect(vm._compile).callCount(3) |
| expect(vm._compile.args[0]).eql([target, dest]) |
| expect(vm._compile.args[1]).eql([target.children[0], { |
| attr: { |
| append: 'tree' |
| }, type: 'a' }]) |
| expect(vm._compile.args[2]).eql([target.children[1], { |
| attr: { |
| append: 'tree' |
| }, type: 'a' }]) |
| expect(vm._createBlock).callCount(0) |
| expect(vm._mergeContext).callCount(0) |
| expect(vm.constructor).callCount(0) |
| done() |
| } |
| |
| vm._compile(target, dest) |
| check() |
| }) |
| |
| it('generate an element with repeat shown children', (done) => { |
| let index = 0 |
| const target = { |
| type: 'a', |
| children: [ |
| { |
| type: 'b', |
| repeat: () => [1, 2, 3], |
| shown: () => { |
| index++ |
| return index % 2 |
| } |
| }, |
| { type: 'c' } |
| ] |
| } |
| const dest = {} |
| |
| function checkRepeatVm (args, target, meta) { |
| expect(args[0]).eql(target) |
| expect(args[2]).eql(meta) |
| const vm = args[1] |
| expect(vm.element).eql({}) |
| expect(vm.data).eql([1, 2, 3]) |
| } |
| |
| function check () { |
| expect(vm._compile).callCount(8) |
| expect(vm._compile.args[0]).eql([target, dest]) |
| expect(vm._compile.args[1]).eql([target.children[0], { type: 'a' }]) |
| checkRepeatVm(vm._compile.args[2], target.children[0], { repeat: 1 }) |
| expect(vm._compile.args[3][0]).eql(target.children[0]) |
| expect(vm._compile.args[3][1].display).eql(true) |
| expect(vm._compile.args[3][2]).eql({ repeat: 1, shown: true }) |
| checkRepeatVm(vm._compile.args[4], target.children[0], { repeat: 2 }) |
| checkRepeatVm(vm._compile.args[5], target.children[0], { repeat: 3 }) |
| expect(vm._compile.args[6][0]).eql(target.children[0]) |
| expect(vm._compile.args[6][1].display).eql(true) |
| expect(vm._compile.args[6][2]).eql({ repeat: 3, shown: true }) |
| expect(vm._compile.args[7]).eql([target.children[1], { type: 'a' }]) |
| expect(vm._createBlock).callCount(4) |
| expect(vm._mergeContext).callCount(3) |
| expect(vm.constructor).callCount(0) |
| done() |
| } |
| |
| vm._compile(target, dest) |
| check() |
| }) |
| |
| it('generate an element with repeat shown tree', (done) => { |
| let index = 0 |
| const target = { |
| type: 'a', |
| children: [ |
| { |
| type: 'b', |
| children: [{ type: 'c' }], |
| repeat: () => [1, 2, 3], |
| shown: function () { |
| index++ |
| return index % 2 |
| } |
| }, |
| { type: 'd' } |
| ] |
| } |
| const dest = {} |
| |
| function checkRepeatVm (args, target, meta) { |
| expect(args[0]).eql(target) |
| expect(args[2]).eql(meta) |
| const vm = args[1] |
| expect(vm.element).eql({}) |
| expect(vm.data).eql([1, 2, 3]) |
| } |
| |
| function check () { |
| expect(vm._compile).callCount(10) |
| expect(vm._compile.args[0]).eql([target, dest]) |
| expect(vm._compile.args[1]).eql([target.children[0], { type: 'a' }]) |
| checkRepeatVm(vm._compile.args[2], target.children[0], { repeat: 1 }) |
| expect(vm._compile.args[3][0]).eql(target.children[0]) |
| expect(vm._compile.args[3][1].display).eql(true) |
| expect(vm._compile.args[3][2]).eql({ repeat: 1, shown: true }) |
| expect(vm._compile.args[4]).eql([target.children[0].children[0], |
| { type: 'b' }]) |
| checkRepeatVm(vm._compile.args[5], target.children[0], { repeat: 2 }) |
| checkRepeatVm(vm._compile.args[6], target.children[0], { repeat: 3 }) |
| expect(vm._compile.args[7][0]).eql(target.children[0]) |
| expect(vm._compile.args[7][1].display).eql(true) |
| expect(vm._compile.args[7][2]).eql({ repeat: 3, shown: true }) |
| expect(vm._compile.args[8]).eql([target.children[0].children[0], |
| { type: 'b' }]) |
| expect(vm._compile.args[9]).eql([target.children[1], { type: 'a' }]) |
| expect(vm._createBlock).callCount(4) |
| expect(vm._mergeContext).callCount(3) |
| expect(vm.constructor).callCount(0) |
| done() |
| } |
| |
| vm._compile(target, dest) |
| check() |
| }) |
| |
| it('generate an element with custom children', (done) => { |
| const target = { |
| type: 'a', |
| children: [ |
| { type: 'b', component: true }, |
| { type: 'c' } |
| ] |
| } |
| const dest = {} |
| |
| function check () { |
| expect(vm._compile).callCount(3) |
| expect(vm._compile.args[0]).eql([target, dest]) |
| expect(vm._compile.args[1]).eql([target.children[0], { type: 'a' }]) |
| expect(vm._compile.args[2]).eql([target.children[1], { type: 'a' }]) |
| expect(vm._createBlock).callCount(0) |
| expect(vm._mergeContext).callCount(0) |
| expect(vm.constructor).callCount(1) |
| expect(vm.constructor.args[0][0]).eql('b') |
| expect(vm.constructor.args[0][1]).eql({}) |
| expect(vm.constructor.args[0][3]).eql({ type: 'a' }) |
| done() |
| } |
| |
| vm._compile(target, dest) |
| check() |
| }) |
| |
| it('with custom repeat show children', (done) => { |
| let index = 0 |
| const target = { |
| type: 'a', |
| children: [ |
| { |
| type: 'b', |
| component: true, |
| repeat: () => [1, 2, 3], |
| shown: function () { |
| index++ |
| return index % 2 |
| } |
| }, |
| { type: 'd' } |
| ] |
| } |
| const dest = {} |
| |
| function checkRepeatVm (args, target, meta) { |
| expect(args[0]).eql(target) |
| expect(args[2]).eql(meta) |
| const vm = args[1] |
| expect(vm.element).eql({}) |
| expect(vm.data).eql([1, 2, 3]) |
| } |
| |
| function check () { |
| expect(vm._compile).callCount(8) |
| expect(vm._compile.args[0]).eql([target, dest]) |
| expect(vm._compile.args[1]).eql([target.children[0], { type: 'a' }]) |
| checkRepeatVm(vm._compile.args[2], target.children[0], { repeat: 1 }) |
| expect(vm._compile.args[3][0]).eql(target.children[0]) |
| expect(vm._compile.args[3][1].display).eql(true) |
| expect(vm._compile.args[3][2]).eql({ repeat: 1, shown: true }) |
| checkRepeatVm(vm._compile.args[4], target.children[0], { repeat: 2 }) |
| checkRepeatVm(vm._compile.args[5], target.children[0], { repeat: 3 }) |
| expect(vm._compile.args[6][0]).eql(target.children[0]) |
| expect(vm._compile.args[6][1].display).eql(true) |
| expect(vm._compile.args[6][2]).eql({ repeat: 3, shown: true }) |
| expect(vm._compile.args[7]).eql([target.children[1], { type: 'a' }]) |
| expect(vm._createBlock).callCount(4) |
| expect(vm._mergeContext).callCount(3) |
| |
| expect(vm.constructor).callCount(2) |
| expect(vm.constructor.args[0][0]).eql('b') |
| expect(vm.constructor.args[0][3]).eql({ element: {}, display: true }) |
| expect(vm.constructor.args[1][0]).eql('b') |
| expect(vm.constructor.args[1][3]).eql({ element: {}, display: true }) |
| |
| done() |
| } |
| |
| vm._compile(target, dest) |
| check() |
| }) |
| }) |
| |
| describe.skip('merge context', () => { |
| const { mergeContext } = compiler |
| let vm |
| |
| beforeEach(() => { |
| vm = { |
| _data: { a: 1, b: 2 } |
| } |
| initState(vm) |
| }) |
| |
| afterEach(() => { |
| vm = null |
| }) |
| |
| it('merge external data', () => { |
| const context = mergeContext(vm, { a: 3 }) |
| expect(context).not.equal(vm) |
| expect(context.a).eql(3) |
| expect(context.b).eql(2) |
| }) |
| |
| it('react with changes, but not with internal for ext-key', () => { |
| const context = mergeContext(vm, { a: 3 }) |
| vm.a = 4 |
| vm.b = 5 |
| expect(context.a).eql(3) |
| expect(context.b).eql(5) |
| context.a = 6 |
| expect(context.a).eql(6) |
| }) |
| |
| it('merge external data if key not bound', () => { |
| const context = mergeContext(vm, { c: 3 }) |
| expect(context).not.equal(vm) |
| expect(context.a).eql(1) |
| expect(context.b).eql(2) |
| expect(context.c).eql(3) |
| }) |
| |
| it('not react with changes for extra key', () => { |
| const context = mergeContext(vm, { c: 3 }) |
| vm.c = 9 |
| expect(context.a).eql(1) |
| expect(context.b).eql(2) |
| expect(context.c).eql(3) |
| }) |
| }) |
