oauth2 0.9.2 → 0.9.3

data/lib/oauth2/strategy/password.rb

@@ -8,7 +8,7 @@ module OAuth2
       #
       # @raise [NotImplementedError]
       def authorize_url
-        raise NotImplementedError, "The authorization endpoint is not used in this strategy"
+        fail(NotImplementedError, 'The authorization endpoint is not used in this strategy')
       end
 
       # Retrieve an access token given the specified End User username and password.
@@ -16,7 +16,7 @@ module OAuth2
       # @param [String] username the End User username
       # @param [String] password the End User password
       # @param [Hash] params additional params
-      def get_token(username, password, params={}, opts={})
+      def get_token(username, password, params = {}, opts = {})
         params = {'grant_type' => 'password',
                   'username'   => username,
                   'password'   => password}.merge(client_params).merge(params)

data/lib/oauth2/version.rb

@@ -1,18 +1,15 @@
 module OAuth2
   class Version
-    MAJOR = 0 unless defined? MAJOR
-    MINOR = 9 unless defined? MINOR
-    PATCH = 2 unless defined? PATCH
-    PRE = nil unless defined? PRE
+    MAJOR = 0
+    MINOR = 9
+    PATCH = 3
+    PRE = nil
 
     class << self
-
       # @return [String]
       def to_s
         [MAJOR, MINOR, PATCH, PRE].compact.join('.')
       end
-
     end
-
   end
 end

data/oauth2.gemspec

@@ -5,26 +5,25 @@ require 'oauth2/version'
 
 Gem::Specification.new do |spec|
   spec.add_development_dependency 'bundler', '~> 1.0'
-  spec.add_dependency 'faraday', '~> 0.8'
-  spec.add_dependency 'httpauth', '~> 0.2'
-  spec.add_dependency 'multi_json', '~> 1.0'
+  spec.add_dependency 'faraday', ['>= 0.8', '< 0.10']
+  spec.add_dependency 'multi_json', '~> 1.3'
   spec.add_dependency 'multi_xml', '~> 0.5'
   spec.add_dependency 'rack', '~> 1.2'
-  spec.add_dependency 'jwt', '~> 0.1.4'
-  spec.authors       = ["Michael Bleigh", "Erik Michaels-Ober"]
+  spec.add_dependency 'jwt', '~> 0.1.8'
+  spec.authors       = ['Michael Bleigh', 'Erik Michaels-Ober']
   spec.cert_chain    = %w(certs/sferik.pem)
   spec.description   = %q{A Ruby wrapper for the OAuth 2.0 protocol built with a similar style to the original OAuth spec.}
   spec.email         = ['michael@intridea.com', 'sferik@gmail.com']
   spec.files         = %w(.document CONTRIBUTING.md LICENSE.md README.md Rakefile oauth2.gemspec)
-  spec.files        += Dir.glob("lib/**/*.rb")
-  spec.files        += Dir.glob("spec/**/*")
+  spec.files        += Dir.glob('lib/**/*.rb')
+  spec.files        += Dir.glob('spec/**/*')
   spec.homepage      = 'http://github.com/intridea/oauth2'
   spec.licenses      = ['MIT']
   spec.name          = 'oauth2'
   spec.require_paths = ['lib']
   spec.required_rubygems_version = '>= 1.3.5'
-  spec.signing_key   = File.expand_path("~/.gem/private_key.pem") if $0 =~ /gem\z/
+  spec.signing_key   = File.expand_path('~/.gem/private_key.pem') if $PROGRAM_NAME =~ /gem\z/
   spec.summary       = %q{A Ruby wrapper for the OAuth 2.0 protocol.}
-  spec.test_files    = Dir.glob("spec/**/*")
+  spec.test_files    = Dir.glob('spec/**/*')
   spec.version       = OAuth2::Version
 end

data/spec/helper.rb

@@ -5,7 +5,11 @@ SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
   SimpleCov::Formatter::HTMLFormatter,
   Coveralls::SimpleCov::Formatter
 ]
-SimpleCov.start
+
+SimpleCov.start do
+  add_filter '/spec/'
+  minimum_coverage(95.29)
+end
 
 require 'oauth2'
 require 'addressable/uri'

data/spec/oauth2/access_token_spec.rb

@@ -3,32 +3,32 @@ require 'helper'
 VERBS = [:get, :post, :put, :delete]
 
 describe AccessToken do
-  let(:token) {'monkey'}
-  let(:token_body) {MultiJson.encode(:access_token => 'foo', :expires_in => 600, :refresh_token => 'bar')}
-  let(:refresh_body) {MultiJson.encode(:access_token => 'refreshed_foo', :expires_in => 600, :refresh_token => 'refresh_bar')}
+  let(:token) { 'monkey' }
+  let(:token_body) { MultiJson.encode(:access_token => 'foo', :expires_in => 600, :refresh_token => 'bar') }
+  let(:refresh_body) { MultiJson.encode(:access_token => 'refreshed_foo', :expires_in => 600, :refresh_token => 'refresh_bar') }
   let(:client) do
     Client.new('abc', 'def', :site => 'https://api.example.com') do |builder|
       builder.request :url_encoded
       builder.adapter :test do |stub|
         VERBS.each do |verb|
-          stub.send(verb, '/token/header') {|env| [200, {}, env[:request_headers]['Authorization']]}
-          stub.send(verb, "/token/query?access_token=#{token}") {|env| [200, {}, Addressable::URI.parse(env[:url]).query_values['access_token']]}
-          stub.send(verb, '/token/body') {|env| [200, {}, env[:body]]}
+          stub.send(verb, '/token/header') { |env| [200, {}, env[:request_headers]['Authorization']] }
+          stub.send(verb, "/token/query?access_token=#{token}") { |env| [200, {}, Addressable::URI.parse(env[:url]).query_values['access_token']] }
+          stub.send(verb, '/token/body') { |env| [200, {}, env[:body]] }
         end
-        stub.post('/oauth/token') {|env| [200, {'Content-Type' => 'application/json'}, refresh_body]}
+        stub.post('/oauth/token') { |env| [200, {'Content-Type' => 'application/json'}, refresh_body] }
       end
     end
   end
 
-  subject {AccessToken.new(client, token)}
+  subject { AccessToken.new(client, token) }
 
-  describe "#initialize" do
-    it "assigns client and token" do
+  describe '#initialize' do
+    it 'assigns client and token' do
       expect(subject.client).to eq(client)
       expect(subject.token).to  eq(token)
     end
 
-    it "assigns extra params" do
+    it 'assigns extra params' do
       target = AccessToken.new(client, token, 'foo' => 'bar')
       expect(target.params).to include('foo')
       expect(target.params['foo']).to eq('bar')
@@ -41,26 +41,26 @@ describe AccessToken do
       expect(target.params['foo']).to eq('bar')
     end
 
-    it "initializes with a Hash" do
+    it 'initializes with a Hash' do
       hash = {:access_token => token, :expires_at => Time.now.to_i + 200, 'foo' => 'bar'}
       target = AccessToken.from_hash(client, hash)
       assert_initialized_token(target)
     end
 
-    it "initalizes with a form-urlencoded key/value string" do
-      kvform = "access_token=#{token}&expires_at=#{Time.now.to_i+200}&foo=bar"
+    it 'initalizes with a form-urlencoded key/value string' do
+      kvform = "access_token=#{token}&expires_at=#{Time.now.to_i + 200}&foo=bar"
       target = AccessToken.from_kvform(client, kvform)
       assert_initialized_token(target)
     end
 
-    it "sets options" do
+    it 'sets options' do
       target = AccessToken.new(client, token, :param_name => 'foo', :header_format => 'Bearer %', :mode => :body)
       expect(target.options[:param_name]).to eq('foo')
       expect(target.options[:header_format]).to eq('Bearer %')
       expect(target.options[:mode]).to eq(:body)
     end
 
-    it "initializes with a string expires_at" do
+    it 'initializes with a string expires_at' do
       hash = {:access_token => token, :expires_at => '1361396829', 'foo' => 'bar'}
       target = AccessToken.from_hash(client, hash)
       assert_initialized_token(target)
@@ -68,8 +68,8 @@ describe AccessToken do
     end
   end
 
-  describe "#request" do
-    context ":mode => :header" do
+  describe '#request' do
+    context ':mode => :header' do
       before do
         subject.options[:mode] = :header
       end
@@ -81,7 +81,7 @@ describe AccessToken do
       end
     end
 
-    context ":mode => :query" do
+    context ':mode => :query' do
       before do
         subject.options[:mode] = :query
       end
@@ -93,7 +93,7 @@ describe AccessToken do
       end
     end
 
-    context ":mode => :body" do
+    context ':mode => :body' do
       before do
         subject.options[:mode] = :body
       end
@@ -106,55 +106,55 @@ describe AccessToken do
     end
   end
 
-  describe "#expires?" do
-    it "is false if there is no expires_at" do
+  describe '#expires?' do
+    it 'is false if there is no expires_at' do
       expect(AccessToken.new(client, token)).not_to be_expires
     end
 
-    it "is true if there is an expires_in" do
+    it 'is true if there is an expires_in' do
       expect(AccessToken.new(client, token, :refresh_token => 'abaca', :expires_in => 600)).to be_expires
     end
 
-    it "is true if there is an expires_at" do
-      expect(AccessToken.new(client, token, :refresh_token => 'abaca', :expires_in => Time.now.getutc.to_i+600)).to be_expires
+    it 'is true if there is an expires_at' do
+      expect(AccessToken.new(client, token, :refresh_token => 'abaca', :expires_in => Time.now.getutc.to_i + 600)).to be_expires
     end
   end
 
-  describe "#expired?" do
-    it "is false if there is no expires_in or expires_at" do
+  describe '#expired?' do
+    it 'is false if there is no expires_in or expires_at' do
       expect(AccessToken.new(client, token)).not_to be_expired
     end
 
-    it "is false if expires_in is in the future" do
-      expect(AccessToken.new(client, token, :refresh_token => 'abaca', :expires_in => 10800)).not_to be_expired
+    it 'is false if expires_in is in the future' do
+      expect(AccessToken.new(client, token, :refresh_token => 'abaca', :expires_in => 10_800)).not_to be_expired
     end
 
-    it "is true if expires_at is in the past" do
+    it 'is true if expires_at is in the past' do
       access = AccessToken.new(client, token, :refresh_token => 'abaca', :expires_in => 600)
-      @now = Time.now + 10800
-      Time.stub!(:now).and_return(@now)
+      @now = Time.now + 10_800
+      allow(Time).to receive(:now).and_return(@now)
       expect(access).to be_expired
     end
 
   end
 
-  describe "#refresh!" do
-    let(:access) {
+  describe '#refresh!' do
+    let(:access) do
       AccessToken.new(client, token, :refresh_token  => 'abaca',
                                      :expires_in     => 600,
                                      :param_name     => 'o_param')
-    }
+    end
 
-    it "returns a refresh token with appropriate values carried over" do
+    it 'returns a refresh token with appropriate values carried over' do
       refreshed = access.refresh!
       expect(access.client).to eq(refreshed.client)
       expect(access.options[:param_name]).to eq(refreshed.options[:param_name])
     end
 
-    context "with a nil refresh_token in the response" do
+    context 'with a nil refresh_token in the response' do
       let(:refresh_body) { MultiJson.encode(:access_token => 'refreshed_foo', :expires_in => 600, :refresh_token => nil) }
 
-      it "copies the refresh_token from the original token" do
+      it 'copies the refresh_token from the original token' do
         refreshed = access.refresh!
 
         expect(refreshed.refresh_token).to eq(access.refresh_token)

data/spec/oauth2/client_spec.rb

@@ -1,81 +1,80 @@
 require 'helper'
 
 describe OAuth2::Client do
-  let!(:error_value) {'invalid_token'}
-  let!(:error_description_value) {'bad bad token'}
+  let!(:error_value) { 'invalid_token' }
+  let!(:error_description_value) { 'bad bad token' }
 
   subject do
     OAuth2::Client.new('abc', 'def', :site => 'https://api.example.com') do |builder|
       builder.adapter :test do |stub|
-        stub.get('/success')      {|env| [200, {'Content-Type' => 'text/awesome'}, 'yay']}
-        stub.get('/reflect')      {|env| [200, {}, env[:body]]}
-        stub.post('/reflect')     {|env| [200, {}, env[:body]]}
-        stub.get('/unauthorized') {|env| [401, {'Content-Type' => 'application/json'}, MultiJson.encode(:error => error_value, :error_description => error_description_value)]}
-        stub.get('/conflict')     {|env| [409, {'Content-Type' => 'text/plain'}, 'not authorized']}
-        stub.get('/redirect')     {|env| [302, {'Content-Type' => 'text/plain', 'location' => '/success' }, '']}
-        stub.post('/redirect')    {|env| [303, {'Content-Type' => 'text/plain', 'location' => '/reflect' }, '']}
-        stub.get('/error')        {|env| [500, {'Content-Type' => 'text/plain'}, 'unknown error']}
-        stub.get('/empty_get')    {|env| [204, {}, nil]}
+        stub.get('/success')      { |env| [200, {'Content-Type' => 'text/awesome'}, 'yay'] }
+        stub.get('/reflect')      { |env| [200, {}, env[:body]] }
+        stub.post('/reflect')     { |env| [200, {}, env[:body]] }
+        stub.get('/unauthorized') { |env| [401, {'Content-Type' => 'application/json'}, MultiJson.encode(:error => error_value, :error_description => error_description_value)] }
+        stub.get('/conflict')     { |env| [409, {'Content-Type' => 'text/plain'}, 'not authorized'] }
+        stub.get('/redirect')     { |env| [302, {'Content-Type' => 'text/plain', 'location' => '/success'}, ''] }
+        stub.post('/redirect')    { |env| [303, {'Content-Type' => 'text/plain', 'location' => '/reflect'}, ''] }
+        stub.get('/error')        { |env| [500, {'Content-Type' => 'text/plain'}, 'unknown error'] }
+        stub.get('/empty_get')    { |env| [204, {}, nil] }
       end
     end
   end
 
-  describe "#initialize" do
-    it "assigns id and secret" do
+  describe '#initialize' do
+    it 'assigns id and secret' do
       expect(subject.id).to eq('abc')
       expect(subject.secret).to eq('def')
     end
 
-    it "assigns site from the options hash" do
+    it 'assigns site from the options hash' do
       expect(subject.site).to eq('https://api.example.com')
     end
 
-    it "assigns Faraday::Connection#host" do
+    it 'assigns Faraday::Connection#host' do
       expect(subject.connection.host).to eq('api.example.com')
     end
 
-    it "leaves Faraday::Connection#ssl unset" do
-      expect(subject.connection.ssl).to eq({})
+    it 'leaves Faraday::Connection#ssl unset' do
+      expect(subject.connection.ssl).to be_empty
     end
 
-    it "is able to pass a block to configure the connection" do
-      connection = stub('connection')
-      session = stub('session', :to_ary => nil)
-      builder = stub('builder')
-      connection.stub(:build).and_yield(builder)
-      Faraday::Connection.stub(:new => connection)
+    it 'is able to pass a block to configure the connection' do
+      connection = double('connection')
+      builder = double('builder')
+      allow(connection).to receive(:build).and_yield(builder)
+      allow(Faraday::Connection).to receive(:new).and_return(connection)
 
-      builder.should_receive(:adapter).with(:test)
+      expect(builder).to receive(:adapter).with(:test)
 
-      OAuth2::Client.new('abc', 'def') do |builder|
-        builder.adapter :test
+      OAuth2::Client.new('abc', 'def') do |client|
+        client.adapter :test
       end.connection
     end
 
-    it "defaults raise_errors to true" do
-      expect(subject.options[:raise_errors]).to be_true
+    it 'defaults raise_errors to true' do
+      expect(subject.options[:raise_errors]).to be true
     end
 
-    it "allows true/false for raise_errors option" do
+    it 'allows true/false for raise_errors option' do
       client = OAuth2::Client.new('abc', 'def', :site => 'https://api.example.com', :raise_errors => false)
-      expect(client.options[:raise_errors]).to be_false
+      expect(client.options[:raise_errors]).to be false
       client = OAuth2::Client.new('abc', 'def', :site => 'https://api.example.com', :raise_errors => true)
-      expect(client.options[:raise_errors]).to be_true
+      expect(client.options[:raise_errors]).to be true
     end
 
-    it "allows override of raise_errors option" do
+    it 'allows override of raise_errors option' do
       client = OAuth2::Client.new('abc', 'def', :site => 'https://api.example.com', :raise_errors => true) do |builder|
         builder.adapter :test do |stub|
-          stub.get('/notfound') {|env| [404, {}, nil]}
+          stub.get('/notfound') { |env| [404, {}, nil] }
         end
       end
-      expect(client.options[:raise_errors]).to be_true
-      expect{client.request(:get, '/notfound')}.to raise_error(OAuth2::Error)
+      expect(client.options[:raise_errors]).to be true
+      expect { client.request(:get, '/notfound') }.to raise_error(OAuth2::Error)
       response = client.request(:get, '/notfound', :raise_errors => false)
       expect(response.status).to eq(404)
     end
 
-    it "allows get/post for access_token_method option" do
+    it 'allows get/post for access_token_method option' do
       client = OAuth2::Client.new('abc', 'def', :site => 'https://api.example.com', :access_token_method => :get)
       expect(client.options[:access_token_method]).to eq(:get)
       client = OAuth2::Client.new('abc', 'def', :site => 'https://api.example.com', :access_token_method => :post)
@@ -83,7 +82,7 @@ describe OAuth2::Client do
     end
 
     it 'does not mutate the opts hash argument' do
-      opts = { site: 'http://example.com/' }
+      opts = {:site => 'http://example.com/'}
       opts2 = opts.dup
       OAuth2::Client.new 'abc', 'def', opts
       expect(opts).to eq(opts2)
@@ -101,44 +100,44 @@ describe OAuth2::Client do
         expect(subject.send("#{url_type}_url")).to eq('https://api.example.com/oauth/custom')
       end
 
-      it "allows a different host than the site" do
+      it 'allows a different host than the site' do
         subject.options[:"#{url_type}_url"] = 'https://api.foo.com/oauth/custom'
         expect(subject.send("#{url_type}_url")).to eq('https://api.foo.com/oauth/custom')
       end
     end
   end
 
-  describe "#request" do
-    it "works with a null response body" do
+  describe '#request' do
+    it 'works with a null response body' do
       expect(subject.request(:get, 'empty_get').body).to eq('')
     end
 
-    it "returns on a successful response" do
+    it 'returns on a successful response' do
       response = subject.request(:get, '/success')
       expect(response.body).to eq('yay')
       expect(response.status).to eq(200)
-      expect(response.headers).to eq({'Content-Type' => 'text/awesome'})
+      expect(response.headers).to eq('Content-Type' => 'text/awesome')
     end
 
-    it "posts a body" do
+    it 'posts a body' do
       response = subject.request(:post, '/reflect', :body => 'foo=bar')
       expect(response.body).to eq('foo=bar')
     end
 
-    it "follows redirects properly" do
+    it 'follows redirects properly' do
       response = subject.request(:get, '/redirect')
       expect(response.body).to eq('yay')
       expect(response.status).to eq(200)
-      expect(response.headers).to eq({'Content-Type' => 'text/awesome'})
+      expect(response.headers).to eq('Content-Type' => 'text/awesome')
     end
 
-    it "redirects using GET on a 303" do
+    it 'redirects using GET on a 303' do
       response = subject.request(:post, '/redirect', :body => 'foo=bar')
       expect(response.body).to be_empty
       expect(response.status).to eq(200)
     end
 
-    it "obeys the :max_redirects option" do
+    it 'obeys the :max_redirects option' do
       max_redirects = subject.options[:max_redirects]
       subject.options[:max_redirects] = 0
       response = subject.request(:get, '/redirect')
@@ -146,25 +145,25 @@ describe OAuth2::Client do
       subject.options[:max_redirects] = max_redirects
     end
 
-    it "returns if raise_errors is false" do
+    it 'returns if raise_errors is false' do
       subject.options[:raise_errors] = false
       response = subject.request(:get, '/unauthorized')
 
       expect(response.status).to eq(401)
-      expect(response.headers).to eq({'Content-Type' => 'application/json'})
+      expect(response.headers).to eq('Content-Type' => 'application/json')
       expect(response.error).not_to be_nil
     end
 
     %w(/unauthorized /conflict /error).each do |error_path|
       it "raises OAuth2::Error on error response to path #{error_path}" do
-        expect{subject.request(:get, error_path)}.to raise_error(OAuth2::Error)
+        expect { subject.request(:get, error_path) }.to raise_error(OAuth2::Error)
       end
     end
 
-    it "parses OAuth2 standard error response" do
+    it 'parses OAuth2 standard error response' do
       begin
         subject.request(:get, '/unauthorized')
-      rescue Exception => e
+      rescue StandardError => e
         expect(e.code).to eq(error_value)
         expect(e.description).to eq(error_description_value)
         expect(e.to_s).to match(/#{error_value}/)
@@ -172,25 +171,25 @@ describe OAuth2::Client do
       end
     end
 
-    it "provides the response in the Exception" do
+    it 'provides the response in the Exception' do
       begin
         subject.request(:get, '/error')
-      rescue Exception => e
+      rescue StandardError => e
         expect(e.response).not_to be_nil
         expect(e.to_s).to match(/unknown error/)
       end
     end
   end
 
-  it "instantiates an AuthCode strategy with this client" do
+  it 'instantiates an AuthCode strategy with this client' do
     expect(subject.auth_code).to be_kind_of(OAuth2::Strategy::AuthCode)
   end
 
-  it "instantiates an Implicit strategy with this client" do
+  it 'instantiates an Implicit strategy with this client' do
     expect(subject.implicit).to be_kind_of(OAuth2::Strategy::Implicit)
   end
 
-  context "with SSL options" do
+  context 'with SSL options' do
     subject do
       cli = OAuth2::Client.new('abc', 'def', :site => 'https://api.example.com', :ssl => {:ca_file => 'foo.pem'})
       cli.connection.build do |b|
@@ -199,8 +198,8 @@ describe OAuth2::Client do
       cli
     end
 
-    it "passes the SSL options along to Faraday::Connection#ssl" do
-      expect(subject.connection.ssl).to eq({:ca_file => 'foo.pem'})
+    it 'passes the SSL options along to Faraday::Connection#ssl' do
+      expect(subject.connection.ssl.fetch(:ca_file)).to eq('foo.pem')
     end
   end
 end