omniauth-identity 3.0.4 → 3.0.9

data/spec/omniauth/identity/models/active_record_spec.rb

@@ -1,6 +1,12 @@
 # frozen_string_literal: true
 
-RSpec.describe(OmniAuth::Identity::Models::ActiveRecord, db: true) do
+require 'sqlite3'
+require 'active_record'
+require 'anonymous_active_record'
+
+class TestIdentity < OmniAuth::Identity::Models::ActiveRecord; end
+
+RSpec.describe(OmniAuth::Identity::Models::ActiveRecord, sqlite3: true) do
   describe 'model', type: :model do
     subject(:model_klass) do
       AnonymousActiveRecord.generate(
@@ -8,23 +14,27 @@ RSpec.describe(OmniAuth::Identity::Models::ActiveRecord, db: true) do
         columns: OmniAuth::Identity::Model::SCHEMA_ATTRIBUTES | %w[provider password_digest],
         connection_params: { adapter: 'sqlite3', encoding: 'utf8', database: ':memory:' }
       ) do
+        auth_key :email
         def flower
           '🌸'
         end
       end
     end
 
-    it 'delegates locate to the where query method' do
-      allow(model_klass).to receive(:where).with('ham_sandwich' => 'open faced', 'category' => 'sandwiches',
-                                                 'provider' => 'identity').and_return(['wakka'])
-      expect(model_klass.locate('ham_sandwich' => 'open faced', 'category' => 'sandwiches')).to eq('wakka')
+    include_context 'persistable model'
+
+    describe '::table_name' do
+      it 'does not use STI rules for its table name' do
+        expect(TestIdentity.table_name).to eq('test_identities')
+      end
     end
-  end
 
-  describe '#table_name' do
-    class TestIdentity < OmniAuth::Identity::Models::ActiveRecord; end
-    it 'does not use STI rules for its table name' do
-      expect(TestIdentity.table_name).to eq('test_identities')
+    describe '::locate' do
+      it 'delegates locate to the where query method' do
+        allow(model_klass).to receive(:where).with('email' => 'open faced', 'category' => 'sandwiches',
+                                                   'provider' => 'identity').and_return(['wakka'])
+        expect(model_klass.locate('email' => 'open faced', 'category' => 'sandwiches')).to eq('wakka')
+      end
     end
   end
 end

data/spec/omniauth/identity/models/sequel_spec.rb

@@ -1,23 +1,39 @@
 # frozen_string_literal: true
 
+require 'sqlite3'
 require 'sequel'
-# Connect to an in-memory sqlite3 database.
+
 DB = Sequel.sqlite
-DB.create_table :sequel_test_identities do
-  primary_key :id
-  String :ham_sandwich, null: false
-  String :password_digest, null: false
-end
 
-class SequelTestIdentity < Sequel::Model
-  include OmniAuth::Identity::Models::Sequel
-  auth_key :ham_sandwich
-end
+RSpec.describe(OmniAuth::Identity::Models::Sequel, sqlite3: true) do
+  before(:all) do
+    # Connect to an in-memory sqlite3 database.
+    DB.create_table :sequel_test_identities do
+      primary_key :id
+      String :email, null: false
+      String :password_digest, null: false
+    end
+  end
+
+  before do
+    sequel_test_identity = Class.new(Sequel::Model(:sequel_test_identities)) do
+      include ::OmniAuth::Identity::Models::Sequel
+      auth_key :email
+    end
+    stub_const('SequelTestIdentity', sequel_test_identity)
+  end
+
+  describe 'model', type: :model do
+    subject(:model_klass) { SequelTestIdentity }
+
+    include_context 'persistable model'
 
-RSpec.describe(OmniAuth::Identity::Models::Sequel, db: true) do
-  it 'delegates locate to the where query method' do
-    allow(SequelTestIdentity).to receive(:where).with('ham_sandwich' => 'open faced',
-                                                      'category' => 'sandwiches').and_return(['wakka'])
-    expect(SequelTestIdentity.locate('ham_sandwich' => 'open faced', 'category' => 'sandwiches')).to eq('wakka')
+    describe '::locate' do
+      it 'delegates to the where query method' do
+        allow(model_klass).to receive(:where).with('email' => 'open faced',
+                                                   'category' => 'sandwiches').and_return(['wakka'])
+        expect(model_klass.locate('email' => 'open faced', 'category' => 'sandwiches')).to eq('wakka')
+      end
+    end
   end
 end

data/spec/omniauth/strategies/identity_spec.rb

@@ -1,10 +1,15 @@
 # frozen_string_literal: true
 
-RSpec.describe OmniAuth::Strategies::Identity do
+require 'sqlite3'
+require 'active_record'
+require 'anonymous_active_record'
+
+RSpec.describe OmniAuth::Strategies::Identity, sqlite3: true do
   attr_accessor :app
 
-  let(:auth_hash) { last_response.headers['env']['omniauth.auth'] }
-  let(:identity_hash) { last_response.headers['env']['omniauth.identity'] }
+  let(:env_hash) { last_response.headers['env'] }
+  let(:auth_hash) { env_hash['omniauth.auth'] }
+  let(:identity_hash) { env_hash['omniauth.identity'] }
   let(:identity_options) { {} }
   let(:anon_ar) do
     AnonymousActiveRecord.generate(
@@ -12,6 +17,7 @@ RSpec.describe OmniAuth::Strategies::Identity do
       columns: OmniAuth::Identity::Model::SCHEMA_ATTRIBUTES | %w[provider password_digest],
       connection_params: { adapter: 'sqlite3', encoding: 'utf8', database: ':memory:' }
     ) do
+      auth_key :email
       def balloon
         '🎈'
       end
@@ -193,7 +199,7 @@ RSpec.describe OmniAuth::Strategies::Identity do
       end
     end
 
-    context 'with successful creation' do
+    context 'with good identity' do
       let(:properties) do
         {
           name: 'Awesome Dude',
@@ -209,9 +215,66 @@ RSpec.describe OmniAuth::Strategies::Identity do
         expect(auth_hash['uid']).to match(/\d+/)
         expect(auth_hash['provider']).to eq('identity')
       end
+
+      context 'with on_validation proc' do
+        let(:identity_options) do
+          { model: anon_ar, on_validation: on_validation_proc }
+        end
+        let(:on_validation_proc) do
+          lambda { |_env|
+            false
+          }
+        end
+
+        context 'when validation fails' do
+          it 'does not set the env hash' do
+            post '/auth/identity/register', properties
+            expect(env_hash).to eq(nil)
+          end
+
+          it 'renders registration form' do
+            post '/auth/identity/register', properties
+            expect(last_response.body).to be_include(described_class.default_options[:registration_form_title])
+          end
+
+          it 'displays validation failure message' do
+            post '/auth/identity/register', properties
+            expect(last_response.body).to be_include(described_class.default_options[:validation_failure_message])
+          end
+        end
+
+        context 'when validation succeeds' do
+          let(:on_validation_proc) do
+            lambda { |_env|
+              true
+            }
+          end
+
+          it 'sets the auth hash' do
+            post '/auth/identity/register', properties
+            expect(auth_hash['uid']).to match(/\d+/)
+            expect(auth_hash['provider']).to eq('identity')
+          end
+
+          it 'does not render registration form' do
+            post '/auth/identity/register', properties
+            expect(last_response.body).not_to be_include(described_class.default_options[:registration_form_title])
+          end
+
+          it 'does not display validation failure message' do
+            post '/auth/identity/register', properties
+            expect(last_response.body).not_to be_include(described_class.default_options[:validation_failure_message])
+          end
+
+          it 'does not display registration failure message' do
+            post '/auth/identity/register', properties
+            expect(last_response.body).not_to be_include(described_class.default_options[:registration_failure_message])
+          end
+        end
+      end
     end
 
-    context 'with invalid identity' do
+    context 'with bad identity' do
       let(:properties) do
         {
           name: 'Awesome Dude',
@@ -249,6 +312,62 @@ RSpec.describe OmniAuth::Strategies::Identity do
           expect(last_response.body).not_to be_include('One or more fields were invalid')
         end
       end
+
+      context 'with on_validation proc' do
+        let(:identity_options) do
+          { model: anon_ar, on_validation: on_validation_proc }
+        end
+        let(:on_validation_proc) do
+          lambda { |_env|
+            false
+          }
+        end
+
+        context 'when validation fails' do
+          it 'does not set the env hash' do
+            post '/auth/identity/register', properties
+            expect(env_hash).to eq(nil)
+          end
+
+          it 'renders registration form' do
+            post '/auth/identity/register', properties
+            expect(last_response.body).to be_include(described_class.default_options[:registration_form_title])
+          end
+
+          it 'displays validation failure message' do
+            post '/auth/identity/register', properties
+            expect(last_response.body).to be_include(described_class.default_options[:validation_failure_message])
+          end
+        end
+
+        context 'when validation succeeds' do
+          let(:on_validation_proc) do
+            lambda { |_env|
+              true
+            }
+          end
+
+          it 'does not set the env hash' do
+            post '/auth/identity/register', properties
+            expect(env_hash).to eq(nil)
+          end
+
+          it 'renders registration form' do
+            post '/auth/identity/register', properties
+            expect(last_response.body).to be_include(described_class.default_options[:registration_form_title])
+          end
+
+          it 'does not display validation failure message' do
+            post '/auth/identity/register', properties
+            expect(last_response.body).not_to be_include(described_class.default_options[:validation_failure_message])
+          end
+
+          it 'display registration failure message' do
+            post '/auth/identity/register', properties
+            expect(last_response.body).to be_include(described_class.default_options[:registration_failure_message])
+          end
+        end
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,21 +1,32 @@
 # frozen_string_literal: true
 
+# NOTE: mongoid and no_brainer can't be loaded at the same time.
+#       If you try it, one or both of them will not work.
+#       This is why the ORM specs are split into a separate directory and run in separate threads.
+
+ENV['RUBY_ENV'] = 'test' # Used by NoBrainer
+ENV['MONGOID_ENV'] = 'test' # Used by Mongoid
+
 ruby_version = Gem::Version.new(RUBY_VERSION)
 require 'simplecov' if ruby_version >= Gem::Version.new('2.7') && RUBY_ENGINE == 'ruby'
 
 require 'rack/test'
-require 'mongoid-rspec'
-require 'sqlite3'
-require 'sequel'
-require 'anonymous_active_record'
+require 'rspec/block_is_expected'
 require 'byebug' if RUBY_ENGINE == 'ruby'
 
 # This gem
 require 'omniauth/identity'
 
+spec_root_matcher = %r{#{__dir__}/(.+)\.rb\Z}
+Dir.glob(Pathname.new(__dir__).join('support/**/', '*.rb')).each { |f| require f.match(spec_root_matcher)[1] }
+
+DEFAULT_PASSWORD = 'hang-a-left-at-the-diner'
+DEFAULT_EMAIL = 'mojo@example.com'
+
 RSpec.configure do |config|
   config.include Rack::Test::Methods
-  config.include Mongoid::Matchers, type: :model
+
+  # config.include ::Mongoid::Matchers, db: :mongodb
 
   # Enable flags like --only-failures and --next-failure
   config.example_status_persistence_file_path = '.rspec_status'

data/spec/support/shared_contexts/instance_with_instance_methods.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'instance with instance methods' do
+  describe '#initialize' do
+    it 'does not raise an error' do
+      block_is_expected.not_to raise_error
+    end
+  end
+
+  describe '#uid' do
+    it 'defaults to #id' do
+      allow(instance).to receive(:respond_to?).with(:id).and_return(true)
+      allow(instance).to receive(:id).and_return 'wakka-do'
+      expect(instance.uid).to eq('wakka-do')
+    end
+
+    it 'stringifies it' do
+      allow(instance).to receive(:id).and_return 123
+      expect(instance.uid).to eq('123')
+    end
+
+    it 'raises NotImplementedError if #id is not defined' do
+      allow(instance).to receive(:respond_to?).with(:id).and_return(false)
+      expect { instance.uid }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#auth_key' do
+    it 'defaults to #email' do
+      allow(instance).to receive(:respond_to?).with(:email).and_return(true)
+      allow(instance).to receive(:email).and_return('bob@bob.com')
+      expect(instance.auth_key).to eq('bob@bob.com')
+    end
+
+    it 'uses the class .auth_key' do
+      instance.class.auth_key 'login'
+      allow(instance).to receive(:login).and_return 'bob'
+      expect(instance.auth_key).to eq('bob')
+      instance.class.auth_key nil
+    end
+  end
+
+  describe '#auth_key=' do
+    it 'defaults to setting email' do
+      allow(instance).to receive(:respond_to?).with(:email=).and_return(true)
+      expect(instance).to receive(:email=).with 'abc'
+
+      instance.auth_key = 'abc'
+    end
+
+    it 'uses a custom .auth_key if one is provided' do
+      instance.class.auth_key 'login'
+      allow(instance).to receive(:respond_to?).with(:login=).and_return(true)
+      expect(instance).to receive(:login=).with('abc')
+
+      instance.auth_key = 'abc'
+    end
+  end
+
+  describe '#info' do
+    it 'includes all attributes as they have been set' do
+      allow(instance).to receive(:name).and_return('Bob Bobson')
+      allow(instance).to receive(:nickname).and_return('bob')
+
+      expect(instance.info).to include({
+                                         'name' => 'Bob Bobson',
+                                         'nickname' => 'bob'
+                                       })
+    end
+
+    it 'uses firstname and lastname, over nickname, to set missing name' do
+      allow(instance).to receive(:first_name).and_return('shoeless')
+      allow(instance).to receive(:last_name).and_return('joe')
+      allow(instance).to receive(:nickname).and_return('george')
+      instance.info['name'] == 'shoeless joe'
+    end
+
+    it 'uses nickname to set missing name when first and last are not set' do
+      allow(instance).to receive(:nickname).and_return('bob')
+      instance.info['name'] == 'bob'
+    end
+
+    it 'does not overwrite a provided name' do
+      allow(instance).to receive(:name).and_return('Awesome Dude')
+      allow(instance).to receive(:first_name).and_return('Frank')
+      expect(instance.info['name']).to eq('Awesome Dude')
+    end
+  end
+end

data/spec/support/shared_contexts/model_with_class_methods.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'model with class methods' do
+  describe 'class definition' do
+    it 'does not raise an error' do
+      block_is_expected.not_to raise_error
+    end
+  end
+
+  describe '::authenticate' do
+    it 'calls locate and then authenticate' do
+      mocked_instance = double('ExampleModel', authenticate: 'abbadoo')
+      allow(model_klass).to receive(:locate).with('email' => 'example').and_return(mocked_instance)
+      expect(model_klass.authenticate({ 'email' => 'example' }, 'pass')).to eq('abbadoo')
+    end
+
+    it 'calls locate with additional scopes when provided' do
+      mocked_instance = double('ExampleModel', authenticate: 'abbadoo')
+      allow(model_klass).to receive(:locate).with('email' => 'example',
+                                                  'user_type' => 'admin').and_return(mocked_instance)
+      expect(model_klass.authenticate({ 'email' => 'example', 'user_type' => 'admin' }, 'pass')).to eq('abbadoo')
+    end
+
+    it 'recovers gracefully if locate is nil' do
+      allow(model_klass).to receive(:locate).and_return(nil)
+      expect(model_klass.authenticate('blah', 'foo')).to be false
+    end
+  end
+end

data/spec/support/shared_contexts/persistable_model.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+RSpec.shared_context 'persistable model' do
+  include_context 'model with class methods'
+
+  describe 'instance methods' do
+    subject(:instance) { model_klass.new }
+
+    include_context 'instance with instance methods'
+
+    describe '#save' do
+      subject(:save) do
+        instance.email = DEFAULT_EMAIL
+        instance.password = DEFAULT_PASSWORD
+        instance.password_confirmation = DEFAULT_PASSWORD
+        instance.save
+      end
+
+      it 'does not raise an error' do
+        save
+      end
+    end
+  end
+end