shingara-devise 0.4.3

data/test/controllers/filters_test.rb

@@ -0,0 +1,103 @@
+require 'test/test_helper'
+require 'ostruct'
+
+class MockController < ApplicationController
+  attr_accessor :env
+
+  def request
+    self
+  end
+
+  def path
+    ''
+  end
+end
+
+class ControllerAuthenticableTest < ActionController::TestCase
+
+  def setup
+    @controller = MockController.new
+    @mock_warden = OpenStruct.new
+    @controller.env = { 'warden' => @mock_warden }
+  end
+
+  test 'setup warden' do
+    assert_not_nil @controller.warden
+  end
+
+  test 'provide access to warden instance' do
+    assert_equal @controller.warden, @controller.env['warden']
+  end
+
+  test 'run authenticate? with scope on warden' do
+    @mock_warden.expects(:authenticated?).with(:my_scope)
+    @controller.signed_in?(:my_scope)
+  end
+
+  test 'proxy signed_in? to authenticated' do
+    @mock_warden.expects(:authenticated?).with(:my_scope)
+    @controller.signed_in?(:my_scope)
+  end
+
+  test 'run user with scope on warden' do
+    @mock_warden.expects(:user).with(:admin).returns(true)
+    @controller.current_admin
+
+    @mock_warden.expects(:user).with(:user).returns(true)
+    @controller.current_user
+  end
+
+  test 'proxy logout to warden' do
+    @mock_warden.expects(:user).with(:user).returns(true)
+    @mock_warden.expects(:logout).with(:user).returns(true)
+    @controller.sign_out(:user)
+  end
+
+  test 'proxy user_authenticate! to authenticate with user scope' do
+    @mock_warden.expects(:authenticate!).with(:scope => :user)
+    @controller.authenticate_user!
+  end
+
+  test 'proxy admin_authenticate! to authenticate with admin scope' do
+    @mock_warden.expects(:authenticate!).with(:scope => :admin)
+    @controller.authenticate_admin!
+  end
+
+  test 'proxy user_authenticated? to authenticate with user scope' do
+    @mock_warden.expects(:authenticated?).with(:user)
+    @controller.user_signed_in?
+  end
+
+  test 'proxy admin_authenticated? to authenticate with admin scope' do
+    @mock_warden.expects(:authenticated?).with(:admin)
+    @controller.admin_signed_in?
+  end
+
+  test 'proxy user_session to session scope in warden' do
+    @mock_warden.expects(:session).with(:user).returns({})
+    @controller.user_session
+  end
+
+  test 'proxy admin_session to session scope in warden' do
+    @mock_warden.expects(:session).with(:admin).returns({})
+    @controller.admin_session
+  end
+
+  test 'sign in automatically proxy to set user on warden' do
+    @mock_warden.expects(:set_user).with(user = mock, :scope => :user).returns(true)
+    @controller.sign_in(:user, user)
+  end
+
+  test 'is not a devise controller' do
+    assert_not @controller.devise_controller?
+  end
+
+  test 'default url options are retrieved from devise' do
+    begin
+      Devise.default_url_options {{ :locale => I18n.locale }}
+      assert_equal({ :locale => :en }, @controller.send(:default_url_options))
+    ensure
+      Devise.default_url_options {{ }}
+    end
+  end
+end

data/test/controllers/helpers_test.rb

@@ -0,0 +1,55 @@
+require 'test/test_helper'
+
+class MyController < ApplicationController
+  include Devise::Controllers::Helpers
+end
+
+class HelpersTest < ActionController::TestCase
+  tests MyController
+
+  test 'get resource name from request path' do
+    @request.path = '/users/session'
+    assert_equal :user, @controller.resource_name
+  end
+
+  test 'get resource name from specific request path' do
+    @request.path = '/admin_area/session'
+    assert_equal :admin, @controller.resource_name
+  end
+
+  test 'get resource class from request path' do
+    @request.path = '/users/session'
+    assert_equal User, @controller.resource_class
+  end
+
+  test 'get resource instance variable from request path' do
+    @request.path = '/admin_area/session'
+    @controller.instance_variable_set(:@admin, admin = Admin.new)
+    assert_equal admin, @controller.resource
+  end
+
+  test 'set resource instance variable from request path' do
+    @request.path = '/admin_area/session'
+
+    admin = @controller.send(:resource_class).new
+    @controller.send(:resource=, admin)
+
+    assert_equal admin, @controller.send(:resource)
+    assert_equal admin, @controller.instance_variable_get(:@admin)
+  end
+
+  test 'resources methods are not controller actions' do
+    assert @controller.class.action_methods.empty?
+  end
+
+  test 'require no authentication tests current mapping' do
+    @controller.expects(:resource_name).returns(:user).twice
+    @mock_warden.expects(:authenticated?).with(:user).returns(true)
+    @controller.expects(:redirect_to).with(root_path)
+    @controller.send :require_no_authentication
+  end
+  
+  test 'is a devise controller' do
+    assert @controller.devise_controller?
+  end
+end

data/test/controllers/url_helpers_test.rb

@@ -0,0 +1,47 @@
+require 'test/test_helper'
+
+class RoutesTest < ActionController::TestCase
+  tests ApplicationController
+
+  def test_path_and_url(name, prepend_path=nil)
+    @request.path = '/users/session'
+    prepend_path = "#{prepend_path}_" if prepend_path
+
+    # Resource param
+    assert_equal @controller.send(:"#{prepend_path}#{name}_path", :user),
+                 send(:"#{prepend_path}user_#{name}_path")
+    assert_equal @controller.send(:"#{prepend_path}#{name}_url", :user),
+                 send(:"#{prepend_path}user_#{name}_url")
+
+    # Default url params
+    assert_equal @controller.send(:"#{prepend_path}#{name}_path", :user, :param => 123),
+                 send(:"#{prepend_path}user_#{name}_path", :param => 123)
+    assert_equal @controller.send(:"#{prepend_path}#{name}_url", :user, :param => 123),
+                 send(:"#{prepend_path}user_#{name}_url", :param => 123)
+
+    @request.path = nil
+    # With an AR object
+    assert_equal @controller.send(:"#{prepend_path}#{name}_path", User.new),
+                 send(:"#{prepend_path}user_#{name}_path")
+    assert_equal @controller.send(:"#{prepend_path}#{name}_url", User.new),
+                 send(:"#{prepend_path}user_#{name}_url")
+  end
+
+
+  test 'should alias session to mapped user session' do
+    test_path_and_url :session
+    test_path_and_url :session, :new
+    test_path_and_url :session, :destroy
+  end
+
+  test 'should alias password to mapped user password' do
+    test_path_and_url :password
+    test_path_and_url :password, :new
+    test_path_and_url :password, :edit
+  end
+
+  test 'should alias confirmation to mapped user confirmation' do
+    test_path_and_url :confirmation
+    test_path_and_url :confirmation, :new
+  end
+end

data/test/devise_test.rb

@@ -0,0 +1,72 @@
+require 'test/test_helper'
+
+module Devise
+  def self.clean_warden_config!
+    @warden_config = nil 
+  end
+end
+
+class DeviseTest < ActiveSupport::TestCase
+  class MockManager
+    attr_accessor :failure_app
+    attr_reader :default_strategies, :silence_missing_strategies
+
+    def silence_missing_strategies!
+      @silence_missing_strategies = true
+    end
+
+    def default_strategies(*args)
+      if args.empty?
+        @default_strategies
+      else
+        @default_strategies = args
+      end
+    end
+  end
+
+  test 'DeviseMailer.sender can be configured through Devise' do
+    swap DeviseMailer, :sender => "foo@bar" do
+      assert_equal "foo@bar", DeviseMailer.sender
+      Devise.mailer_sender = "bar@foo"
+      assert_equal "bar@foo", DeviseMailer.sender
+    end
+  end
+
+  test 'model options can be configured through Devise' do
+    swap Devise, :confirm_within => 113, :pepper => "foo" do
+      assert_equal 113, Devise.confirm_within
+      assert_equal "foo", Devise.pepper
+    end
+  end
+
+  test 'setup block yields self' do
+    Devise.setup do |config|
+      assert_equal Devise, config
+    end
+  end
+
+  test 'warden manager configuration' do
+    manager = MockManager.new
+    Devise.configure_warden_manager(manager)
+
+    assert_equal Devise::Failure, manager.failure_app
+    assert_equal [:rememberable, :authenticatable], manager.default_strategies
+    assert manager.silence_missing_strategies
+  end
+
+  test 'warden manager user configuration through a block' do
+    begin
+      @executed = false
+      Devise.warden do |manager|
+        @executed = true
+        assert_kind_of MockManager, manager
+      end
+
+      manager = MockManager.new
+      Devise.configure_warden_manager(manager)
+      assert @executed
+    ensure
+      Devise.clean_warden_config!
+    end
+  end
+end

data/test/encryptors_test.rb

@@ -0,0 +1,28 @@
+class Encryptors < ActiveSupport::TestCase
+
+  test 'should match a password created by authlogic' do
+    authlogic = "b623c3bc9c775b0eb8edb218a382453396fec4146422853e66ecc4b6bc32d7162ee42074dcb5f180a770dc38b5df15812f09bbf497a4a1b95fe5e7d2b8eb7eb4"
+    encryptor = Devise::Encryptors::AuthlogicSha512.digest('123mudar', 20, 'usZK_z_EAaF61Gwkw-ed', '')
+    assert_equal authlogic, encryptor
+  end
+
+  test 'should match a password created by restful_authentication' do
+    restful_authentication = "93110f71309ce91366375ea44e2a6f5cc73fa8d4"
+    encryptor = Devise::Encryptors::RestfulAuthenticationSha1.digest('123mudar', 10, '48901d2b247a54088acb7f8ea3e695e50fe6791b', 'fee9a51ec0a28d11be380ca6dee6b4b760c1a3bf')
+    assert_equal restful_authentication, encryptor
+  end
+
+  test 'should match a password created by clearance' do
+    clearance = "0f40bbae18ddefd7066276c3ef209d40729b0378"
+    encryptor = Devise::Encryptors::ClearanceSha1.digest('123mudar', nil, '65c58472c207c829f28c68619d3e3aefed18ab3f', nil)
+    assert_equal clearance, encryptor
+  end
+
+  Devise::ENCRYPTORS_LENGTH.each do |key, value|
+    test "should have length #{value} for #{key.inspect}" do
+      swap Devise, :encryptor => key do
+        assert_equal value, Devise.encryptor.digest('a', 2, 'b', 'c').size
+      end
+    end
+  end
+end

data/test/failure_test.rb

@@ -0,0 +1,34 @@
+require 'test/test_helper'
+
+class FailureTest < ActiveSupport::TestCase
+
+  def call_failure(env_params={})
+    env = {'warden.options' => {:scope => :user}.update(env_params)}
+    Devise::Failure.call(env)
+  end
+
+  test 'return 302 status' do
+    assert_equal 302, call_failure.first
+  end
+
+  test 'return redirect location based on mapping with params' do
+    assert_equal '/users/sign_in', call_failure.second['Location']
+  end
+
+  test 'add params to redirect location' do
+    location = call_failure(:params => {:test => true}).second['Location']
+    assert_equal '/users/sign_in?test=true', location
+  end
+
+  test 'set content type to default text/plain' do
+    assert_equal 'text/plain', call_failure.second['Content-Type']
+  end
+
+  test 'setup a default message' do
+    assert_equal ['You are being redirected to /users/sign_in'], call_failure.last
+  end
+
+  test 'pass in a different message' do
+    assert_equal ['Hello world'], call_failure(:message => 'Hello world').last
+  end
+end

data/test/integration/authenticatable_test.rb

@@ -0,0 +1,195 @@
+require 'test/test_helper'
+
+class AuthenticationTest < ActionController::IntegrationTest
+
+  test 'home should be accessible without signed in' do
+    visit '/'
+    assert_response :success
+    assert_template 'home/index'
+  end
+
+  test 'sign in as user should not authenticate admin scope' do
+    sign_in_as_user
+
+    assert warden.authenticated?(:user)
+    assert_not warden.authenticated?(:admin)
+  end
+
+  test 'sign in as admin should not authenticate user scope' do
+    sign_in_as_admin
+
+    assert warden.authenticated?(:admin)
+    assert_not warden.authenticated?(:user)
+  end
+
+  test 'sign in as both user and admin at same time' do
+    sign_in_as_user
+    sign_in_as_admin
+
+    assert warden.authenticated?(:user)
+    assert warden.authenticated?(:admin)
+  end
+
+  test 'sign out as user should not touch admin authentication' do
+    sign_in_as_user
+    sign_in_as_admin
+
+    get destroy_user_session_path
+    assert_not warden.authenticated?(:user)
+    assert warden.authenticated?(:admin)
+  end
+
+  test 'sign out as admin should not touch user authentication' do
+    sign_in_as_user
+    sign_in_as_admin
+
+    get destroy_admin_session_path
+    assert_not warden.authenticated?(:admin)
+    assert warden.authenticated?(:user)
+  end
+
+  test 'not signed in as admin should not be able to access admins actions' do
+    get admins_path
+
+    assert_redirected_to new_admin_session_path(:unauthenticated => true)
+    assert_not warden.authenticated?(:admin)
+  end
+
+  test 'signed in as user should not be able to access admins actions' do
+    sign_in_as_user
+    assert warden.authenticated?(:user)
+    assert_not warden.authenticated?(:admin)
+
+    get admins_path
+    assert_redirected_to new_admin_session_path(:unauthenticated => true)
+  end
+
+  test 'signed in as admin should be able to access admin actions' do
+    sign_in_as_admin
+    assert warden.authenticated?(:admin)
+    assert_not warden.authenticated?(:user)
+
+    get admins_path
+
+    assert_response :success
+    assert_template 'admins/index'
+    assert_contain 'Welcome Admin'
+  end
+
+  test 'admin signing in with invalid email should return to sign in form with error message' do
+    sign_in_as_admin do
+      fill_in 'email', :with => 'wrongemail@test.com'
+    end
+
+    assert_contain 'Invalid email or password'
+    assert_not warden.authenticated?(:admin)
+  end
+
+  test 'admin signing in with invalid pasword should return to sign in form with error message' do
+    sign_in_as_admin do
+      fill_in 'password', :with => 'abcdef'
+    end
+
+    assert_contain 'Invalid email or password'
+    assert_not warden.authenticated?(:admin)
+  end
+
+  test 'error message is configurable by resource name' do
+    begin
+      I18n.backend.store_translations(:en, :devise => { :sessions =>
+        { :admin => { :invalid => "Invalid credentials" } } })
+
+      sign_in_as_admin do
+        fill_in 'password', :with => 'abcdef'
+      end
+
+      assert_contain 'Invalid credentials'
+    ensure
+      I18n.reload!
+    end
+  end
+
+  test 'authenticated admin should not be able to sign as admin again' do
+    sign_in_as_admin
+    get new_admin_session_path
+
+    assert_response :redirect
+    assert_redirected_to admin_root_path
+    assert warden.authenticated?(:admin)
+  end
+
+  test 'authenticated admin should be able to sign out' do
+    sign_in_as_admin
+    assert warden.authenticated?(:admin)
+
+    get destroy_admin_session_path
+    assert_response :redirect
+    assert_redirected_to root_path
+
+    get root_path
+    assert_contain 'Signed out successfully'
+    assert_not warden.authenticated?(:admin)
+  end
+
+  test 'unauthenticated admin does not set message on sign out' do
+    get destroy_admin_session_path
+    assert_response :redirect
+    assert_redirected_to root_path
+
+    get root_path
+    assert_not_contain 'Signed out successfully'
+  end
+
+  test 'redirect from warden shows sign in or sign up message' do
+    get admins_path
+
+    warden_path = new_admin_session_path(:unauthenticated => true)
+    assert_redirected_to warden_path
+
+    get warden_path
+    assert_contain 'You need to sign in or sign up before continuing.'
+  end
+
+  test 'render 404 on roles without permission' do
+    get 'admin_area/password/new'
+    assert_response :not_found
+    assert_not_contain 'Send me reset password instructions'
+  end
+
+  test 'return to default url if no other was requested' do
+    sign_in_as_user
+
+    assert_template 'home/index'
+    assert_nil session[:return_to]
+  end
+
+  test 'return to given url after sign in' do
+    get users_path
+    assert_redirected_to new_user_session_path(:unauthenticated => true)
+    assert_equal users_path, session[:"user.return_to"]
+    follow_redirect!
+
+    sign_in_as_user :visit => false
+    assert_template 'users/index'
+    assert_nil session[:"user.return_to"]
+  end
+
+  test 'return to configured home path after sign in' do
+    sign_in_as_admin
+    assert_equal "/admin_area/home", @request.path
+  end
+
+  test 'allows session to be set by a given scope' do
+    sign_in_as_user
+    visit 'users/index'
+    assert_equal "Cart", @controller.user_session[:cart]
+  end
+  
+  test 'destroyed account is logged out' do
+    sign_in_as_user
+    visit 'users/index'
+    User.destroy_all
+    visit 'users/index'
+    assert_redirected_to '/users/sign_in?unauthenticated=true'
+  end
+end

data/test/integration/confirmable_test.rb

@@ -0,0 +1,89 @@
+require 'test/test_helper'
+
+class ConfirmationTest < ActionController::IntegrationTest
+
+  def visit_user_confirmation_with_token(confirmation_token)
+    visit user_confirmation_path(:confirmation_token => confirmation_token)
+  end
+
+  test 'user should be able to request a new confirmation' do
+    user = create_user(:confirm => false)
+    ActionMailer::Base.deliveries.clear
+
+    visit new_user_session_path
+    click_link 'Didn\'t receive confirmation instructions?'
+
+    fill_in 'email', :with => user.email
+    click_button 'Resend confirmation instructions'
+
+    assert_template 'sessions/new'
+    assert_contain 'You will receive an email with instructions about how to confirm your account in a few minutes'
+    assert_equal 1, ActionMailer::Base.deliveries.size
+  end
+
+  test 'user with invalid confirmation token should not be able to confirm an account' do
+    visit_user_confirmation_with_token('invalid_confirmation')
+
+    assert_response :success
+    assert_template 'confirmations/new'
+    assert_have_selector '#errorExplanation'
+    assert_contain 'Confirmation token is invalid'
+  end
+
+  test 'user with valid confirmation token should be able to confirm an account' do
+    user = create_user(:confirm => false)
+    assert_not user.confirmed?
+
+    visit_user_confirmation_with_token(user.confirmation_token)
+
+    assert_template 'home/index'
+    assert_contain 'Your account was successfully confirmed.'
+
+    assert user.reload.confirmed?
+  end
+
+  test 'user already confirmed user should not be able to confirm the account again' do
+    user = create_user
+    visit_user_confirmation_with_token(user.confirmation_token)
+
+    assert_template 'confirmations/new'
+    assert_have_selector '#errorExplanation'
+    assert_contain 'already confirmed'
+  end
+
+  test 'sign in user automatically after confirming it\'s email' do
+    user = create_user(:confirm => false)
+    visit_user_confirmation_with_token(user.confirmation_token)
+
+    assert warden.authenticated?(:user)
+  end
+
+  test 'not confirmed user and setup to block without confirmation should not be able to sign in' do
+    Devise.confirm_within = 0
+    user = sign_in_as_user(:confirm => false)
+
+    assert_redirected_to new_user_session_path(:unconfirmed => true)
+    assert_not warden.authenticated?(:user)
+  end
+
+  test 'not confirmed user but configured with some days to confirm should be able to sign in' do
+    Devise.confirm_within = 1
+    user = sign_in_as_user(:confirm => false)
+
+    assert_response :success
+    assert warden.authenticated?(:user)
+  end
+
+  test 'error message is configurable by resource name' do
+    begin
+      I18n.backend.store_translations(:en, :devise => { :sessions =>
+        { :admin => { :unconfirmed => "Not confirmed user" } } })
+
+      get new_admin_session_path(:unconfirmed => true)
+
+      assert_contain 'Not confirmed user'
+    ensure
+      I18n.reload!
+    end
+  end
+end