feature | added tests

package.json

@@ -21,16 +21,29 @@
     "url": "git+https://github.com/pagekit/vue-event-manager.git"
   },
   "scripts": {
+    "test": "jest --env=node",
+    "karma": "karma start test/karma.conf.js --single-run",
     "build": "node build/build.js",
-    "release": "node build/release.js"
+    "release": "node build/release.js",
+    "webpack": "webpack --config test/webpack.config.js -wd"
   },
   "devDependencies": {
     "buble": "^0.15.2",
     "buble-loader": "^0.4.1",
-    "jest": "^21.0.2",
+    "jasmine": "^2.8.0",
+    "jasmine-core": "^2.8.0",
+    "jest": "^22.0.3",
+    "karma": "^1.7.1",
+    "karma-chrome-launcher": "^2.2.0",
+    "karma-firefox-launcher": "^1.1.0",
+    "karma-jasmine": "^1.1.1",
+    "karma-safari-launcher": "^1.0.0",
+    "karma-webpack": "^2.0.9",
     "replace-in-file": "^2.6.4",
     "rollup": "^0.49.3",
     "rollup-plugin-buble": "^0.15.0",
-    "uglify-js": "^3.1.0"
+    "uglify-js": "^3.1.0",
+    "vue": "^2.5.13",
+    "webpack": "^3.10.0"
   }
 }

test/event.js

@@ -0,0 +1,141 @@
+import Vue from 'vue';
+
+describe('Vue.eventmanager', () => {
+
+  it('Trigger Method with one param', () => {
+    new Vue({
+      created() {
+        this.$trigger('someEvent', 'foo');
+      },
+      events: {
+        someEvent(param) { 
+          expect(param).toBe('foo');
+        }
+      }
+    });
+  });
+
+  it('Trigger Method with Array', () => {
+    new Vue({
+      created() {
+        this.$trigger('paramArray', ['foo', 'bar']);
+      },
+      events: {
+        paramArray(param, param2) { 
+          expect(param).toBe('foo');
+          expect(param2).toBe('bar');
+        }
+      }
+    });
+  });
+
+  it('Trigger Method with Object', () => {
+    new Vue({
+      created() {
+        this.$trigger('paramObject', { foo : 'bar' });
+      },
+      events: {
+        paramObject(param) { 
+          expect(param.foo).toBe('bar');
+        }
+      }
+    });
+  });
+
+  it('Trigger Method with Priority', () => {
+    var vm = new Vue({
+      data() {
+        return {
+          lastPrio : null
+        }
+      },
+      events: {
+        // event handler (priority 10)
+        prioHandler: [
+          {
+            // handler callback
+            handler(param) {
+              this.lastPrio = 10;
+            },
+            // a higher priority, means earlier execution
+            priority: 10
+          },
+          {
+            // handler callback
+            handler(param) {
+              expect(this.lastPrio).toBe(10);
+              this.lastPrio = -10;
+            },
+            // a higher priority, means earlier execution
+            priority: -10
+          }
+        ]
+      }
+    });
+    vm.$trigger('prioHandler');
+  });
+
+
+  it('Trigger Method with Different Instances and Priority', () => {
+
+    var vm1 = new Vue({
+      data() {
+        return {
+          isLoaded : false
+        }
+      },
+      events: {
+        testEvent(param) { 
+          this.isLoaded = true;
+          expect(this.isLoaded).toBe(true);
+        }
+      }
+    });
+
+    var vm2 = new Vue({
+      events: {
+        testEvent:{
+          handler(param) { 
+           expect(param).toBe('foo');
+          },
+          priority: 10
+        }
+      }
+    });
+   vm1.$trigger('testEvent', 'foo');
+  });  
+
+  it('Trigger Method with Cancel Event', () => {
+
+    var vm1 = new Vue({
+      data() {
+        return {
+          isLoaded: false
+        }
+      },
+      events: {
+        actionCancel(param) { 
+          this.isLoaded = true;
+          return "lastAction";
+        }
+      }
+    });
+
+    var vm2 = new Vue({
+      events: {
+        actionCancel:{
+          handler(param) { 
+           expect(param).toBe('foo');
+           return false;
+          },
+          priority: 10
+        }
+      }
+    });
+
+    vm1.$trigger('actionCancel', 'foo');
+    expect(vm1.isLoaded).toBe(false);
+
+  });
+
+});

test/eventAsync.js

@@ -0,0 +1,60 @@
+import Vue from 'vue';
+
+describe('Vue.eventmanager Async', () => {
+  it('Trigger Method asynchronous', () => {
+    new Vue({
+      data() {
+        return {
+          isRun : false
+        }
+      },
+      created() {
+        this.$trigger('setRun', [], true);
+        this.$trigger('sendParam', 'foo');
+      },
+      events: {
+        setRun() { 
+          this.isRun = true;
+          expect(this.isRun).toBe(true);
+        },
+        sendParam(param) { 
+          expect(this.isRun).toBe(false);
+        }
+      }
+    });
+  });
+
+  it('Trigger Method asynchronous with Different Instances', (done) => {
+
+    var vm1 = new Vue({
+      data() {
+        return {
+          isLoaded : false
+        }
+      },
+      events: {
+        testEvent(param) { 
+          this.isLoaded = true;
+          expect(this.isLoaded).toBe(true);
+          done();
+        }
+      }
+    });
+
+    var vm2 = new Vue({
+      events: {
+        testEvent:{
+          handler(param) { 
+           expect(param).toBe('foo');
+           return new Promise((resolve) => {
+            setTimeout(resolve, 300);
+           });
+          },
+          priority: 10
+        }
+      }
+    });
+   vm1.$trigger('testEvent', 'foo', true);
+  });
+
+});

test/index.html

@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Vue EventManager - Jasmine</title>
+
+  <link rel="shortcut icon" type="image/png" href="../node_modules/jasmine-core/images/jasmine_favicon.png">
+  <link rel="stylesheet" href="../node_modules/jasmine-core/lib/jasmine-core/jasmine.css">
+
+  <script src="../node_modules/jasmine-core/lib/jasmine-core/jasmine.js"></script>
+  <script src="../node_modules/jasmine-core/lib/jasmine-core/jasmine-html.js"></script>
+  <script src="../node_modules/jasmine-core/lib/jasmine-core/boot.js"></script>
+  <script src="specs.js"></script>
+
+</head>
+<body>
+</body>
+</html>

test/index.js

@@ -0,0 +1,9 @@
+import Vue from 'vue';
+import VueEventManager from '../src/index';
+
+Vue.use(VueEventManager);
+
+x();
+
+require('./event');
+require('./eventAsync');

test/karma.conf.js

@@ -0,0 +1,15 @@
+module.exports = config => {
+
+  config.set({
+    basePath: __dirname,
+    frameworks: ['jasmine'],
+    browsers: ['Chrome', 'Safari', 'Firefox'],
+    files: ['index.js'],
+    preprocessors: {
+      'index.js' : ['webpack']
+    },
+    proxies: {
+
+    }
+  });
+};

test/webpack.config.js

@@ -0,0 +1,17 @@
+var webpack = require('webpack');
+
+module.exports = {
+    entry: __dirname + '/index.js',
+    output: {
+        path: __dirname + '/',
+        filename: 'specs.js'
+    },
+    module: {
+        loaders: [
+            {test: /\.js$/, loader: 'buble-loader', exclude: /node_modules/}
+        ]
+    },
+    plugins: [
+        new webpack.optimize.ModuleConcatenationPlugin()
+    ]
+};