diff --git a/client/route.js b/client/route.js
index f9eadbe..a8b53f7 100644
--- a/client/route.js
+++ b/client/route.js
@@ -42,15 +42,6 @@ Route.prototype.getAllSubscriptions = function() {
   return this._subsMap;
 };
 
-
-Route.prototype._processTriggersEnter = function(context) {
-  _.each(this._triggersEnter, function(fn) {
-    if (typeof fn === 'function') {
-      fn(context);
-    }
-  });
-};
-
 Route.prototype._processMiddlewares = function(context, after) {
   var currentIndex = 0;
   var self = this;
@@ -76,8 +67,6 @@ Route.prototype._processMiddlewares = function(context, after) {
 Route.prototype.callAction = function(current) {
   var self = this;
 
-  self._processTriggersEnter(current);
-
   self._processMiddlewares(current.context, function() {
     self._action(current.params, current.queryParams);
   });
diff --git a/client/router.js b/client/router.js
index 60e5934..950082a 100644
--- a/client/router.js
+++ b/client/router.js
@@ -21,11 +21,8 @@ Router = function () {
   // when doing subscriptions
   this.safeToRun = false;
 
-  var self = this;
-  this.triggers = {
-    enter: self._getRegisterTriggersFn(self._triggersEnter),
-    exit: self._getRegisterTriggersFn(self._triggersExit)
-  };
+  this._redirectFn = _.bind(this._page.redirect, this._page);
+  this._initTriggersAPI();
 };
 
 Router.prototype.route = function(path, options, group) {
@@ -38,7 +35,8 @@ Router.prototype.route = function(path, options, group) {
   var self = this;
   var route = new Route(this, path, options, group);
 
-  route._handler = function (context, next) {
+  // calls when the page route being activates
+  route._actionHandle = function (context, next) {
     var oldRoute = self._current.route;
 
     self._current = {
@@ -53,7 +51,31 @@ Router.prototype.route = function(path, options, group) {
     // to backward compatibility
     self._current.params.query = self._current.queryParams;
 
-    self._invalidateTracker();
+    // we need to invalidate if all the triggers have been completed
+    // if not that means, we've been redirected to another path
+    // then we don't need to invalidate
+    var afterAllTriggersRan = function() {
+      self._invalidateTracker();
+    };
+
+    var triggers = self._triggersEnter.concat(route._triggersEnter);
+    Triggers.runTriggers(
+      triggers, 
+      self._current, 
+      self._redirectFn, 
+      afterAllTriggersRan
+    );
+  };
+
+  // calls when you exit from the page js route
+  route._exitHandle = function(context, next) {
+    var triggers = self._triggersExit.concat(route._triggersExit);
+    Triggers.runTriggers(
+      triggers,
+      self._current,
+      self._redirectFn,
+      next
+    );
   };
 
   this._routes.push(route);
@@ -317,8 +339,6 @@ Router.prototype._buildTracker = function() {
     Tracker.nonreactive(function() {
       var currentContext = self._current;
 
-      self._processTriggersEnter(currentContext);
-
       var isRouteChange = currentContext.oldRoute !== currentContext.route;
       var isFirstRoute = !currentContext.oldRoute;
       // first route is not a route change
@@ -353,98 +373,11 @@ Router.prototype._buildTracker = function() {
 Router.prototype._invalidateTracker = function() {
   this.safeToRun = true;
   this._tracker.invalidate();
-};
-
-Router.prototype._getRegisterTriggersFn = function(triggers) {
-  var fn = function(triggerFns, options) {
-    options = options || {};
-
-    if (options.only && options.except) {
-      var message = "triggers does not support 'only' and 'except' at the same time.";
-      throw new Error(message);
-    }
-
-    _.each(triggerFns, function(fn) {
-      if (typeof fn !== 'function') {
-        return;
-      }
-
-      if (options.only) {
-        fn._only = {};
-        _.each(options.only, function(name) {
-          fn._only[name] = 1;
-        });
-      }
-
-      if (options.except) {
-        fn._except = {};
-        _.each(options.except, function(name) {
-          fn._except[name] = 1;
-        });
-      }
-
-      triggers.push(fn);
-    });
-  };
-
-  return fn;
-};
-
-Router.prototype._shouldCallTrigger = function(current, fn) {
-  var name = current.route.name;
-  var shouldCall;
-
-  if (typeof fn !== 'function') {
-    return false;
-  }
-
-  if (fn._only) {
-    shouldCall = !!fn._only[name];
-  } else if (fn._except) {
-    shouldCall = !fn._except[name];
-  } else {
-    shouldCall = true;
-  }
-
-  return shouldCall;
-};
-
-Router.prototype._processTriggersEnter = function(current) {
-  var self = this;
-
-  _.each(this._triggersEnter, function(fn) {
-    if (self._shouldCallTrigger(current, fn)) {
-      fn(current);
-    }
-  });
-};
-
-Router.prototype._processTriggersExit = function(ctx, next) {
-  var self = this;
-
-  _.each(self._triggersExit, function(fn) {
-    if (self._shouldCallTrigger(self._current, fn)) {
-      fn(self._current);
-    }
-  });
-
-  next();
-};
-
-Router.prototype._registerRouteTriggersExit = function(route) {
-  var self = this;
-
-  if (route._triggersExit.length > 0) {
-    // add route's exit triggers
-    self._page.exit(route.path, function(ctx, next) {
-      _.each(route._triggersExit, function(fn) {
-        if (typeof fn === 'function') {
-          fn(self._current);
-        }
-      });
-
-      next();
-    });
+  // we need to trigger the above invalidations immediately
+  // otherwise, we need to face some issues with route context swapping
+  // if this is a running autorun we don't need to flush it
+  if(!Tracker.currentComputation) {
+    Tracker.flush();
   }
 };
 
@@ -460,16 +393,29 @@ Router.prototype._updateCallbacks = function () {
   });
 
   _.each(self._routes, function(route) {
-    self._page(route.path, route._handler);
-    self._registerRouteTriggersExit(route);
+    self._page(route.path, route._actionHandle);
+    self._page.exit(route.path, route._exitHandle);
   });
 
-  self._page.exit("*", self._processTriggersExit.bind(self));
-
   self._page("*", function(context) {
     self._notfoundRoute(context);
   });
 };
 
+Router.prototype._initTriggersAPI = function() {
+  var self = this;
+  this.triggers = {
+    enter: function(triggers, filter) {
+      triggers = Triggers.applyFilters(triggers, filter);
+      _.extend(self._triggersEnter, triggers);
+    },
+
+    exit: function(triggers, filter) {
+      triggers = Triggers.applyFilters(triggers, filter);
+      _.extend(self._triggersExit, triggers);
+    }
+  };
+};
+
 Router.prototype._page = page;
-Router.prototype._qs = qs;
+Router.prototype._qs = qs;
\ No newline at end of file
diff --git a/client/triggers.js b/client/triggers.js
new file mode 100644
index 0000000..2fc0f2f
--- /dev/null
+++ b/client/triggers.js
@@ -0,0 +1,108 @@
+// a set of utility functions for triggers
+
+Triggers = {};
+
+// Apply filters for a set of triggers
+// @triggers - a set of triggers
+// @filter - filter with array fileds with `only` and `except` 
+//           support only either `only` or `except`, but not both
+Triggers.applyFilters = function(triggers, filter) {
+  if(!(triggers instanceof Array)) {
+    triggers = [triggers];
+  }
+
+  if(!filter) {
+    return triggers;
+  }
+
+  if(filter.only && filter.except) {
+    throw new Error("Triggers don't support only and except filters at once");
+  }
+
+  if(filter.only && !(filter.only instanceof Array)) {
+    throw new Error("only filters needs to be an array");
+  }
+
+  if(filter.except && !(filter.except instanceof Array)) {
+    throw new Error("except filters needs to be an array");
+  }
+
+  if(filter.only) {
+    return Triggers.createRouteBoundTriggers(triggers, filter.only);
+  }
+
+  if(filter.except) {
+    return Triggers.createRouteBoundTriggers(triggers, filter.except, true);
+  }
+
+  throw new Error("Provided a filter but not supported");
+};
+
+//  create triggers by bounding them to a set of route names
+//  @triggers - a set of triggers 
+//  @names - list of route names to be bound (trigger runs only for these names)
+//  @negate - negate the result (triggers won't run for above names)
+Triggers.createRouteBoundTriggers = function(triggers, names, negate) {
+  var namesMap = {};
+  _.each(names, function(name) {
+    namesMap[name] = true;
+  });
+
+  var filteredTriggers = _.map(triggers, function(originalTrigger) {
+    var modifiedTrigger = function(context, next) {
+      var routeName = context.route.name;
+      var matched = (namesMap[routeName])? 1: -1;
+      matched = (negate)? matched * -1 : matched;
+
+      if(matched === 1) {
+        originalTrigger(context, next);
+      }
+    };
+    return modifiedTrigger;
+  });
+
+  return filteredTriggers;
+};
+
+//  run triggers and abort if redirected
+//  @triggers - a set of triggers 
+//  @context - context we need to pass (it must have the route)
+//  @redirectFn - function which used to redirect 
+//  @after - called after if only all the triggers runs
+Triggers.runTriggers = function(triggers, context, redirectFn, after) {
+  var abort = false;
+  var inCurrentLoop = true;
+  var alreadyRedirected = false;
+
+  for(var lc=0; lc<triggers.length; lc++) {
+    var trigger = triggers[lc];
+    trigger(context, doRedirect);
+
+    if(abort) {
+      return;
+    }
+  }
+
+  // mark that, we've exceeds the currentEventloop for
+  // this set of triggers.
+  inCurrentLoop = false;
+  after();
+
+  function doRedirect(url) {
+    if(alreadyRedirected) {
+      throw new Error("already redirected");
+    }
+
+    if(!inCurrentLoop) {
+      throw new Error("redirect needs to be done in sync");
+    }
+
+    if(!url) {
+      throw new Error("trigger redirect requires an URL");
+    }
+
+    abort = true;
+    alreadyRedirected = true;
+    redirectFn(url);
+  }
+};
\ No newline at end of file
diff --git a/package.js b/package.js
index 5ad134f..4e49537 100644
--- a/package.js
+++ b/package.js
@@ -11,36 +11,15 @@ Npm.depends({
 });
 
 Package.onUse(function(api) {
-  api.versionsFrom('1.0');
-
-  api.use('underscore');
-  api.use('tracker');
-  api.use('reactive-dict');
-  api.use('reactive-var');
-
-  api.use('meteorhacks:fast-render@2.3.2', ['client', 'server'], {weak: true});
-  api.use('cosmos:browserify@0.1.3', 'client');
-
-  api.addFiles('client.browserify.js', 'client');
-  api.addFiles('client/router.js', 'client');
-  api.addFiles('client/group.js', 'client');
-  api.addFiles('client/route.js', 'client');
-  api.addFiles('client/_init.js', 'client');
-  api.addFiles('server/router.js', 'server');
-  api.addFiles('server/group.js', 'server');
-  api.addFiles('server/route.js', 'server');
-  api.addFiles('server/_init.js', 'server');
-
-  api.addFiles('server/plugins/fast_render.js', 'server');
-
+  configure(api);
   api.export('FlowRouter');
 });
 
 Package.onTest(function(api) {
+  configure(api);
   api.use('tinytest');
   api.use('mongo');
   api.use('http');
-  api.use('meteorhacks:flow-router');
   api.use('practicalmeteor:sinon');
   api.use('meteorhacks:fast-render');
   api.use('meteorhacks:inject-data');
@@ -57,6 +36,34 @@ Package.onTest(function(api) {
   api.addFiles('test/client/router.reactivity.spec.js', 'client');
   api.addFiles('test/client/group.spec.js', 'client');
   api.addFiles('test/client/trigger.spec.js', 'client');
+  api.addFiles('test/client/triggers.js', 'client');
 
   api.addFiles('test/server/plugins/fast_render.js', 'server');
 });
+
+
+function configure(api) {
+  api.versionsFrom('1.0');
+
+  api.use('underscore');
+  api.use('tracker');
+  api.use('reactive-dict');
+  api.use('reactive-var');
+
+  api.use('meteorhacks:fast-render@2.3.2', ['client', 'server'], {weak: true});
+  api.use('cosmos:browserify@0.1.3', 'client');
+
+  api.addFiles('client.browserify.js', 'client');
+  api.addFiles('client/triggers.js', 'client');
+  api.addFiles('client/router.js', 'client');
+  api.addFiles('client/group.js', 'client');
+  api.addFiles('client/route.js', 'client');
+  api.addFiles('client/_init.js', 'client');
+
+  api.addFiles('server/router.js', 'server');
+  api.addFiles('server/group.js', 'server');
+  api.addFiles('server/route.js', 'server');
+  api.addFiles('server/_init.js', 'server');
+
+  api.addFiles('server/plugins/fast_render.js', 'server');
+}
\ No newline at end of file
diff --git a/test/client/trigger.spec.js b/test/client/trigger.spec.js
index 22a1cf5..7a9dd1f 100644
--- a/test/client/trigger.spec.js
+++ b/test/client/trigger.spec.js
@@ -1,58 +1,3 @@
-Tinytest.add('Client - Triggers - should call trigger', function(test) {
-  var current = {route: {}};
-  var fn = null;
-
-  // tests for route without name
-
-  test.isFalse(FlowRouter._shouldCallTrigger(current, fn));
-
-  fn = function() {};
-  test.isTrue(FlowRouter._shouldCallTrigger(current, fn));
-
-  fn._only = {'foo': 1};
-  test.isFalse(FlowRouter._shouldCallTrigger(current, fn));
-
-  fn._except = {'foo': 1};
-  fn._only = null;
-  test.isTrue(FlowRouter._shouldCallTrigger(current, fn));
-
-  // tests for route with name
-
-  current.route.name = 'bar';
-  fn._except = null;
-
-  fn._only = {'foo': 1};
-  test.isFalse(FlowRouter._shouldCallTrigger(current, fn));
-
-  fn._only = {'bar': 1};
-  test.isTrue(FlowRouter._shouldCallTrigger(current, fn));
-
-  fn._only = null;
-
-  fn._except = {'foo': 1};
-  test.isTrue(FlowRouter._shouldCallTrigger(current, fn));
-
-  fn._except = {'bar': 1};
-  test.isFalse(FlowRouter._shouldCallTrigger(current, fn));
-});
-
-Tinytest.add('Client - Triggers - get register triggers function', function(test) {
-  var triggers = [];
-
-  var registerFn = FlowRouter._getRegisterTriggersFn(triggers);
-  test.equal(typeof registerFn, 'function');
-
-  // does not accept "only" and "except" at the same time
-  test.throws(function() {
-    registerFn([], {only: ['foo'], except: ['bar']});
-  });
-
-  var fn = function() {};
-  registerFn([fn, 'trigger'], {only: ['foo']});
-
-  test.equal(triggers.length, 1);
-});
-
 Tinytest.addAsync('Client - Triggers - global enter triggers', function(test, next) {
   var rand = Random.id(), rand2 = Random.id();
   var log = [];
@@ -378,7 +323,6 @@ Tinytest.addAsync('Client - Triggers - group exit triggers', function (test, nex
   var log = [];
 
   var triggerFn = function (context) {
-    test.equal(context.path, '/' + rand);
     log.push(4);
   };
 
@@ -409,3 +353,118 @@ Tinytest.addAsync('Client - Triggers - group exit triggers', function (test, nex
     }, 100);
   }, 100);
 });
+
+Tinytest.addAsync('Client - Triggers - redirect from enter', function(test, next) {
+  var rand = Random.id(), rand2 = Random.id();
+  var log = [];
+
+  FlowRouter.route('/' + rand, {
+    triggersEnter: [function(context, redirect) {
+      redirect("/" + rand2);
+    }, function() {
+      throw new Error("should not execute this trigger");
+    }],
+    action: function(_params) {
+      log.push(1);
+    },
+    name: rand
+  });
+
+  FlowRouter.route('/' + rand2, {
+    action: function(_params) {
+      log.push(2);
+    },
+    name: rand2
+  });
+
+  FlowRouter.go('/');
+  FlowRouter.go('/' + rand);
+
+  setTimeout(function() {
+    test.equal(log, [2]);
+    next();
+  }, 300);
+});
+
+Tinytest.addAsync('Client - Triggers - redirect from exit', function(test, next) {
+  var rand = Random.id(), rand2 = Random.id(), rand3 = Random.id();
+  var log = [];
+
+  FlowRouter.route('/' + rand, {
+    action: function() {
+      log.push(1);
+    },
+    triggersExit: [
+      function(context, redirect) {
+        redirect('/' + rand3);
+      },
+      function() {
+        throw new Error("should not call this trigger");
+      }
+    ]
+  });
+
+  FlowRouter.route('/' + rand2, {
+    action: function() {
+      log.push(2);
+    }
+  });
+
+  FlowRouter.route('/' + rand3, {
+    action: function() {
+      log.push(3);
+    }
+  });
+
+  FlowRouter.go('/' + rand);
+
+  setTimeout(function() {
+    FlowRouter.go('/' + rand2);
+    
+    setTimeout(function() {
+      test.equal(log, [1, 3]);
+      next();
+    }, 100);
+  }, 100);
+});
+
+Tinytest.addAsync(
+'Client - Triggers - invalidate inside an autorun', 
+function(test, next) {
+  var rand = Random.id(), rand2 = Random.id();
+  var log = [];
+  var paths = ['/' + rand2, '/' + rand];
+  var done = false;
+
+  FlowRouter.route('/' + rand, {
+    action: function(_params) {
+      log.push(1);
+    }
+  });
+
+  FlowRouter.route('/' + rand2, {
+    action: function(_params) {
+      log.push(2);
+    }
+  });
+
+  FlowRouter.triggers.enter([function(context) {
+    if(done) return;
+    test.equal(context.path, paths.pop());
+    log.push(0);
+  }]);
+
+  Tracker.autorun(function(c) {
+    FlowRouter.go('/' + rand);
+  });
+
+  setTimeout(function() {
+    FlowRouter.go('/' + rand2);
+
+    setTimeout(function() {
+      test.equal(log, [0, 1, 0, 2]);
+      done = true;
+      setTimeout(next, 100);
+    }, 100);
+  }, 100);
+});
diff --git a/test/client/triggers.js b/test/client/triggers.js
new file mode 100644
index 0000000..655f851
--- /dev/null
+++ b/test/client/triggers.js
@@ -0,0 +1,279 @@
+Tinytest.addAsync(
+'Triggers - runTriggers - run all and after',
+function(test, done) {
+  var store = [];
+  var triggers = MakeTriggers(2, store);
+  Triggers.runTriggers(triggers, null, null, function() {
+    test.equal(store, [0, 1]);
+    done();
+  });
+});
+
+Tinytest.addAsync(
+'Triggers - runTriggers - redirect with url',
+function(test, done) {
+  var store = [];
+  var url = "http://google.com";
+  var triggers = MakeTriggers(2, store);
+  triggers.splice(1, 0, function(context, redirect) {
+    redirect(url); 
+  });
+
+  Triggers.runTriggers(triggers, null, function(u) {
+    test.equal(store, [0]);
+    test.equal(u, url);
+    done();
+  }, null);
+});
+
+Tinytest.addAsync(
+'Triggers - runTriggers - redirect without url',
+function(test, done) {
+  var store = [];
+  var url = "http://google.com";
+  var triggers = MakeTriggers(2, store);
+  triggers.splice(1, 0, function(context, redirect) {
+    try {
+      redirect(); 
+    } catch(ex) {
+      test.isTrue(/requires an URL/.test(ex.message));
+      test.equal(store, [0]);
+      done();
+    }
+  });
+
+  Triggers.runTriggers(triggers, null, null, null);
+});
+
+Tinytest.addAsync(
+'Triggers - runTriggers - redirect in a different event loop',
+function(test, done) {
+  var store = [];
+  var url = "http://google.com";
+  var triggers = MakeTriggers(2, store);
+  var doneCalled = false;
+
+  triggers.splice(1, 0, function(context, redirect) {
+    setTimeout(function() {
+      try {
+        redirect(url); 
+      } catch(ex) {
+        test.isTrue(/sync/.test(ex.message));
+        test.equal(store, [0, 1]);
+        test.isTrue(doneCalled);
+        done();
+      }
+    }, 0);
+  });
+
+  Triggers.runTriggers(triggers, null, null, function() {
+    doneCalled = true;
+  });
+});
+
+Tinytest.addAsync(
+'Triggers - runTriggers - redirect called multiple times',
+function(test, done) {
+  var store = [];
+  var url = "http://google.com";
+  var triggers = MakeTriggers(2, store);
+  var redirectCalled = false;
+
+  triggers.splice(1, 0, function(context, redirect) {
+    redirect(url); 
+    try {
+      redirect(url);
+    } catch(ex) {
+      test.isTrue(/already redirected/.test(ex.message));
+      test.equal(store, [0]);
+      test.isTrue(redirectCalled);
+      done();
+    }
+  });
+
+  Triggers.runTriggers(triggers, null, function() {
+    redirectCalled = true;
+  }, null);
+});
+
+Tinytest.addAsync(
+'Triggers - runTriggers - get context',
+function(test, done) {
+  var context = {};
+  var trigger = function(c) {
+    test.equal(c, context);
+    done();
+  };
+
+  Triggers.runTriggers([trigger], context, function() {}, function() {});
+});
+
+Tinytest.addAsync(
+'Triggers - createRouteBoundTriggers - matching trigger',
+function(test, done) {
+  var context = {route: {name: "abc"}};
+  var redirect = function() {};
+
+  var trigger = function(c, r) {
+    test.equal(c, context);
+    test.equal(r, redirect);
+    done();
+  };
+
+  var triggers = Triggers.createRouteBoundTriggers([trigger], ["abc"]);
+  triggers[0](context, redirect);
+});
+
+Tinytest.addAsync(
+'Triggers - createRouteBoundTriggers - multiple matching triggers',
+function(test, done) {
+  var context = {route: {name: "abc"}};
+  var redirect = function() {};
+  var doneCount = 0;
+
+  var trigger = function(c, r) {
+    test.equal(c, context);
+    test.equal(r, redirect);
+    doneCount++;
+  };
+
+  var triggers = Triggers.createRouteBoundTriggers([trigger, trigger], ["abc"]);
+  triggers[0](context, redirect);
+  triggers[1](context, redirect);
+
+  test.equal(doneCount, 2);
+  done();
+});
+
+Tinytest.addAsync(
+'Triggers - createRouteBoundTriggers - no matching trigger',
+function(test, done) {
+  var context = {route: {name: "some-other-route"}};
+  var redirect = function() {};
+  var doneCount = 0;
+
+  var trigger = function(c, r) {
+    test.equal(c, context);
+    test.equal(r, redirect);
+    doneCount++;
+  };
+
+  var triggers = Triggers.createRouteBoundTriggers([trigger], ["abc"]);
+  triggers[0](context, redirect);
+
+  test.equal(doneCount, 0);
+  done();
+});
+
+Tinytest.addAsync(
+'Triggers - createRouteBoundTriggers - negate logic',
+function(test, done) {
+  var context = {route: {name: "some-other-route"}};
+  var redirect = function() {};
+  var doneCount = 0;
+
+  var trigger = function(c, r) {
+    test.equal(c, context);
+    test.equal(r, redirect);
+    doneCount++;
+  };
+
+  var triggers = Triggers.createRouteBoundTriggers([trigger], ["abc"], true);
+  triggers[0](context, redirect);
+
+  test.equal(doneCount, 1);
+  done();
+});
+
+Tinytest.addAsync(
+'Triggers - applyFilters - no filters',
+function(test, done) {
+  var original = [];
+  test.equal(Triggers.applyFilters(original), original);
+  done();
+});
+
+Tinytest.addAsync(
+'Triggers - applyFilters - single trigger to array',
+function(test, done) {
+  var original = function() {};
+  test.equal(Triggers.applyFilters(original)[0], original);
+  done();
+});
+
+Tinytest.addAsync(
+'Triggers - applyFilters - only and except both',
+function(test, done) {
+  var original = [];
+  try {
+    Triggers.applyFilters(original, {only: [], except: []});
+  } catch(ex) {
+    test.isTrue(/only and except/.test(ex.message));
+    done();
+  }
+});
+
+Tinytest.addAsync(
+'Triggers - applyFilters - only is not an array',
+function(test, done) {
+  var original = [];
+  try {
+    Triggers.applyFilters(original, {only: "name"});
+  } catch(ex) {
+    test.isTrue(/to be an array/.test(ex.message));
+    done();
+  }
+});
+
+Tinytest.addAsync(
+'Triggers - applyFilters - except is not an array',
+function(test, done) {
+  var original = [];
+  try {
+    Triggers.applyFilters(original, {except: "name"});
+  } catch(ex) {
+    test.isTrue(/to be an array/.test(ex.message));
+    done();
+  }
+});
+
+Tinytest.addAsync(
+'Triggers - applyFilters - unsupporeted filter',
+function(test, done) {
+  var original = [];
+  try {
+    Triggers.applyFilters(original, {wowFilter: []});
+  } catch(ex) {
+    test.isTrue(/not supported/.test(ex.message));
+    done();
+  }
+});
+
+Tinytest.addAsync(
+'Triggers - applyFilters - just only filter',
+function(test, done) {
+  var bounded = Triggers.applyFilters(done, {only: ["abc"]});
+  bounded[0]({route: {name: "abc"}});
+});
+
+Tinytest.addAsync(
+'Triggers - applyFilters - just except filter',
+function(test, done) {
+  var bounded = Triggers.applyFilters(done, {except: ["abc"]});
+  bounded[0]({route: {name: "some-other"}});
+});
+
+function MakeTriggers(count, store) {
+  var triggers = [];
+
+  function addTrigger(no) {
+    triggers.push(function() {
+      store.push(no);
+    });
+  }
+
+  for(var lc=0; lc<count; lc++) {
+    addTrigger(lc);
+  }
+  return triggers;
+}
\ No newline at end of file