     refreshParams = ->
       params = id: _.uniqueId('paramsId')
       path = "test/#{params.id}"
+      options = {}
+      stdOptions = create addedOptions
+
+      # Fake route objects, walk like a route and swim like a route
       route1 = {controller: 'test1', action: 'show', path}
       route2 = {controller: 'test2', action: 'show', path}
-      options = {}
-      stdOptions = create addedOptions
-
-    beforeEach refreshParams
+      redirectToURLRoute =
+        {controller: 'test1', action: 'redirectToURL', path}
+      redirectToControllerRoute =
+        {controller: 'test1', action: 'redirectToController', path}
+
+    # Register before/after handlers
+
+    beforeEach ->
+      # Create a fresh Dispatcher instance for each test
+      dispatcher = new Dispatcher()
+      refreshParams()
+
+    afterEach ->
+      if dispatcher
+        dispatcher.dispose()
+        dispatcher = null
+
+    # The Tests
 
     it 'should dispatch routes to controller actions', (done) ->
       proto = Test1Controller.prototype
       initialize = sinon.spy proto, 'initialize'
       action     = sinon.spy proto, 'show'
 
-      mediator.publish 'router:match', route1, params, create options
+      publishMatch route1, params, options
 
       loadTest1Controller ->
         for spy in [initialize, action]
           expect(spy).was.calledOnce()
-          args = spy.firstCall.args
-          expect(args[0]).to.eql params
-          expect(args[1].controller).to.eql route1.controller
-          expect(args[1].action).to.eql route1.action
-          expect(args[2]).to.eql stdOptions
+          [passedParams, passedRoute, passedOptions] = spy.firstCall.args
+          expect(passedParams).to.eql params
+          expect(passedRoute).to.eql create(route1, previous: {})
+          expect(passedOptions).to.eql stdOptions
 
         initialize.restore()
         action.restore()

      spy = sinon.spy()
      mediator.subscribe '!router:changeURL', spy

      options =
        path: 'my-little-path', changeURL: false,
        controller: 'test1', action: 'show'
      mediator.publish 'router:match', route1, params, options

      loadTest1Controller ->
        expect(spy).was.notCalled()

      dispatch = sinon.spy()
      mediator.subscribe 'dispatcher:dispatch', dispatch

      # Dispatch a route to check if previous controller info is correct after
      # redirection
      publishMatch route1, params, options

      # Open another route that redirects somewhere
      refreshParams()
      actionName = 'redirectToURL'
      action = sinon.spy Test1Controller.prototype, actionName
      publishMatch redirectToURLRoute, params, options

      loadTest1Controller ->
        expect(action).was.calledOnce()
        [passedParams, passedRoute, passedOptions] = action.firstCall.args
        expect(passedParams).to.eql params
        expect(passedRoute.previous.controller).to.eql 'test1'
        expect(passedOptions).to.eql stdOptions

        # Don’t expect that the new controller was called
        # because we’re not testing the router. Just test
