loyal_devise 2.1.2

data/test/integration/token_authenticatable_test.rb

@@ -0,0 +1,162 @@
+# -*- encoding : utf-8 -*-
+require 'test_helper'
+
+class TokenAuthenticationTest < ActionController::IntegrationTest
+
+  test 'authenticate with valid authentication token key and value through params' do
+    swap Devise, :token_authentication_key => :secret_token do
+      sign_in_as_new_user_with_token
+
+      assert_response :success
+      assert_current_url "/users?secret_token=#{VALID_AUTHENTICATION_TOKEN}"
+      assert_contain 'Welcome'
+      assert warden.authenticated?(:user)
+    end
+  end
+
+  test 'authenticate with valid authentication token key and value through params, when params with the same key as scope exist' do
+    swap Devise, :token_authentication_key => :secret_token do
+      user = create_user_with_authentication_token
+      post exhibit_user_path(user), Devise.token_authentication_key => user.authentication_token, :user => { :some => "data" }
+
+      assert_response :success
+      assert_contain 'User is authenticated'
+      assert warden.authenticated?(:user)
+    end
+  end
+
+  test 'authenticate with valid authentication token key but does not store if stateless' do
+    swap Devise, :token_authentication_key => :secret_token, :skip_session_storage => [:token_auth] do
+      sign_in_as_new_user_with_token
+      assert warden.authenticated?(:user)
+
+      get users_path
+      assert_redirected_to new_user_session_path
+      assert_not warden.authenticated?(:user)
+    end
+  end
+
+  test 'authenticate with valid authentication token key and value through http' do
+    swap Devise, :token_authentication_key => :secret_token do
+      sign_in_as_new_user_with_token(:http_auth => true)
+
+      assert_response :success
+      assert_match '<email>user@test.com</email>', response.body
+      assert warden.authenticated?(:user)
+    end
+  end
+
+  test 'does authenticate with valid authentication token key and value through params if not configured' do
+    swap Devise, :token_authentication_key => :secret_token, :params_authenticatable => [:database] do
+      sign_in_as_new_user_with_token
+
+      assert_contain 'You need to sign in or sign up before continuing'
+      assert_contain 'Sign in'
+      assert_not warden.authenticated?(:user)
+    end
+  end
+
+  test 'does authenticate with valid authentication token key and value through http if not configured' do
+    swap Devise, :token_authentication_key => :secret_token, :http_authenticatable => [:database] do
+      sign_in_as_new_user_with_token(:http_auth => true)
+
+      assert_response 401
+      assert_contain 'Invalid email or password.'
+      assert_not warden.authenticated?(:user)
+    end
+  end
+
+  test 'does not authenticate with improper authentication token key' do
+    swap Devise, :token_authentication_key => :donald_duck_token do
+      sign_in_as_new_user_with_token(:auth_token_key => :secret_token)
+      assert_equal new_user_session_path, @request.path
+
+      assert_contain 'You need to sign in or sign up before continuing'
+      assert_contain 'Sign in'
+      assert_not warden.authenticated?(:user)
+    end
+  end
+
+  test 'does not authenticate with improper authentication token value' do
+    store_translations :en, :devise => {:failure => {:invalid_token => 'LOL, that was not a single character correct.'}} do
+      sign_in_as_new_user_with_token(:auth_token => '*** INVALID TOKEN ***')
+      assert_equal new_user_session_path, @request.path
+
+      assert_contain 'LOL, that was not a single character correct.'
+      assert_contain 'Sign in'
+      assert_not warden.authenticated?(:user)
+    end
+  end
+
+  test 'authenticate with valid authentication token key and do not store if stateless and timeoutable are enabled' do
+    swap Devise, :token_authentication_key => :secret_token, :skip_session_storage => [:token_auth], :timeout_in => (0.1).second do
+      user = sign_in_as_new_user_with_token
+      assert warden.authenticated?(:user)
+
+      # Expiring does not work because we are setting the session value when accessing it
+      sleep 0.3
+
+      get_users_path_as_existing_user(user)
+      assert warden.authenticated?(:user)
+    end
+  end
+
+  test 'should reset token and not authenticate when expire_auth_token_on_timeout is set to true, timeoutable is enabled and we have a timed out session' do
+    swap Devise, :token_authentication_key => :secret_token, :expire_auth_token_on_timeout => true, :timeout_in => (-1).minute do
+      user = sign_in_as_new_user_with_token
+      assert warden.authenticated?(:user)
+      token = user.authentication_token
+
+      get_users_path_as_existing_user(user)
+      assert_not warden.authenticated?(:user)
+      user.reload
+      assert_not_equal token, user.authentication_token
+    end
+  end
+
+  test 'should not be subject to injection' do
+    swap Devise, :token_authentication_key => :secret_token do
+      user1 = create_user_with_authentication_token()
+
+      # Clean up user cache
+      @user = nil
+
+      user2 = create_user_with_authentication_token(:email => "another@test.com")
+      user2.update_attribute(:authentication_token, "ANOTHERTOKEN")
+
+      assert_not_equal user1, user2
+      visit users_path(Devise.token_authentication_key.to_s + '[$ne]' => user1.authentication_token)
+      assert_nil warden.user(:user)
+    end
+  end
+
+  private
+
+    def sign_in_as_new_user_with_token(options = {})
+      user = options.delete(:user) || create_user_with_authentication_token(options)
+
+      options[:auth_token_key] ||= Devise.token_authentication_key
+      options[:auth_token]     ||= user.authentication_token
+
+      if options[:http_auth]
+        header = "Basic #{Base64.encode64("#{VALID_AUTHENTICATION_TOKEN}:X")}"
+        get users_path(:format => :xml), {}, "HTTP_AUTHORIZATION" => header
+      else
+        visit users_path(options[:auth_token_key].to_sym => options[:auth_token])
+      end
+
+      user
+    end
+
+    def create_user_with_authentication_token(options={})
+      user = create_user(options)
+      user.authentication_token = VALID_AUTHENTICATION_TOKEN
+      user.save
+      user
+    end
+
+    def get_users_path_as_existing_user(user)
+      sign_in_as_new_user_with_token(:user => user)
+    end
+
+end

data/test/integration/trackable_test.rb

@@ -0,0 +1,93 @@
+# -*- encoding : utf-8 -*-
+require 'test_helper'
+
+class TrackableHooksTest < ActionController::IntegrationTest
+
+  test "current and last sign in timestamps are updated on each sign in" do
+    user = create_user
+    assert_nil user.current_sign_in_at
+    assert_nil user.last_sign_in_at
+
+    sign_in_as_user
+    user.reload
+
+    assert_kind_of Time, user.current_sign_in_at
+    assert_kind_of Time, user.last_sign_in_at
+
+    assert_equal user.current_sign_in_at, user.last_sign_in_at
+    assert user.current_sign_in_at >= user.created_at
+
+    visit destroy_user_session_path
+    new_time = 2.seconds.from_now
+    Time.stubs(:now).returns(new_time)
+
+    sign_in_as_user
+    user.reload
+    assert user.current_sign_in_at > user.last_sign_in_at
+  end
+
+  test "current and last sign in remote ip are updated on each sign in" do
+    user = create_user
+    assert_nil user.current_sign_in_ip
+    assert_nil user.last_sign_in_ip
+
+    sign_in_as_user
+    user.reload
+
+    assert_equal "127.0.0.1", user.current_sign_in_ip
+    assert_equal "127.0.0.1", user.last_sign_in_ip
+  end
+
+  test "current remote ip returns original ip behind a non transparent proxy" do
+    user = create_user
+
+    arbitrary_ip = '200.121.1.69'
+    sign_in_as_user do
+      header 'HTTP_X_FORWARDED_FOR', arbitrary_ip
+    end
+    user.reload
+    assert_equal arbitrary_ip, user.current_sign_in_ip
+  end
+
+  test "increase sign in count" do
+    user = create_user
+    assert_equal 0, user.sign_in_count
+
+    sign_in_as_user
+    user.reload
+    assert_equal 1, user.sign_in_count
+
+    visit destroy_user_session_path
+    sign_in_as_user
+    user.reload
+    assert_equal 2, user.sign_in_count
+  end
+
+  test "does not update anything if user has signed out along the way" do
+    swap Devise, :allow_unconfirmed_access_for => 0 do
+      user = create_user(:confirm => false)
+      sign_in_as_user
+
+      user.reload
+      assert_nil user.current_sign_in_at
+      assert_nil user.last_sign_in_at
+    end
+  end
+
+  test "do not track if devise.skip_trackable is set" do
+    user = create_user
+    sign_in_as_user do
+      header 'devise.skip_trackable', '1'
+    end
+    user.reload
+    assert_equal 0, user.sign_in_count
+    visit destroy_user_session_path
+
+    sign_in_as_user do
+      header 'devise.skip_trackable', false
+    end
+    user.reload
+    assert_equal 1, user.sign_in_count
+  end
+
+end

data/test/mailers/confirmation_instructions_test.rb

@@ -0,0 +1,103 @@
+# -*- encoding : utf-8 -*-
+require 'test_helper'
+
+class ConfirmationInstructionsTest < ActionMailer::TestCase
+
+  def setup
+    setup_mailer
+    Devise.mailer = 'Devise::Mailer'
+    Devise.mailer_sender = 'test@example.com'
+  end
+
+  def teardown
+    Devise.mailer = 'Devise::Mailer'
+    Devise.mailer_sender = 'please-change-me@config-initializers-devise.com'
+  end
+
+  def user
+    @user ||= create_user
+  end
+
+  def mail
+    @mail ||= begin
+      user
+      ActionMailer::Base.deliveries.first
+    end
+  end
+
+  test 'email sent after creating the user' do
+    assert_not_nil mail
+  end
+
+  test 'content type should be set to html' do
+    assert mail.content_type.include?('text/html')
+  end
+
+  test 'send confirmation instructions to the user email' do
+    mail
+    assert_equal [user.email], mail.to
+  end
+
+  test 'setup sender from configuration' do
+    assert_equal ['test@example.com'], mail.from
+  end
+
+  test 'setup sender from custom mailer defaults' do
+    Devise.mailer = 'Users::Mailer'
+    assert_equal ['custom@example.com'], mail.from
+  end
+
+  test 'setup reply to as copy from sender' do
+    assert_equal ['test@example.com'], mail.reply_to
+  end
+
+  test 'setup reply to as different if set in defaults' do
+    Devise.mailer = 'Users::ReplyToMailer'
+    assert_equal ['custom@example.com'], mail.from
+    assert_equal ['custom_reply_to@example.com'], mail.reply_to
+  end
+
+
+  test 'setup subject from I18n' do
+    store_translations :en, :devise => { :mailer => { :confirmation_instructions => { :subject => 'Account Confirmation' } } } do
+      assert_equal 'Account Confirmation', mail.subject
+    end
+  end
+
+  test 'subject namespaced by model' do
+    store_translations :en, :devise => { :mailer => { :confirmation_instructions => { :user_subject => 'User Account Confirmation' } } } do
+      assert_equal 'User Account Confirmation', mail.subject
+    end
+  end
+
+  test 'body should have user info' do
+    assert_match /#{user.email}/, mail.body.encoded
+  end
+
+  test 'body should have link to confirm the account' do
+    host = ActionMailer::Base.default_url_options[:host]
+    confirmation_url_regexp = %r{<a href=\"http://#{host}/users/confirmation\?confirmation_token=#{user.confirmation_token}">}
+    assert_match confirmation_url_regexp, mail.body.encoded
+  end
+
+  test 'renders a scoped if scoped_views is set to true' do
+    swap Devise, :scoped_views => true do
+      assert_equal user.email, mail.body.decoded
+    end
+  end
+
+  test 'renders a scoped if scoped_views is set in the mailer class' do
+    begin
+      Devise::Mailer.scoped_views = true
+      assert_equal user.email, mail.body.decoded
+    ensure
+      Devise::Mailer.send :remove_instance_variable, :@scoped_views
+    end
+  end
+
+  test 'mailer sender accepts a proc' do
+    swap Devise, :mailer_sender => proc { "another@example.com" } do
+      assert_equal ['another@example.com'], mail.from
+    end
+  end
+end

data/test/mailers/reset_password_instructions_test.rb

@@ -0,0 +1,84 @@
+# -*- encoding : utf-8 -*-
+require 'test_helper'
+
+class ResetPasswordInstructionsTest < ActionMailer::TestCase
+
+  def setup
+    setup_mailer
+    Devise.mailer = 'Devise::Mailer'
+    Devise.mailer_sender = 'test@example.com'
+  end
+
+  def teardown
+    Devise.mailer = 'Devise::Mailer'
+    Devise.mailer_sender = 'please-change-me@config-initializers-devise.com'
+  end
+
+  def user
+    @user ||= begin
+      user = create_user
+      user.send_reset_password_instructions
+      user
+    end
+  end
+
+  def mail
+    @mail ||= begin
+      user
+      ActionMailer::Base.deliveries.last
+    end
+  end
+
+  test 'email sent after reseting the user password' do
+    assert_not_nil mail
+  end
+
+  test 'content type should be set to html' do
+    assert mail.content_type.include?('text/html')
+  end
+
+  test 'send confirmation instructions to the user email' do
+    assert_equal [user.email], mail.to
+  end
+
+  test 'setup sender from configuration' do
+    assert_equal ['test@example.com'], mail.from
+  end
+
+  test 'setup sender from custom mailer defaults' do
+    Devise.mailer = 'Users::Mailer'
+    assert_equal ['custom@example.com'], mail.from
+  end
+
+  test 'setup reply to as copy from sender' do
+    assert_equal ['test@example.com'], mail.reply_to
+  end
+
+  test 'setup subject from I18n' do
+    store_translations :en, :devise => { :mailer => { :reset_password_instructions => { :subject => 'Reset instructions' } } } do
+      assert_equal 'Reset instructions', mail.subject
+    end
+  end
+
+  test 'subject namespaced by model' do
+    store_translations :en, :devise => { :mailer => { :reset_password_instructions => { :user_subject => 'User Reset Instructions' } } } do
+      assert_equal 'User Reset Instructions', mail.subject
+    end
+  end
+
+  test 'body should have user info' do
+    assert_match(/#{user.email}/, mail.body.encoded)
+  end
+
+  test 'body should have link to confirm the account' do
+    host = ActionMailer::Base.default_url_options[:host]
+    reset_url_regexp = %r{<a href=\"http://#{host}/users/password/edit\?reset_password_token=#{user.reset_password_token}">}
+    assert_match reset_url_regexp, mail.body.encoded
+  end
+
+  test 'mailer sender accepts a proc' do
+    swap Devise, :mailer_sender => proc { "another@example.com" } do
+      assert_equal ['another@example.com'], mail.from
+    end
+  end
+end

data/test/mailers/unlock_instructions_test.rb

@@ -0,0 +1,78 @@
+# -*- encoding : utf-8 -*-
+require 'test_helper'
+
+class UnlockInstructionsTest < ActionMailer::TestCase
+
+  def setup
+    setup_mailer
+    Devise.mailer = 'Devise::Mailer'
+    Devise.mailer_sender = 'test@example.com'
+  end
+
+  def teardown
+    Devise.mailer = 'Devise::Mailer'
+    Devise.mailer_sender = 'please-change-me@config-initializers-devise.com'
+  end
+
+  def user
+    @user ||= begin
+      user = create_user
+      user.lock_access!
+      user
+    end
+  end
+
+  def mail
+    @mail ||= begin
+      user
+      ActionMailer::Base.deliveries.last
+    end
+  end
+
+  test 'email sent after locking the user' do
+    assert_not_nil mail
+  end
+
+  test 'content type should be set to html' do
+    assert mail.content_type.include?('text/html')
+  end
+
+  test 'send unlock instructions to the user email' do
+    assert_equal [user.email], mail.to
+  end
+
+  test 'setup sender from configuration' do
+    assert_equal ['test@example.com'], mail.from
+  end
+
+  test 'setup sender from custom mailer defaults' do
+    Devise.mailer = 'Users::Mailer'
+    assert_equal ['custom@example.com'], mail.from
+  end
+
+  test 'setup reply to as copy from sender' do
+    assert_equal ['test@example.com'], mail.reply_to
+  end
+
+  test 'setup subject from I18n' do
+    store_translations :en, :devise => { :mailer => { :unlock_instructions =>  { :subject => 'Yo unlock instructions' } } } do
+      assert_equal 'Yo unlock instructions', mail.subject
+    end
+  end
+
+  test 'subject namespaced by model' do
+    store_translations :en, :devise => { :mailer => { :unlock_instructions => { :user_subject => 'User Unlock Instructions' } } } do
+      assert_equal 'User Unlock Instructions', mail.subject
+    end
+  end
+
+  test 'body should have user info' do
+    assert_match(/#{user.email}/, mail.body.encoded)
+  end
+
+  test 'body should have link to unlock the account' do
+    host = ActionMailer::Base.default_url_options[:host]
+    unlock_url_regexp = %r{<a href=\"http://#{host}/users/unlock\?unlock_token=#{user.unlock_token}">}
+    assert_match unlock_url_regexp, mail.body.encoded
+  end
+end

data/test/mapping_test.rb

@@ -0,0 +1,128 @@
+# -*- encoding : utf-8 -*-
+require 'test_helper'
+
+class FakeRequest < Struct.new(:path_info, :params)
+end
+
+class MappingTest < ActiveSupport::TestCase
+  def fake_request(path, params={})
+    FakeRequest.new(path, params)
+  end
+
+  test 'store options' do
+    mapping = Devise.mappings[:user]
+    assert_equal User,                mapping.to
+    assert_equal User.devise_modules, mapping.modules
+    assert_equal "users",             mapping.scoped_path
+    assert_equal :user,               mapping.singular
+    assert_equal "users",             mapping.path
+    assert_equal "/users",            mapping.fullpath
+  end
+
+  test 'store options with namespace' do
+    mapping = Devise.mappings[:publisher_account]
+    assert_equal Admin,                 mapping.to
+    assert_equal "publisher/accounts",  mapping.scoped_path
+    assert_equal :publisher_account,    mapping.singular
+    assert_equal "accounts",            mapping.path
+    assert_equal "/publisher/accounts", mapping.fullpath
+  end
+
+  test 'allows path to be given' do
+    assert_equal "admin_area", Devise.mappings[:admin].path
+  end
+
+  test 'allows to skip all routes' do
+    assert_equal [], Devise.mappings[:skip_admin].used_routes
+  end
+
+  test 'sign_out_via defaults to :get' do
+    assert_equal :get, Devise.mappings[:user].sign_out_via
+  end
+
+  test 'allows custom sign_out_via to be given' do
+    assert_equal :delete,          Devise.mappings[:sign_out_via_delete].sign_out_via
+    assert_equal :post,            Devise.mappings[:sign_out_via_post].sign_out_via
+    assert_equal [:delete, :post], Devise.mappings[:sign_out_via_delete_or_post].sign_out_via
+  end
+
+  test 'allows custom singular to be given' do
+    assert_equal "accounts", Devise.mappings[:manager].path
+  end
+
+  test 'has strategies depending on the model declaration' do
+    assert_equal [:rememberable, :token_authenticatable, :database_authenticatable], Devise.mappings[:user].strategies
+    assert_equal [:database_authenticatable], Devise.mappings[:admin].strategies
+  end
+
+  test 'has no input strategies depending on the model declaration' do
+    assert_equal [:rememberable, :token_authenticatable], Devise.mappings[:user].no_input_strategies
+    assert_equal [], Devise.mappings[:admin].no_input_strategies
+  end
+
+  test 'find scope for a given object' do
+    assert_equal :user, Devise::Mapping.find_scope!(User)
+    assert_equal :user, Devise::Mapping.find_scope!(:user)
+    assert_equal :user, Devise::Mapping.find_scope!(User.new)
+  end
+
+  test 'find scope works with single table inheritance' do
+    assert_equal :user, Devise::Mapping.find_scope!(Class.new(User))
+    assert_equal :user, Devise::Mapping.find_scope!(Class.new(User).new)
+  end
+
+  test 'find scope raises an error if cannot be found' do
+    assert_raise RuntimeError do
+      Devise::Mapping.find_scope!(String)
+    end
+  end
+
+  test 'return default path names' do
+    mapping = Devise.mappings[:user]
+    assert_equal 'sign_in',      mapping.path_names[:sign_in]
+    assert_equal 'sign_out',     mapping.path_names[:sign_out]
+    assert_equal 'password',     mapping.path_names[:password]
+    assert_equal 'confirmation', mapping.path_names[:confirmation]
+    assert_equal 'sign_up',      mapping.path_names[:sign_up]
+    assert_equal 'unlock',       mapping.path_names[:unlock]
+  end
+
+  test 'allow custom path names to be given' do
+    mapping = Devise.mappings[:manager]
+    assert_equal 'login',        mapping.path_names[:sign_in]
+    assert_equal 'logout',       mapping.path_names[:sign_out]
+    assert_equal 'secret',       mapping.path_names[:password]
+    assert_equal 'verification', mapping.path_names[:confirmation]
+    assert_equal 'register',     mapping.path_names[:sign_up]
+    assert_equal 'unblock',      mapping.path_names[:unlock]
+  end
+
+  test 'magic predicates' do
+    mapping = Devise.mappings[:user]
+    assert mapping.authenticatable?
+    assert mapping.confirmable?
+    assert mapping.recoverable?
+    assert mapping.rememberable?
+    assert mapping.registerable?
+
+    mapping = Devise.mappings[:admin]
+    assert mapping.authenticatable?
+    assert mapping.recoverable?
+    assert mapping.lockable?
+    assert_not mapping.omniauthable?
+  end
+  
+  test 'find mapping by path' do
+    assert_raise RuntimeError do
+      Devise::Mapping.find_by_path!('/accounts/facebook/callback')
+    end
+    
+    assert_nothing_raised do
+      Devise::Mapping.find_by_path!('/:locale/accounts/login')
+    end
+
+    assert_nothing_raised do
+      Devise::Mapping.find_by_path!('/accounts/facebook/callback', :path)
+    end
+  end  
+end

data/test/models/authenticatable_test.rb

@@ -0,0 +1,8 @@
+# -*- encoding : utf-8 -*-
+require 'test_helper'
+
+class AuthenticatableTest < ActiveSupport::TestCase
+  test 'required_fields should be an empty array' do
+    assert_equal Devise::Models::Validatable.required_fields(User), []
+  end
+end