clearance 0.10.3.2 → 0.10.4

data/test/controllers/sessions_controller_test.rb

@@ -1,150 +0,0 @@
-require 'test_helper'
-
-class SessionsControllerTest < ActionController::TestCase
-  tests Clearance::SessionsController
-
-  context "on GET to /sessions/new" do
-    setup { get :new }
-
-    should respond_with(:success)
-    should render_template(:new)
-    should_not set_the_flash
-  end
-
-  context "on POST to #create with good credentials" do
-    setup do
-      @user = Factory(:user)
-      @user.update_attribute(:remember_token, "old-token")
-      post :create, :session => {
-                      :email    => @user.email,
-                      :password => @user.password }
-    end
-
-    should set_the_flash.to(/signed in/i)
-    should_redirect_to_url_after_create
-
-    should_set_cookie("remember_token", "old-token", Clearance.configuration.cookie_expiration.call)
-
-    should "have a default of 1 year from now" do
-      assert_in_delta Clearance.configuration.cookie_expiration.call, 1.year.from_now, 100
-    end
-
-    should "not change the remember token" do
-      assert_equal "old-token", @user.reload.remember_token
-    end
-  end
-
-  context "on POST to #create with good credentials - cookie duration set to 2 weeks" do
-    custom_duration = 2.weeks.from_now.utc
-
-    setup do
-      Clearance.configuration.cookie_expiration = lambda { custom_duration }
-      @user = Factory(:user)
-      @user.update_attribute(:remember_token, "old-token2")
-      post :create, :session => {
-                      :email    => @user.email,
-                      :password => @user.password }
-    end
-
-    should_set_cookie("remember_token", "old-token2", custom_duration)
-
-    teardown do
-      # restore default Clearance configuration
-      Clearance.configuration = nil
-      Clearance.configure {}
-    end
-  end
-
-  context "on POST to #create with good credentials - cookie expiration set to nil (session cookie)" do
-    setup do
-      Clearance.configuration.cookie_expiration = lambda { nil }
-      @user = Factory(:user)
-      @user.update_attribute(:remember_token, "old-token3")
-      post :create, :session => {
-                      :email    => @user.email,
-                      :password => @user.password }
-    end
-
-    should_set_cookie("remember_token", "old-token3", nil)
-
-    teardown do
-      # restore default Clearance configuration
-      Clearance.configuration = nil
-      Clearance.configure {}
-    end
-  end
-
-  context "on POST to #create with good credentials and a session return url" do
-    setup do
-      @user = Factory(:user)
-      @return_url = '/url_in_the_session'
-      @request.session[:return_to] = @return_url
-      post :create, :session => {
-                      :email    => @user.email,
-                      :password => @user.password }
-    end
-
-    should redirect_to("the return URL") { @return_url }
-  end
-
-  context "on POST to #create with good credentials and a request return url" do
-    setup do
-      @user = Factory(:user)
-      @return_url = '/url_in_the_request'
-      post :create, :session => {
-                      :email     => @user.email,
-                      :password  => @user.password },
-                      :return_to => @return_url
-    end
-
-    should redirect_to("the return URL") { @return_url }
-  end
-
-  context "on POST to #create with good credentials and a session return url and request return url" do
-    setup do
-      @user = Factory(:user)
-      @return_url = '/url_in_the_session'
-      @request.session[:return_to] = @return_url
-      post :create, :session => {
-                      :email     => @user.email,
-                      :password  => @user.password },
-                      :return_to => '/url_in_the_request'
-    end
-
-    should redirect_to("the return URL") { @return_url }
-  end
-
-  context "on DELETE to #destroy given a signed out user" do
-    setup do
-      sign_out
-      delete :destroy
-    end
-    should set_the_flash.to(/signed out/i)
-    should_redirect_to_url_after_destroy
-  end
-
-  context "on DELETE to #destroy with a cookie" do
-    setup do
-      @user = Factory(:user)
-      @user.update_attribute(:remember_token, "old-token")
-      @request.cookies["remember_token"] = "old-token"
-      delete :destroy
-    end
-
-    should set_the_flash.to(/signed out/i)
-    should_redirect_to_url_after_destroy
-
-    should "delete the cookie token" do
-      assert_nil cookies['remember_token']
-    end
-
-    should "reset the remember token" do
-      assert_not_equal "old-token", @user.reload.remember_token
-    end
-
-    should "unset the current user" do
-      assert_nil @controller.current_user
-    end
-  end
-
-end

data/test/controllers/users_controller_test.rb

@@ -1,64 +0,0 @@
-require 'test_helper'
-
-class UsersControllerTest < ActionController::TestCase
-
-  tests Clearance::UsersController
-
-  context "when signed out" do
-    setup { sign_out }
-
-    context "on GET to #new" do
-      setup { get :new }
-
-      should respond_with(:success)
-      should render_template(:new)
-      should_not set_the_flash
-    end
-
-    context "on GET to #new with email" do
-      setup do
-        @email = "a@example.com"
-        get :new, :user => { :email => @email }
-      end
-
-      should "set assigned user's email" do
-        assert_equal @email, assigns(:user).email
-      end
-    end
-
-    context "on POST to #create with valid attributes" do
-      setup do
-        user_attributes = Factory.attributes_for(:user)
-        @old_user_count = User.count
-        post :create, :user => user_attributes
-      end
-
-      should assign_to(:user)
-
-      should "create a new user" do
-        assert_equal @old_user_count + 1, User.count
-      end
-
-      should set_the_flash.to(/signed up/i)
-      should_redirect_to_url_after_create
-    end
-  end
-
-  context "A signed-in user" do
-    setup do
-      @user = Factory(:user)
-      sign_in_as @user
-    end
-
-    context "GET to new" do
-      setup { get :new }
-      should redirect_to("the home page") { root_url }
-    end
-
-    context "POST to create" do
-      setup { post :create, :user => {} }
-      should redirect_to("the home page") { root_url }
-    end
-  end
-
-end

data/test/models/clearance_mailer_test.rb

@@ -1,29 +0,0 @@
-require 'test_helper'
-
-class ClearanceMailerTest < ActiveSupport::TestCase
-  context "A change password email" do
-    setup do
-      @user  = Factory(:user)
-      @user.forgot_password!
-      @email = ClearanceMailer.change_password @user
-    end
-
-    should "be from DO_NOT_REPLY" do
-      assert_match /#{@email.from[0]}/i, Clearance.configuration.mailer_sender
-    end
-
-    should "be sent to user" do
-      assert_match /#{@user.email}/i, @email.to.first
-    end
-
-    should "contain a link to edit the user's password" do
-      host = ActionMailer::Base.default_url_options[:host]
-      regexp = %r{http://#{host}/users/#{@user.id}/password/edit\?token=#{@user.confirmation_token}}
-      assert_match regexp, @email.body.to_s
-    end
-
-    should "set its subject" do
-      assert_match /Change your password/, @email.subject
-    end
-  end
-end

data/test/models/user_test.rb

@@ -1,244 +0,0 @@
-require 'test_helper'
-
-class UserTest < ActiveSupport::TestCase
-
-  # db
-
-  should have_db_index(:email)
-  should have_db_index(:remember_token)
-
-  # signing up
-
-  context "When signing up" do
-    should validate_presence_of(:email)
-    should validate_presence_of(:password)
-    should allow_value("foo@example.co.uk").for(:email)
-    should allow_value("foo@example.com").for(:email)
-    should_not allow_value("foo@").for(:email)
-    should_not allow_value("foo@example..com").for(:email)
-    should_not allow_value("foo@.example.com").for(:email)
-    should_not allow_value("foo").for(:email)
-    should_not allow_value("example.com").for(:email)
-
-    should "require password confirmation on create" do
-      user = Factory.build(:user, :password              => 'blah',
-                                  :password_confirmation => 'boogidy')
-      assert ! user.save
-      assert user.errors[:password].any?
-    end
-
-    should "require non blank password confirmation on create" do
-      user = Factory.build(:user, :password              => 'blah',
-                                  :password_confirmation => '')
-      assert ! user.save
-      assert user.errors[:password].any?
-    end
-
-    should "initialize salt" do
-      assert_not_nil Factory(:user).salt
-    end
-
-    context "encrypt password" do
-      setup do
-        @salt = "salt"
-        @user = Factory.build(:user, :salt => @salt)
-        def @user.initialize_salt; end
-        @user.save!
-        @password = @user.password
-
-        @user.send(:encrypt, @password)
-        @expected = Digest::SHA1.hexdigest("--#{@salt}--#{@password}--")
-      end
-
-      should "create an encrypted password using SHA1 encryption" do
-        assert_equal @expected, @user.encrypted_password
-      end
-    end
-
-    should "store email in exact case" do
-      user = Factory(:user, :email => "John.Doe@example.com")
-      assert_equal "John.Doe@example.com", user.email
-    end
-  end
-
-  context "When multiple users have signed up" do
-    setup { Factory(:user) }
-    should validate_uniqueness_of(:email)
-  end
-
-  # authenticating
-
-  context "A user" do
-    setup do
-      @user     = Factory(:user)
-      @password = @user.password
-    end
-
-    should "authenticate with good credentials" do
-      assert ::User.authenticate(@user.email, @password)
-      assert @user.authenticated?(@password)
-    end
-
-    should "not authenticate with bad credentials" do
-      assert ! ::User.authenticate(@user.email, 'bad_password')
-      assert ! @user.authenticated?('bad_password')
-    end
-  end
-
-  # resetting remember token
-
-  context "When resetting authentication with reset_remember_token!" do
-    setup do
-      @user  = Factory(:user)
-      @user.remember_token = "old-token"
-      @user.reset_remember_token!
-    end
-
-    should "change the remember token" do
-      assert_not_equal "old-token", @user.remember_token
-    end
-  end
-
-  # updating password
-
-  context "An email confirmed user" do
-    setup do
-      @user = Factory(:user)
-      @old_encrypted_password = @user.encrypted_password
-    end
-
-    context "who updates password with confirmation" do
-      setup do
-        @user.update_password("new_password", "new_password")
-      end
-
-      should "change encrypted password" do
-        assert_not_equal @user.encrypted_password,
-                         @old_encrypted_password
-      end
-    end
-  end
-
-  should "not generate the same remember token for users with the same password at the same time" do
-    Time.stubs(:now => Time.now)
-    password    = 'secret'
-    first_user  = Factory(:user,
-                          :password              => password,
-                          :password_confirmation => password)
-    second_user = Factory(:user,
-                          :password              => password,
-                          :password_confirmation => password)
-
-    assert_not_equal first_user.remember_token, second_user.remember_token
-  end
-
-  # recovering forgotten password
-
-  context "An user" do
-    setup do
-      @user = Factory(:user)
-      @old_encrypted_password = @user.encrypted_password
-    end
-
-    context "who requests password reminder" do
-      setup do
-        assert_nil @user.confirmation_token
-        @user.forgot_password!
-      end
-
-      should "generate confirmation token" do
-        assert_not_nil @user.confirmation_token
-      end
-
-      context "and then updates password" do
-        context 'with confirmation' do
-          setup do
-            @user.update_password("new_password", "new_password")
-          end
-
-          should "change encrypted password" do
-            assert_not_equal @user.encrypted_password,
-                             @old_encrypted_password
-          end
-
-          should "clear confirmation token" do
-            assert_nil @user.confirmation_token
-          end
-        end
-
-        context 'without confirmation' do
-          setup do
-            @user.update_password("new_password", "")
-          end
-
-          should "not change encrypted password" do
-            assert_equal @user.encrypted_password,
-                         @old_encrypted_password
-          end
-
-          should "not clear confirmation token" do
-            assert_not_nil @user.confirmation_token
-          end
-        end
-      end
-    end
-
-  end
-
-  # optional email/password fields
-  context "a user with an optional email" do
-    setup do
-      @user = User.new
-      class << @user
-        def email_optional?
-          true
-        end
-      end
-    end
-
-    subject { @user }
-
-    should allow_value(nil).for(:email)
-    should allow_value("").for(:email)
-  end
-
-  context "a user with an optional password" do
-    setup do
-      @user = User.new
-      class << @user
-        def password_optional?
-          true
-        end
-      end
-    end
-
-    subject { @user }
-
-    should allow_value(nil).for(:password)
-    should allow_value("").for(:password)
-  end
-
-  context "user factory" do
-    should "create a valid user with just an overridden password" do
-      assert Factory.build(:user, :password => "test").valid?
-    end
-  end
-
-  context "when user exists before Clearance was installed" do
-    setup do
-      @user = Factory(:user)
-      sql  = "update users set salt = NULL, encrypted_password = NULL, remember_token = NULL where id = #{@user.id}"
-      ActiveRecord::Base.connection.update(sql)
-      assert_nil @user.reload.salt
-      assert_nil @user.reload.encrypted_password
-      assert_nil @user.reload.remember_token
-    end
-
-    should "initialize salt, generate remember token, and save encrypted password on update_password" do
-      @user.update_password('password', 'password')
-      assert_not_nil @user.salt
-      assert_not_nil @user.encrypted_password
-      assert_not_nil @user.remember_token
-    end
-  end
-end