signet 0.5.1 → 0.6.0

data/spec/signet/oauth_2_spec.rb

@@ -27,66 +27,66 @@ describe Signet::OAuth2 do
       parameters = Signet::OAuth2.parse_authorization_header(
         'Basic czZCaGRSa3F0MzpnWDFmQmF0M2JW'
       ).inject({}) { |h,(k,v)| h[k]=v; h }
-      parameters['client_id'].should == 's6BhdRkqt3'
-      parameters['client_secret'].should == 'gX1fBat3bV'
+      expect(parameters['client_id']).to eq 's6BhdRkqt3'
+      expect(parameters['client_secret']).to eq 'gX1fBat3bV'
     end
 
     it 'should correctly handle OAuth auth-scheme' do
       parameters = Signet::OAuth2.parse_authorization_header(
         'OAuth vF9dft4qmT'
       ).inject({}) { |h,(k,v)| h[k]=v; h }
-      parameters['access_token'].should == 'vF9dft4qmT'
+      expect(parameters['access_token']).to eq 'vF9dft4qmT'
     end
 
     it 'should correctly handle OAuth auth-scheme with realm' do
       parameters = Signet::OAuth2.parse_authorization_header(
         'OAuth vF9dft4qmT, realm="http://sp.example.com/"'
       ).inject({}) { |h,(k,v)| h[k]=v; h }
-      parameters['access_token'].should == 'vF9dft4qmT'
-      parameters['realm'].should == 'http://sp.example.com/'
+      expect(parameters['access_token']).to eq 'vF9dft4qmT'
+      expect(parameters['realm']).to eq 'http://sp.example.com/'
     end
 
     it 'should correctly handle OAuth auth-scheme with multiple auth-params' do
       parameters = Signet::OAuth2.parse_authorization_header(
         'OAuth vF9dft4qmT, first="one", second="two"'
       ).inject({}) { |h,(k,v)| h[k]=v; h }
-      parameters['access_token'].should == 'vF9dft4qmT'
-      parameters['first'].should == 'one'
-      parameters['second'].should == 'two'
+      expect(parameters['access_token']).to eq 'vF9dft4qmT'
+      expect(parameters['first']).to eq 'one'
+      expect(parameters['second']).to eq 'two'
     end
 
     it 'should liberally handle auth-params with single-quoted strings' do
       parameters = Signet::OAuth2.parse_authorization_header(
         'OAuth vF9dft4qmT, first=\'one\', second=\'two\''
       ).inject({}) { |h,(k,v)| h[k]=v; h }
-      parameters['access_token'].should == 'vF9dft4qmT'
-      parameters['first'].should == 'one'
-      parameters['second'].should == 'two'
+      expect(parameters['access_token']).to eq 'vF9dft4qmT'
+      expect(parameters['first']).to eq 'one'
+      expect(parameters['second']).to eq 'two'
     end
 
     it 'should liberally handle auth-params with unquoted strings' do
       parameters = Signet::OAuth2.parse_authorization_header(
         'OAuth vF9dft4qmT, first=one, second=two'
       ).inject({}) { |h,(k,v)| h[k]=v; h }
-      parameters['access_token'].should == 'vF9dft4qmT'
-      parameters['first'].should == 'one'
-      parameters['second'].should == 'two'
+      expect(parameters['access_token']).to eq 'vF9dft4qmT'
+      expect(parameters['first']).to eq 'one'
+      expect(parameters['second']).to eq 'two'
     end
 
     it 'should not allow unquoted strings that do not match tchar' do
-      (lambda do
+      expect(lambda do
         parameters = Signet::OAuth2.parse_authorization_header(
           'OAuth vF9dft4qmT, first=one:1'
         )
-      end).should raise_error(Signet::ParseError)
+      end).to raise_error(Signet::ParseError)
     end
 
     it 'should not parse non-OAuth auth-schemes' do
-      (lambda do
+      expect(lambda do
         Signet::OAuth2.parse_authorization_header(
           'AuthSub token="GD32CMCL25aZ-v____8B"'
         )
-      end).should raise_error(Signet::ParseError)
+      end).to raise_error(Signet::ParseError)
     end
   end
 
@@ -97,9 +97,9 @@ describe Signet::OAuth2 do
         'OAuth realm="http://sp.example.com/", error="expired_token", ' +
         'error_description="The access token has expired."'
       ).inject({}) { |h,(k,v)| h[k]=v; h }
-      parameters['realm'].should == 'http://sp.example.com/'
-      parameters['error'].should == 'expired_token'
-      parameters['error_description'].should == 'The access token has expired.'
+      expect(parameters['realm']).to eq 'http://sp.example.com/'
+      expect(parameters['error']).to eq 'expired_token'
+      expect(parameters['error_description']).to eq 'The access token has expired.'
     end
 
     it 'should liberally handle auth-params with single-quoted strings' do
@@ -107,9 +107,9 @@ describe Signet::OAuth2 do
         'OAuth realm=\'http://sp.example.com/\', error=\'expired_token\', ' +
         'error_description=\'The access token has expired.\''
       ).inject({}) { |h,(k,v)| h[k]=v; h }
-      parameters['realm'].should == 'http://sp.example.com/'
-      parameters['error'].should == 'expired_token'
-      parameters['error_description'].should == 'The access token has expired.'
+      expect(parameters['realm']).to eq 'http://sp.example.com/'
+      expect(parameters['error']).to eq 'expired_token'
+      expect(parameters['error_description']).to eq 'The access token has expired.'
     end
 
     it 'should liberally handle auth-params with token strings' do
@@ -117,9 +117,9 @@ describe Signet::OAuth2 do
         'OAuth realm="http://sp.example.com/", error=expired_token, ' +
         'error_description="The access token has expired."'
       ).inject({}) { |h,(k,v)| h[k]=v; h }
-      parameters['realm'].should == 'http://sp.example.com/'
-      parameters['error'].should == 'expired_token'
-      parameters['error_description'].should == 'The access token has expired.'
+      expect(parameters['realm']).to eq 'http://sp.example.com/'
+      expect(parameters['error']).to eq 'expired_token'
+      expect(parameters['error_description']).to eq 'The access token has expired.'
     end
 
     it 'should liberally handle out-of-order auth-params' do
@@ -127,64 +127,74 @@ describe Signet::OAuth2 do
         'OAuth error_description=\'The access token has expired.\', ' +
         'error=\'expired_token\', realm=\'http://sp.example.com/\''
       ).inject({}) { |h,(k,v)| h[k]=v; h }
-      parameters['realm'].should == 'http://sp.example.com/'
-      parameters['error'].should == 'expired_token'
-      parameters['error_description'].should == 'The access token has expired.'
+      expect(parameters['realm']).to eq 'http://sp.example.com/'
+      expect(parameters['error']).to eq 'expired_token'
+      expect(parameters['error_description']).to eq 'The access token has expired.'
     end
 
     it 'should not allow unquoted strings that do not match tchar' do
-      (lambda do
+      expect(lambda do
         Signet::OAuth2.parse_www_authenticate_header(
           'OAuth realm=http://sp.example.com/, error=expired_token, ' +
           'error_description="The access token has expired."'
         )
-      end).should raise_error(Signet::ParseError)
+      end).to raise_error(Signet::ParseError)
     end
 
     it 'should not parse non-OAuth challenges' do
-      (lambda do
+      expect(lambda do
         Signet::OAuth2.parse_www_authenticate_header(
           'AuthSub realm="https://www.google.com/accounts/AuthSubRequest"'
         )
-      end).should raise_error(Signet::ParseError)
+      end).to raise_error(Signet::ParseError)
     end
   end
 
   describe 'when generating a Basic Authorization header' do
     it 'should correctly handle client ID and password pairs' do
       # Example from OAuth 2 spec
-      Signet::OAuth2.generate_basic_authorization_header(
+      expect(Signet::OAuth2.generate_basic_authorization_header(
         's6BhdRkqt3', 'gX1fBat3bV'
-      ).should == 'Basic czZCaGRSa3F0MzpnWDFmQmF0M2JW'
+      )).to eq 'Basic czZCaGRSa3F0MzpnWDFmQmF0M2JW'
     end
 
     it 'should correctly encode using the alogrithm given in RFC 2617' do
       # Example from RFC 2617
-      Signet::OAuth2.generate_basic_authorization_header(
+      expect(Signet::OAuth2.generate_basic_authorization_header(
         'Aladdin', 'open sesame'
-      ).should == 'Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ=='
+      )).to eq 'Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ=='
     end
   end
 
   describe 'when parsing a token response body' do
+
     it 'should correctly handle just an access token' do
-      Signet::OAuth2.parse_json_credentials(
-        '{"access_token": "12345"}'
-      ).should == {"access_token" => "12345"}
+      expect(Signet::OAuth2.parse_credentials(
+        '{"access_token": "12345"}',
+        'application/json; charset=utf-8'
+      )).to eq ({"access_token" => "12345"})
+    end
+
+    it 'should handle form encoded responses' do
+      expect(Signet::OAuth2.parse_credentials(
+        'access_token=12345&expires=1000',
+        'application/x-www-form-urlencoded; charset=utf-8'
+      )).to eq({"access_token" => "12345", "expires" => "1000" })
     end
 
     it 'should raise an error for an invalid body' do
-      (lambda do
-        Signet::OAuth2.parse_json_credentials(
-          'This is not JSON.'
+      expect(lambda do
+        Signet::OAuth2.parse_credentials(
+          'This is not JSON.',
+          'application/json'
         )
-      end).should raise_error(MultiJson::DecodeError)
+      end).to raise_error(MultiJson::DecodeError)
     end
 
     it 'should raise an error for a bogus body' do
-      (lambda do
-        Signet::OAuth2.parse_json_credentials(:bogus)
-      end).should raise_error(TypeError)
+      expect(lambda do
+        Signet::OAuth2.parse_credentials(:bogus, 'application/json')
+      end).to raise_error(TypeError)
     end
   end
 end

data/spec/signet_spec.rb

@@ -26,59 +26,59 @@ describe Signet do
       parameters = Signet.parse_auth_param_list(
         'a="1, 2" , b="3,4",c="5 , 6" ,d="7 ,8"'
       ).inject({}) { |h,(k,v)| h[k]=v; h }
-      parameters['a'].should == '1, 2'
-      parameters['b'].should == '3,4'
-      parameters['c'].should == '5 , 6'
-      parameters['d'].should == '7 ,8'
+      expect(parameters['a']).to eq '1, 2'
+      expect(parameters['b']).to eq '3,4'
+      expect(parameters['c']).to eq '5 , 6'
+      expect(parameters['d']).to eq '7 ,8'
     end
 
     it 'should correctly handle backslash-escaped pairs' do
       parameters = Signet.parse_auth_param_list(
         'token="\t\o\k\e\n" sigalg="\s\i\g\a\l\g" data="\d\a\t\a"'
       ).inject({}) { |h,(k,v)| h[k]=v; h }
-      parameters['token'].should == 'token'
-      parameters['sigalg'].should == 'sigalg'
-      parameters['data'].should == 'data'
+      expect(parameters['token']).to eq 'token'
+      expect(parameters['sigalg']).to eq 'sigalg'
+      expect(parameters['data']).to eq 'data'
     end
 
     it 'should liberally handle space-separated auth-param lists' do
       parameters = Signet.parse_auth_param_list(
         'token="token" sigalg="sigalg" data="data" sig="sig"'
       ).inject({}) { |h,(k,v)| h[k]=v; h }
-      parameters['token'].should == 'token'
-      parameters['sigalg'].should == 'sigalg'
-      parameters['data'].should == 'data'
-      parameters['sig'].should == 'sig'
+      expect(parameters['token']).to eq 'token'
+      expect(parameters['sigalg']).to eq 'sigalg'
+      expect(parameters['data']).to eq 'data'
+      expect(parameters['sig']).to eq 'sig'
     end
 
     it 'should liberally handle single-quoted auth-param lists' do
       parameters = Signet.parse_auth_param_list(
         'token=\'token\' sigalg=\'sigalg\' data=\'data\' sig=\'sig\''
       ).inject({}) { |h,(k,v)| h[k]=v; h }
-      parameters['token'].should == 'token'
-      parameters['sigalg'].should == 'sigalg'
-      parameters['data'].should == 'data'
-      parameters['sig'].should == 'sig'
+      expect(parameters['token']).to eq 'token'
+      expect(parameters['sigalg']).to eq 'sigalg'
+      expect(parameters['data']).to eq 'data'
+      expect(parameters['sig']).to eq 'sig'
     end
 
     it 'should liberally handle unquoted auth-param lists' do
       parameters = Signet.parse_auth_param_list(
         'token=token sigalg=sigalg data=data sig=sig'
       ).inject({}) { |h,(k,v)| h[k]=v; h }
-      parameters['token'].should == 'token'
-      parameters['sigalg'].should == 'sigalg'
-      parameters['data'].should == 'data'
-      parameters['sig'].should == 'sig'
+      expect(parameters['token']).to eq 'token'
+      expect(parameters['sigalg']).to eq 'sigalg'
+      expect(parameters['data']).to eq 'data'
+      expect(parameters['sig']).to eq 'sig'
     end
 
     it 'should liberally handle auth-param lists with empty sections' do
       parameters = Signet.parse_auth_param_list(
         'token=token, , sigalg=sigalg,, data=data, sig=sig'
       ).inject({}) { |h,(k,v)| h[k]=v; h }
-      parameters['token'].should == 'token'
-      parameters['sigalg'].should == 'sigalg'
-      parameters['data'].should == 'data'
-      parameters['sig'].should == 'sig'
+      expect(parameters['token']).to eq 'token'
+      expect(parameters['sigalg']).to eq 'sigalg'
+      expect(parameters['data']).to eq 'data'
+      expect(parameters['sig']).to eq 'sig'
     end
   end
 end

data/spec/spec_helper.rb

@@ -11,6 +11,8 @@ $:.uniq!
 require 'rubygems'
 require 'signet'
 require 'rspec'
-
+require 'simplecov'
 require 'faraday'
+
+SimpleCov.start if ENV["COVERAGE"]
 Faraday::Adapter.load_middleware(:test)

data/tasks/gem.rake

@@ -1,62 +1,10 @@
 require "rubygems/package_task"
 
 namespace :gem do
-  GEM_SPEC = Gem::Specification.new do |s|
-    unless s.respond_to?(:add_development_dependency)
-      puts "The gem spec requires a newer version of RubyGems."
-      exit(1)
-    end
-
-    s.name = PKG_NAME
-    s.version = PKG_VERSION
-    s.author = PKG_AUTHOR
-    s.email = PKG_AUTHOR_EMAIL
-    s.homepage = PKG_HOMEPAGE
-    s.summary = PKG_SUMMARY
-    s.description = PKG_DESCRIPTION
-
-    s.files = PKG_FILES.to_a
-
-    s.has_rdoc = true
-    s.extra_rdoc_files = %w( README.md )
-    s.rdoc_options.concat ["--main",  "README.md"]
-
-    s.add_runtime_dependency("addressable", ">= 2.2.3")
-    s.add_runtime_dependency("faraday", ">= 0.9.0.rc5")
-    s.add_runtime_dependency("multi_json", ">= 1.0.0")
-    s.add_runtime_dependency("jwt", ">= 0.1.5")
-
-    s.add_development_dependency("rake", ">= 0.9.0")
-    s.add_development_dependency("rspec", ">= 2.11.0")
-    s.add_development_dependency("launchy", ">= 2.1.1")
-
-    s.require_path = "lib"
-  end
-
-  Gem::PackageTask.new(GEM_SPEC) do |p|
-    p.gem_spec = GEM_SPEC
-    p.need_tar = true
-    p.need_zip = true
-  end
-
-  desc "Generates .gemspec file"
-  task :gemspec do
-    spec_string = GEM_SPEC.to_ruby
-
-    begin
-      Thread.new { eval("$SAFE = 3\n#{spec_string}", binding) }.join
-    rescue
-      abort "unsafe gemspec: #{$!}"
-    else
-      File.open("#{GEM_SPEC.name}.gemspec", 'w') do |file|
-        file.write spec_string
-      end
-    end
-  end
 
-  desc "Show information about the gem"
-  task :debug do
-    puts GEM_SPEC.to_ruby
+  desc "Build the gem"
+  task :build do
+    system "gem build signet.gemspec"
   end
 
   desc "Install the gem"

data/tasks/spec.rake

@@ -4,33 +4,15 @@ require 'rake/clean'
 CLOBBER.include('coverage', 'specdoc')
 
 namespace :spec do
-  RSpec::Core::RakeTask.new(:rcov) do |t|
-    t.pattern = FileList['spec/**/*_spec.rb']
-    t.rspec_opts = ['--color', '--format', 'documentation']
-
-    t.rcov = RCOV_ENABLED
-    t.rcov_opts = [
-      '--exclude', 'lib\\/compat',
-      '--exclude', 'spec',
-      '--exclude', '\\.rvm\\/gems',
-      '--exclude', '1\\.8\\/gems',
-      '--exclude', '1\\.9\\/gems',
-      '--exclude', '\\.rvm',
-      '--exclude', '\\/Library\\/Ruby',
-      '--exclude', 'addressable\\/idna' # environment dependant
-    ]
-  end
 
   RSpec::Core::RakeTask.new(:normal) do |t|
     t.pattern = FileList['spec/**/*_spec.rb'].exclude(/compat/)
     t.rspec_opts = ['--color', '--format', 'documentation']
-    t.rcov = false
   end
 
   RSpec::Core::RakeTask.new(:all) do |t|
     t.pattern = FileList['spec/**/*_spec.rb']
     t.rspec_opts = ['--color', '--format', 'documentation']
-    t.rcov = false
   end
 
   desc "Generate HTML Specdocs for all specs"
@@ -46,13 +28,6 @@ namespace :spec do
     t.fail_on_error = false
   end
 
-  namespace :rcov do
-    desc "Browse the code coverage report."
-    task :browse => "spec:rcov" do
-      require "launchy"
-      Launchy::Browser.run("coverage/index.html")
-    end
-  end
 end
 
 desc "Alias to spec:normal"