omniauth 1.1.4 → 1.2.1

data/lib/omniauth/test.rb

@@ -1,12 +1,8 @@
 module OmniAuth
-
   # Support for testing OmniAuth strategies.
   module Test
-
     autoload :PhonySession,     'omniauth/test/phony_session'
     autoload :StrategyMacros,   'omniauth/test/strategy_macros'
     autoload :StrategyTestCase, 'omniauth/test/strategy_test_case'
-
   end
-
 end

data/lib/omniauth/test/phony_session.rb

@@ -1,5 +1,8 @@
 class OmniAuth::Test::PhonySession
-  def initialize(app); @app = app end
+  def initialize(app)
+    @app = app
+  end
+
   def call(env)
     @session ||= (env['rack.session'] || {})
     env['rack.session'] = @session

data/lib/omniauth/test/strategy_macros.rb

@@ -1,11 +1,8 @@
 module OmniAuth
-
   module Test
-
     module StrategyMacros
-
       def sets_an_auth_hash
-        it "sets an auth hash" do
+        it 'sets an auth hash' do
           expect(last_request.env['omniauth.auth']).to be_kind_of(Hash)
         end
       end
@@ -28,7 +25,5 @@ module OmniAuth
         end
       end
     end
-
   end
-
 end

data/lib/omniauth/test/strategy_test_case.rb

@@ -2,9 +2,7 @@ require 'rack'
 require 'omniauth/test'
 
 module OmniAuth
-
   module Test
-
     # Support for testing OmniAuth strategies.
     #
     # @example Usage
@@ -19,15 +17,14 @@ module OmniAuth
     #     end
     #   end
     module StrategyTestCase
-
       def app
-        strat = self.strategy
-        resp = self.app_response
-        Rack::Builder.new {
-          use OmniAuth::Test::PhonySession
-          use *strat
-          run lambda {|env| [404, {'Content-Type' => 'text/plain'}, [resp || env.key?('omniauth.auth').to_s]] }
-        }.to_app
+        strat = strategy
+        resp = app_response
+        Rack::Builder.new do
+          use(OmniAuth::Test::PhonySession)
+          use(*strat)
+          run lambda { |env| [404, {'Content-Type' => 'text/plain'}, [resp || env.key?('omniauth.auth').to_s]] }
+        end.to_app
       end
 
       def app_response
@@ -39,11 +36,9 @@ module OmniAuth
       end
 
       def strategy
-        raise NotImplementedError.new('Including specs must define #strategy')
+        error = NotImplementedError.new('Including specs must define #strategy')
+        fail(error)
       end
-
     end
-
   end
-
 end

data/lib/omniauth/version.rb

@@ -1,3 +1,3 @@
 module OmniAuth
-  VERSION = "1.1.4" unless defined?(OmniAuth::VERSION)
+  VERSION = '1.2.1'
 end

data/omniauth.gemspec

@@ -5,22 +5,20 @@ require 'omniauth/version'
 
 Gem::Specification.new do |spec|
   spec.add_dependency 'hashie', ['>= 1.2', '< 3']
-  spec.add_dependency 'rack'
+  spec.add_dependency 'rack', '~> 1.0'
   spec.add_development_dependency 'bundler', '~> 1.0'
   spec.authors       = ['Michael Bleigh', 'Erik Michaels-Ober']
   spec.cert_chain    = %w(certs/sferik.pem)
   spec.description   = %q{A generalized Rack framework for multiple-provider authentication.}
   spec.email         = ['michael@intridea.com', 'sferik@gmail.com']
-  spec.files         = %w(.yardopts LICENSE.md README.md Rakefile omniauth.gemspec)
-  spec.files        += Dir.glob("lib/**/*.rb")
-  spec.files        += Dir.glob("spec/**/*")
+  spec.files         = `git ls-files`.split($/)
   spec.homepage      = 'http://github.com/intridea/omniauth'
   spec.licenses      = ['MIT']
   spec.name          = 'omniauth'
   spec.require_paths = ['lib']
-  spec.required_rubygems_version = '>= 1.3.6'
-  spec.signing_key   = File.expand_path("~/.gem/private_key.pem") if $0 =~ /gem\z/
+  spec.required_rubygems_version = '>= 1.3.5'
+  spec.signing_key   = File.expand_path('~/.gem/private_key.pem') if $PROGRAM_NAME =~ /gem\z/
   spec.summary       = spec.description
-  spec.test_files    = Dir.glob("spec/**/*")
+  spec.test_files    = spec.files.grep(%r{^spec/})
   spec.version       = OmniAuth::VERSION
 end

data/spec/helper.rb

@@ -5,14 +5,17 @@ SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
   SimpleCov::Formatter::HTMLFormatter,
   Coveralls::SimpleCov::Formatter
 ]
-SimpleCov.start
+SimpleCov.start do
+  add_filter '/spec/'
+  minimum_coverage(93.05)
+end
 
 require 'rspec'
 require 'rack/test'
 require 'omniauth'
 require 'omniauth/test'
 
-OmniAuth.config.logger = Logger.new("/dev/null")
+OmniAuth.config.logger = Logger.new('/dev/null')
 
 RSpec.configure do |config|
   config.include Rack::Test::Methods
@@ -24,23 +27,29 @@ end
 
 class ExampleStrategy
   include OmniAuth::Strategy
-  option :name, 'test'
-  def call(env); self.call!(env) end
   attr_reader :last_env
+  option :name, 'test'
+
+  def call(env)
+    self.call!(env)
+  end
+
   def initialize(*args, &block)
     super
     @fail = nil
   end
+
   def request_phase
     @fail = fail!(options[:failure]) if options[:failure]
     @last_env = env
     return @fail if @fail
-    raise "Request Phase"
+    fail('Request Phase')
   end
+
   def callback_phase
     @fail = fail!(options[:failure]) if options[:failure]
     @last_env = env
     return @fail if @fail
-    raise "Callback Phase"
+    fail('Callback Phase')
   end
 end

data/spec/omniauth/auth_hash_spec.rb

@@ -1,106 +1,109 @@
 require 'helper'
 
 describe OmniAuth::AuthHash do
-  subject{ OmniAuth::AuthHash.new }
-  it "converts a supplied info key into an InfoHash object" do
+  subject { OmniAuth::AuthHash.new }
+  it 'converts a supplied info key into an InfoHash object' do
     subject.info = {:first_name => 'Awesome'}
     expect(subject.info).to be_kind_of(OmniAuth::AuthHash::InfoHash)
     expect(subject.info.first_name).to eq('Awesome')
   end
 
-  describe "#valid?" do
-    subject{ OmniAuth::AuthHash.new(:uid => '123', :provider => 'example', :info => {:name => 'Steven'}) }
+  describe '#valid?' do
+    subject { OmniAuth::AuthHash.new(:uid => '123', :provider => 'example', :info => {:name => 'Steven'}) }
 
-    it "is valid with the right parameters" do
+    it 'is valid with the right parameters' do
       expect(subject).to be_valid
     end
 
-    it "requires a uid" do
+    it 'requires a uid' do
       subject.uid = nil
       expect(subject).not_to be_valid
     end
 
-    it "requires a provider" do
+    it 'requires a provider' do
       subject.provider = nil
       expect(subject).not_to be_valid
     end
 
-    it "requires a name in the user info hash" do
+    it 'requires a name in the user info hash' do
       subject.info.name = nil
       expect(subject).not_to be_valid?
     end
   end
 
-  describe "#name" do
-    subject{ OmniAuth::AuthHash.new(
-      :info => {
-        :name => 'Phillip J. Fry',
-        :first_name => 'Phillip',
-        :last_name => 'Fry',
-        :nickname => 'meatbag',
-        :email => 'fry@planetexpress.com'
-    })}
-
-    it "defaults to the name key" do
+  describe '#name' do
+    subject do
+      OmniAuth::AuthHash.new(
+        :info => {
+          :name => 'Phillip J. Fry',
+          :first_name => 'Phillip',
+          :last_name => 'Fry',
+          :nickname => 'meatbag',
+          :email => 'fry@planetexpress.com',
+        }
+      )
+    end
+
+    it 'defaults to the name key' do
       expect(subject.info.name).to eq('Phillip J. Fry')
     end
 
-    it "falls back to go to first_name last_name concatenation" do
+    it 'falls back to go to first_name last_name concatenation' do
       subject.info.name = nil
       expect(subject.info.name).to eq('Phillip Fry')
     end
 
-    it "displays only a first or last name if only that is available" do
+    it 'displays only a first or last name if only that is available' do
       subject.info.name = nil
       subject.info.first_name = nil
       expect(subject.info.name).to eq('Fry')
     end
 
-    it "displays the nickname if no name, first, or last is available" do
+    it 'displays the nickname if no name, first, or last is available' do
       subject.info.name = nil
-      %w(first_name last_name).each{|k| subject.info[k] = nil}
+      %w(first_name last_name).each { |k| subject.info[k] = nil }
       expect(subject.info.name).to eq('meatbag')
     end
 
-    it "displays the email if no name, first, last, or nick is available" do
+    it 'displays the email if no name, first, last, or nick is available' do
       subject.info.name = nil
-      %w(first_name last_name nickname).each{|k| subject.info[k] = nil}
+      %w(first_name last_name nickname).each { |k| subject.info[k] = nil }
       expect(subject.info.name).to eq('fry@planetexpress.com')
     end
   end
 
-  describe "#to_hash" do
-    subject{ OmniAuth::AuthHash.new(:uid => '123', :provider => 'test', :name => 'Bob Example')}
-    let(:hash){ subject.to_hash }
+  describe '#to_hash' do
+    subject { OmniAuth::AuthHash.new(:uid => '123', :provider => 'test', :name => 'Example User') }
+    let(:hash) { subject.to_hash }
 
-    it "is a plain old hash" do
+    it 'is a plain old hash' do
       expect(hash.class).to eq(::Hash)
     end
 
-    it "has string keys" do
+    it 'has string keys' do
       expect(hash.keys).to be_include('uid')
     end
 
-    it "converts an info hash as well" do
-      subject.info = {:first_name => 'Bob', :last_name => 'Example'}
+    it 'converts an info hash as well' do
+      subject.info = {:first_name => 'Example', :last_name => 'User'}
       expect(subject.info.class).to eq(OmniAuth::AuthHash::InfoHash)
       expect(subject.to_hash['info'].class).to eq(::Hash)
     end
 
-    it "supplies the calculated name in the converted hash" do
-      subject.info = {:first_name => 'Bob', :last_name => 'Examplar'}
-      expect(hash['info']['name']).to eq('Bob Examplar')
+    it 'supplies the calculated name in the converted hash' do
+      subject.info = {:first_name => 'Examplar', :last_name => 'User'}
+      expect(hash['info']['name']).to eq('Examplar User')
     end
 
     it "does not pollute the URL hash with 'name' etc" do
-      subject.info = {'urls' => {'Homepage' => "http://homepage.com"}}
-      expect(subject.to_hash['info']['urls']).to eq({'Homepage' => "http://homepage.com"})
+      subject.info = {'urls' => {'Homepage' => 'http://homepage.com'}}
+      expect(subject.to_hash['info']['urls']).to eq('Homepage' => 'http://homepage.com')
     end
   end
 
   describe OmniAuth::AuthHash::InfoHash do
-    describe "#valid?" do
-      it "is valid if there is a name" do
+    describe '#valid?' do
+      it 'is valid if there is a name' do
         expect(OmniAuth::AuthHash::InfoHash.new(:name => 'Awesome')).to be_valid
       end
     end

data/spec/omniauth/builder_spec.rb

@@ -1,47 +1,47 @@
 require 'helper'
 
 describe OmniAuth::Builder do
-  describe "#provider" do
-    it "translates a symbol to a constant" do
-      OmniAuth::Strategies.should_receive(:const_get).with('MyStrategy').and_return(Class.new)
+  describe '#provider' do
+    it 'translates a symbol to a constant' do
+      expect(OmniAuth::Strategies).to receive(:const_get).with('MyStrategy').and_return(Class.new)
       OmniAuth::Builder.new(nil) do
         provider :my_strategy
       end
     end
 
-    it "accepts a class" do
+    it 'accepts a class' do
       class ::ExampleClass; end
 
-      expect{
+      expect do
         OmniAuth::Builder.new(nil) do
           provider ::ExampleClass
         end
-      }.not_to raise_error
+      end.not_to raise_error
     end
 
     it "raises a helpful LoadError message if it can't find the class" do
-      expect {
+      expect do
         OmniAuth::Builder.new(nil) do
           provider :lorax
         end
-      }.to raise_error(LoadError, "Could not find matching strategy for :lorax. You may need to install an additional gem (such as omniauth-lorax).")
+      end.to raise_error(LoadError, 'Could not find matching strategy for :lorax. You may need to install an additional gem (such as omniauth-lorax).')
     end
   end
 
-  describe "#options" do
-    it "merges provided options in" do
+  describe '#options' do
+    it 'merges provided options in' do
       k = Class.new
       b = OmniAuth::Builder.new(nil)
-      b.should_receive(:use).with(k, :foo => 'bar', :baz => 'tik')
+      expect(b).to receive(:use).with(k, :foo => 'bar', :baz => 'tik')
 
       b.options :foo => 'bar'
       b.provider k, :baz => 'tik'
     end
 
-    it "adds an argument if no options are provided" do
+    it 'adds an argument if no options are provided' do
       k = Class.new
       b = OmniAuth::Builder.new(nil)
-      b.should_receive(:use).with(k, :foo => 'bar')
+      expect(b).to receive(:use).with(k, :foo => 'bar')
 
       b.options :foo => 'bar'
       b.provider k

data/spec/omniauth/failure_endpoint_spec.rb

@@ -1,50 +1,55 @@
 require 'helper'
 
 describe OmniAuth::FailureEndpoint do
-  subject{ OmniAuth::FailureEndpoint }
+  subject { OmniAuth::FailureEndpoint }
 
-  context "development" do
+  context 'raise-out environment' do
     before do
       @rack_env = ENV['RACK_ENV']
-      ENV['RACK_ENV'] = 'development'
+      ENV['RACK_ENV'] = 'test'
+
+      @default = OmniAuth.config.failure_raise_out_environments
+      OmniAuth.config.failure_raise_out_environments = ['test']
     end
 
-    it "raises out the error" do
+    it 'raises out the error' do
       expect do
-        subject.call('omniauth.error' => StandardError.new("Blah"))
-      end.to raise_error(StandardError, "Blah")
+        subject.call('omniauth.error' => StandardError.new('Blah'))
+      end.to raise_error(StandardError, 'Blah')
     end
 
-    it "raises out an OmniAuth::Error if no omniauth.error is set" do
-      expect{ subject.call('omniauth.error.type' => 'example') }.to raise_error(OmniAuth::Error, "example")
+    it 'raises out an OmniAuth::Error if no omniauth.error is set' do
+      expect { subject.call('omniauth.error.type' => 'example') }.to raise_error(OmniAuth::Error, 'example')
     end
 
     after do
       ENV['RACK_ENV'] = @rack_env
+      OmniAuth.config.failure_raise_out_environments = @default
     end
   end
 
-  context "non-development" do
-    let(:env){ {'omniauth.error.type' => 'invalid_request',
-                'omniauth.error.strategy' => ExampleStrategy.new({}) } }
+  context 'non-raise-out environment' do
+    let(:env) do
+      {'omniauth.error.type' => 'invalid_request', 'omniauth.error.strategy' => ExampleStrategy.new({})}
+    end
 
-    it "is a redirect" do
+    it 'is a redirect' do
       status, _, _ = *subject.call(env)
       expect(status).to eq(302)
     end
 
-    it "includes the SCRIPT_NAME" do
+    it 'includes the SCRIPT_NAME' do
       _, head, _ = *subject.call(env.merge('SCRIPT_NAME' => '/random'))
       expect(head['Location']).to eq('/random/auth/failure?message=invalid_request&strategy=test')
     end
 
-    it "respects the configured path prefix" do
-      OmniAuth.config.stub(:path_prefix => '/boo')
+    it 'respects the configured path prefix' do
+      allow(OmniAuth.config).to receive(:path_prefix).and_return('/boo')
       _, head, _ = *subject.call(env)
-      expect(head["Location"]).to eq('/boo/failure?message=invalid_request&strategy=test')
+      expect(head['Location']).to eq('/boo/failure?message=invalid_request&strategy=test')
     end
 
-    it "includes the origin (escaped) if one is provided" do
+    it 'includes the origin (escaped) if one is provided' do
       env.merge! 'omniauth.origin' => '/origin-example'
       _, head, _ = *subject.call(env)
       expect(head['Location']).to be_include('&origin=%2Forigin-example')