sorcery 0.8.5 → 0.9.0

data/spec/shared_examples/user_shared_examples.rb

@@ -1,86 +1,102 @@
 shared_examples_for "rails_3_core_model" do
-  describe User, "loaded plugin configuration" do
-    after(:each) do
-      User.sorcery_config.reset!
-    end
 
-    it "should enable configuration option 'username_attribute_names'" do
+  let(:user) { create_new_user }
+  let(:crypted_password) { user.send User.sorcery_config.crypted_password_attribute_name }
+
+  describe "loaded plugin configuration" do
+
+    after(:each) { User.sorcery_config.reset! }
+
+    it "enables configuration option 'username_attribute_names'" do
       sorcery_model_property_set(:username_attribute_names, :email)
-      User.sorcery_config.username_attribute_names.should == [:email]
+
+      expect(User.sorcery_config.username_attribute_names).to eq [:email]
     end
 
-    it "should enable configuration option 'password_attribute_name'" do
+    it "enables configuration option 'password_attribute_name'" do
       sorcery_model_property_set(:password_attribute_name, :mypassword)
-      User.sorcery_config.password_attribute_name.should equal(:mypassword)
+
+      expect(User.sorcery_config.password_attribute_name).to eq :mypassword
     end
 
-    it "should enable configuration option 'email_attribute_name'" do
+    it "enables configuration option 'email_attribute_name'" do
       sorcery_model_property_set(:email_attribute_name, :my_email)
-      User.sorcery_config.email_attribute_name.should equal(:my_email)
+
+      expect(User.sorcery_config.email_attribute_name).to eq :my_email
     end
 
-    it "should enable configuration option 'crypted_password_attribute_name'" do
+    it "enables configuration option 'crypted_password_attribute_name'" do
       sorcery_model_property_set(:crypted_password_attribute_name, :password)
-      User.sorcery_config.crypted_password_attribute_name.should equal(:password)
+
+      expect(User.sorcery_config.crypted_password_attribute_name).to eq :password
     end
 
-    it "should enable configuration option 'salt_attribute_name'" do
+    it "enables configuration option 'salt_attribute_name'" do
       sorcery_model_property_set(:salt_attribute_name, :my_salt)
-      User.sorcery_config.salt_attribute_name.should equal(:my_salt)
+
+      expect(User.sorcery_config.salt_attribute_name).to eq :my_salt
     end
 
-    it "should enable configuration option 'encryption_algorithm'" do
+    it "enables configuration option 'encryption_algorithm'" do
       sorcery_model_property_set(:encryption_algorithm, :none)
-      User.sorcery_config.encryption_algorithm.should equal(:none)
+
+      expect(User.sorcery_config.encryption_algorithm).to eq :none
     end
 
-    it "should enable configuration option 'encryption_key'" do
+    it "enables configuration option 'encryption_key'" do
       sorcery_model_property_set(:encryption_key, 'asdadas424234242')
-      User.sorcery_config.encryption_key.should == 'asdadas424234242'
+
+      expect(User.sorcery_config.encryption_key).to eq 'asdadas424234242'
     end
 
-    it "should enable configuration option 'custom_encryption_provider'" do
+    it "enables configuration option 'custom_encryption_provider'" do
       sorcery_model_property_set(:encryption_algorithm, :custom)
       sorcery_model_property_set(:custom_encryption_provider, Array)
-      User.sorcery_config.custom_encryption_provider.should equal(Array)
+
+      expect(User.sorcery_config.custom_encryption_provider).to eq Array
     end
 
-    it "should enable configuration option 'salt_join_token'" do
+    it "enables configuration option 'salt_join_token'" do
       salt_join_token = "--%%*&-"
       sorcery_model_property_set(:salt_join_token, salt_join_token)
-      User.sorcery_config.salt_join_token.should equal(salt_join_token)
+
+      expect(User.sorcery_config.salt_join_token).to eq salt_join_token
     end
 
-    it "should enable configuration option 'stretches'" do
+    it "enables configuration option 'stretches'" do
       stretches = 15
       sorcery_model_property_set(:stretches, stretches)
-      User.sorcery_config.stretches.should equal(stretches)
+
+      expect(User.sorcery_config.stretches).to eq stretches
     end
-  end
 
-  # ----------------- PLUGIN ACTIVATED -----------------------
-  describe User, "when activated with sorcery" do
-    before(:all) do
-      sorcery_reload!
+    it 'respond to username=' do
+      expect(User.new).to respond_to(:username=)
     end
+  end
 
-    before(:each) do
-      User.delete_all
+  describe "when activated with sorcery" do
+    before(:all) { sorcery_reload! }
+    before(:each) { User.sorcery_adapter.delete_all }
+
+    it "does not add authenticate method to base class", active_record: true do
+      expect(ActiveRecord::Base).not_to respond_to(:authenticate) if defined?(ActiveRecord)
     end
 
-    it "should respond to class method authenticate" do
-      ActiveRecord::Base.should_not respond_to(:authenticate) if defined?(ActiveRecord)
-      User.should respond_to(:authenticate)
+    it "responds to class method authenticate" do
+      expect(User).to respond_to :authenticate
     end
 
-    it "authenticate should return true if credentials are good" do
-      create_new_user
-      User.authenticate(@user.send(User.sorcery_config.username_attribute_names.first), 'secret').should be_true
+    it "authenticate returns true if credentials are good" do
+      username = user.send(User.sorcery_config.username_attribute_names.first)
+
+      expect(User.authenticate username, 'secret').to be_truthy
     end
 
-    it "authenticate should return false if credentials are bad" do
-      create_new_user
-      User.authenticate(@user.send(User.sorcery_config.username_attribute_names.first), 'wrong!').should be_false
+    it "authenticate returns nil if credentials are bad" do
+      username = user.send(User.sorcery_config.username_attribute_names.first)
+
+      expect(User.authenticate username, 'wrong!').to be nil
     end
 
     context "with empty credentials" do
@@ -93,116 +109,151 @@ shared_examples_for "rails_3_core_model" do
       end
 
       it "don't downcase empty credentials" do
-        expect(User.authenticate(nil, 'wrong!')).to be_false
+        expect(User.authenticate(nil, 'wrong!')).to be_falsy
       end
     end
 
-    specify { User.should respond_to(:encrypt) }
+    specify { expect(User).to respond_to(:encrypt) }
 
-    it "subclass should inherit config if defined so" do
+    it "subclass inherits config if defined so" do
       sorcery_reload!([],{:subclasses_inherit_config => true})
-      class Admin < User
-      end
-      Admin.sorcery_config.should_not be_nil
-      Admin.sorcery_config.should == User.sorcery_config
+      class Admin < User; end
+
+      expect(Admin.sorcery_config).not_to be_nil
+      expect(Admin.sorcery_config).to eq User.sorcery_config
     end
 
-    it "subclass should not inherit config if not defined so" do
+    it "subclass does not inherit config if not defined so" do
       sorcery_reload!([],{:subclasses_inherit_config => false})
-      class Admin2 < User
-      end
-      Admin2.sorcery_config.should be_nil
+      class Admin2 < User; end
+
+      expect(Admin2.sorcery_config).to be_nil
     end
   end
 
-  # ----------------- REGISTRATION -----------------------
-  describe User, "registration" do
 
-    before(:all) do
-      sorcery_reload!()
-    end
+  describe "registration" do
 
-    before(:each) do
-      User.delete_all
-    end
+    before(:all) { sorcery_reload! }
+    before(:each) { User.sorcery_adapter.delete_all }
 
-    it "by default, encryption_provider should not be nil" do
-      User.sorcery_config.encryption_provider.should_not be_nil
+    it "by default, encryption_provider is not nil" do
+      expect(User.sorcery_config.encryption_provider).not_to be_nil
     end
 
-    it "should encrypt password when a new user is saved" do
-      create_new_user
-      User.sorcery_config.encryption_provider.matches?(@user.send(User.sorcery_config.crypted_password_attribute_name),'secret',@user.salt).should be_true
+    it "encrypts password when a new user is saved" do
+      expect(User.sorcery_config.encryption_provider.matches? crypted_password, 'secret', user.salt).to be true
     end
 
-    it "should clear the virtual password field if the encryption process worked" do
-      create_new_user
-      @user.password.should be_nil
+    it "clears the virtual password field if the encryption process worked" do
+      expect(user.password).to be_nil
     end
 
-    it "should not clear the virtual password field if save failed due to validity" do
-      create_new_user
+    it "does not clear the virtual password field if save failed due to validity" do
       User.class_eval do
         validates_format_of :email, :with => /\A(.)+@(.)+\Z/, :if => Proc.new {|r| r.email}, :message => "is invalid"
       end
-      @user.password = 'blupush'
-      @user.email = 'asd'
-      @user.save
-      @user.password.should_not be_nil
+
+      user.password = 'blupush'
+      user.email = 'asd'
+      user.save
+
+      expect(user.password).not_to be_nil
     end
 
-    it "should not clear the virtual password field if save failed due to exception" do
-      create_new_user
-      @user.password = '4blupush'
-      @user.username = nil
-      User.class_eval do
-        validates_presence_of :username
-      end
+    it "does not clear the virtual password field if save failed due to exception" do
+      user.password = '4blupush'
+      user.username = nil
+
+      expect(user).to receive(:save) { raise RuntimeError }
+
       begin
-        @user.save! # triggers validation exception since username field is required.
+        user.save
       rescue
       end
-      @user.password.should_not be_nil
+
+      expect(user.password).not_to be_nil
     end
 
-    it "should not encrypt the password twice when a user is updated" do
-      create_new_user
-      @user.email = "blup@bla.com"
-      @user.save!
-      User.sorcery_config.encryption_provider.matches?(@user.send(User.sorcery_config.crypted_password_attribute_name),'secret',@user.salt).should be_true
+    it "does not encrypt the password twice when a user is updated" do
+      user.email = "blup@bla.com"
+      user.save
+
+      expect(User.sorcery_config.encryption_provider.matches? crypted_password, 'secret', user.salt).to be true
     end
 
-    it "should replace the crypted_password in case a new password is set" do
-      create_new_user
-      @user.password = 'new_secret'
-      @user.save!
-      User.sorcery_config.encryption_provider.matches?(@user.send(User.sorcery_config.crypted_password_attribute_name),'secret',@user.salt).should be_false
+    it "replaces the crypted_password in case a new password is set" do
+      user.password = 'new_secret'
+      user.save
+
+      expect(User.sorcery_config.encryption_provider.matches? crypted_password, 'secret', user.salt).to be false
     end
 
+    describe "when user has password_confirmation_defined" do
+      before(:all) do
+        update_model { attr_accessor :password_confirmation }
+      end
+
+      after(:all) do
+        User.send(:remove_method, :password_confirmation)
+        User.send(:remove_method, :password_confirmation=)
+      end
+
+      it "clears the virtual password field if the encryption process worked" do
+        user = create_new_user(username: "u", password: "secret", password_confirmation: "secret", email: "email@example.com")
+
+        expect(user.password_confirmation).to be_nil
+      end
+
+      it "does not clear the virtual password field if save failed due to validity" do
+        User.class_eval do
+          validates_format_of :email, :with => /\A(.)+@(.)+\Z/
+        end
+        user = build_new_user(username: "u", password: "secret", password_confirmation: "secret", email: "asd")
+        user.save
+
+        expect(user.password_confirmation).not_to be_nil
+      end
+    end
   end
 
-  # ----------------- PASSWORD ENCRYPTION -----------------------
-  describe User, "special encryption cases" do
+  describe "password validation" do
+
+    let(:user_with_pass) { create_new_user({:username => 'foo_bar', :email => "foo@bar.com", :password => 'foobar'})}
+
+    specify { expect(user_with_pass).to respond_to :valid_password? }
+    
+    it "returns true if password is correct" do
+      expect(user_with_pass.valid_password?("foobar")).to be true
+    end
+  
+    it "returns false if password is incorrect" do
+      expect(user_with_pass.valid_password?("foobug")).to be false
+    end
+  end
+
+  describe "special encryption cases" do
     before(:all) do
       sorcery_reload!()
       @text = "Some Text!"
     end
 
     before(:each) do
-      User.delete_all
+      User.sorcery_adapter.delete_all
     end
 
     after(:each) do
       User.sorcery_config.reset!
     end
 
-    it "should work with no password encryption" do
+    it "works with no password encryption" do
       sorcery_model_property_set(:encryption_algorithm, :none)
-      create_new_user
-      User.authenticate(@user.send(User.sorcery_config.username_attribute_names.first), 'secret').should be_true
+      username = user.send(User.sorcery_config.username_attribute_names.first)
+
+      expect(User.authenticate username, 'secret').to be_truthy
     end
 
-    it "should work with custom password encryption" do
+    it "works with custom password encryption" do
       class MyCrypto
         def self.encrypt(*tokens)
           tokens.flatten.join('').gsub(/e/,'A')
@@ -214,122 +265,218 @@ shared_examples_for "rails_3_core_model" do
       end
       sorcery_model_property_set(:encryption_algorithm, :custom)
       sorcery_model_property_set(:custom_encryption_provider, MyCrypto)
-      create_new_user
-      User.authenticate(@user.send(User.sorcery_config.username_attribute_names.first), 'secret').should be_true
+
+      username = user.send(User.sorcery_config.username_attribute_names.first)
+
+      expect(User.authenticate username, 'secret').to be_truthy
     end
 
-    it "if encryption algo is aes256, it should set key to crypto provider" do
+    it "if encryption algo is aes256, it sets key to crypto provider" do
       sorcery_model_property_set(:encryption_algorithm, :aes256)
       sorcery_model_property_set(:encryption_key, nil)
-      expect{User.encrypt(@text)}.to raise_error(ArgumentError)
+
+      expect { User.encrypt @text }.to raise_error(ArgumentError)
+
       sorcery_model_property_set(:encryption_key, "asd234dfs423fddsmndsflktsdf32343")
-      expect{User.encrypt(@text)}.to_not raise_error
+
+      expect { User.encrypt @text }.not_to raise_error
     end
 
-    it "if encryption algo is aes256, it should set key to crypto provider, even if attributes are set in reverse" do
+    it "if encryption algo is aes256, it sets key to crypto provider, even if attributes are set in reverse" do
       sorcery_model_property_set(:encryption_key, nil)
       sorcery_model_property_set(:encryption_algorithm, :none)
       sorcery_model_property_set(:encryption_key, "asd234dfs423fddsmndsflktsdf32343")
       sorcery_model_property_set(:encryption_algorithm, :aes256)
-      expect{User.encrypt(@text)}.to_not raise_error
+
+      expect { User.encrypt @text }.not_to raise_error
     end
 
-    it "if encryption algo is md5 it should work" do
+    it "if encryption algo is md5 it works" do
       sorcery_model_property_set(:encryption_algorithm, :md5)
-      User.encrypt(@text).should == Sorcery::CryptoProviders::MD5.encrypt(@text)
+
+      expect(User.encrypt @text).to eq Sorcery::CryptoProviders::MD5.encrypt(@text)
     end
 
-    it "if encryption algo is sha1 it should work" do
+    it "if encryption algo is sha1 it works" do
       sorcery_model_property_set(:encryption_algorithm, :sha1)
-      User.encrypt(@text).should == Sorcery::CryptoProviders::SHA1.encrypt(@text)
+
+      expect(User.encrypt @text).to eq Sorcery::CryptoProviders::SHA1.encrypt(@text)
     end
 
-    it "if encryption algo is sha256 it should work" do
+    it "if encryption algo is sha256 it works" do
       sorcery_model_property_set(:encryption_algorithm, :sha256)
-      User.encrypt(@text).should == Sorcery::CryptoProviders::SHA256.encrypt(@text)
+
+      expect(User.encrypt @text).to eq Sorcery::CryptoProviders::SHA256.encrypt(@text)
     end
 
-    it "if encryption algo is sha512 it should work" do
+    it "if encryption algo is sha512 it works" do
       sorcery_model_property_set(:encryption_algorithm, :sha512)
-      User.encrypt(@text).should == Sorcery::CryptoProviders::SHA512.encrypt(@text)
+
+      expect(User.encrypt @text).to eq Sorcery::CryptoProviders::SHA512.encrypt(@text)
     end
 
-    it "salt should be random for each user and saved in db" do
+    it "salt is random for each user and saved in db" do
       sorcery_model_property_set(:salt_attribute_name, :salt)
-      create_new_user
-      @user.salt.should_not be_nil
+
+      expect(user.salt).not_to be_nil
     end
 
-    it "if salt is set should use it to encrypt" do
+    it "if salt is set uses it to encrypt" do
       sorcery_model_property_set(:salt_attribute_name, :salt)
       sorcery_model_property_set(:encryption_algorithm, :sha512)
-      create_new_user
-      @user.crypted_password.should_not == Sorcery::CryptoProviders::SHA512.encrypt('secret')
-      @user.crypted_password.should == Sorcery::CryptoProviders::SHA512.encrypt('secret',@user.salt)
+
+      expect(user.crypted_password).not_to eq Sorcery::CryptoProviders::SHA512.encrypt('secret')
+      expect(user.crypted_password).to eq Sorcery::CryptoProviders::SHA512.encrypt('secret',user.salt)
     end
 
-    it "if salt_join_token is set should use it to encrypt" do
+    it "if salt_join_token is set uses it to encrypt" do
       sorcery_model_property_set(:salt_attribute_name, :salt)
       sorcery_model_property_set(:salt_join_token, "-@=>")
       sorcery_model_property_set(:encryption_algorithm, :sha512)
-      create_new_user
-      @user.crypted_password.should_not == Sorcery::CryptoProviders::SHA512.encrypt('secret')
+
+      expect(user.crypted_password).not_to eq Sorcery::CryptoProviders::SHA512.encrypt('secret')
+
       Sorcery::CryptoProviders::SHA512.join_token = ""
-      @user.crypted_password.should_not == Sorcery::CryptoProviders::SHA512.encrypt('secret',@user.salt)
+
+      expect(user.crypted_password).not_to eq Sorcery::CryptoProviders::SHA512.encrypt('secret',user.salt)
+
       Sorcery::CryptoProviders::SHA512.join_token = User.sorcery_config.salt_join_token
-      @user.crypted_password.should == Sorcery::CryptoProviders::SHA512.encrypt('secret',@user.salt)
-    end
 
+      expect(user.crypted_password).to eq Sorcery::CryptoProviders::SHA512.encrypt('secret',user.salt)
+    end
   end
 
-  describe User, "ORM adapter" do
+  describe "ORM adapter" do
     before(:all) do
       sorcery_reload!()
-      User.delete_all
+      User.sorcery_adapter.delete_all
     end
 
-    before(:each) do
-      create_new_user
-    end
+    before(:each) { user }
 
     after(:each) do
-      User.delete_all
+      User.sorcery_adapter.delete_all
       User.sorcery_config.reset!
     end
 
-    it "find_by_username should work as expected" do
+
+    it "find_by_username works as expected" do
       sorcery_model_property_set(:username_attribute_names, [:username])
-      User.find_by_username("gizmo").should == @user
+
+      expect(User.sorcery_adapter.find_by_username "gizmo").to eq user
     end
 
-    it "find_by_username should work as expected with multiple username attributes" do
+    it "find_by_username works as expected with multiple username attributes" do
       sorcery_model_property_set(:username_attribute_names, [:username, :email])
-      User.find_by_username("gizmo").should == @user
+
+      expect(User.sorcery_adapter.find_by_username "gizmo").to eq user
     end
 
-    it "find_by_email should work as expected" do
-      User.find_by_email("bla@bla.com").should == @user
+    it "find_by_email works as expected" do
+      expect(User.sorcery_adapter.find_by_email "bla@bla.com").to eq user
     end
   end
 end
 
 shared_examples_for "external_user" do
+  let(:user) { create_new_user }
+  let(:external_user) { create_new_external_user :twitter }
+
   before(:each) do
-    User.delete_all
+    User.sorcery_adapter.delete_all
+  end
+
+  it "responds to 'external?'" do
+    expect(user).to respond_to(:external?)
   end
 
-  it "should respond to 'external?'" do
-    create_new_user
-    @user.should respond_to(:external?)
+  it "external? is false for regular users" do
+    expect(user.external?).to be false
   end
 
-  it "external? should be false for regular users" do
-    create_new_user
-    @user.external?.should be_false
+  it "external? is true for external users" do
+    expect(external_user.external?).to be true
+  end
+
+  describe ".create_from_provider" do
+
+    before(:all) do
+      if SORCERY_ORM == :active_record
+        ActiveRecord::Migrator.migrate("#{Rails.root}/db/migrate/external")
+        User.reset_column_information
+      end
+
+      sorcery_reload!([:external])
+    end
+
+    after(:all) do
+      if SORCERY_ORM == :active_record
+        ActiveRecord::Migrator.rollback("#{Rails.root}/db/migrate/external")
+      end
+    end
+
+    it 'supports nested attributes' do
+      sorcery_model_property_set(:authentications_class, Authentication)
+
+      expect { User.create_from_provider('facebook', '123', {username: 'Noam Ben Ari'}) }.to change { User.count }.by(1)
+      expect(User.first.username).to eq 'Noam Ben Ari'
+    end
+
+    context 'with block' do
+      it 'create user when block return true' do
+        expect {
+          User.create_from_provider('facebook', '123', {username: 'Noam Ben Ari'}) { true }
+        }.to change { User.count }.by(1)
+      end
+
+      it 'does not create user when block return false' do
+        expect {
+          User.create_from_provider('facebook', '123', {username: 'Noam Ben Ari'}) { false }
+        }.not_to change { User.count }
+      end
+    end
+
   end
 
-  it "external? should be true for external users" do
-    create_new_external_user(:twitter)
-    @user.external?.should be_true
+  describe 'activation' do
+    before(:all) do
+      if SORCERY_ORM == :active_record
+        ActiveRecord::Migrator.migrate("#{Rails.root}/db/migrate/external")
+        ActiveRecord::Migrator.migrate("#{Rails.root}/db/migrate/activation")
+      end
+
+      sorcery_reload!([:user_activation,:external], :user_activation_mailer => ::SorceryMailer)
+    end
+
+    after(:all) do
+      if SORCERY_ORM == :active_record
+        ActiveRecord::Migrator.rollback("#{Rails.root}/db/migrate/activation")
+        ActiveRecord::Migrator.rollback("#{Rails.root}/db/migrate/external")
+      end
+    end
+
+    after(:each) do
+      User.sorcery_adapter.delete_all
+    end
+
+    [:facebook, :github, :google, :liveid].each do |provider|
+
+      it "does not send activation email to external users" do
+        old_size = ActionMailer::Base.deliveries.size
+        create_new_external_user(provider)
+
+        expect(ActionMailer::Base.deliveries.size).to eq old_size
+      end
+
+      it "does not send external users an activation success email" do
+        sorcery_model_property_set(:activation_success_email_method_name, nil)
+        create_new_external_user(provider)
+        old_size = ActionMailer::Base.deliveries.size
+        @user.activate!
+
+        expect(ActionMailer::Base.deliveries.size).to eq old_size
+      end
+    end
+
   end
-end
+end