oauth2 1.0.0 → 1.1.0

data/Rakefile

@@ -1,39 +0,0 @@
-require 'bundler'
-Bundler::GemHelper.install_tasks
-
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:spec)
-
-task :test => :spec
-
-namespace :doc do
-  require 'rdoc/task'
-  require File.expand_path('../lib/oauth2/version', __FILE__)
-  RDoc::Task.new do |rdoc|
-    rdoc.rdoc_dir = 'rdoc'
-    rdoc.title = "oauth2 #{OAuth2::Version}"
-    rdoc.main = 'README.md'
-    rdoc.rdoc_files.include('README.md', 'LICENSE.md', 'lib/**/*.rb')
-  end
-end
-
-begin
-  require 'rubocop/rake_task'
-  RuboCop::RakeTask.new
-rescue LoadError
-  task :rubocop do
-    $stderr.puts 'RuboCop is disabled'
-  end
-end
-
-require 'yardstick/rake/measurement'
-Yardstick::Rake::Measurement.new do |measurement|
-  measurement.output = 'measurement/report.txt'
-end
-
-require 'yardstick/rake/verify'
-Yardstick::Rake::Verify.new do |verify|
-  verify.threshold = 58.8
-end
-
-task :default => [:spec, :rubocop, :verify_measurements]

data/spec/helper.rb

@@ -1,42 +0,0 @@
-require 'simplecov'
-require 'coveralls'
-
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-  SimpleCov::Formatter::HTMLFormatter,
-  Coveralls::SimpleCov::Formatter
-]
-
-SimpleCov.start do
-  add_filter '/spec/'
-  minimum_coverage(95.33)
-end
-
-require 'oauth2'
-require 'addressable/uri'
-require 'rspec'
-
-RSpec.configure do |config|
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-end
-
-Faraday.default_adapter = :test
-
-RSpec.configure do |conf|
-  include OAuth2
-end
-
-def capture_output(&block)
-  begin
-    old_stdout = $stdout
-    $stdout = StringIO.new
-    block.call
-    result = $stdout.string
-  ensure
-    $stdout = old_stdout
-  end
-  result
-end
-
-VERBS = [:get, :post, :put, :delete]

data/spec/oauth2/access_token_spec.rb

@@ -1,169 +0,0 @@
-require 'helper'
-
-describe AccessToken do
-  let(:token) { 'monkey' }
-  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]] }
-        end
-        stub.post('/oauth/token') { |env| [200, {'Content-Type' => 'application/json'}, refresh_body] }
-      end
-    end
-  end
-
-  subject { AccessToken.new(client, token) }
-
-  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
-      target = AccessToken.new(client, token, 'foo' => 'bar')
-      expect(target.params).to include('foo')
-      expect(target.params['foo']).to eq('bar')
-    end
-
-    def assert_initialized_token(target)
-      expect(target.token).to eq(token)
-      expect(target).to be_expires
-      expect(target.params.keys).to include('foo')
-      expect(target.params['foo']).to eq('bar')
-    end
-
-    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"
-      target = AccessToken.from_kvform(client, kvform)
-      assert_initialized_token(target)
-    end
-
-    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
-      hash = {:access_token => token, :expires_at => '1361396829', 'foo' => 'bar'}
-      target = AccessToken.from_hash(client, hash)
-      assert_initialized_token(target)
-      expect(target.expires_at).to be_a(Integer)
-    end
-  end
-
-  describe '#request' do
-    context ':mode => :header' do
-      before do
-        subject.options[:mode] = :header
-      end
-
-      VERBS.each do |verb|
-        it "sends the token in the Authorization header for a #{verb.to_s.upcase} request" do
-          expect(subject.post('/token/header').body).to include(token)
-        end
-      end
-    end
-
-    context ':mode => :query' do
-      before do
-        subject.options[:mode] = :query
-      end
-
-      VERBS.each do |verb|
-        it "sends the token in the Authorization header for a #{verb.to_s.upcase} request" do
-          expect(subject.post('/token/query').body).to eq(token)
-        end
-      end
-    end
-
-    context ':mode => :body' do
-      before do
-        subject.options[:mode] = :body
-      end
-
-      VERBS.each do |verb|
-        it "sends the token in the Authorization header for a #{verb.to_s.upcase} request" do
-          expect(subject.post('/token/body').body.split('=').last).to eq(token)
-        end
-      end
-    end
-  end
-
-  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
-      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
-    end
-  end
-
-  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 => 10_800)).not_to be_expired
-    end
-
-    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 + 10_800
-      allow(Time).to receive(:now).and_return(@now)
-      expect(access).to be_expired
-    end
-
-  end
-
-  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
-      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
-      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
-        refreshed = access.refresh!
-
-        expect(refreshed.refresh_token).to eq(access.refresh_token)
-      end
-    end
-  end
-
-  describe '#to_hash' do
-    it 'return a hash equals to the hash used to initialize access token' do
-      hash = {:access_token => token, :refresh_token => 'foobar', :expires_at => Time.now.to_i + 200, 'foo' => 'bar'}
-      access_token = AccessToken.from_hash(client, hash.clone)
-      expect(access_token.to_hash).to eq(hash)
-    end
-  end
-end

data/spec/oauth2/client_spec.rb

@@ -1,215 +0,0 @@
-require 'helper'
-
-describe OAuth2::Client do
-  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] }
-      end
-    end
-  end
-
-  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
-      expect(subject.site).to eq('https://api.example.com')
-    end
-
-    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 be_empty
-    end
-
-    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)
-
-      expect(builder).to receive(:adapter).with(: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
-    end
-
-    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
-      client = OAuth2::Client.new('abc', 'def', :site => 'https://api.example.com', :raise_errors => true)
-      expect(client.options[:raise_errors]).to be true
-    end
-
-    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] }
-        end
-      end
-      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
-      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)
-      expect(client.options[:access_token_method]).to eq(:post)
-    end
-
-    it 'does not mutate the opts hash argument' do
-      opts = {:site => 'http://example.com/'}
-      opts2 = opts.dup
-      OAuth2::Client.new 'abc', 'def', opts
-      expect(opts).to eq(opts2)
-    end
-  end
-
-  %w(authorize token).each do |url_type|
-    describe ":#{url_type}_url option" do
-      it "defaults to a path of /oauth/#{url_type}" do
-        expect(subject.send("#{url_type}_url")).to eq("https://api.example.com/oauth/#{url_type}")
-      end
-
-      it "is settable via the :#{url_type}_url option" do
-        subject.options[:"#{url_type}_url"] = '/oauth/custom'
-        expect(subject.send("#{url_type}_url")).to eq('https://api.example.com/oauth/custom')
-      end
-
-      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
-      expect(subject.request(:get, 'empty_get').body).to eq('')
-    end
-
-    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')
-    end
-
-    it 'outputs to $stdout when OAUTH_DEBUG=true' do
-      allow(ENV).to receive(:[]).with('http_proxy').and_return(nil)
-      allow(ENV).to receive(:[]).with('OAUTH_DEBUG').and_return('true')
-      output = capture_output do
-        subject.request(:get, '/success')
-      end
-
-      expect(output).to include 'INFO -- : get https://api.example.com/success', 'INFO -- : get https://api.example.com/success'
-    end
-
-    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
-      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')
-    end
-
-    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
-      max_redirects = subject.options[:max_redirects]
-      subject.options[:max_redirects] = 0
-      response = subject.request(:get, '/redirect')
-      expect(response.status).to eq(302)
-      subject.options[:max_redirects] = max_redirects
-    end
-
-    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.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)
-      end
-    end
-
-    it 'parses OAuth2 standard error response' do
-      begin
-        subject.request(:get, '/unauthorized')
-      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}/)
-        expect(e.to_s).to match(/#{error_description_value}/)
-      end
-    end
-
-    it 'provides the response in the Exception' do
-      begin
-        subject.request(:get, '/error')
-      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
-    expect(subject.auth_code).to be_kind_of(OAuth2::Strategy::AuthCode)
-  end
-
-  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
-    subject do
-      cli = OAuth2::Client.new('abc', 'def', :site => 'https://api.example.com', :ssl => {:ca_file => 'foo.pem'})
-      cli.connection.build do |b|
-        b.adapter :test
-      end
-      cli
-    end
-
-    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