sorcery 0.8.5 → 0.8.6

data/spec/shared_examples/controller_oauth2_shared_examples.rb

@@ -1,56 +1,52 @@
-shared_examples_for "oauth2_controller" do
-  describe "using 'create_from'" do
+shared_examples_for 'oauth2_controller' do
+  describe 'using create_from' do
     before(:each) do
       stub_all_oauth2_requests!
       User.delete_all
       Authentication.delete_all
     end
 
-    it "should create a new user" do
+    it 'creates a new user' do
       sorcery_model_property_set(:authentications_class, Authentication)
-      sorcery_controller_external_property_set(:facebook, :user_info_mapping, {:username => "name"})
-      lambda do
-        get :test_create_from_provider, :provider => "facebook"
-      end.should change(User, :count).by(1)
-      User.first.username.should == "Noam Ben Ari"
+      sorcery_controller_external_property_set(:facebook, :user_info_mapping, { username: 'name' })
+
+      expect { get :test_create_from_provider, provider: 'facebook' }.to change { User.count }.by 1
+      expect(User.first.username).to eq 'Noam Ben Ari'
     end
 
-    it "should support nested attributes" do
+    it 'supports nested attributes' do
       sorcery_model_property_set(:authentications_class, Authentication)
-      sorcery_controller_external_property_set(:facebook, :user_info_mapping, {:username => "hometown/name"})
-      lambda do
-        get :test_create_from_provider, :provider => "facebook"
-      end.should change(User, :count).by(1)
-      User.first.username.should == "Haifa, Israel"
+      sorcery_controller_external_property_set(:facebook, :user_info_mapping, { username: 'hometown/name' })
+
+      expect { get :test_create_from_provider, provider: 'facebook' }.to change { User.count }.by(1)
+      expect(User.first.username).to eq 'Haifa, Israel'
     end
 
-    it "should not crash on missing nested attributes" do
+    it 'does not crash on missing nested attributes' do
       sorcery_model_property_set(:authentications_class, Authentication)
-      sorcery_controller_external_property_set(:facebook, :user_info_mapping, {:username => "name", :created_at => "does/not/exist"})
-      lambda do
-        get :test_create_from_provider, :provider => "facebook"
-      end.should change(User, :count).by(1)
-      User.first.username.should == "Noam Ben Ari"
-      User.first.created_at.should_not be_nil
+      sorcery_controller_external_property_set(:facebook, :user_info_mapping, { username: 'name', created_at: 'does/not/exist' })
+
+      expect { get :test_create_from_provider, provider: 'facebook' }.to change { User.count }.by 1
+      expect(User.first.username).to eq 'Noam Ben Ari'
+      expect(User.first.created_at).not_to be_nil
     end
-   
-    describe "with a block" do
-      
+
+    describe 'with a block' do
+
       before(:each) do
-        user = User.new(:username => 'Noam Ben Ari')
-        user.save!(:validate => false)
-        user.authentications.create(:provider => 'twitter', :uid => '456')
+        user = User.new(username: 'Noam Ben Ari')
+        user.save!(validate: false)
+        user.authentications.create(provider: 'twitter', uid: '456')
       end
-      
-      it "should not create user" do
+
+      it 'does not create user' do
         sorcery_model_property_set(:authentications_class, Authentication)
-        sorcery_controller_external_property_set(:facebook, :user_info_mapping, {:username => "name"})
-        lambda do
-          # test_create_from_provider_with_block in controller will check for uniqueness of username
-          get :test_create_from_provider_with_block, :provider => "facebook"
-        end.should_not change(User, :count)
+        sorcery_controller_external_property_set(:facebook, :user_info_mapping, { username: 'name' })
+
+        # test_create_from_provider_with_block in controller will check for uniqueness of username
+        expect { get :test_create_from_provider_with_block, provider: 'facebook' }.not_to change { User.count }
       end
-    
+
     end
   end
-end
+end

data/spec/shared_examples/controller_oauth_shared_examples.rb

@@ -6,32 +6,29 @@ shared_examples_for "oauth_controller" do
       Authentication.delete_all
     end
 
-    it "should create a new user" do
+    it "creates a new user" do
       sorcery_model_property_set(:authentications_class, Authentication)
       sorcery_controller_external_property_set(:twitter, :user_info_mapping, {:username => "screen_name"})
-      lambda do
-        get :test_create_from_provider, :provider => "twitter"
-      end.should change(User, :count).by(1)
-      User.first.username.should == "nbenari"
+
+      expect { get :test_create_from_provider, :provider => "twitter" }.to change { User.count }.by 1
+      expect(User.first.username).to eq "nbenari"
     end
 
-    it "should support nested attributes" do
+    it "supports nested attributes" do
       sorcery_model_property_set(:authentications_class, Authentication)
       sorcery_controller_external_property_set(:twitter, :user_info_mapping, {:username => "status/text"})
-      lambda do
-        get :test_create_from_provider, :provider => "twitter"
-      end.should change(User, :count).by(1)
-      User.first.username.should == "coming soon to sorcery gem: twitter and facebook authentication support."
+
+      expect { get :test_create_from_provider, :provider => "twitter" }.to change { User.count }.by 1
+      expect(User.first.username).to eq "coming soon to sorcery gem: twitter and facebook authentication support."
     end
 
-    it "should not crash on missing nested attributes" do
+    it "does not crash on missing nested attributes" do
       sorcery_model_property_set(:authentications_class, Authentication)
       sorcery_controller_external_property_set(:twitter, :user_info_mapping, {:username => "status/text", :created_at => "does/not/exist"})
-      lambda do
-        get :test_create_from_provider, :provider => "twitter"
-      end.should change(User, :count).by(1)
-      User.first.username.should == "coming soon to sorcery gem: twitter and facebook authentication support."
-      User.first.created_at.should_not be_nil
+
+      expect { get :test_create_from_provider, :provider => "twitter" }.to change { User.count }.by 1
+      expect(User.first.username).to eq "coming soon to sorcery gem: twitter and facebook authentication support."
+      expect(User.first.created_at).not_to be_nil
     end
 
     it "binds new provider" do
@@ -40,12 +37,9 @@ shared_examples_for "oauth_controller" do
       current_user = custom_create_new_external_user(:facebook, UserProvider)
       login_user(current_user)
 
-      lambda do
-        get :test_add_second_provider, :provider => "twitter"
-      end.should change(UserProvider, :count).by(1)
-
-      UserProvider.where(:user_id => current_user.id).should have(2).items
-      User.should have(1).item
+      expect { get :test_add_second_provider, :provider => "twitter" }.to change { UserProvider.count }.by 1
+      expect(UserProvider.where(:user_id => current_user.id).size).to eq 2
+      expect(User.count).to eq 1
     end
 
     describe "with a block" do
@@ -56,12 +50,11 @@ shared_examples_for "oauth_controller" do
         user.authentications.create(:provider => 'github', :uid => '456')
       end
 
-      it "should not create user" do
+      it "does not create user" do
         sorcery_model_property_set(:authentications_class, Authentication)
         sorcery_controller_external_property_set(:twitter, :user_info_mapping, {:username => "screen_name"})
-        lambda do
-          get :test_create_from_provider_with_block, :provider => "twitter"
-        end.should_not change(User, :count)
+
+        expect { get :test_create_from_provider_with_block, :provider => "twitter" }.not_to change { User.count }
       end
 
     end

data/spec/shared_examples/controller_shared_examples.rb

@@ -0,0 +1,203 @@
+shared_examples_for "sorcery_controller" do
+
+  describe "plugin configuration" do
+    before(:all) do
+      sorcery_reload!
+    end
+
+    after(:each) do
+      Sorcery::Controller::Config.reset!
+      sorcery_reload!
+    end
+
+    it "enables configuration option 'user_class'" do
+      sorcery_controller_property_set(:user_class, "TestUser")
+
+      expect(Sorcery::Controller::Config.user_class).to eq "TestUser"
+    end
+
+    it "enables configuration option 'not_authenticated_action'" do
+      sorcery_controller_property_set(:not_authenticated_action, :my_action)
+
+      expect(Sorcery::Controller::Config.not_authenticated_action).to eq :my_action
+    end
+
+  end
+
+  # ----------------- PLUGIN ACTIVATED -----------------------
+  context "when activated with sorcery" do
+    let!(:user) { create_new_user }
+
+    before(:all) do
+      sorcery_reload!
+      User.delete_all
+    end
+
+    after(:each) do
+      Sorcery::Controller::Config.reset!
+      sorcery_reload!
+      User.delete_all
+      sorcery_controller_property_set(:user_class, User)
+      sorcery_model_property_set(:username_attribute_names, [:email])
+    end
+
+    specify { should respond_to(:login) }
+
+    specify { should respond_to(:logout) }
+
+    specify { should respond_to(:logged_in?) }
+
+    specify { should respond_to(:current_user) }
+
+    it "login(username,password) returns the user when success and set the session with user.id" do
+      get :test_login, :email => 'bla@bla.com', :password => 'secret'
+
+      expect(assigns[:user]).to eq user
+      expect(session[:user_id]).to eq user.id
+    end
+
+    it "login(email,password) returns the user when success and set the session with user.id" do
+      get :test_login, :email => 'bla@bla.com', :password => 'secret'
+
+      expect(assigns[:user]).to eq user
+      expect(session[:user_id]).to eq user.id
+    end
+
+    it "login(username,password) returns nil and not set the session when failure" do
+      get :test_login, :email => 'bla@bla.com', :password => 'opensesame!'
+
+      expect(assigns[:user]).to be_nil
+      expect(session[:user_id]).to be_nil
+    end
+
+    it "login(email,password) returns the user when success and set the session with the _csrf_token" do
+      get :test_login, :email => 'bla@bla.com', :password => 'secret'
+
+      expect(session[:_csrf_token]).not_to be_nil
+    end
+
+    it "login(username,password) returns nil and not set the session when upper case username" do
+      skip('DM Adapter dependant') if SORCERY_ORM == :datamapper
+      get :test_login, :email => 'BLA@BLA.COM', :password => 'secret'
+
+      expect(assigns[:user]).to be_nil
+      expect(session[:user_id]).to be_nil
+    end
+
+    it "login(username,password) returns the user and set the session with user.id when upper case username and config is downcase before authenticating" do
+      sorcery_model_property_set(:downcase_username_before_authenticating, true)
+      get :test_login, :email => 'BLA@BLA.COM', :password => 'secret'
+
+      expect(assigns[:user]).to eq user
+      expect(session[:user_id]).to eq user.id
+    end
+
+    it "login(username,password) returns nil and not set the session when user was created with upper case username, config is default, and log in username is lower case" do
+      skip('DM Adapter dependant') if SORCERY_ORM == :datamapper
+      create_new_user({:username => "", :email => "BLA1@BLA.COM", :password => 'secret1'})
+      get :test_login, :email => 'bla1@bla.com', :password => 'secret1'
+
+      expect(assigns[:user]).to be_nil
+      expect(session[:user_id]).to be_nil
+    end
+
+    it "login(username,password) returns the user and set the session with user.id when user was created with upper case username and config is downcase before authenticating" do
+      skip('DM Adapter dependant') if SORCERY_ORM == :datamapper
+      sorcery_model_property_set(:downcase_username_before_authenticating, true)
+      new_user = create_new_user({:username => "", :email => "BLA1@BLA.COM", :password => 'secret1'})
+      get :test_login, :email => 'bla1@bla.com', :password => 'secret1'
+
+      expect(assigns[:user]).to eq new_user
+      expect(session[:user_id]).to eq new_user.id
+    end
+
+    it "logout clears the session" do
+      cookies[:remember_me_token] = nil
+      session[:user_id] = user.id
+      get :test_logout
+
+      expect(session[:user_id]).to be_nil
+    end
+
+    it "logged_in? returns true if logged in" do
+      session[:user_id] = user.id
+
+      expect(subject.logged_in?).to be true
+    end
+
+    it "logged_in? returns false if not logged in" do
+      session[:user_id] = nil
+
+      expect(subject.logged_in?).to be false
+    end
+
+    it "current_user returns the user instance if logged in" do
+      create_new_user
+      session[:user_id] = user.id
+
+      2.times { expect(subject.current_user).to eq user } # memoized!
+    end
+
+    it "current_user returns false if not logged in" do
+      session[:user_id] = nil
+
+      2.times { expect(subject.current_user).to be_nil } # memoized!
+    end
+
+    specify { should respond_to(:require_login) }
+
+    it "calls the configured 'not_authenticated_action' when authenticate before_filter fails" do
+      session[:user_id] = nil
+      sorcery_controller_property_set(:not_authenticated_action, :test_not_authenticated_action)
+      get :test_logout
+
+      expect(response.body).to eq "test_not_authenticated_action"
+    end
+
+    it "require_login before_filter saves the url that the user originally wanted" do
+      get :some_action
+
+      expect(session[:return_to_url]).to eq "http://test.host/some_action"
+      expect(response).to redirect_to("http://test.host/")
+    end
+
+    it "require_login before_filter does not save the url that the user originally wanted upon all non-get http methods" do
+      [:post, :put, :delete].each do |m|
+        self.send(m, :some_action)
+
+        expect(session[:return_to_url]).to be_nil
+      end
+    end
+
+    it "on successful login the user is redirected to the url he originally wanted" do
+      session[:return_to_url] = "http://test.host/some_action"
+      post :test_return_to, :email => 'bla@bla.com', :password => 'secret'
+
+      expect(response).to redirect_to("http://test.host/some_action")
+      expect(flash[:notice]).to eq "haha!"
+    end
+
+
+    # --- auto_login(user) ---
+    specify { should respond_to(:auto_login) }
+
+    it "auto_login(user) los in a user instance" do
+      session[:user_id] = nil
+      subject.auto_login(user)
+
+      expect(subject.logged_in?).to be true
+    end
+
+    it "auto_login(user) works even if current_user was already set to false" do
+      get :test_logout
+
+      expect(session[:user_id]).to be_nil
+      expect(subject.current_user).to be_nil
+
+      get :test_auto_login
+
+      expect(assigns[:result]).to eq User.first
+    end
+  end
+
+end

data/spec/shared_examples/user_activation_shared_examples.rb

@@ -1,6 +1,8 @@
 shared_examples_for "rails_3_activation_model" do
-  # ----------------- PLUGIN CONFIGURATION -----------------------
-  describe User, "loaded plugin configuration" do
+  let(:user) { create_new_user }
+  let(:new_user) { build_new_user }
+
+  context "loaded plugin configuration" do
     before(:all) do
       sorcery_reload!([:user_activation], :user_activation_mailer => ::SorceryMailer)
     end
@@ -10,34 +12,40 @@ shared_examples_for "rails_3_activation_model" do
       sorcery_reload!([:user_activation], :user_activation_mailer => ::SorceryMailer)
     end
 
-    it "should enable configuration option 'activation_state_attribute_name'" do
+    it "enables configuration option 'activation_state_attribute_name'" do
       sorcery_model_property_set(:activation_state_attribute_name, :status)
-      User.sorcery_config.activation_state_attribute_name.should equal(:status)
+
+      expect(User.sorcery_config.activation_state_attribute_name).to eq :status
     end
 
-    it "should enable configuration option 'activation_token_attribute_name'" do
+    it "enables configuration option 'activation_token_attribute_name'" do
       sorcery_model_property_set(:activation_token_attribute_name, :code)
-      User.sorcery_config.activation_token_attribute_name.should equal(:code)
+
+      expect(User.sorcery_config.activation_token_attribute_name).to eql :code
     end
 
-    it "should enable configuration option 'user_activation_mailer'" do
+    it "enables configuration option 'user_activation_mailer'" do
       sorcery_model_property_set(:user_activation_mailer, TestMailer)
-      User.sorcery_config.user_activation_mailer.should equal(TestMailer)
+
+      expect(User.sorcery_config.user_activation_mailer).to equal(TestMailer)
     end
 
-    it "should enable configuration option 'activation_needed_email_method_name'" do
+    it "enables configuration option 'activation_needed_email_method_name'" do
       sorcery_model_property_set(:activation_needed_email_method_name, :my_activation_email)
-      User.sorcery_config.activation_needed_email_method_name.should equal(:my_activation_email)
+
+      expect(User.sorcery_config.activation_needed_email_method_name).to eq :my_activation_email
     end
 
-    it "should enable configuration option 'activation_success_email_method_name'" do
+    it "enables configuration option 'activation_success_email_method_name'" do
       sorcery_model_property_set(:activation_success_email_method_name, :my_activation_email)
-      User.sorcery_config.activation_success_email_method_name.should equal(:my_activation_email)
+
+      expect(User.sorcery_config.activation_success_email_method_name).to eq :my_activation_email
     end
 
-    it "should enable configuration option 'activation_mailer_disabled'" do
+    it "enables configuration option 'activation_mailer_disabled'" do
       sorcery_model_property_set(:activation_mailer_disabled, :my_activation_mailer_disabled)
-      User.sorcery_config.activation_mailer_disabled.should equal(:my_activation_mailer_disabled)
+
+      expect(User.sorcery_config.activation_mailer_disabled).to eq :my_activation_mailer_disabled
     end
 
     it "if mailer is nil and mailer is enabled, throw exception!" do
@@ -49,83 +57,88 @@ shared_examples_for "rails_3_activation_model" do
     end
   end
 
-  # ----------------- ACTIVATION PROCESS -----------------------
-  describe User, "activation process" do
+
+  context "activation process" do
     before(:all) do
       sorcery_reload!([:user_activation], :user_activation_mailer => ::SorceryMailer)
     end
 
-    before(:each) do
-      create_new_user
+    it "initializes user state to 'pending'" do
+      expect(user.activation_state).to eq "pending"
     end
 
-    it "should initialize user state to 'pending'" do
-      @user.activation_state.should == "pending"
-    end
+    specify { expect(user).to respond_to :activate! }
 
-    specify { @user.should respond_to(:activate!) }
+    it "clears activation code and change state to 'active' on activation" do
+      activation_token = user.activation_token
+      user.activate!
+      user2 = User.find(user.id) # go to db to make sure it was saved and not just in memory
 
-    it "should clear activation code and change state to 'active' on activation" do
-      activation_token = @user.activation_token
-      @user.activate!
-      @user2 = User.find(@user.id) # go to db to make sure it was saved and not just in memory
-      @user2.activation_token.should be_nil
-      @user2.activation_state.should == "active"
-      User.find_by_activation_token(activation_token).should be_nil
+      expect(user2.activation_token).to be_nil
+      expect(user2.activation_state).to eq "active"
+      expect(User.find_by_activation_token activation_token).to be_nil
     end
 
 
     context "mailer is enabled" do
-      it "should send the user an activation email" do
+      it "sends the user an activation email" do
         old_size = ActionMailer::Base.deliveries.size
         create_new_user
-        ActionMailer::Base.deliveries.size.should == old_size + 1
+
+        expect(ActionMailer::Base.deliveries.size).to eq old_size + 1
       end
 
-      it "should call send_activation_needed_email! method of user" do
-        user = build_new_user
-        user.should_receive(:send_activation_needed_email!).once
-        user.save!
+      it "calls send_activation_needed_email! method of user" do
+        expect(new_user).to receive(:send_activation_needed_email!).once
+
+        new_user.sorcery_save(:raise_on_failure => true)
       end
 
       it "subsequent saves do not send activation email" do
+        user
         old_size = ActionMailer::Base.deliveries.size
-        @user.email = "Shauli"
-        @user.save!
-        ActionMailer::Base.deliveries.size.should == old_size
+        user.email = "Shauli"
+        user.sorcery_save(:raise_on_failure => true)
+
+        expect(ActionMailer::Base.deliveries.size).to eq old_size
       end
 
-      it "should send the user an activation success email on successful activation" do
+      it "sends the user an activation success email on successful activation" do
+        user
         old_size = ActionMailer::Base.deliveries.size
-        @user.activate!
-        ActionMailer::Base.deliveries.size.should == old_size + 1
+        user.activate!
+
+        expect(ActionMailer::Base.deliveries.size).to eq old_size + 1
       end
 
-      it "should call send_activation_success_email! method of user on activation" do
-        @user.should_receive(:send_activation_success_email!).once
-        @user.activate!
+      it "calls send_activation_success_email! method of user on activation" do
+        expect(user).to receive(:send_activation_success_email!).once
+
+        user.activate!
       end
 
       it "subsequent saves do not send activation success email" do
-        @user.activate!
+        user.activate!
         old_size = ActionMailer::Base.deliveries.size
-        @user.email = "Shauli"
-        @user.save!
-        ActionMailer::Base.deliveries.size.should == old_size
+        user.email = "Shauli"
+        user.sorcery_save(:raise_on_failure => true)
+
+        expect(ActionMailer::Base.deliveries.size).to eq old_size
       end
 
       it "activation needed email is optional" do
         sorcery_model_property_set(:activation_needed_email_method_name, nil)
         old_size = ActionMailer::Base.deliveries.size
-        create_new_user
-        ActionMailer::Base.deliveries.size.should == old_size
+
+        expect(ActionMailer::Base.deliveries.size).to eq old_size
       end
 
       it "activation success email is optional" do
         sorcery_model_property_set(:activation_success_email_method_name, nil)
         old_size = ActionMailer::Base.deliveries.size
-        @user.activate!
-        ActionMailer::Base.deliveries.size.should == old_size
+        user.activate!
+
+        expect(ActionMailer::Base.deliveries.size).to eq old_size
       end
     end
 
@@ -134,52 +147,56 @@ shared_examples_for "rails_3_activation_model" do
         sorcery_reload!([:user_activation], :activation_mailer_disabled => true, :user_activation_mailer => ::SorceryMailer)
       end
 
-      it "should not send the user an activation email" do
+      it "does not send the user an activation email" do
         old_size = ActionMailer::Base.deliveries.size
-        create_new_user
-        ActionMailer::Base.deliveries.size.should == old_size
+
+        expect(ActionMailer::Base.deliveries.size).to eq old_size
       end
 
-      it "should not call send_activation_needed_email! method of user" do
+      it "does not call send_activation_needed_email! method of user" do
         user = build_new_user
-        user.should_receive(:send_activation_needed_email!).never
-        user.save!
+
+        expect(user).to receive(:send_activation_needed_email!).never
+
+        user.sorcery_save(:raise_on_failure => true)
       end
 
-      it "should not send the user an activation success email on successful activation" do
+      it "does not send the user an activation success email on successful activation" do
         old_size = ActionMailer::Base.deliveries.size
-        @user.activate!
-        ActionMailer::Base.deliveries.size.should == old_size
+        user.activate!
+
+        expect(ActionMailer::Base.deliveries.size).to eq old_size
       end
 
-      it "should call send_activation_success_email! method of user on activation" do
-        @user.should_receive(:send_activation_success_email!).never
-        @user.activate!
+      it "calls send_activation_success_email! method of user on activation" do
+        expect(user).to receive(:send_activation_success_email!).never
+
+        user.activate!
       end
     end
   end
 
-  describe User, "prevent non-active login feature" do
+  describe "prevent non-active login feature" do
     before(:all) do
       sorcery_reload!([:user_activation], :user_activation_mailer => ::SorceryMailer)
     end
 
     before(:each) do
       User.delete_all
-      create_new_user
     end
 
-    it "should not allow a non-active user to authenticate" do
-      User.authenticate(@user.email, 'secret').should be_false
+    it "does not allow a non-active user to authenticate" do
+      expect(User.authenticate user.email, 'secret').to be_falsy
     end
 
-    it "should allow a non-active user to authenticate if configured so" do
+    it "allows a non-active user to authenticate if configured so" do
       sorcery_model_property_set(:prevent_non_active_users_to_login, false)
-      User.authenticate(@user.email, 'secret').should be_true
+
+      expect(User.authenticate user.email, 'secret').to be_truthy
     end
   end
 
-  describe User, "load_from_activation_token" do
+  describe "load_from_activation_token" do
     before(:all) do
       sorcery_reload!([:user_activation], :user_activation_mailer => ::SorceryMailer)
     end
@@ -188,38 +205,38 @@ shared_examples_for "rails_3_activation_model" do
       Timecop.return
     end
 
-    it "load_from_activation_token should return user when token is found" do
-      create_new_user
-      User.load_from_activation_token(@user.activation_token).should == @user
+    it "load_from_activation_token returns user when token is found" do
+      expect(User.load_from_activation_token user.activation_token).to eq user
     end
 
-    it "load_from_activation_token should NOT return user when token is NOT found" do
-      create_new_user
-      User.load_from_activation_token("a").should == nil
+    it "load_from_activation_token does NOT return user when token is NOT found" do
+      expect(User.load_from_activation_token "a").to be_nil
     end
 
-    it "load_from_activation_token should return user when token is found and not expired" do
+    it "load_from_activation_token returas user when token is found and not expired" do
       sorcery_model_property_set(:activation_token_expiration_period, 500)
-      create_new_user
-      User.load_from_activation_token(@user.activation_token).should == @user
+
+      expect(User.load_from_activation_token user.activation_token).to eq user
     end
 
-    it "load_from_activation_token should NOT return user when token is found and expired" do
+    it "load_from_activation_token does NOT return user when token is found and expired" do
       sorcery_model_property_set(:activation_token_expiration_period, 0.1)
-      create_new_user
+      user
+
       Timecop.travel(Time.now.in_time_zone+0.5)
-      User.load_from_activation_token(@user.activation_token).should == nil
+
+      expect(User.load_from_activation_token user.activation_token).to be_nil
     end
 
-    it "load_from_activation_token should return nil if token is blank" do
-      User.load_from_activation_token(nil).should == nil
-      User.load_from_activation_token("").should == nil
+    it "load_from_activation_token returns nil if token is blank" do
+      expect(User.load_from_activation_token nil).to be_nil
+      expect(User.load_from_activation_token "").to be_nil
     end
 
-    it "load_from_activation_token should always be valid if expiration period is nil" do
+    it "load_from_activation_token is always valid if expiration period is nil" do
       sorcery_model_property_set(:activation_token_expiration_period, nil)
-      create_new_user
-      User.load_from_activation_token(@user.activation_token).should == @user
+
+      expect(User.load_from_activation_token user.activation_token).to eq user
     end
   end
-end
+end