omniauth-identity 3.0.8 → 3.1.0

data/spec/omniauth/identity/model_spec.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe OmniAuth::Identity::Model do
-  before do
-    identity_test_klass = Class.new do
-      include OmniAuth::Identity::Model
-    end
-    stub_const('IdentityTestClass', identity_test_klass)
-  end
-
-  describe 'Class Methods' do
-    subject(:model_klass) { IdentityTestClass }
-
-    include_context 'model with class methods'
-
-    describe '::locate' do
-      it('is abstract') do
-        expect { model_klass.locate('email' => 'example') }.to raise_error(NotImplementedError)
-      end
-    end
-  end
-
-  describe 'Instance Methods' do
-    subject(:instance) { IdentityTestClass.new }
-
-    include_context 'instance with instance methods'
-
-    describe '#authenticate' do
-      it('is abstract') { expect { instance.authenticate('my-password') }.to raise_error(NotImplementedError) }
-    end
-
-    describe '#auth_key' do
-      it 'raises a NotImplementedError if the auth_key method is not defined' do
-        expect { instance.auth_key }.to raise_error(NotImplementedError)
-      end
-    end
-
-    describe '#auth_key=' do
-      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
-end

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

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-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: OmniAuth::Identity::Model::SCHEMA_ATTRIBUTES | %w[provider password_digest],
-        connection_params: { adapter: 'sqlite3', encoding: 'utf8', database: ':memory:' }
-      ) do
-        def flower
-          '🌸'
-        end
-      end
-    end
-
-    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
-
-    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,38 +0,0 @@
-# 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/identity/secure_password_spec.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-class HasTheMethod
-  def self.has_secure_password; end
-end
-
-class DoesNotHaveTheMethod
-end
-
-RSpec.describe OmniAuth::Identity::SecurePassword do
-  it 'extends with the class methods if it does not have the method' do
-    expect(DoesNotHaveTheMethod).to receive(:extend).with(OmniAuth::Identity::SecurePassword::ClassMethods)
-    DoesNotHaveTheMethod.include described_class
-  end
-
-  it 'does not extend if the method is already defined' do
-    expect(HasTheMethod).not_to receive(:extend)
-    HasTheMethod.include described_class
-  end
-
-  it 'responds to has_secure_password afterwards' do
-    [HasTheMethod, DoesNotHaveTheMethod].each do |klass|
-      klass.send(:include, described_class)
-      expect(klass).to be_respond_to(:has_secure_password)
-    end
-  end
-end

data/spec/omniauth/strategies/identity_spec.rb

@@ -1,372 +0,0 @@
-# frozen_string_literal: true
-
-require 'sqlite3'
-require 'active_record'
-require 'anonymous_active_record'
-
-RSpec.describe OmniAuth::Strategies::Identity, sqlite3: true do
-  attr_accessor :app
-
-  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(
-      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
-        '🎈'
-      end
-    end
-  end
-
-  # customize rack app for testing, if block is given, reverts to default
-  # rack app after testing is done
-  def set_app!(identity_options = {})
-    old_app = app
-    self.app = Rack::Builder.app do
-      use Rack::Session::Cookie, secret: '1234567890qwertyuiop'
-      use OmniAuth::Strategies::Identity, identity_options
-      run ->(env) { [404, { 'env' => env }, ['HELLO!']] }
-    end
-    if block_given?
-      yield
-      self.app = old_app
-    end
-    app
-  end
-
-  before do
-    opts = identity_options.reverse_merge({ model: anon_ar })
-    set_app!(opts)
-  end
-
-  describe '#request_phase' do
-    context 'with default settings' do
-      let(:identity_options) { { model: anon_ar } }
-
-      it 'displays a form' do
-        get '/auth/identity'
-
-        expect(last_response.body).not_to eq('HELLO!')
-        expect(last_response.body).to be_include('<form')
-      end
-    end
-
-    context 'when login is enabled' do
-      context 'when registration is enabled' do
-        let(:identity_options) { { model: anon_ar, enable_registration: true, enable_login: true } }
-
-        it 'displays a form with a link to register' do
-          get '/auth/identity'
-
-          expect(last_response.body).not_to eq('HELLO!')
-          expect(last_response.body).to be_include('<form')
-          expect(last_response.body).to be_include('<a')
-          expect(last_response.body).to be_include('Create an Identity')
-        end
-      end
-
-      context 'when registration is disabled' do
-        let(:identity_options) { { model: anon_ar, enable_registration: false, enable_login: true } }
-
-        it 'displays a form without a link to register' do
-          get '/auth/identity'
-
-          expect(last_response.body).not_to eq('HELLO!')
-          expect(last_response.body).to be_include('<form')
-          expect(last_response.body).not_to be_include('<a')
-          expect(last_response.body).not_to be_include('Create an Identity')
-        end
-      end
-    end
-
-    context 'when login is disabled' do
-      context 'when registration is enabled' do
-        let(:identity_options) { { model: anon_ar, enable_registration: true, enable_login: false } }
-
-        it 'bypasses registration form' do
-          get '/auth/identity'
-
-          expect(last_response.body).to eq('HELLO!')
-          expect(last_response.body).not_to be_include('<form')
-          expect(last_response.body).not_to be_include('<a')
-          expect(last_response.body).not_to be_include('Create an Identity')
-        end
-      end
-
-      context 'when registration is disabled' do
-        let(:identity_options) { { model: anon_ar, enable_registration: false, enable_login: false } }
-
-        it 'displays a form without a link to register' do
-          get '/auth/identity'
-
-          expect(last_response.body).to eq('HELLO!')
-          expect(last_response.body).not_to be_include('<form')
-          expect(last_response.body).not_to be_include('<a')
-          expect(last_response.body).not_to be_include('Create an Identity')
-        end
-      end
-    end
-  end
-
-  describe '#callback_phase' do
-    let(:user) { double(uid: 'user1', info: { 'name' => 'Rockefeller' }) }
-
-    context 'with valid credentials' do
-      before do
-        allow(anon_ar).to receive('auth_key').and_return('email')
-        expect(anon_ar).to receive('authenticate').with({ 'email' => 'john' }, 'awesome').and_return(user)
-        post '/auth/identity/callback', auth_key: 'john', password: 'awesome'
-      end
-
-      it 'populates the auth hash' do
-        expect(auth_hash).to be_kind_of(Hash)
-      end
-
-      it 'populates the uid' do
-        expect(auth_hash['uid']).to eq('user1')
-      end
-
-      it 'populates the info hash' do
-        expect(auth_hash['info']).to eq({ 'name' => 'Rockefeller' })
-      end
-    end
-
-    context 'with invalid credentials' do
-      before do
-        allow(anon_ar).to receive('auth_key').and_return('email')
-        OmniAuth.config.on_failure = ->(env) { [401, {}, [env['omniauth.error.type'].inspect]] }
-        expect(anon_ar).to receive(:authenticate).with({ 'email' => 'wrong' }, 'login').and_return(false)
-        post '/auth/identity/callback', auth_key: 'wrong', password: 'login'
-      end
-
-      it 'fails with :invalid_credentials' do
-        expect(last_response.body).to eq(':invalid_credentials')
-      end
-    end
-
-    context 'with auth scopes' do
-      let(:identity_options) do
-        { model: anon_ar, locate_conditions: lambda { |req|
-                                               { model.auth_key => req['auth_key'], 'user_type' => 'admin' }
-                                             } }
-      end
-
-      it 'evaluates and pass through conditions proc' do
-        allow(anon_ar).to receive('auth_key').and_return('email')
-        expect(anon_ar).to receive('authenticate').with({ 'email' => 'john', 'user_type' => 'admin' },
-                                                        'awesome').and_return(user)
-        post '/auth/identity/callback', auth_key: 'john', password: 'awesome'
-      end
-    end
-  end
-
-  describe '#registration_form' do
-    context 'registration is enabled' do
-      it 'triggers from /auth/identity/register by default' do
-        get '/auth/identity/register'
-        expect(last_response.body).to be_include('Register Identity')
-      end
-    end
-
-    context 'registration is disabled' do
-      let(:identity_options) { { model: anon_ar, enable_registration: false } }
-
-      it 'calls app' do
-        get '/auth/identity/register'
-        expect(last_response.body).to be_include('HELLO!')
-      end
-    end
-
-    it 'supports methods other than GET and POST' do
-      head '/auth/identity/register'
-      expect(last_response.status).to eq(404)
-    end
-  end
-
-  describe '#registration_phase' do
-    context 'registration is disabled' do
-      let(:identity_options) { { model: anon_ar, enable_registration: false } }
-
-      it 'calls app' do
-        post '/auth/identity/register'
-        expect(last_response.body).to eq('HELLO!')
-      end
-    end
-
-    context 'with good identity' do
-      let(:properties) do
-        {
-          name: 'Awesome Dude',
-          email: 'awesome@example.com',
-          password: 'face',
-          password_confirmation: 'face',
-          provider: 'identity'
-        }
-      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
-
-      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 bad identity' do
-      let(:properties) do
-        {
-          name: 'Awesome Dude',
-          email: 'awesome@example.com',
-          password: 'NOT',
-          password_confirmation: 'MATCHING',
-          provider: 'identity'
-        }
-      end
-      let(:invalid_identity) { double(persisted?: false, save: false) }
-
-      before do
-        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
-
-      context 'custom on_failed_registration endpoint' do
-        let(:identity_options) do
-          { model: anon_ar, on_failed_registration: lambda { |env|
-                                                      [404, { 'env' => env }, ["FAIL'DOH!"]]
-                                                    } }
-        end
-
-        it 'sets the identity hash' 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
-  end
-end

data/spec/spec_helper.rb

@@ -1,40 +0,0 @@
-# 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 '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, db: :mongodb
-
-  # Enable flags like --only-failures and --next-failure
-  config.example_status_persistence_file_path = '.rspec_status'
-
-  # Disable RSpec exposing methods globally on `Module` and `main`
-  config.disable_monkey_patching!
-
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-end

data/spec/support/shared_contexts/instance_with_instance_methods.rb

@@ -1,89 +0,0 @@
-# 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

@@ -1,29 +0,0 @@
-# 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