omniauth-identity 3.0.2 → 3.0.7

data/spec/omniauth/identity/model_spec.rb

@@ -1,123 +1,43 @@
 # frozen_string_literal: true
 
-class ExampleModel
-  include OmniAuth::Identity::Model
-end
-
 RSpec.describe OmniAuth::Identity::Model do
-  context 'Class Methods' do
-    subject { ExampleModel }
-
-    describe '.locate' do
-      it('is abstract') { expect { subject.locate('abc') }.to raise_error(NotImplementedError) }
+  before do
+    identity_test_klass = Class.new do
+      include OmniAuth::Identity::Model
     end
+    stub_const('IdentityTestClass', identity_test_klass)
+  end
 
-    describe '.authenticate' do
-      it 'calls locate and then authenticate' do
-        mocked_instance = double('ExampleModel', authenticate: 'abbadoo')
-        allow(subject).to receive(:locate).with('email' => 'example').and_return(mocked_instance)
-        expect(subject.authenticate({ 'email' => 'example' }, 'pass')).to eq('abbadoo')
-      end
+  describe 'Class Methods' do
+    subject(:model_klass) { IdentityTestClass }
 
-      it 'calls locate with additional scopes when provided' do
-        mocked_instance = double('ExampleModel', authenticate: 'abbadoo')
-        allow(subject).to receive(:locate).with('email' => 'example',
-                                                'user_type' => 'admin').and_return(mocked_instance)
-        expect(subject.authenticate({ 'email' => 'example', 'user_type' => 'admin' }, 'pass')).to eq('abbadoo')
-      end
+    include_context 'model with class methods'
 
-      it 'recovers gracefully if locate is nil' do
-        allow(subject).to receive(:locate).and_return(nil)
-        expect(subject.authenticate('blah', 'foo')).to be false
+    describe '::locate' do
+      it('is abstract') do
+        expect { model_klass.locate('email' => 'example') }.to raise_error(NotImplementedError)
       end
     end
   end
 
-  context 'Instance Methods' do
-    subject { ExampleModel.new }
+  describe 'Instance Methods' do
+    subject(:instance) { IdentityTestClass.new }
 
-    describe '#authenticate' do
-      it('is abstract') { expect { subject.authenticate('abc') }.to raise_error(NotImplementedError) }
-    end
+    include_context 'instance with instance methods'
 
-    describe '#uid' do
-      it 'defaults to #id' do
-        allow(subject).to receive(:respond_to?).with(:id).and_return(true)
-        allow(subject).to receive(:id).and_return 'wakka-do'
-        expect(subject.uid).to eq('wakka-do')
-      end
-
-      it 'stringifies it' do
-        allow(subject).to receive(:id).and_return 123
-        expect(subject.uid).to eq('123')
-      end
-
-      it 'raises NotImplementedError if #id is not defined' do
-        allow(subject).to receive(:respond_to?).with(:id).and_return(false)
-        expect { subject.uid }.to raise_error(NotImplementedError)
-      end
+    describe '#authenticate' do
+      it('is abstract') { expect { instance.authenticate('my-password') }.to raise_error(NotImplementedError) }
     end
 
     describe '#auth_key' do
-      it 'defaults to #email' do
-        allow(subject).to receive(:respond_to?).with(:email).and_return(true)
-        allow(subject).to receive(:email).and_return('bob@bob.com')
-        expect(subject.auth_key).to eq('bob@bob.com')
-      end
-
-      it 'uses the class .auth_key' do
-        subject.class.auth_key 'login'
-        allow(subject).to receive(:login).and_return 'bob'
-        expect(subject.auth_key).to eq('bob')
-        subject.class.auth_key nil
-      end
-
       it 'raises a NotImplementedError if the auth_key method is not defined' do
-        expect { subject.auth_key }.to raise_error(NotImplementedError)
+        expect { instance.auth_key }.to raise_error(NotImplementedError)
       end
     end
 
     describe '#auth_key=' do
-      it 'defaults to setting email' do
-        allow(subject).to receive(:respond_to?).with(:email=).and_return(true)
-        expect(subject).to receive(:email=).with 'abc'
-
-        subject.auth_key = 'abc'
-      end
-
-      it 'uses a custom .auth_key if one is provided' do
-        subject.class.auth_key 'login'
-        allow(subject).to receive(:respond_to?).with(:login=).and_return(true)
-        expect(subject).to receive(:login=).with('abc')
-
-        subject.auth_key = 'abc'
-      end
-
-      it 'raises a NotImplementedError if the autH_key method is not defined' do
-        expect { subject.auth_key = 'broken' }.to raise_error(NotImplementedError)
-      end
-    end
-
-    describe '#info' do
-      it 'includes attributes that are set' do
-        allow(subject).to receive(:name).and_return('Bob Bobson')
-        allow(subject).to receive(:nickname).and_return('bob')
-
-        expect(subject.info).to eq({
-                                     'name' => 'Bob Bobson',
-                                     'nickname' => 'bob'
-                                   })
-      end
-
-      it 'automaticallies set name off of nickname' do
-        allow(subject).to receive(:nickname).and_return('bob')
-        subject.info['name'] == 'bob'
-      end
-
-      it 'does not overwrite a provided name' do
-        allow(subject).to receive(:name).and_return('Awesome Dude')
-        allow(subject).to receive(:first_name).and_return('Frank')
-        expect(subject.info['name']).to eq('Awesome Dude')
+      it 'raises a NotImplementedError if the auth_key method is not defined' do
+        expect { instance.auth_key = 'broken' }.to raise_error(NotImplementedError)
       end
     end
   end

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

@@ -1,11 +1,17 @@
 # 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(
         parent_klass: 'OmniAuth::Identity::Models::ActiveRecord',
-        columns: %w[name provider],
+        columns: OmniAuth::Identity::Model::SCHEMA_ATTRIBUTES | %w[provider password_digest],
         connection_params: { adapter: 'sqlite3', encoding: 'utf8', database: ':memory:' }
       ) do
         def flower
@@ -14,17 +20,20 @@ RSpec.describe(OmniAuth::Identity::Models::ActiveRecord, db: true) do
       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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'sqlite3'
+require 'sequel'
+
+DB = Sequel.sqlite
+
+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
+    end
+    stub_const('SequelTestIdentity', sequel_test_identity)
+  end
+
+  describe 'model', type: :model do
+    subject(:model_klass) { SequelTestIdentity }
+
+    include_context 'persistable model'
+
+    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,14 +1,20 @@
 # 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(
-      columns: %w[name provider],
+      parent_klass: 'OmniAuth::Identity::Models::ActiveRecord',
+      columns: OmniAuth::Identity::Model::SCHEMA_ATTRIBUTES | %w[provider password_digest],
       connection_params: { adapter: 'sqlite3', encoding: 'utf8', database: ':memory:' }
     ) do
       def balloon
@@ -192,7 +198,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',
@@ -203,20 +209,71 @@ RSpec.describe OmniAuth::Strategies::Identity do
         }
       end
 
-      before do
-        allow(anon_ar).to receive('auth_key').and_return('email')
-        m = double(uid: 'abc', name: 'Awesome Dude', email: 'awesome@example.com',
-                   info: { name: 'DUUUUDE!' }, persisted?: true)
-        expect(anon_ar).to receive(:create).with(properties).and_return(m)
-      end
-
       it 'sets the auth hash' do
         post '/auth/identity/register', properties
-        expect(auth_hash['uid']).to eq('abc')
+        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',
@@ -226,16 +283,17 @@ RSpec.describe OmniAuth::Strategies::Identity do
           provider: 'identity'
         }
       end
-      let(:invalid_identity) { double(persisted?: false) }
+      let(:invalid_identity) { double(persisted?: false, save: false) }
 
       before do
-        expect(anon_ar).to receive(:create).with(properties).and_return(invalid_identity)
+        expect(anon_ar).to receive(:new).with(properties).and_return(invalid_identity)
       end
 
       context 'default' do
         it 'shows registration form' do
           post '/auth/identity/register', properties
           expect(last_response.body).to be_include('Register Identity')
+          expect(last_response.body).to be_include('One or more fields were invalid')
         end
       end
 
@@ -250,6 +308,63 @@ RSpec.describe OmniAuth::Strategies::Identity do
           post '/auth/identity/register', properties
           expect(identity_hash).to eq(invalid_identity)
           expect(last_response.body).to be_include("FAIL'DOH!")
+          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

data/spec/spec_helper.rb

@@ -1,20 +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 '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'