devise-warbler 2.2.3

data/test/controllers/url_helpers_test.rb

@@ -0,0 +1,59 @@
+require 'test_helper'
+
+class RoutesTest < ActionController::TestCase
+  tests ApplicationController
+
+  def assert_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 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
+    assert_path_and_url :session
+    assert_path_and_url :session, :new
+    assert_path_and_url :session, :destroy
+  end
+
+  test 'should alias password to mapped user password' do
+    assert_path_and_url :password
+    assert_path_and_url :password, :new
+    assert_path_and_url :password, :edit
+  end
+
+  test 'should alias confirmation to mapped user confirmation' do
+    assert_path_and_url :confirmation
+    assert_path_and_url :confirmation, :new
+  end
+
+  test 'should alias unlock to mapped user unlock' do
+    assert_path_and_url :unlock
+    assert_path_and_url :unlock, :new
+  end
+
+  test 'should alias registration to mapped user registration' do
+    assert_path_and_url :registration
+    assert_path_and_url :registration, :new
+    assert_path_and_url :registration, :edit
+    assert_path_and_url :registration, :cancel
+  end
+end

data/test/delegator_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+class DelegatorTest < ActiveSupport::TestCase
+  def delegator
+    Devise::Delegator.new
+  end
+
+  test 'failure_app returns default failure app if no warden options in env' do
+    assert_equal Devise::FailureApp, delegator.failure_app({})
+  end
+
+  test 'failure_app returns default failure app if no scope in warden options' do
+    assert_equal Devise::FailureApp, delegator.failure_app({"warden.options" => {}})
+  end
+
+  test 'failure_app returns associated failure app by scope in the given environment' do
+    assert_kind_of Proc, delegator.failure_app({"warden.options" => {:scope => "manager"}})
+  end
+end

data/test/devise_test.rb

@@ -0,0 +1,83 @@
+require 'test_helper'
+
+module Devise
+  def self.yield_and_restore
+    @@warden_configured = nil
+    c, b = @@warden_config, @@warden_config_block
+    yield
+  ensure
+    @@warden_config, @@warden_config_block = c, b
+  end
+end
+
+class DeviseTest < ActiveSupport::TestCase
+  test 'model options can be configured through Devise' do
+    swap Devise, :allow_unconfirmed_access_for => 113, :pepper => "foo" do
+      assert_equal 113, Devise.allow_unconfirmed_access_for
+      assert_equal "foo", Devise.pepper
+    end
+  end
+
+  test 'setup block yields self' do
+    Devise.setup do |config|
+      assert_equal Devise, config
+    end
+  end
+
+  test 'stores warden configuration' do
+    assert_kind_of Devise::Delegator, Devise.warden_config.failure_app
+    assert_equal :user, Devise.warden_config.default_scope
+  end
+
+  test 'warden manager user configuration through a block' do
+    Devise.yield_and_restore do
+      @executed = false
+      Devise.warden do |config|
+        @executed = true
+        assert_kind_of Warden::Config, config
+      end
+
+      Devise.configure_warden!
+      assert @executed
+    end
+  end
+
+  test 'add new module using the helper method' do
+    assert_nothing_raised(Exception) { Devise.add_module(:coconut) }
+    assert_equal 1, Devise::ALL.select { |v| v == :coconut }.size
+    assert_not Devise::STRATEGIES.include?(:coconut)
+    assert_not defined?(Devise::Models::Coconut)
+    Devise::ALL.delete(:coconut)
+
+    assert_nothing_raised(Exception) { Devise.add_module(:banana, :strategy => :fruits) }
+    assert_equal :fruits, Devise::STRATEGIES[:banana]
+    Devise::ALL.delete(:banana)
+    Devise::STRATEGIES.delete(:banana)
+
+    assert_nothing_raised(Exception) { Devise.add_module(:kivi, :controller => :fruits) }
+    assert_equal :fruits, Devise::CONTROLLERS[:kivi]
+    Devise::ALL.delete(:kivi)
+    Devise::CONTROLLERS.delete(:kivi)
+  end
+  
+  test 'should complain when comparing empty or different sized passes' do
+    [nil, ""].each do |empty|
+      assert_not Devise.secure_compare(empty, "something")
+      assert_not Devise.secure_compare("something", empty)
+      assert_not Devise.secure_compare(empty, empty)
+    end
+    assert_not Devise.secure_compare("size_1", "size_four")
+  end
+
+  test 'Devise.email_regexp should match valid email addresses' do
+    valid_emails = ["test@example.com", "jo@jo.co", "f4$_m@you.com", "testing.example@example.com.ua"]
+    non_valid_emails = ["rex", "test@go,com", "test user@example.com", "test_user@example server.com"]
+
+    valid_emails.each do |email|
+      assert_match Devise.email_regexp, email
+    end
+    non_valid_emails.each do |email|
+      assert_no_match Devise.email_regexp, email
+    end
+  end
+end

data/test/failure_app_test.rb

@@ -0,0 +1,221 @@
+require 'test_helper'
+require 'ostruct'
+
+class FailureTest < ActiveSupport::TestCase
+  class RootFailureApp < Devise::FailureApp
+    def fake_app
+      Object.new
+    end
+  end
+
+  def self.context(name, &block)
+    instance_eval(&block)
+  end
+
+  def call_failure(env_params={})
+    env = {
+      'REQUEST_URI' => 'http://test.host/',
+      'HTTP_HOST' => 'test.host',
+      'REQUEST_METHOD' => 'GET',
+      'warden.options' => { :scope => :user },
+      'rack.session' => {},
+      'action_dispatch.request.formats' => Array(env_params.delete('formats') || Mime::HTML),
+      'rack.input' => "",
+      'warden' => OpenStruct.new(:message => nil)
+    }.merge!(env_params)
+
+    @response = (env.delete(:app) || Devise::FailureApp).call(env).to_a
+    @request  = ActionDispatch::Request.new(env)
+  end
+
+  context 'When redirecting' do
+    test 'returns to the default redirect location' do
+      call_failure
+      assert_equal 302, @response.first
+      assert_equal 'You need to sign in or sign up before continuing.', @request.flash[:alert]
+      assert_equal 'http://test.host/users/sign_in', @response.second['Location']
+    end
+
+    test 'returns to the default redirect location for wildcard requests' do
+      call_failure 'action_dispatch.request.formats' => nil, 'HTTP_ACCEPT' => '*/*'
+      assert_equal 302, @response.first
+      assert_equal 'http://test.host/users/sign_in', @response.second['Location']
+    end
+
+    test 'returns to the root path if no session path is available' do
+      swap Devise, :router_name => :fake_app do
+        call_failure :app => RootFailureApp
+        assert_equal 302, @response.first
+        assert_equal 'You need to sign in or sign up before continuing.', @request.flash[:alert]
+        assert_equal 'http://test.host/', @response.second['Location']
+      end
+    end
+
+    if Rails.application.config.respond_to?(:relative_url_root)
+      test 'returns to the default redirect location considering the relative url root' do
+        swap Rails.application.config, :relative_url_root => "/sample" do
+          call_failure
+          assert_equal 302, @response.first
+          assert_equal 'http://test.host/sample/users/sign_in', @response.second['Location']
+        end
+      end
+    end
+
+    test 'uses the proxy failure message as symbol' do
+      call_failure('warden' => OpenStruct.new(:message => :invalid))
+      assert_equal 'Invalid email or password.', @request.flash[:alert]
+      assert_equal 'http://test.host/users/sign_in', @response.second["Location"]
+    end
+
+    test 'uses the proxy failure message as string' do
+      call_failure('warden' => OpenStruct.new(:message => 'Hello world'))
+      assert_equal 'Hello world', @request.flash[:alert]
+      assert_equal 'http://test.host/users/sign_in', @response.second["Location"]
+    end
+
+    test 'set content type to default text/html' do
+      call_failure
+      assert_equal 'text/html; charset=utf-8', @response.second['Content-Type']
+    end
+
+    test 'setup a default message' do
+      call_failure
+      assert_match /You are being/, @response.last.body
+      assert_match /redirected/, @response.last.body
+      assert_match /users\/sign_in/, @response.last.body
+    end
+
+    test 'works for any navigational format' do
+      swap Devise, :navigational_formats => [:xml] do
+        call_failure('formats' => Mime::XML)
+        assert_equal 302, @response.first
+      end
+    end
+
+    test 'redirects the correct format if it is a non-html format request' do
+      swap Devise, :navigational_formats => [:js] do
+        call_failure('formats' => Mime::JS)
+        assert_equal 'http://test.host/users/sign_in.js', @response.second["Location"]
+      end
+    end
+  end
+
+  context 'For HTTP request' do
+    test 'return 401 status' do
+      call_failure('formats' => Mime::XML)
+      assert_equal 401, @response.first
+    end
+
+    test 'return appropriate body for xml' do
+      call_failure('formats' => Mime::XML)
+      result = %(<?xml version="1.0" encoding="UTF-8"?>\n<errors>\n  <error>You need to sign in or sign up before continuing.</error>\n</errors>\n)
+      assert_equal result, @response.last.body
+    end
+
+    test 'return appropriate body for json' do
+      call_failure('formats' => Mime::JSON)
+      result = %({"error":"You need to sign in or sign up before continuing."})
+      assert_equal result, @response.last.body
+    end
+
+    test 'return 401 status for unknown formats' do
+      call_failure 'formats' => []
+      assert_equal 401, @response.first
+    end
+
+    test 'return WWW-authenticate headers if model allows' do
+      call_failure('formats' => Mime::XML)
+      assert_equal 'Basic realm="Application"', @response.second["WWW-Authenticate"]
+    end
+
+    test 'does not return WWW-authenticate headers if model does not allow' do
+      swap Devise, :http_authenticatable => false do
+        call_failure('formats' => Mime::XML)
+        assert_nil @response.second["WWW-Authenticate"]
+      end
+    end
+
+    test 'works for any non navigational format' do
+      swap Devise, :navigational_formats => [] do
+        call_failure('formats' => Mime::HTML)
+        assert_equal 401, @response.first
+      end
+    end
+
+    test 'uses the failure message as response body' do
+      call_failure('formats' => Mime::XML, 'warden' => OpenStruct.new(:message => :invalid))
+      assert_match '<error>Invalid email or password.</error>', @response.third.body
+    end
+
+    context 'on ajax call' do
+      context 'when http_authenticatable_on_xhr is false' do
+        test 'dont return 401 with navigational formats' do
+          swap Devise, :http_authenticatable_on_xhr => false do
+            call_failure('formats' => Mime::HTML, 'HTTP_X_REQUESTED_WITH' => 'XMLHttpRequest')
+            assert_equal 302, @response.first
+            assert_equal 'http://test.host/users/sign_in', @response.second["Location"]
+          end
+        end
+
+        test 'dont return 401 with non navigational formats' do
+          swap Devise, :http_authenticatable_on_xhr => false do
+            call_failure('formats' => Mime::JSON, 'HTTP_X_REQUESTED_WITH' => 'XMLHttpRequest')
+            assert_equal 302, @response.first
+            assert_equal 'http://test.host/users/sign_in.json', @response.second["Location"]
+          end
+        end
+      end
+
+      context 'when http_authenticatable_on_xhr is true' do
+        test 'return 401' do
+          swap Devise, :http_authenticatable_on_xhr => true do
+            call_failure('formats' => Mime::HTML, 'HTTP_X_REQUESTED_WITH' => 'XMLHttpRequest')
+            assert_equal 401, @response.first
+          end
+        end
+
+        test 'skip WWW-Authenticate header' do
+          swap Devise, :http_authenticatable_on_xhr => true do
+            call_failure('formats' => Mime::HTML, 'HTTP_X_REQUESTED_WITH' => 'XMLHttpRequest')
+            assert_nil @response.second['WWW-Authenticate']
+          end
+        end
+      end
+    end
+  end
+
+  context 'With recall' do
+    test 'calls the original controller if invalid email or password' do
+      env = {
+        "warden.options" => { :recall => "devise/sessions#new", :attempted_path => "/users/sign_in" },
+        "devise.mapping" => Devise.mappings[:user],
+        "warden" => stub_everything
+      }
+      call_failure(env)
+      assert @response.third.body.include?('<h2>Sign in</h2>')
+      assert @response.third.body.include?('Invalid email or password.')
+    end
+
+    test 'calls the original controller if not confirmed email' do
+      env = {
+        "warden.options" => { :recall => "devise/sessions#new", :attempted_path => "/users/sign_in", :message => :unconfirmed },
+        "devise.mapping" => Devise.mappings[:user],
+        "warden" => stub_everything
+      }
+      call_failure(env)
+      assert @response.third.body.include?('<h2>Sign in</h2>')
+      assert @response.third.body.include?('You have to confirm your account before continuing.')
+    end
+
+    test 'calls the original controller if inactive account' do
+      env = {
+        "warden.options" => { :recall => "devise/sessions#new", :attempted_path => "/users/sign_in", :message => :inactive },
+        "devise.mapping" => Devise.mappings[:user],
+        "warden" => stub_everything
+      }
+      call_failure(env)
+      assert @response.third.body.include?('<h2>Sign in</h2>')
+      assert @response.third.body.include?('Your account was not activated yet.')
+    end
+  end
+end

data/test/generators/active_record_generator_test.rb

@@ -0,0 +1,75 @@
+require "test_helper"
+
+if DEVISE_ORM == :active_record
+  require "generators/active_record/devise_generator"
+
+  class ActiveRecordGeneratorTest < Rails::Generators::TestCase
+    tests ActiveRecord::Generators::DeviseGenerator
+    destination File.expand_path("../../tmp", __FILE__)
+    setup :prepare_destination
+
+    test "all files are properly created with rails31 migration syntax" do
+      run_generator %w(monster)
+      assert_file "app/models/monster.rb", /devise/, /attr_accessible (:[a-z_]+(, )?)+/
+      assert_migration "db/migrate/devise_create_monsters.rb", /def change/
+    end
+
+    test "all files for namespaced model are properly created" do
+      run_generator %w(admin/monster)
+      assert_file "app/models/admin/monster.rb", /devise/, /attr_accessible (:[a-z_]+(, )?)+/
+      assert_migration "db/migrate/devise_create_admin_monsters.rb", /def change/
+    end
+
+    test "update model migration when model exists" do
+      run_generator %w(monster)
+      assert_file "app/models/monster.rb"
+      run_generator %w(monster)
+      assert_migration "db/migrate/add_devise_to_monsters.rb"
+    end
+
+    test "all files are properly deleted" do
+      run_generator %w(monster)
+      run_generator %w(monster)
+      assert_migration "db/migrate/devise_create_monsters.rb"
+      assert_migration "db/migrate/add_devise_to_monsters.rb"
+      run_generator %w(monster), :behavior => :revoke
+      assert_no_migration "db/migrate/add_devise_to_monsters.rb"
+      assert_migration "db/migrate/devise_create_monsters.rb"
+      run_generator %w(monster), :behavior => :revoke
+      assert_no_file "app/models/monster.rb"
+      assert_no_migration "db/migrate/devise_create_monsters.rb"
+    end
+  end
+
+  module RailsEngine
+    class Engine < Rails::Engine
+      isolate_namespace RailsEngine
+    end
+  end
+
+  def simulate_inside_engine(engine, namespace)
+    if Rails::Generators.respond_to?(:namespace=)
+      swap Rails::Generators, :namespace => namespace do
+        yield
+      end
+    else
+      swap Rails, :application => engine.instance do
+        yield
+      end
+    end
+  end
+
+  class ActiveRecordEngineGeneratorTest < Rails::Generators::TestCase
+    tests ActiveRecord::Generators::DeviseGenerator
+    destination File.expand_path("../../tmp", __FILE__)
+    setup :prepare_destination
+
+    test "all files are properly created" do
+      simulate_inside_engine(RailsEngine::Engine, RailsEngine) do
+        run_generator ["monster"]
+
+        assert_file "app/models/rails_engine/monster.rb", /devise/,/attr_accessible (:[a-z_]+(, )?)+/
+      end
+    end
+  end
+end