sorcery 0.17.0 → 0.18.0

data/spec/shared_examples/user_magic_login_shared_examples.rb

@@ -1,150 +0,0 @@
-shared_examples_for 'magic_login_model' do
-  let(:user) { create_new_user }
-  before(:each) do
-    User.sorcery_adapter.delete_all
-  end
-
-  context 'loaded plugin configuration' do
-    let(:config) { User.sorcery_config }
-
-    before(:all) do
-      sorcery_reload!([:magic_login])
-    end
-
-    after(:each) do
-      User.sorcery_config.reset!
-    end
-
-    describe 'enables configuration options' do
-      it do
-        sorcery_model_property_set(:magic_login_token_attribute_name, :test_magic_login_token)
-        expect(config.magic_login_token_attribute_name).to eq :test_magic_login_token
-      end
-
-      it do
-        sorcery_model_property_set(:magic_login_token_expires_at_attribute_name, :test_magic_login_token_expires_at)
-        expect(config.magic_login_token_expires_at_attribute_name).to eq :test_magic_login_token_expires_at
-      end
-
-      it do
-        sorcery_model_property_set(:magic_login_email_sent_at_attribute_name, :test_magic_login_email_sent_at)
-        expect(config.magic_login_email_sent_at_attribute_name).to eq :test_magic_login_email_sent_at
-      end
-
-      it do
-        TestMailerClass = Class.new # need a mailer class to test
-        sorcery_model_property_set(:magic_login_mailer_class, TestMailerClass)
-        expect(config.magic_login_mailer_class).to eq TestMailerClass
-      end
-
-      it do
-        sorcery_model_property_set(:magic_login_mailer_disabled, false)
-        expect(config.magic_login_mailer_disabled).to eq false
-      end
-
-      it do
-        sorcery_model_property_set(:magic_login_email_method_name, :test_magic_login_email)
-        expect(config.magic_login_email_method_name).to eq :test_magic_login_email
-      end
-
-      it do
-        sorcery_model_property_set(:magic_login_expiration_period, 100_000_000)
-        expect(config.magic_login_expiration_period).to eq 100_000_000
-      end
-
-      it do
-        sorcery_model_property_set(:magic_login_time_between_emails, 100_000_000)
-        expect(config.magic_login_time_between_emails).to eq 100_000_000
-      end
-    end
-
-    describe '#generate_magic_login_token!' do
-      context 'magic_login_token is nil' do
-        it "magic_login_token_expires_at and magic_login_email_sent_at aren't nil " do
-          user.generate_magic_login_token!
-          expect(user.magic_login_token_expires_at).not_to be_nil
-          expect(user.magic_login_email_sent_at).not_to be_nil
-        end
-
-        it 'magic_login_token is different from the one before' do
-          token_before = user.magic_login_token
-          user.generate_magic_login_token!
-          expect(user.magic_login_token).not_to eq token_before
-        end
-      end
-
-      context 'magic_login_token is not nil' do
-        it 'changes `user.magic_login_token`' do
-          token_before = user.magic_login_token
-          user.generate_magic_login_token!
-          expect(user.magic_login_token).not_to eq token_before
-        end
-      end
-    end
-
-    describe '#deliver_magic_login_instructions!' do
-      context 'success' do
-        before do
-          sorcery_model_property_set(:magic_login_time_between_emails, 30 * 60)
-          sorcery_model_property_set(:magic_login_mailer_disabled, false)
-          Timecop.travel(10.days.ago) do
-            user.send(:"#{config.magic_login_email_sent_at_attribute_name}=", DateTime.now)
-          end
-          sorcery_model_property_set(:magic_login_mailer_class, ::SorceryMailer)
-        end
-
-        it do
-          user.deliver_magic_login_instructions!
-          expect(ActionMailer::Base.deliveries.size).to eq 1
-        end
-
-        it do
-          expect(user.deliver_magic_login_instructions!).to eq true
-        end
-      end
-
-      context 'failure' do
-        context 'magic_login_time_between_emails is nil' do
-          it 'returns false' do
-            sorcery_model_property_set(:magic_login_time_between_emails, nil)
-            expect(user.deliver_magic_login_instructions!).to eq false
-          end
-        end
-
-        context 'magic_login_email_sent_at is nil' do
-          it 'returns false' do
-            user.send(:"#{config.magic_login_email_sent_at_attribute_name}=", nil)
-            expect(user.deliver_magic_login_instructions!).to eq false
-          end
-        end
-
-        context 'now is before magic_login_email_sent_at plus the interval' do
-          it 'returns false' do
-            user.send(:"#{config.magic_login_email_sent_at_attribute_name}=", DateTime.now)
-            sorcery_model_property_set(:magic_login_time_between_emails, 30 * 60)
-            expect(user.deliver_magic_login_instructions!).to eq false
-          end
-        end
-
-        context 'magic_login_mailer_disabled is true' do
-          it 'returns false' do
-            sorcery_model_property_set(:magic_login_mailer_disabled, true)
-            expect(user.deliver_magic_login_instructions!).to eq false
-          end
-        end
-      end
-    end
-
-    describe '#clear_magic_login_token!' do
-      it 'makes magic_login_token_attribute_name and magic_login_token_expires_at_attribute_name nil' do
-        user.magic_login_token = 'test_token'
-        user.magic_login_token_expires_at = Time.now
-
-        user.clear_magic_login_token!
-
-        expect(user.magic_login_token).to eq nil
-        expect(user.magic_login_token_expires_at).to eq nil
-      end
-    end
-  end
-end

data/spec/shared_examples/user_oauth_shared_examples.rb

@@ -1,33 +0,0 @@
-shared_examples_for 'rails_3_oauth_model' do
-  # ----------------- PLUGIN CONFIGURATION -----------------------
-
-  let(:external_user) { create_new_external_user :twitter }
-
-  describe 'loaded plugin configuration' do
-    before(:all) do
-      Authentication.sorcery_adapter.delete_all
-      User.sorcery_adapter.delete_all
-
-      sorcery_reload!([:external])
-      sorcery_controller_property_set(:external_providers, [:twitter])
-      sorcery_model_property_set(:authentications_class, Authentication)
-      sorcery_controller_external_property_set(:twitter, :key, 'eYVNBjBDi33aa9GkA3w')
-      sorcery_controller_external_property_set(:twitter, :secret, 'XpbeSdCoaKSmQGSeokz5qcUATClRW5u08QWNfv71N8')
-      sorcery_controller_external_property_set(:twitter, :callback_url, 'http://blabla.com')
-    end
-
-    it "responds to 'load_from_provider'" do
-      expect(User).to respond_to(:load_from_provider)
-    end
-
-    it "'load_from_provider' loads user if exists" do
-      external_user
-      expect(User.load_from_provider(:twitter, 123)).to eq external_user
-    end
-
-    it "'load_from_provider' returns nil if user doesn't exist" do
-      external_user
-      expect(User.load_from_provider(:twitter, 980_342)).to be_nil
-    end
-  end
-end

data/spec/shared_examples/user_remember_me_shared_examples.rb

@@ -1,129 +0,0 @@
-shared_examples_for 'rails_3_remember_me_model' do
-  let(:user) { create_new_user }
-
-  describe 'loaded plugin configuration' do
-    before(:all) do
-      sorcery_reload!([:remember_me])
-    end
-
-    after(:each) do
-      User.sorcery_config.reset!
-    end
-
-    it "allows configuration option 'remember_me_token_attribute_name'" do
-      sorcery_model_property_set(:remember_me_token_attribute_name, :my_token)
-
-      expect(User.sorcery_config.remember_me_token_attribute_name).to eq :my_token
-    end
-
-    it "allows configuration option 'remember_me_token_expires_at_attribute_name'" do
-      sorcery_model_property_set(:remember_me_token_expires_at_attribute_name, :my_expires)
-
-      expect(User.sorcery_config.remember_me_token_expires_at_attribute_name).to eq :my_expires
-    end
-
-    it "allows configuration option 'remember_me_token_persist_globally'" do
-      sorcery_model_property_set(:remember_me_token_persist_globally, true)
-
-      expect(User.sorcery_config.remember_me_token_persist_globally).to eq true
-    end
-
-    specify { expect(user).to respond_to :remember_me! }
-
-    specify { expect(user).to respond_to :forget_me! }
-
-    specify { expect(user).to respond_to :force_forget_me! }
-
-    it "sets an expiration based on 'remember_me_for' attribute" do
-      sorcery_model_property_set(:remember_me_for, 2 * 60 * 60 * 24)
-
-      ts = Time.now.in_time_zone
-      Timecop.freeze(ts) do
-        user.remember_me!
-      end
-
-      expect(user.remember_me_token_expires_at.utc.to_s).to eq((ts + 2 * 60 * 60 * 24).utc.to_s)
-    end
-
-    context 'when not persisting globally' do
-      before { sorcery_model_property_set(:remember_me_token_persist_globally, false) }
-
-      it "generates a new token on 'remember_me!' when a token doesn't exist" do
-        expect(user.remember_me_token).to be_nil
-        user.remember_me!
-
-        expect(user.remember_me_token).not_to be_nil
-      end
-
-      it "generates a new token on 'remember_me!' when a token exists" do
-        user.remember_me_token = 'abc123'
-        user.remember_me!
-
-        expect(user.remember_me_token).not_to be_nil
-        expect(user.remember_me_token).not_to eq('abc123')
-      end
-
-      it "deletes the token and expiration on 'forget_me!'" do
-        user.remember_me!
-
-        expect(user.remember_me_token).not_to be_nil
-
-        user.forget_me!
-
-        expect(user.remember_me_token).to be_nil
-        expect(user.remember_me_token_expires_at).to be_nil
-      end
-
-      it "deletes the token and expiration on 'force_forget_me!'" do
-        user.remember_me!
-
-        expect(user.remember_me_token).not_to be_nil
-
-        user.force_forget_me!
-
-        expect(user.remember_me_token).to be_nil
-        expect(user.remember_me_token_expires_at).to be_nil
-      end
-    end
-
-    context 'when persisting globally' do
-      before { sorcery_model_property_set(:remember_me_token_persist_globally, true) }
-
-      it "generates a new token on 'remember_me!' when a token doesn't exist" do
-        expect(user.remember_me_token).to be_nil
-        user.remember_me!
-
-        expect(user.remember_me_token).not_to be_nil
-      end
-
-      it "keeps existing token on 'remember_me!' when a token exists" do
-        user.remember_me_token = 'abc123'
-        user.remember_me!
-
-        expect(user.remember_me_token).to eq('abc123')
-      end
-
-      it "keeps the token and expiration on 'forget_me!'" do
-        user.remember_me!
-
-        expect(user.remember_me_token).not_to be_nil
-
-        user.forget_me!
-
-        expect(user.remember_me_token).to_not be_nil
-        expect(user.remember_me_token_expires_at).to_not be_nil
-      end
-
-      it "deletes the token and expiration on 'force_forget_me!'" do
-        user.remember_me!
-
-        expect(user.remember_me_token).not_to be_nil
-
-        user.force_forget_me!
-
-        expect(user.remember_me_token).to be_nil
-        expect(user.remember_me_token_expires_at).to be_nil
-      end
-    end
-  end
-end

data/spec/shared_examples/user_reset_password_shared_examples.rb

@@ -1,370 +0,0 @@
-shared_examples_for 'rails_3_reset_password_model' do
-  # ----------------- PLUGIN CONFIGURATION -----------------------
-  let(:user) { create_new_user }
-
-  describe 'loaded plugin configuration' do
-    before(:all) do
-      sorcery_reload!([:reset_password], reset_password_mailer: ::SorceryMailer)
-    end
-
-    after(:each) do
-      User.sorcery_config.reset!
-    end
-
-    context 'API' do
-      specify { expect(user).to respond_to :deliver_reset_password_instructions! }
-
-      specify { expect(user).to respond_to :change_password }
-
-      specify { expect(user).to respond_to :change_password! }
-
-      it 'responds to .load_from_reset_password_token' do
-        expect(User).to respond_to :load_from_reset_password_token
-      end
-    end
-
-    it "allows configuration option 'reset_password_token_attribute_name'" do
-      sorcery_model_property_set(:reset_password_token_attribute_name, :my_code)
-
-      expect(User.sorcery_config.reset_password_token_attribute_name).to eq :my_code
-    end
-
-    it "allows configuration option 'reset_password_mailer'" do
-      sorcery_model_property_set(:reset_password_mailer, TestUser)
-
-      expect(User.sorcery_config.reset_password_mailer).to eq TestUser
-    end
-
-    it "enables configuration option 'reset_password_mailer_disabled'" do
-      sorcery_model_property_set(:reset_password_mailer_disabled, :my_reset_password_mailer_disabled)
-
-      expect(User.sorcery_config.reset_password_mailer_disabled).to eq :my_reset_password_mailer_disabled
-    end
-
-    it 'if mailer is nil and mailer is enabled, throw exception!' do
-      expect { sorcery_reload!([:reset_password], reset_password_mailer_disabled: false) }.to raise_error(ArgumentError)
-    end
-
-    it 'if mailer is disabled and mailer is nil, do NOT throw exception' do
-      expect { sorcery_reload!([:reset_password], reset_password_mailer_disabled: true) }.to_not raise_error
-    end
-
-    it "allows configuration option 'reset_password_email_method_name'" do
-      sorcery_model_property_set(:reset_password_email_method_name, :my_mailer_method)
-
-      expect(User.sorcery_config.reset_password_email_method_name).to eq :my_mailer_method
-    end
-
-    it "allows configuration option 'reset_password_expiration_period'" do
-      sorcery_model_property_set(:reset_password_expiration_period, 16)
-
-      expect(User.sorcery_config.reset_password_expiration_period).to eq 16
-    end
-
-    it "allows configuration option 'reset_password_email_sent_at_attribute_name'" do
-      sorcery_model_property_set(:reset_password_email_sent_at_attribute_name, :blabla)
-
-      expect(User.sorcery_config.reset_password_email_sent_at_attribute_name).to eq :blabla
-    end
-
-    it "allows configuration option 'reset_password_time_between_emails'" do
-      sorcery_model_property_set(:reset_password_time_between_emails, 16)
-
-      expect(User.sorcery_config.reset_password_time_between_emails).to eq 16
-    end
-  end
-
-  describe 'when activated with sorcery' do
-    before(:all) do
-      sorcery_reload!([:reset_password], reset_password_mailer: ::SorceryMailer)
-    end
-
-    before(:each) do
-      User.sorcery_adapter.delete_all
-      user
-    end
-
-    after(:each) do
-      Timecop.return
-    end
-
-    it 'load_from_reset_password_token returns user when token is found' do
-      user.generate_reset_password_token!
-      updated_user = User.sorcery_adapter.find(user.id)
-
-      expect(User.load_from_reset_password_token(user.reset_password_token)).to eq updated_user
-    end
-
-    it 'load_from_reset_password_token does NOT return user when token is NOT found' do
-      user.generate_reset_password_token!
-
-      expect(User.load_from_reset_password_token('a')).to be_nil
-    end
-
-    it 'load_from_reset_password_token returns user when token is found and not expired' do
-      sorcery_model_property_set(:reset_password_expiration_period, 500)
-      user.generate_reset_password_token!
-      updated_user = User.sorcery_adapter.find(user.id)
-
-      expect(User.load_from_reset_password_token(user.reset_password_token)).to eq updated_user
-    end
-
-    it 'load_from_reset_password_token does NOT return user when token is found and expired' do
-      sorcery_model_property_set(:reset_password_expiration_period, 0.1)
-      user.generate_reset_password_token!
-      Timecop.travel(Time.now.in_time_zone + 0.5)
-
-      expect(User.load_from_reset_password_token(user.reset_password_token)).to be_nil
-    end
-
-    it 'load_from_reset_password_token is always valid if expiration period is nil' do
-      sorcery_model_property_set(:reset_password_expiration_period, nil)
-      user.generate_reset_password_token!
-      updated_user = User.sorcery_adapter.find(user.id)
-
-      expect(User.load_from_reset_password_token(user.reset_password_token)).to eq updated_user
-    end
-
-    it 'load_from_reset_password_token returns nil if token is blank' do
-      expect(User.load_from_reset_password_token(nil)).to be_nil
-      expect(User.load_from_reset_password_token('')).to be_nil
-    end
-
-    describe '#load_from_reset_password_token' do
-      context 'in block mode' do
-        it 'yields user when token is found' do
-          user.generate_reset_password_token!
-          updated_user = User.sorcery_adapter.find(user.id)
-
-          User.load_from_reset_password_token(user.reset_password_token) do |user2, failure|
-            expect(user2).to eq updated_user
-            expect(failure).to be_nil
-          end
-        end
-
-        it 'does NOT yield user when token is NOT found' do
-          user.generate_reset_password_token!
-
-          User.load_from_reset_password_token('a') do |user2, failure|
-            expect(user2).to be_nil
-            expect(failure).to eq :user_not_found
-          end
-        end
-
-        it 'yields user when token is found and not expired' do
-          sorcery_model_property_set(:reset_password_expiration_period, 500)
-          user.generate_reset_password_token!
-          updated_user = User.sorcery_adapter.find(user.id)
-
-          User.load_from_reset_password_token(user.reset_password_token) do |user2, failure|
-            expect(user2).to eq updated_user
-            expect(failure).to be_nil
-          end
-        end
-
-        it 'yields user and failure reason when token is found and expired' do
-          sorcery_model_property_set(:reset_password_expiration_period, 0.1)
-          user.generate_reset_password_token!
-          Timecop.travel(Time.now.in_time_zone + 0.5)
-
-          User.load_from_reset_password_token(user.reset_password_token) do |user2, failure|
-            expect(user2).to eq user
-            expect(failure).to eq :token_expired
-          end
-        end
-
-        it 'is always valid if expiration period is nil' do
-          sorcery_model_property_set(:reset_password_expiration_period, nil)
-          user.generate_reset_password_token!
-          updated_user = User.sorcery_adapter.find(user.id)
-
-          User.load_from_reset_password_token(user.reset_password_token) do |user2, failure|
-            expect(user2).to eq updated_user
-            expect(failure).to be_nil
-          end
-        end
-
-        it 'returns nil if token is blank' do
-          [nil, ''].each do |token|
-            User.load_from_reset_password_token(token) do |user2, failure|
-              expect(user2).to be_nil
-              expect(failure).to eq :invalid_token
-            end
-          end
-        end
-      end
-    end
-
-    it "'deliver_reset_password_instructions!' generates a reset_password_token" do
-      expect(user.reset_password_token).to be_nil
-
-      user.deliver_reset_password_instructions!
-
-      expect(user.reset_password_token).not_to be_nil
-    end
-
-    it "'deliver_reset_password_instructions! returns a Mail::Message object" do
-      expect(user.deliver_reset_password_instructions!).to be_an_instance_of Mail::Message
-    end
-
-    it 'the reset_password_token is random' do
-      sorcery_model_property_set(:reset_password_time_between_emails, 0)
-      user.deliver_reset_password_instructions!
-      old_password_code = user.reset_password_token
-      user.deliver_reset_password_instructions!
-
-      expect(user.reset_password_token).not_to eq old_password_code
-    end
-
-    describe '#increment_password_reset_page_access_counter' do
-      it 'increments reset_password_page_access_count_attribute_name' do
-        expected_count = user.access_count_to_reset_password_page + 1
-        user.increment_password_reset_page_access_counter
-        expect(user.access_count_to_reset_password_page).to eq expected_count
-      end
-    end
-
-    describe '#reset_password_reset_page_access_counter' do
-      it 'reset reset_password_page_access_count_attribute_name into 0' do
-        user.update(access_count_to_reset_password_page: 10)
-        user.reset_password_reset_page_access_counter
-        expect(user.access_count_to_reset_password_page).to eq 0
-      end
-    end
-
-    context 'mailer is enabled' do
-      it 'sends an email on reset' do
-        old_size = ActionMailer::Base.deliveries.size
-        user.deliver_reset_password_instructions!
-
-        expect(ActionMailer::Base.deliveries.size).to eq old_size + 1
-      end
-
-      it 'calls send_reset_password_email! on reset' do
-        expect(user).to receive(:send_reset_password_email!).once
-
-        user.deliver_reset_password_instructions!
-      end
-
-      it 'does not send an email if time between emails has not passed since last email' do
-        sorcery_model_property_set(:reset_password_time_between_emails, 10_000)
-        old_size = ActionMailer::Base.deliveries.size
-        user.deliver_reset_password_instructions!
-
-        expect(ActionMailer::Base.deliveries.size).to eq old_size + 1
-
-        user.deliver_reset_password_instructions!
-
-        expect(ActionMailer::Base.deliveries.size).to eq old_size + 1
-      end
-
-      it 'sends an email if time between emails has passed since last email' do
-        sorcery_model_property_set(:reset_password_time_between_emails, 0.5)
-        old_size = ActionMailer::Base.deliveries.size
-        user.deliver_reset_password_instructions!
-
-        expect(ActionMailer::Base.deliveries.size).to eq old_size + 1
-
-        Timecop.travel(Time.now.in_time_zone + 0.5)
-        user.deliver_reset_password_instructions!
-
-        expect(ActionMailer::Base.deliveries.size).to eq old_size + 2
-      end
-    end
-
-    context 'mailer is disabled' do
-      before(:all) do
-        sorcery_reload!([:reset_password], reset_password_mailer_disabled: true, reset_password_mailer: ::SorceryMailer)
-      end
-
-      it 'sends an email on reset' do
-        old_size = ActionMailer::Base.deliveries.size
-        user.deliver_reset_password_instructions!
-
-        expect(ActionMailer::Base.deliveries.size).to eq old_size
-      end
-
-      it 'does not call send_reset_password_email! on reset' do
-        expect(user).to receive(:send_reset_password_email!).never
-
-        user.deliver_reset_password_instructions!
-      end
-
-      it 'does not send an email if time between emails has not passed since last email' do
-        sorcery_model_property_set(:reset_password_time_between_emails, 10_000)
-        old_size = ActionMailer::Base.deliveries.size
-        user.deliver_reset_password_instructions!
-
-        expect(ActionMailer::Base.deliveries.size).to eq old_size
-
-        user.deliver_reset_password_instructions!
-
-        expect(ActionMailer::Base.deliveries.size).to eq old_size
-      end
-
-      it 'sends an email if time between emails has passed since last email' do
-        sorcery_model_property_set(:reset_password_time_between_emails, 0.5)
-        old_size = ActionMailer::Base.deliveries.size
-        user.deliver_reset_password_instructions!
-
-        expect(ActionMailer::Base.deliveries.size).to eq old_size
-
-        Timecop.travel(Time.now.in_time_zone + 0.5)
-        user.deliver_reset_password_instructions!
-
-        expect(ActionMailer::Base.deliveries.size).to eq old_size
-      end
-    end
-
-    it 'when change_password! is called, deletes reset_password_token and calls #save!' do
-      user.deliver_reset_password_instructions!
-
-      expect(user.reset_password_token).not_to be_nil
-      expect(user).to_not receive(:save)
-      expect(user).to receive(:save!)
-
-      user.change_password!('blabulsdf')
-
-      expect(user.reset_password_token).to be_nil
-    end
-
-    it 'when change_password! is called with empty argument, raise an exception' do
-      expect {
-        user.change_password!('')
-      }.to raise_error(ArgumentError, 'Blank password passed to change_password!')
-    end
-
-    it 'when change_password! is called with nil argument, raise an exception' do
-      expect {
-        user.change_password!(nil)
-      }.to raise_error(ArgumentError, 'Blank password passed to change_password!')
-    end
-
-    it 'when change_password is called, deletes reset_password_token and calls #save' do
-      new_password = 'blabulsdf'
-
-      user.deliver_reset_password_instructions!
-      expect(user.reset_password_token).not_to be_nil
-      expect(user).to_not receive(:save!)
-      expect(user).to receive(:save)
-
-      user.change_password(new_password)
-
-      expect(user.reset_password_token).to be_nil
-    end
-
-    it 'returns false if time between emails has not passed since last email' do
-      sorcery_model_property_set(:reset_password_time_between_emails, 10_000)
-      user.deliver_reset_password_instructions!
-
-      expect(user.deliver_reset_password_instructions!).to be false
-    end
-
-    it 'encrypts properly on reset' do
-      user.deliver_reset_password_instructions!
-      user.change_password!('blagu')
-
-      expect(Sorcery::CryptoProviders::BCrypt.matches?(user.crypted_password, 'blagu', user.salt)).to be true
-    end
-  end
-end