clearance 1.4.3 → 1.5.0

data/spec/controllers/permissions_controller_spec.rb

@@ -32,13 +32,13 @@ describe PermissionsController do
     it 'allows access to new' do
       get :new
 
-      subject.should_not deny_access
+      expect(subject).not_to deny_access
     end
 
     it 'allows access to show' do
       get :show
 
-      subject.should_not deny_access
+      expect(subject).not_to deny_access
     end
   end
 
@@ -46,13 +46,13 @@ describe PermissionsController do
     it 'allows access to new' do
       get :new
 
-      subject.should_not deny_access
+      expect(subject).not_to deny_access
     end
 
     it 'denies access to show' do
       get :show
 
-      subject.should deny_access(redirect: sign_in_url)
+      expect(subject).to deny_access(redirect: sign_in_url)
     end
   end
 
@@ -64,7 +64,7 @@ describe PermissionsController do
 
       get :show
 
-      subject.should deny_access
+      expect(subject).to deny_access
     end
   end
 end

data/spec/controllers/sessions_controller_spec.rb

@@ -34,11 +34,11 @@ describe Clearance::SessionsController do
     it { should redirect_to_url_after_create }
 
     it 'sets the user in the clearance session' do
-      controller.current_user.should == @user
+      expect(controller.current_user).to eq @user
     end
 
     it 'should not change the remember token' do
-      @user.reload.remember_token.should == 'old-token'
+      expect(@user.reload.remember_token).to eq 'old-token'
     end
   end
 
@@ -75,11 +75,11 @@ describe Clearance::SessionsController do
     it { should redirect_to_url_after_destroy }
 
     it 'should reset the remember token' do
-      @user.reload.remember_token.should_not == 'old-token'
+      expect(@user.reload.remember_token).not_to eq 'old-token'
     end
 
     it 'should unset the current user' do
-      @controller.current_user.should be_nil
+      expect(@controller.current_user).to be_nil
     end
   end
 end

data/spec/controllers/users_controller_spec.rb

@@ -9,9 +9,9 @@ describe Clearance::UsersController do
     describe 'on GET to #new' do
       before { get :new }
 
-      it { should respond_with(:success) }
-      it { should render_template(:new) }
-      it { should_not set_the_flash }
+      it { is_expected.to respond_with(:success) }
+      it { is_expected.to render_template(:new) }
+      it { is_expected.not_to set_the_flash }
     end
 
     describe 'on GET to #new with email' do
@@ -21,7 +21,7 @@ describe Clearance::UsersController do
       end
 
       it 'should set assigned user email' do
-        assigns(:user).email.should == @email
+        expect(assigns(:user).email).to eq @email
       end
     end
 
@@ -33,11 +33,11 @@ describe Clearance::UsersController do
       end
 
       it 'assigns a user' do
-        assigns(:user).should be
+        expect(assigns(:user)).to be_present
       end
 
       it 'should create a new user' do
-        User.count.should == @old_user_count + 1
+        expect(User.count).to eq @old_user_count + 1
       end
 
       it { should redirect_to_url_after_create }
@@ -53,11 +53,11 @@ describe Clearance::UsersController do
       end
 
       it 'assigns a user' do
-        assigns(:user).should be
+        expect(assigns(:user)).to be_present
       end
 
       it 'should create a new user' do
-        User.count.should == @old_user_count + 1
+        expect(User.count).to eq @old_user_count + 1
       end
 
       it { should redirect_to(@return_url) }

data/spec/mailers/clearance_mailer_spec.rb

@@ -8,28 +8,28 @@ describe ClearanceMailer do
   end
 
   it 'is from DO_NOT_REPLY' do
-    Clearance.configuration.mailer_sender.should =~ /#{@email.from[0]}/i
+    expect(Clearance.configuration.mailer_sender).to match(/#{@email.from[0]}/i)
   end
 
   it 'is sent to user' do
-    @email.to.first.should =~ /#{@user.email}/i
+    expect(@email.to.first).to match(/#{@user.email}/i)
   end
 
   it 'contains a link to edit the password' do
     host = ActionMailer::Base.default_url_options[:host]
     regexp = %r{http://#{host}/users/#{@user.id}/password/edit\?token=#{@user.confirmation_token}}
-    @email.body.to_s.should =~ regexp
+    expect(@email.body.to_s).to match(regexp)
   end
 
   it 'sets its subject' do
-    @email.subject.should =~ /Change your password/
+    expect(@email.subject).to match(/Change your password/)
   end
 
   it 'contains opening text in the body' do
-    @email.body.should =~ /a link to change your password/
+    expect(@email.body).to match(/a link to change your password/)
   end
 
   it 'contains closing text in the body' do
-    @email.body.should =~ /Your password has not been changed/
+    expect(@email.body).to match(/Your password has not been changed/)
   end
 end

data/spec/models/bcrypt_migration_from_sha1_spec.rb

@@ -14,21 +14,23 @@ describe Clearance::PasswordStrategies::BCryptMigrationFromSHA1 do
 
     before do
       subject.salt = salt
-      subject.encrypted_password = Digest::SHA1.hexdigest("--#{salt}--#{password}--")
+      digestable = "--#{salt}--#{password}--"
+      subject.encrypted_password = Digest::SHA1.hexdigest(digestable)
       BCrypt::Password.stubs create: encrypted_password
       subject.password = password
     end
 
     it 'encrypts the password into a BCrypt-encrypted encrypted_password' do
-      subject.encrypted_password.should == encrypted_password
+      expect(subject.encrypted_password).to eq encrypted_password
     end
 
     it 'encrypts with BCrypt' do
-      BCrypt::Password.should have_received(:create).with(password, anything)
+      have_received_password = have_received(:create).with(password, anything)
+      expect(BCrypt::Password).to have_received_password
     end
 
     it 'sets the pasword on the subject' do
-      subject.password.should be_present
+      expect(subject.password).to be_present
     end
   end
 
@@ -45,23 +47,21 @@ describe Clearance::PasswordStrategies::BCryptMigrationFromSHA1 do
       end
 
       it 'is authenticated' do
-        subject.should be_authenticated(password)
+        expect(subject).to be_authenticated(password)
       end
 
       it 'changes the hash into a BCrypt-encrypted one' do
         subject.authenticated? password
-        subject.encrypted_password.should_not == sha1_hash
+        expect(subject.encrypted_password).not_to eq sha1_hash
       end
 
       it 'does not raise a BCrypt error for invalid passwords' do
-        expect {
-          subject.authenticated? 'bad' + password
-        }.not_to raise_error
+        expect { subject.authenticated? 'bad' + password }.not_to raise_error
       end
 
       it 'saves the subject to database' do
         subject.authenticated? password
-        subject.should have_received(:save)
+        expect(subject).to have_received(:save)
       end
     end
 
@@ -73,12 +73,12 @@ describe Clearance::PasswordStrategies::BCryptMigrationFromSHA1 do
       end
 
       it 'is authenticated' do
-        subject.should be_authenticated(password)
+        expect(subject).to be_authenticated(password)
       end
 
       it 'does not change the hash' do
         subject.authenticated? password
-        subject.encrypted_password.to_s.should == bcrypt_hash.to_s
+        expect(subject.encrypted_password.to_s).to eq bcrypt_hash.to_s
       end
     end
   end

data/spec/models/bcrypt_spec.rb

@@ -16,7 +16,7 @@ describe Clearance::PasswordStrategies::BCrypt do
     it 'encrypts the password into encrypted_password' do
       subject.password = password
 
-      subject.encrypted_password.should == encrypted_password
+      expect(subject.encrypted_password).to eq encrypted_password
     end
 
     it 'encrypts with BCrypt using default cost in non test environments' do
@@ -24,7 +24,7 @@ describe Clearance::PasswordStrategies::BCrypt do
 
       subject.password = password
 
-      BCrypt::Password.should have_received(:create).with(
+      expect(BCrypt::Password).to have_received(:create).with(
         password,
         cost: ::BCrypt::Engine::DEFAULT_COST
       )
@@ -33,7 +33,7 @@ describe Clearance::PasswordStrategies::BCrypt do
     it 'encrypts with BCrypt using minimum cost in test environment' do
       subject.password = password
 
-      BCrypt::Password.should have_received(:create).with(
+      expect(BCrypt::Password).to have_received(:create).with(
         password,
         cost: ::BCrypt::Engine::MIN_COST
       )
@@ -50,7 +50,7 @@ describe Clearance::PasswordStrategies::BCrypt do
       let(:password) { 'password' }
 
       it 'is authenticated with BCrypt' do
-        subject.should be_authenticated(password)
+        expect(subject).to be_authenticated(password)
       end
     end
 
@@ -58,7 +58,7 @@ describe Clearance::PasswordStrategies::BCrypt do
       let(:password) { nil }
 
       it 'is not authenticated' do
-        subject.should_not be_authenticated(password)
+        expect(subject).not_to be_authenticated(password)
       end
     end
   end

data/spec/models/blowfish_spec.rb

@@ -16,14 +16,14 @@ describe Clearance::PasswordStrategies::Blowfish do
       end
 
       it 'does not initialize the salt' do
-        subject.salt.should == salt
+        expect(subject.salt).to eq salt
       end
 
       it 'encrypts the password using Blowfish and the existing salt' do
         cipher = OpenSSL::Cipher::Cipher.new('bf-cbc').encrypt
         cipher.key = Digest::SHA256.digest(salt)
         expected = cipher.update("--#{salt}--#{password}--") << cipher.final
-        subject.encrypted_password.should == expected
+        expect(subject.encrypted_password).to eq expected
       end
     end
 
@@ -34,7 +34,7 @@ describe Clearance::PasswordStrategies::Blowfish do
       end
 
       it 'should initialize the salt' do
-        subject.salt.should_not be_nil
+        expect(subject.salt).not_to be_nil
       end
     end
   end

data/spec/models/password_strategies_spec.rb

@@ -25,7 +25,7 @@ describe Clearance::User do
     before { Clearance.configuration.password_strategy = mock_password_strategy }
 
     it 'includes the value it is set to' do
-      subject.should be_kind_of(mock_password_strategy)
+      expect(subject).to be_kind_of(mock_password_strategy)
     end
   end
 
@@ -33,7 +33,7 @@ describe Clearance::User do
     before { Clearance.configuration.password_strategy = nil }
 
     it 'includes Clearance::PasswordStrategies::BCrypt' do
-      subject.should be_kind_of(Clearance::PasswordStrategies::BCrypt)
+      expect(subject).to be_kind_of(Clearance::PasswordStrategies::BCrypt)
     end
   end
 end

data/spec/models/sha1_spec.rb

@@ -16,12 +16,12 @@ describe Clearance::PasswordStrategies::SHA1 do
       end
 
       it 'does not initialize the salt' do
-        subject.salt.should == salt
+        expect(subject.salt).to eq salt
       end
 
       it 'encrypts the password using SHA1 and the existing salt' do
         expected = Digest::SHA1.hexdigest("--#{salt}--#{password}--")
-        subject.encrypted_password.should == expected
+        expect(subject.encrypted_password).to eq expected
       end
     end
 
@@ -32,11 +32,11 @@ describe Clearance::PasswordStrategies::SHA1 do
       end
 
       it "initializes the salt" do
-        subject.salt.should_not be_nil
+        expect(subject.salt).not_to be_nil
       end
 
       it "doesn't encrpt the password" do
-        subject.encrypted_password.should be_nil
+        expect(subject.encrypted_password).to be_nil
       end
     end
   end

data/spec/models/user_spec.rb

@@ -5,27 +5,27 @@ describe User do
   it { should have_db_index(:remember_token) }
 
   describe 'when signing up' do
-    it { should validate_presence_of(:email) }
-    it { should validate_presence_of(:password) }
-    it { should allow_value('foo@example.co.uk').for(:email) }
-    it { should allow_value('foo@example.com').for(:email) }
-    it { should allow_value('foo+bar@example.com').for(:email) }
-    it { should_not allow_value('foo@').for(:email) }
-    it { should_not allow_value('foo@example..com').for(:email) }
-    it { should_not allow_value('foo@.example.com').for(:email) }
-    it { should_not allow_value('foo').for(:email) }
-    it { should_not allow_value('example.com').for(:email) }
-    it { should_not allow_value('foo;@example.com').for(:email) }
+    it { is_expected.to validate_presence_of(:email) }
+    it { is_expected.to validate_presence_of(:password) }
+    it { is_expected.to allow_value('foo@example.co.uk').for(:email) }
+    it { is_expected.to allow_value('foo@example.com').for(:email) }
+    it { is_expected.to allow_value('foo+bar@example.com').for(:email) }
+    it { is_expected.not_to allow_value('foo@').for(:email) }
+    it { is_expected.not_to allow_value('foo@example..com').for(:email) }
+    it { is_expected.not_to allow_value('foo@.example.com').for(:email) }
+    it { is_expected.not_to allow_value('foo').for(:email) }
+    it { is_expected.not_to allow_value('example.com').for(:email) }
+    it { is_expected.not_to allow_value('foo;@example.com').for(:email) }
 
     it 'stores email in down case and removes whitespace' do
       user = create(:user, email: 'Jo hn.Do e @exa mp le.c om')
-      user.email.should == 'john.doe@example.com'
+      expect(user.email).to eq 'john.doe@example.com'
     end
   end
 
   describe 'when multiple users have signed up' do
     before { create(:user) }
-    it { should validate_uniqueness_of(:email) }
+    it { is_expected.to validate_uniqueness_of(:email) }
   end
 
   describe 'a user' do
@@ -35,22 +35,22 @@ describe User do
     end
 
     it 'is authenticated with correct email and password' do
-      User.authenticate(@user.email, @password).should eq(@user)
-      @user.should be_authenticated(@password)
+      expect(User.authenticate(@user.email, @password)).to eq(@user)
+      expect(@user).to be_authenticated(@password)
     end
 
     it 'is authenticated with correct uppercased email and correct password' do
-      User.authenticate(@user.email.upcase, @password).should eq(@user)
-      @user.should be_authenticated(@password)
+      expect(User.authenticate(@user.email.upcase, @password)).to eq(@user)
+      expect(@user).to be_authenticated(@password)
     end
 
     it 'is not authenticated with incorrect credentials' do
-      User.authenticate(@user.email, 'bad_password').should be_nil
-      @user.should_not be_authenticated('bad password')
+      expect(User.authenticate(@user.email, 'bad_password')).to be_nil
+      expect(@user).not_to be_authenticated('bad password')
     end
 
     it 'is retrieved via a case-insensitive search' do
-      User.find_by_normalized_email(@user.email.upcase).should eq(@user)
+      expect(User.find_by_normalized_email(@user.email.upcase)).to eq(@user)
     end
   end
 
@@ -62,7 +62,7 @@ describe User do
     end
 
     it 'changes the remember token' do
-      @user.remember_token.should_not == 'old-token'
+      expect(@user.remember_token).not_to eq 'old-token'
     end
   end
 
@@ -78,7 +78,7 @@ describe User do
       end
 
       it 'changes encrypted password' do
-        @user.encrypted_password.should_not == @old_encrypted_password
+        expect(@user.encrypted_password).not_to eq @old_encrypted_password
       end
     end
   end
@@ -88,7 +88,7 @@ describe User do
     password = 'secret'
     first_user = create(:user, password: password)
     second_user = create(:user, password: password)
-    second_user.remember_token.should_not == first_user.remember_token
+    expect(second_user.remember_token).not_to eq first_user.remember_token
   end
 
   describe 'a user' do
@@ -99,12 +99,12 @@ describe User do
 
     describe 'who requests password reminder' do
       before do
-        @user.confirmation_token.should be_nil
+        expect(@user.confirmation_token).to be_nil
         @user.forgot_password!
       end
 
       it 'generates confirmation token' do
-        @user.confirmation_token.should_not be_nil
+        expect(@user.confirmation_token).not_to be_nil
       end
 
       describe 'and then updates password' do
@@ -114,11 +114,11 @@ describe User do
           end
 
           it 'changes encrypted password' do
-            @user.encrypted_password.should_not == @old_encrypted_password
+            expect(@user.encrypted_password).not_to eq @old_encrypted_password
           end
 
           it 'clears confirmation token' do
-            @user.confirmation_token.should be_nil
+            expect(@user.confirmation_token).to be_nil
           end
         end
 
@@ -128,11 +128,11 @@ describe User do
           end
 
           it 'does not change encrypted password' do
-            @user.encrypted_password.to_s.should == @old_encrypted_password
+            expect(@user.encrypted_password.to_s).to eq @old_encrypted_password
           end
 
           it 'does not clear confirmation token' do
-            @user.confirmation_token.should_not be_nil
+            expect(@user.confirmation_token).to_not be_nil
           end
         end
       end
@@ -152,13 +152,13 @@ describe User do
 
     subject { @user }
 
-    it { should allow_value(nil).for(:email) }
-    it { should allow_value('').for(:email) }
+    it { is_expected.to allow_value(nil).for(:email) }
+    it { is_expected.to allow_value('').for(:email) }
   end
 
   describe 'user factory' do
     it 'should create a valid user with just an overridden password' do
-      build(:user, password: 'test').should be_valid
+      expect(build(:user, password: 'test')).to be_valid
     end
   end
 
@@ -166,7 +166,7 @@ describe User do
     let(:email) { 'Jo hn.Do e @exa mp le.c om' }
 
     it 'downcases the address and strips spaces' do
-      User.normalize_email(email).should eq 'john.doe@example.com'
+      expect(User.normalize_email(email)).to eq 'john.doe@example.com'
     end
   end
 
@@ -175,22 +175,22 @@ describe User do
     before { subject.send(:password=, password) }
 
     it 'sets password to the plain-text password' do
-      subject.password.should == password
+      expect(subject.password).to eq password
     end
 
     it 'also sets encrypted_password' do
-      subject.encrypted_password.should_not be_nil
+      expect(subject.encrypted_password).to_not be_nil
     end
   end
 end
 
 describe UserWithOptionalPassword do
-  it { should allow_value(nil).for(:password) }
-  it { should allow_value('').for(:password) }
+  it { is_expected.to allow_value(nil).for(:password) }
+  it { is_expected.to allow_value('').for(:password) }
 
   it 'cannot authenticate with blank password' do
     user = create(:user_with_optional_password)
 
-    UserWithOptionalPassword.authenticate(user.email, '').should be_nil
+    expect(UserWithOptionalPassword.authenticate(user.email, '')).to be_nil
   end
 end