token_action 0.0.1 → 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 85d900369c77734a24aa10bc37527ce4bb7a47c5
+  data.tar.gz: 0dafd5321105460b8eb6dec7179406dfd024ffe2
+SHA512:
+  metadata.gz: f44e1b756a0917db2b7a65d4e9852cd2d86a40b977f4fdb2756bedde6edfefe961cbfb1da0b2e854b655cef11f5ea8bac84e8b74d8a4c10ad747ce07f5188bb8
+  data.tar.gz: c0f1dd85cdd3d9f4a7e7446ef3bfc2886bb28e4ad038310fb5b526f02de37454e44f8065b7187223535c5652e4ec148b452c2d44e103486ab296dedd943a2acb

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2013 Open North Inc.
+Copyright (c) 2013 James McKinney
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,8 +1,10 @@
 # TokenAction
 
-[![Build Status](https://secure.travis-ci.org/opennorth/token_action.png)](http://travis-ci.org/opennorth/token_action)
-[![Dependency Status](https://gemnasium.com/opennorth/token_action.png)](https://gemnasium.com/opennorth/token_action)
-[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/opennorth/token_action)
+[![Gem Version](https://badge.fury.io/rb/token_action.svg)](https://badge.fury.io/rb/token_action)
+[![Build Status](https://secure.travis-ci.org/jpmckinney/token_action.png)](https://travis-ci.org/jpmckinney/token_action)
+[![Dependency Status](https://gemnasium.com/jpmckinney/token_action.png)](https://gemnasium.com/jpmckinney/token_action)
+[![Coverage Status](https://coveralls.io/repos/jpmckinney/token_action/badge.png)](https://coveralls.io/r/jpmckinney/token_action)
+[![Code Climate](https://codeclimate.com/github/jpmckinney/token_action.png)](https://codeclimate.com/github/jpmckinney/token_action)
 
 TokenAction lets you create tokens to be used to authenticate actions. For example:
 
@@ -29,7 +31,7 @@ If you are using ActiveRecord, run the migration:
 
 Create a shared secret to confirm a user account, for example:
 
-    token = TokenAction::Token.create! :kind => 'User', :args => [1, :confirm]
+    token = TokenAction::Token.create! kind: 'User', args: [1, :confirm]
     token.token # a 20-character alphanumeric string like "j7NtCaYfUpZXyDCseKG2"
 
 You can then send the token with instructions to the user via email. When the user visits `/tokens/j7NtCaYfUpZXyDCseKG2/confirm`, TokenAction will look up the token. If not found, it will log an informational message to the Rails logger, set `flash[:alert]` and redirect to the `root_path`. If found, it will call the `redeem_token` method on the `User` class, passing in the arguments `1` and `:confirm`. You must implement the public `redeem_token` method. For example:
@@ -54,7 +56,7 @@ You can customize the redirect URLs, the routes, the flash messages and the toke
 
 To change the default success and failure URLs from `root_path`, edit the `config/initializers/token_action.rb` file created by `rails generate token_action`. You may also set success and failure URLs for each token, by creating tokens with `:success_url` and `:failure_url` arguments:
 
-    token = TokenAction::Token.create! :kind => 'Cat', :success_url => cat_path(1), :failure_url => '/oops'
+    token = TokenAction::Token.create! kind: 'Cat', success_url: cat_path(1), failure_url: '/oops'
 
 **Note:** If you change your URL structure after creating tokens, TokenAction may attempt to redirect to an unroutable path. If a path is unroutable, TokenAction will redirect to another URL in this order of precedence:
 
@@ -72,13 +74,13 @@ If an exception was raised and a path is unroutable, it will redirect in this or
 
 The TokenAction generator will add `mount TokenAction::Engine => '/token_action'` to your routes, which defines:
 
-    get 'tokens/:token/*path', :to => 'tokens#redeem'
+    get 'tokens/:token/*path', to: 'tokens#redeem'
 
 As such, you can write URLs like `tokens/xxx/confirm` or `tokens/xxx/unsubscribe` or `tokens/xxx/a/b/c`.
 
 To customize the first part of the route, replace `mount TokenAction::Engine => '/token_action'` with something like:
 
-    get 'jetons/:token/*path', :to => 'token_action/tokens#redeem'
+    get 'jetons/:token/*path', to: 'token_action/tokens#redeem'
 
 ### Flash messages
 
@@ -110,7 +112,7 @@ To customize the controller without monkey patching, create a new controller lik
 
 And replace the route with something like:
 
-    get 'tokens/:token/*path', :to => 'tokens#redeem'
+    get 'tokens/:token/*path', to: 'tokens#redeem'
 
 You can then override the `redeem` method in your new controller.
 
@@ -131,13 +133,4 @@ If using Sequel, you will want to use the [orm_adapter-sequel](https://github.co
 * If you change the name of a class, update the `kind` attribute on its tokens to avoid making them unprocessable.
 * Be careful when changing the behavior of a `redeem_token` method, to avoid making tokens unprocessable.
 
-## Roadmap
-
-* The tokens controller only responds to HTML requests. Pull requests to add JSON and XML responders are welcome!
-* The generators do not have specs.
-
-## Bugs? Questions?
-
-This engine's main repository is on GitHub: [http://github.com/opennorth/token_action](http://github.com/opennorth/token_action), where your contributions, forks, bug reports, feature requests, and feedback are greatly welcomed.
-
-Copyright (c) 2012 Open North Inc., released under the MIT license
+Copyright (c) 2012 James McKinney, released under the MIT license

data/Rakefile

@@ -1,10 +1,19 @@
-require 'bundler'
-Bundler::GemHelper.install_tasks
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+APP_RAKEFILE = File.expand_path('../spec/dummy/Rakefile', __FILE__)
+load 'rails/tasks/engine.rake'
+
+require 'thor'
+helper = Bundler::GemHelper.new
+helper.install
 
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)
-
-task :default => :spec
+task default: :spec
 
 begin
   require 'yard'

data/app/controllers/token_action/tokens_controller.rb

@@ -1,20 +1,22 @@
+require_dependency 'token_action/application_controller'
+
 module TokenAction
   class TokensController < ApplicationController
     def redeem
-      @token = TokenAction::Token.to_adapter.find_first(:token => params[:token])
+      @token = TokenAction::Token.to_adapter.find_first(token: params[:token])
       if @token
         begin
           # Do this in the controller's scope to allow access to request methods.
           ActiveSupport::Inflector.constantize(@token.kind).redeem_token(*@token.args)
-          redirect_to success_url, :notice => translate(:success)
+          redirect_to success_url, notice: translate(:success)
         rescue => e
-          key = ActiveSupport::Inflector.underscore(e.class).gsub('/', I18n.default_separator)
+          key = ActiveSupport::Inflector.underscore(e.class.name).gsub('/', I18n.default_separator)
           logger.warn "TokenAction failed to perform the action for the token '#{params[:token]}': #{e.message}"
-          redirect_to failure_url, :alert => translate(key, :failure)
+          redirect_to failure_url, alert: translate(key, :failure)
         end
       else
         logger.info "TokenAction failed to find the token '#{params[:token]}'"
-        redirect_to failure_url, :alert => translate(:not_found)
+        redirect_to failure_url, alert: translate(:not_found)
       end
     end
 
@@ -39,23 +41,29 @@ module TokenAction
       end
 
       key, *default = *keys
-      I18n.translate(key, :default => default)
+      I18n.translate(key, default: default)
     end
 
     # Returns the success URL.
     #
     # @return [String] a URL
     def success_url
-      [@token && @token.success_url, TokenAction.success_url].find do |url|
-        url.present? && routable?(url)
-      end || main_app.root_path
+      redirect_url([@token && @token.success_url, TokenAction.success_url])
     end
 
     # Returns the failure URL.
     #
     # @return [String] a URL
     def failure_url
-      [@token && @token.failure_url, TokenAction.failure_url].find do |url|
+      redirect_url([@token && @token.failure_url, TokenAction.failure_url])
+    end
+
+    # Returns the routeable URL with the highest preference.
+    #
+    # @param [Array<String>] a list of URLs in order of preference
+    # @return [String] the routable URL with the highest preference
+    def redirect_url(urls)
+      urls.find do |url|
         url.present? && routable?(url)
       end || main_app.root_path
     end
@@ -65,7 +73,7 @@ module TokenAction
     # @param [String] path a path
     # @return [Boolean] whether the path is routable
     def routable?(path)
-      !!Rails.application.routes.recognize_path(path, :method => :get)
+      !!Rails.application.routes.recognize_path(path, method: :get)
     rescue ActionController::RoutingError
       false
     end

data/config/routes.rb

@@ -1,3 +1,3 @@
 TokenAction::Engine.routes.draw do
-  get 'tokens/:token/*path', :to => 'tokens#redeem'
+  get 'tokens/:token/*path', to: 'tokens#redeem'
 end

data/lib/generators/active_record/templates/migration.rb

@@ -10,6 +10,6 @@ class CreateTokenActionTokens < ActiveRecord::Migration
       t.timestamps
     end
 
-    add_index :token_action_tokens, :token, :unique => true
+    add_index :token_action_tokens, :token, unique: true
   end
 end

data/lib/generators/templates/README

@@ -2,7 +2,7 @@ To complete the installation of TokenAction:
 
   1. Define a root route in config/routes.rb. For example:
 
-       root :to => 'home#index'
+       root to: 'home#index'
 
   2. Add flash messages to app/views/layouts/application.html.erb. For example:
 

data/lib/token_action.rb

@@ -67,5 +67,5 @@ module TokenAction
   end
 end
 
-require 'token_action/mixins/token_generator'
-require 'token_action/mixins/model'
+require 'token_action/concerns/token_generator'
+require 'token_action/concerns/model'

data/lib/token_action/orm/mongoid.rb

@@ -10,25 +10,25 @@ module TokenAction
 
     # A shared secret.
     # @return [String] a token
-    field :token, :type => String
+    field :token, type: String
 
     # The class on which to perform the action.
     # @return [String] a class name
     # @note `class` clashes with `Object#class` and Mongoid reserves `klass`.
-    field :kind, :type => String
+    field :kind, type: String
 
     # Any additional arguments for the action.
     # @return [Array] a list of arguments
-    field :args, :type => Array
+    field :args, type: Array
 
     # The URL to redirect to after performing the action successfully.
     # @return [String] a URL or path
-    field :success_url, :type => String
+    field :success_url, type: String
 
     # The URL to redirect to after failing to perform the action.
     # @return [String] a URL or path
-    field :failure_url, :type => String
+    field :failure_url, type: String
 
-    index({:token => 1}, :unique => true)
+    index({token: 1}, unique: true)
   end
 end

data/lib/token_action/version.rb

@@ -1,3 +1,3 @@
 module TokenAction
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/controllers/token_action/tokens_controller_spec.rb

@@ -1,171 +1,173 @@
-require 'spec_helper'
+require 'rails_helper'
 
-describe TokenAction::TokensController do
-  before :each do
-    @routes = TokenAction::Engine.routes
-  end
+module TokenAction
+  RSpec.describe TokensController, type: :controller do
+    before :each do
+      @routes = TokenAction::Engine.routes
+    end
 
-  describe 'GET redeem' do
-    context 'after failing to perform the action' do
-      let :token_with_failure_url do
-        FactoryGirl.create(:token, :args => ['upgrade'], :failure_url => '/hello/token_failure').token
-      end
-      let :token_with_unroutable_failure_url do
-        FactoryGirl.create(:token, :args => ['upgrade'], :failure_url => '/missing').token
-      end
-      let :token_without_failure_url do
-        FactoryGirl.create(:token, :args => ['upgrade']).token
-      end
-      let :token_with_error do
-        FactoryGirl.create(:token, :args => ['metamorphose']).token
-      end
-      let :token_with_namespaced_error do
-        FactoryGirl.create(:token, :args => ['fly']).token
-      end
+    describe 'GET redeem' do
+      context 'after failing to perform the action' do
+        let :token_with_failure_url do
+          FactoryGirl.create(:token, args: ['upgrade'], failure_url: '/hello/token_failure').token
+        end
+        let :token_with_unroutable_failure_url do
+          FactoryGirl.create(:token, args: ['upgrade'], failure_url: '/missing').token
+        end
+        let :token_without_failure_url do
+          FactoryGirl.create(:token, args: ['upgrade']).token
+        end
+        let :token_with_error do
+          FactoryGirl.create(:token, args: ['metamorphose']).token
+        end
+        let :token_with_namespaced_error do
+          FactoryGirl.create(:token, args: ['fly']).token
+        end
 
-      it "redirects to the token's failure URL" do
-        TokenAction.failure_url = '/hello/failure'
-        get :redeem, :token => token_with_failure_url, :path => 'redeem'
-        response.should redirect_to '/hello/token_failure'
-      end
-      it "redirects to the default failure URL if the token's failure URL is not routable" do
-        TokenAction.failure_url = '/hello/failure'
-        get :redeem, :token => token_with_unroutable_failure_url, :path => 'redeem'
-        response.should redirect_to '/hello/failure'
-      end
-      it "redirects to the default failure URL if the token's failure URL is not set" do
-        TokenAction.failure_url = '/hello/failure'
-        get :redeem, :token => token_without_failure_url, :path => 'redeem'
-        response.should redirect_to '/hello/failure'
-      end
-      it "redirects to the application's root_path if the default failure URL is not routable" do
-        TokenAction.failure_url = '/missing'
-        get :redeem, :token => token_without_failure_url, :path => 'redeem'
-        response.should redirect_to Rails.application.routes.url_for(:controller => 'hello', :action => 'hello')
-      end
-      it "redirects to the application's root_path if the default failure URL is not set" do
-        TokenAction.failure_url = nil
-        get :redeem, :token => token_without_failure_url, :path => 'redeem'
-        response.should redirect_to Rails.application.routes.url_for(:controller => 'hello', :action => 'hello')
-      end
+        it "redirects to the token's failure URL" do
+          TokenAction.failure_url = '/hello/failure'
+          get :redeem, token: token_with_failure_url, path: 'redeem'
+          expect(response).to redirect_to('/hello/token_failure')
+        end
+        it "redirects to the default failure URL if the token's failure URL is not routable" do
+          TokenAction.failure_url = '/hello/failure'
+          get :redeem, token: token_with_unroutable_failure_url, path: 'redeem'
+          expect(response).to redirect_to('/hello/failure')
+        end
+        it "redirects to the default failure URL if the token's failure URL is not set" do
+          TokenAction.failure_url = '/hello/failure'
+          get :redeem, token: token_without_failure_url, path: 'redeem'
+          expect(response).to redirect_to('/hello/failure')
+        end
+        it "redirects to the application's root_path if the default failure URL is not routable" do
+          TokenAction.failure_url = '/missing'
+          get :redeem, token: token_without_failure_url, path: 'redeem'
+          expect(response).to redirect_to(Rails.application.routes.url_for(controller: 'hello', action: 'hello', only_path: true))
+        end
+        it "redirects to the application's root_path if the default failure URL is not set" do
+          TokenAction.failure_url = nil
+          get :redeem, token: token_without_failure_url, path: 'redeem'
+          expect(response).to redirect_to(Rails.application.routes.url_for(controller: 'hello', action: 'hello', only_path: true))
+        end
 
-      it 'flashes a path-based, error-based failure message' do
-        get :redeem, :token => token_with_error, :path => 'confirm'
-        flash[:notice].should be_nil
-        flash[:alert].should == 'This is an path-based, error-based failure message.'
-      end
-      it 'flashes a error-based failure message' do
-        get :redeem, :token => token_with_error, :path => 'redeem'
-        flash[:notice].should be_nil
-        flash[:alert].should == 'This is an error-based failure message.'
-      end
-      it 'flashes a long error-based failure message' do
-        get :redeem, :token => token_with_namespaced_error, :path => 'redeem'
-        flash[:notice].should be_nil
-        flash[:alert].should == 'This is another error-based failure message.'
-      end
-      it 'flashes a path-based failure message' do
-        get :redeem, :token => token_without_failure_url, :path => 'confirm'
-        flash[:notice].should be_nil
-        flash[:alert].should == 'This is a path-based failure message.'
-      end
-      it 'flashes a long path-based failure message' do
-        get :redeem, :token => token_without_failure_url, :path => 'a/b/c'
-        flash[:notice].should be_nil
-        flash[:alert].should == 'This is another path-based failure message.'
-      end
-      it 'flashes the default failure message' do
-        get :redeem, :token => token_without_failure_url, :path => 'redeem'
-        flash[:notice].should be_nil
-        flash[:alert].should == 'An error occurred while processing your request.'
+        it 'flashes a path-based, error-based failure message' do
+          get :redeem, token: token_with_error, path: 'confirm'
+          expect(flash[:notice]).to eq(nil)
+          expect(flash[:alert]).to eq('This is an path-based, error-based failure message.')
+        end
+        it 'flashes a error-based failure message' do
+          get :redeem, token: token_with_error, path: 'redeem'
+          expect(flash[:notice]).to eq(nil)
+          expect(flash[:alert]).to eq('This is an error-based failure message.')
+        end
+        it 'flashes a long error-based failure message' do
+          get :redeem, token: token_with_namespaced_error, path: 'redeem'
+          expect(flash[:notice]).to eq(nil)
+          expect(flash[:alert]).to eq('This is another error-based failure message.')
+        end
+        it 'flashes a path-based failure message' do
+          get :redeem, token: token_without_failure_url, path: 'confirm'
+          expect(flash[:notice]).to eq(nil)
+          expect(flash[:alert]).to eq('This is a path-based failure message.')
+        end
+        it 'flashes a long path-based failure message' do
+          get :redeem, token: token_without_failure_url, path: 'a/b/c'
+          expect(flash[:notice]).to eq(nil)
+          expect(flash[:alert]).to eq('This is another path-based failure message.')
+        end
+        it 'flashes the default failure message' do
+          get :redeem, token: token_without_failure_url, path: 'redeem'
+          expect(flash[:notice]).to eq(nil)
+          expect(flash[:alert]).to eq('An error occurred while processing your request.')
+        end
       end
-    end
 
-    context 'when the token is not found' do
-      it 'redirects to the default failure URL' do
-        TokenAction.failure_url = '/hello/not_found'
-        get :redeem, :token => 'missing', :path => 'redeem'
-        response.should redirect_to '/hello/not_found'
-      end
-      it "redirects to the application's root_path if the default failure URL is not routable" do
-        TokenAction.failure_url = '/missing'
-        get :redeem, :token => 'missing', :path => 'redeem'
-        response.should redirect_to Rails.application.routes.url_for(:controller => 'hello', :action => 'hello')
-      end
-      it "redirects to the application's root_path if the default failure URL is not set" do
-        TokenAction.failure_url = nil
-        get :redeem, :token => 'missing', :path => 'redeem'
-        response.should redirect_to Rails.application.routes.url_for(:controller => 'hello', :action => 'hello')
-      end
+      context 'when the token is not found' do
+        it 'redirects to the default failure URL' do
+          TokenAction.failure_url = '/hello/not_found'
+          get :redeem, token: 'missing', path: 'redeem'
+          expect(response).to redirect_to('/hello/not_found')
+        end
+        it "redirects to the application's root_path if the default failure URL is not routable" do
+          TokenAction.failure_url = '/missing'
+          get :redeem, token: 'missing', path: 'redeem'
+          expect(response).to redirect_to(Rails.application.routes.url_for(controller: 'hello', action: 'hello', only_path: true))
+        end
+        it "redirects to the application's root_path if the default failure URL is not set" do
+          TokenAction.failure_url = nil
+          get :redeem, token: 'missing', path: 'redeem'
+          expect(response).to redirect_to(Rails.application.routes.url_for(controller: 'hello', action: 'hello', only_path: true))
+        end
 
-      it 'flashes a path-based failure message' do
-        get :redeem, :token => 'missing', :path => 'confirm'
-        flash[:notice].should be_nil
-        flash[:alert].should == 'This is a path-based not found message.'
-      end
-      it 'flashes a long path-based failure message' do
-        get :redeem, :token => 'missing', :path => 'a/b/c'
-        flash[:notice].should be_nil
-        flash[:alert].should == 'This is another path-based not found message.'
+        it 'flashes a path-based failure message' do
+          get :redeem, token: 'missing', path: 'confirm'
+          expect(flash[:notice]).to eq(nil)
+          expect(flash[:alert]).to eq('This is a path-based not found message.')
+        end
+        it 'flashes a long path-based failure message' do
+          get :redeem, token: 'missing', path: 'a/b/c'
+          expect(flash[:notice]).to eq(nil)
+          expect(flash[:alert]).to eq('This is another path-based not found message.')
+        end
+        it 'flashes the default failure message if no path-based failure message is set' do
+          get :redeem, token: 'missing', path: 'redeem'
+          expect(flash[:notice]).to eq(nil)
+          expect(flash[:alert]).to eq('Sorry, your request could not be processed.')
+        end
       end
-      it 'flashes the default failure message if no path-based failure message is set' do
-        get :redeem, :token => 'missing', :path => 'redeem'
-        flash[:notice].should be_nil
-        flash[:alert].should == 'Sorry, your request could not be processed.'
-      end
-    end
 
-    context 'after performing the action successfully' do
-      let :token_with_success_url do
-        FactoryGirl.create(:token, :success_url => '/hello/token_success').token
-      end
-      let :token_with_unroutable_success_url do
-        FactoryGirl.create(:token, :success_url => '/missing').token
-      end
-      let :token_without_success_url do
-        FactoryGirl.create(:token).token
-      end
+      context 'after performing the action successfully' do
+        let :token_with_success_url do
+          FactoryGirl.create(:token, success_url: '/hello/token_success').token
+        end
+        let :token_with_unroutable_success_url do
+          FactoryGirl.create(:token, success_url: '/missing').token
+        end
+        let :token_without_success_url do
+          FactoryGirl.create(:token).token
+        end
 
-      it "redirects to the token's success URL" do
-        TokenAction.success_url = '/hello/success'
-        get :redeem, :token => token_with_success_url, :path => 'redeem'
-        response.should redirect_to '/hello/token_success'
-      end
-      it "redirects to the default success URL if the token's success URL is not routable" do
-        TokenAction.success_url = '/hello/success'
-        get :redeem, :token => token_with_unroutable_success_url, :path => 'redeem'
-        response.should redirect_to '/hello/success'
-      end
-      it "redirects to the default success URL if the token's success URL is not set" do
-        TokenAction.success_url = '/hello/success'
-        get :redeem, :token => token_without_success_url, :path => 'redeem'
-        response.should redirect_to '/hello/success'
-      end
-      it "redirects to the application's root_path if the default success URL is not routable" do
-        TokenAction.success_url = '/missing'
-        get :redeem, :token => token_without_success_url, :path => 'redeem'
-        response.should redirect_to Rails.application.routes.url_for(:controller => 'hello', :action => 'hello')
-      end
-      it "redirects to the application's root_path if the default success URL is not set" do
-        TokenAction.success_url = nil
-        get :redeem, :token => token_without_success_url, :path => 'redeem'
-        response.should redirect_to Rails.application.routes.url_for(:controller => 'hello', :action => 'hello')
-      end
+        it "redirects to the token's success URL" do
+          TokenAction.success_url = '/hello/success'
+          get :redeem, token: token_with_success_url, path: 'redeem'
+          expect(response).to redirect_to('/hello/token_success')
+        end
+        it "redirects to the default success URL if the token's success URL is not routable" do
+          TokenAction.success_url = '/hello/success'
+          get :redeem, token: token_with_unroutable_success_url, path: 'redeem'
+          expect(response).to redirect_to('/hello/success')
+        end
+        it "redirects to the default success URL if the token's success URL is not set" do
+          TokenAction.success_url = '/hello/success'
+          get :redeem, token: token_without_success_url, path: 'redeem'
+          expect(response).to redirect_to('/hello/success')
+        end
+        it "redirects to the application's root_path if the default success URL is not routable" do
+          TokenAction.success_url = '/missing'
+          get :redeem, token: token_without_success_url, path: 'redeem'
+          expect(response).to redirect_to(Rails.application.routes.url_for(controller: 'hello', action: 'hello', only_path: true))
+        end
+        it "redirects to the application's root_path if the default success URL is not set" do
+          TokenAction.success_url = nil
+          get :redeem, token: token_without_success_url, path: 'redeem'
+          expect(response).to redirect_to(Rails.application.routes.url_for(controller: 'hello', action: 'hello', only_path: true))
+        end
 
-      it 'flashes a path-based success message' do
-        get :redeem, :token => token_without_success_url, :path => 'confirm'
-        flash[:notice].should == 'This is a path-based success message.'
-        flash[:alert].should be_nil
-      end
-      it 'flashes a long path-based success message' do
-        get :redeem, :token => token_without_success_url, :path => 'a/b/c'
-        flash[:notice].should == 'This is another path-based success message.'
-        flash[:alert].should be_nil
-      end
-      it 'flashes the default success message if no path-based success message is set' do
-        get :redeem, :token => token_without_success_url, :path => 'redeem'
-        flash[:notice].should == 'Your request was successfully processed.'
-        flash[:alert].should be_nil
+        it 'flashes a path-based success message' do
+          get :redeem, token: token_without_success_url, path: 'confirm'
+          expect(flash[:notice]).to eq('This is a path-based success message.')
+          expect(flash[:alert]).to eq(nil)
+        end
+        it 'flashes a long path-based success message' do
+          get :redeem, token: token_without_success_url, path: 'a/b/c'
+          expect(flash[:notice]).to eq('This is another path-based success message.')
+          expect(flash[:alert]).to eq(nil)
+        end
+        it 'flashes the default success message if no path-based success message is set' do
+          get :redeem, token: token_without_success_url, path: 'redeem'
+          expect(flash[:notice]).to eq('Your request was successfully processed.')
+          expect(flash[:alert]).to eq(nil)
+        end
       end
     end
   end