| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| import * as utils from '../../../../render/vue/utils/func' |
| describe('utils', function () { |
| describe('function', function () { |
| before(() => { |
| this.clock = sinon.useFakeTimers() |
| }) |
| after(() => { |
| this.clock.restore() |
| }) |
| it('extend', () => { |
| const { |
| extend |
| } = utils |
| expect(extend).to.be.a('function') |
| const abc = { |
| name: 'abc' |
| } |
| expect(extend(abc)).to.deep.equal(abc) |
| expect(extend(abc, { |
| name: 'x' |
| }) === abc).to.be.true |
| expect(abc).to.deep.equal({ |
| name: 'x' |
| }) |
| expect(abc).to.deep.equal({ |
| name: 'x' |
| }) |
| expect(extend(abc, {})).to.be.deep.equal(abc) |
| }) |
| it('extendTruthy', () => { |
| const { |
| extendTruthy |
| } = utils |
| expect(extendTruthy).to.be.a('function') |
| const from = { |
| '': '', |
| 'undefined': 'undefined', |
| 0: '0', |
| test: 'test' |
| } |
| expect(extendTruthy({}, [from])[0]).to.be.deep.equal(from) |
| expect(extendTruthy({}, [])).to.be.deep.equal({}) |
| }) |
| it('extendKeys', () => { |
| const { |
| extendKeys |
| } = utils |
| expect(extendKeys).to.be.a('function') |
| const from = { |
| test1: 'test1', |
| test2: 'test2' |
| } |
| const expected = { |
| test1: 'test1' |
| } |
| expect(extendKeys({}, from, ['test1'])).to.be.deep.equal(expected) |
| }) |
| it('extractKeys', () => { |
| const { |
| extractKeys |
| } = utils |
| expect(extractKeys).to.be.a('function') |
| const from = { |
| test1: 'test1', |
| test2: 'test2' |
| } |
| const toExpected = { |
| test1: 'test1' |
| } |
| const fromExpected = { |
| test2: 'test2' |
| } |
| expect(extractKeys({}, from, ['test1'])).to.be.deep.equal(toExpected) |
| expect(from).to.be.deep.equal(fromExpected) |
| expect(extractKeys({}, {}, [])).to.be.deep.equal({}) |
| }) |
| it('bind', () => { |
| const { |
| bind |
| } = utils |
| const testfn = function (name) { |
| if (name) { |
| this.name = name |
| } |
| return this.name ? this.name : '' |
| } |
| function TEST () { |
| this.name = 'test' |
| } |
| const shouldBe = bind(testfn, new TEST())() |
| expect(bind).to.be.a('function') |
| expect(shouldBe).to.be.equal('test') |
| }) |
| it('debounce', () => { |
| const { |
| debounce |
| } = utils |
| const shouldBe = 'test' |
| let expected |
| debounce(() => { |
| expected = shouldBe |
| }, 500)() |
| this.clock.tick(500) |
| expect(shouldBe).to.be.equal(expected) |
| expect(debounce).to.be.a('function') |
| }) |
| it('depress', () => { |
| const { |
| depress |
| } = utils |
| const shouldBe = 'test' |
| let expected |
| depress(() => { |
| expected = shouldBe |
| }, 100)() |
| this.clock.tick(100) |
| expect(shouldBe).to.be.equal(expected) |
| expect(depress).to.be.a('function') |
| }) |
| it('throttle', () => { |
| const { |
| throttle |
| } = utils |
| let expected |
| const wait = 100 |
| const throttlecb = throttle(function (parmas) { |
| expected = parmas |
| }, wait, true) |
| throttlecb('test1') |
| setTimeout(() => { |
| throttlecb('test2') |
| }, 50) |
| this.clock.tick(wait) |
| this.clock.tick(50) |
| this.clock.tick(wait + (wait > 25 ? wait : 25)) |
| expect(expected).to.be.equal('test1') |
| expect(throttle).to.be.a('function') |
| }) |
| it('loopArray', () => { |
| const { |
| loopArray |
| } = utils |
| expect(loopArray).to.be.a('function') |
| expect(loopArray()).to.be.equal(undefined) |
| expect(loopArray([1, 2, 3], 1)).to.be.deep.equal([3, 1, 2]) |
| expect(loopArray([1, 2, 3], -1)).to.be.deep.equal([2, 3, 1]) |
| expect(loopArray([1, 2, 3], 0)).to.be.deep.equal([1, 2, 3]) |
| }) |
| it('cached', () => { |
| expect(utils.cached).to.be.a('function') |
| }) |
| it('camelize', () => { |
| const { |
| camelize |
| } = utils |
| expect(camelize).to.be.a('function') |
| expect(camelize('')).to.be.equal('') |
| expect(camelize('dispaly')).to.be.equal('dispaly') |
| expect(camelize('-webkit-transform')).to.be.equal('WebkitTransform') |
| expect(camelize('text-overflow')).to.be.equal('textOverflow') |
| expect(camelize('a-b-c-d')).to.be.equal('aBCD') |
| }) |
| it('camelizeKeys', () => { |
| const { |
| camelizeKeys |
| } = utils |
| const camelizeobj = { |
| dispaly: 'none', |
| '-webkit-transform': 'all 1s ease' |
| } |
| const shouldBe = camelizeKeys(camelizeobj) |
| const expected = { |
| dispaly: 'none', |
| WebkitTransform: 'all 1s ease' |
| } |
| expect(camelizeKeys).to.be.a('function') |
| expect(shouldBe).to.be.deep.equal(expected) |
| }) |
| it('capitalize', () => { |
| const { |
| capitalize |
| } = utils |
| expect(capitalize).to.be.a('function') |
| expect(capitalize('')).to.be.equal('') |
| expect(capitalize('string')).to.be.equal('String') |
| expect(capitalize('string object')).to.be.equal('String object') |
| expect(capitalize('[string object]')).to.be.equal('[string object]') |
| expect(capitalize('I have an apple')).to.be.equal('I have an apple') |
| }) |
| it('hyphenate', () => { |
| const { |
| hyphenate |
| } = utils |
| expect(hyphenate).to.be.a('function') |
| expect(hyphenate('')).to.be.equal('') |
| expect(hyphenate('dispaly')).to.be.equal('dispaly') |
| expect(hyphenate('WebkitTransform')).to.be.equal('webkit-transform') |
| expect(hyphenate('textOverflow')).to.be.equal('text-overflow') |
| expect(hyphenate('aBCD')).to.be.equal('a-b-c-d') |
| }) |
| it('hyphenateKeys', () => { |
| const { |
| hyphenateKeys |
| } = utils |
| const hyphenateobj = { |
| dispaly: 'none', |
| WebkitTransform: 'all 1s ease' |
| } |
| const shouldBe = hyphenateKeys(hyphenateobj) |
| const expected = { |
| dispaly: 'none', |
| 'webkit-transform': 'all 1s ease' |
| } |
| expect(hyphenateKeys).to.be.a('function') |
| expect(shouldBe).to.be.deep.equal(expected) |
| }) |
| it('hyphenateStyleKeys', () => { |
| const { |
| hyphenateStyleKeys |
| } = utils |
| const hyphenateStyleObj = { |
| dispaly: 'none', |
| 'webkit-transform': 'all 1s ease' |
| } |
| const shouldBe = hyphenateStyleKeys(hyphenateStyleObj) |
| const expected = { |
| dispaly: 'none', |
| '-webkit-transform': 'all 1s ease' |
| } |
| expect(hyphenateStyleKeys).to.be.a('function') |
| expect(shouldBe).to.be.deep.equal(expected) |
| }) |
| it('camelToKebab', () => { |
| const { |
| camelToKebab |
| } = utils |
| expect(camelToKebab).to.be.a('function') |
| expect(camelToKebab('')).to.be.equal('') |
| expect(camelToKebab('ABC')).to.be.equal('-a-b-c') |
| }) |
| it('appendCss', () => { |
| const { |
| appendCss |
| } = utils |
| const cssid = 'append-test' |
| const css = '.test{font-size:12px}' |
| expect(appendCss).to.be.a('function') |
| appendCss(css, cssid, true) |
| let handler = document.querySelector('#' + cssid) |
| expect(handler.textContent).to.be.equal(css) |
| const anothercss = '.test2{font-size:16px}' |
| appendCss(anothercss, cssid, true) |
| handler = document.querySelector('#' + cssid) |
| expect(handler.textContent).to.be.equal(anothercss) |
| }) |
| it('nextFrame', done => { |
| const { |
| nextFrame |
| } = utils |
| let shouldBe |
| const expected = 'test' |
| const cb = () => { |
| shouldBe = expected |
| } |
| expect(nextFrame).to.be.a('function') |
| this.clock.restore() |
| nextFrame(cb) |
| setTimeout(() => { |
| expect(shouldBe).to.be.equal(expected) |
| done() |
| }, 10) |
| }) |
| it('toCSSText', () => { |
| const { |
| toCSSText |
| } = utils |
| const expected = 'font-size:12px;' |
| const shouldBe = toCSSText({ |
| 'font-size': '12px' |
| }) |
| expect(toCSSText).to.be.a('function') |
| expect(shouldBe).to.be.equal(expected) |
| }) |
| }) |
| }) |
