module test

Author: leozdgao

package.json

@@ -41,7 +41,6 @@
     "jest-cli": "^0.9.2",
     "karma": "~0.13.22",
     "karma-chai": "~0.1.0",
-    "karma-chrome-launcher": "~0.2.3",
     "karma-mocha": "~0.2.2",
     "karma-mocha-reporter": "~2.0.0",
     "karma-phantomjs-launcher": "~1.0.0",

src/utils.js

@@ -63,7 +63,7 @@ export const series = (...tasks) => (each) => (cb) => {
     const key = nextKey.next()
     let thunk = tasks[key]
     if (Array.isArray(thunk)) thunk = parallel.apply(null, thunk).call(null, each)
-    return [ key, thunk ]
+    return [ +key, thunk ] // convert `key` to number
   }
   let key, thunk
   let next = nextThunk()

test/index.spec.js

@@ -0,0 +1,74 @@
+const ReactTestUtils = require('react-addons-test-utils')
+const React = require('react')
+const AsyncScriptLoader = require('../src').default
+
+class TestComponent extends React.Component {
+  render () {
+    return <div></div>
+  }
+}
+
+function renderTestComponent (deps, onScriptLoaded) {
+  const MockedComponent = AsyncScriptLoader.apply(null, deps)(TestComponent)
+  const result = ReactTestUtils.renderIntoDocument(<MockedComponent onScriptLoaded={onScriptLoaded} />)
+
+  return ReactTestUtils.findRenderedComponentWithType(result, TestComponent)
+}
+
+function checkScriptLoaded (getComponent, done) {
+  return _ => {
+    const com = getComponent()
+    console.log(com)
+
+    expect(com.props.isScriptLoaded).to.be.true
+    expect(com.props.isScriptLoadSucceed).to.be.true
+
+    done()
+  }
+}
+
+describe('Test this module', _ => {
+  it('[react-async-script-loader] Load external script after component mounted',
+    function (done) {
+      const deps = [ '//cdn.bootcss.com/jquery/2.2.1/jquery.min.js' ]
+      const com = renderTestComponent(deps, onScriptLoaded)
+
+      // check script tags
+      deps.forEach(testScript => {
+        const tag = document.querySelector(`script[src='${testScript}']`)
+        expect(tag).to.be.exist
+      })
+
+      // check component props before loading
+      expect(com.props.isScriptLoaded).to.be.false
+      expect(com.props.isScriptLoadSucceed).to.be.false
+
+      function onScriptLoaded () {
+        expect(com.props.isScriptLoaded).to.be.true
+        expect(com.props.isScriptLoadSucceed).to.be.true
+
+        done()
+      }
+    }
+  )
+
+  it('[react-async-script-loader] No redundant script tag will be appended',
+    function (done) {
+      const deps = [ '//cdn.bootcss.com/jquery/2.2.1/jquery.min.js' ]
+      const com0 = renderTestComponent(deps, checkScriptLoaded(_ => com0, checkAllDone))
+      const com1 = renderTestComponent(deps, checkScriptLoaded(_ => com1, checkAllDone))
+      let count = 0
+
+      // check script tags
+      deps.forEach(testScript => {
+        const tags = document.querySelectorAll(`script[src='${testScript}']`)
+        expect(tags.length).to.equal(1)
+      })
+
+      function checkAllDone () {
+        count ++
+        if (count == 2) done()
+      }
+    }
+  )
+})

test/utils.spec.js

@@ -1,19 +1,65 @@
 const { newScript, parallel, series } = require('../src/utils')
 
 describe('Test util functions', _ => {
+  const testTask = v => cb => setTimeout(_ => cb(null, v), 100)
+  const taskBundle = [1, 2, 3, 4, 5].map(testTask)
 
   it('[utils/newScript] A thunk task, append new script tag', function (done) {
     const testScript = '//cdn.bootcss.com/jquery/2.2.1/jquery.min.js'
     const task = newScript(testScript)
 
-    task(function (err, src) {
+    // start task
+    task((err, src) => {
       const tag = document.querySelector(`script[src='${testScript}']`)
 
+      // assert
       expect(err).to.not.exist
       expect(src).to.equal(testScript)
       expect(tag).to.exist
 
       done()
     })
   })
+
+  it('[utils/parallel] Run thunk task in parallel mode', function (done) {
+    const startTime = Date.now()
+
+    parallel.apply(null, taskBundle)((err, val, i) => {
+      // assert for iteration
+      expect(err).to.not.exist
+      expect(val).to.equal(i + 1)
+    })((err, ret) => {
+      const finishTime = Date.now()
+      const delta = finishTime - startTime
+
+      // assert for success callback
+      expect(err).to.not.exist
+      expect(ret).to.eql([1, 2, 3, 4, 5])
+      // check execute time, parallel mode would take about >100, <200 ms
+      expect(delta).to.be.below(200)
+
+      done()
+    })
+  })
+
+  it('[utils/series] Run thunk task in series mode', function (done) {
+    const startTime = Date.now()
+
+    series.apply(null, taskBundle)((err, val, i) => {
+      // assert for iteration
+      expect(err).to.not.exist
+      expect(val).to.equal(i + 1)
+    })((err, ret) => {
+      const finishTime = Date.now()
+      const delta = finishTime - startTime
+
+      // assert for success callback
+      expect(err).to.not.exist
+      expect(ret).to.eql([1, 2, 3, 4, 5])
+      // check execute time, series mode would >500 ms
+      expect(delta).to.be.above(500)
+
+      done()
+    })
+  })
 })