Specs (#6)

* wire up specs

* tests + fixes for #1

* travis

test/unit/index.js

@@ -0,0 +1,13 @@
+import Vue from 'vue'
+
+Vue.config.productionTip = false
+
+// require all test files (files that ends with .spec.js)
+const testsContext = require.context('./specs', true, /\.spec$/)
+testsContext.keys().forEach(testsContext)
+
+// require all src files except main.js for coverage.
+// you can also change this to match only the subset of files that
+// you want coverage for.
+const srcContext = require.context('../../src', true, /^\.\/(?!main(\.js)?$)/)
+srcContext.keys().forEach(srcContext)

test/unit/karma.conf.js

@@ -0,0 +1,44 @@
+var webpackConfig = require('../../webpack.config.js')
+
+module.exports = function (config) {
+  configuration = {
+    browsers: [
+      //'Chrome'
+      'ChromeHeadless'
+    ],
+    frameworks: [
+      'mocha',
+      'sinon-chai'
+    ],
+    reporters: ['spec', 'coverage'],
+    files: ['./index.js'],
+    preprocessors: {
+      './index.js': ['webpack', 'sourcemap']
+    },
+    webpack: webpackConfig,
+    webpackMiddleware: {
+      noInfo: true
+    },
+    coverageReporter: {
+      dir: './coverage',
+      reporters: [
+        { type: 'lcov', subdir: '.' },
+        { type: 'text-summary' }
+      ]
+    },
+    customLaunchers: {
+      ChromeHeadless: {
+        base: 'Chrome',
+        flags: [
+          '--headless',
+          '--disable-gpu',
+          // Without a remote debugging port, Google Chrome exits immediately.
+          '--remote-debugging-port=9222',
+        ]
+      }
+    }
+  }
+
+  config.set(configuration)
+}
+

test/unit/specs/Emitter.spec.js

@@ -0,0 +1,41 @@
+import Vue from 'vue'
+
+// bring in the Emitter class, not the singleton
+let EmitterClass = require('exports-loader?Emitter!@/Emitter')
+
+describe ("Emitter.js", () => {
+
+  let vm = new Vue()
+  let Emitter
+
+  beforeEach (() => {
+    Emitter = new EmitterClass()
+  })
+
+  it ('registers an handler', () => {
+    expect(Emitter.listeners.size).to.equal(0)
+    Emitter.addListener('[event_type]', (value) => {}, vm)
+    expect(Emitter.listeners.size).to.equal(1)
+  })
+
+  it ('unregisters a registered handler', () => {
+    let event_type = 'atype', cb = (value) => {}
+    should.not.exist(Emitter.listeners.get(event_type))
+    Emitter.addListener(event_type, cb, vm)
+    expect(Emitter.listeners.get(event_type).length).to.equal(1)
+    Emitter.removeListener(event_type, cb, vm)
+    expect(Emitter.listeners.get(event_type).length).to.equal(0)
+  })
+
+  it ('fires an events', (done) => {
+    let event_type = 'syn', expected_response = 'ack'
+    expect(Emitter.listeners.size).to.equal(0)
+    Emitter.addListener(event_type, (value) => {
+      expect(value).to.equal(expected_response)
+      done()
+    }, vm)
+    expect(Emitter.listeners.size).to.equal(1)
+    Emitter.emit(event_type, expected_response)
+  })
+
+})

test/unit/specs/Main.spec.js

@@ -0,0 +1,21 @@
+import Vue from 'vue'
+import VueNativeSock from '@/Main'
+
+import { Server } from 'mock-socket'
+
+describe("Main.js", () =>{
+
+  let mockServer
+
+  it ('can be bound to the onopen event', (done) => {
+    mockServer = new Server('ws://localhost:8080')
+    Vue.use(VueNativeSock, 'ws://localhost:8080', null)
+    let vm = new Vue()
+    vm.$options.sockets.onopen = (data) => {
+      expect(data.type).to.equal('open')
+      mockServer.stop(done)
+    }
+  })
+
+})
+

test/unit/specs/Observer.spec.js

@@ -0,0 +1,77 @@
+import Vue from 'vue'
+import Emitter from '@/Emitter'
+import Observer from '@/Observer'
+
+import { Server, WebSocket } from 'mock-socket'
+
+describe ("Observer.js", () => {
+  let observer, mockServer
+
+  let wsUrl = 'ws://localhost:8080'
+
+  it ('fires onopen event', (done) => {
+    mockServer = new Server(wsUrl)
+    mockServer.on('connection', ws => {
+      ws.send('hi')
+    })
+    Vue.use(VueNativeSock, wsUrl)
+    let vm = new Vue()
+    observer = new Observer(wsUrl)
+    Emitter.addListener('onopen', (data) => {
+      expect(data.type).to.equal('open')
+      mockServer.stop(done)
+    }, vm)
+  })
+
+  // TODO: DRY
+  it ('passes a json event to the provided vuex store', (done) => {
+    let expectedMsg = { mutation: 'setName', value: 'steve' }
+    let mockStore = sinon.mock({ commit: () => {} })
+    mockStore.expects('commit').withArgs('SOCKET_ONOPEN')
+    mockStore.expects('commit').withArgs(expectedMsg.mutation)
+
+    mockServer = new Server(wsUrl)
+    mockServer.on('connection', ws => {
+      ws.send(JSON.stringify(expectedMsg))
+    })
+
+    Vue.use(VueNativeSock, wsUrl)
+    let vm = new Vue()
+    observer = new Observer(wsUrl, null, mockStore.object, {
+      format: 'json',
+      websocket: new WebSocket(wsUrl)
+    })
+
+    setTimeout(() => {
+      mockStore.verify()
+      mockServer.stop(done)
+    }, 100)
+  })
+
+  // TODO: DRY
+  it ('passes a namespaced json event to the provided vuex store', (done) => {
+    let expectedMsg = { namespace: 'users', mutation: 'setName', value: 'steve' }
+    let mockStore = sinon.mock({ commit: () => {} })
+    mockStore.expects('commit').withArgs('SOCKET_ONOPEN')
+    mockStore.expects('commit').withArgs(expectedMsg.namespace + '/' + expectedMsg.mutation)
+
+    mockServer = new Server(wsUrl)
+    mockServer.on('connection', ws => {
+      ws.send(JSON.stringify(expectedMsg))
+    })
+
+    Vue.use(VueNativeSock, wsUrl)
+    let vm = new Vue()
+    observer = new Observer(wsUrl, null, mockStore.object, {
+      format: 'json',
+      websocket: new WebSocket(wsUrl)
+    })
+
+    setTimeout(() => {
+      mockStore.verify()
+      mockServer.stop(done)
+    }, 100)
+  })
+
+})
+