signet 0.13.2 → 0.16.0

data/lib/signet/oauth_2.rb

@@ -16,7 +16,7 @@ require "base64"
 require "signet"
 require "multi_json"
 
-module Signet #:nodoc:
+module Signet # :nodoc:
   ##
   # An implementation of http://tools.ietf.org/html/draft-ietf-oauth-v2-10
   #
@@ -28,10 +28,10 @@ module Signet #:nodoc:
       case auth_scheme
       when /^Basic$/i
         # HTTP Basic is allowed in OAuth 2
-        return parse_basic_credentials(field_value[/^Basic\s+(.*)$/i, 1])
+        parse_basic_credentials(field_value[/^Basic\s+(.*)$/i, 1])
       when /^OAuth$/i
         # Other token types may be supported eventually
-        return parse_bearer_credentials(field_value[/^OAuth\s+(.*)$/i, 1])
+        parse_bearer_credentials(field_value[/^OAuth\s+(.*)$/i, 1])
       else
         raise ParseError,
               "Parsing non-OAuth Authorization headers is out of scope."
@@ -43,7 +43,7 @@ module Signet #:nodoc:
       case auth_scheme
       when /^OAuth$/i
         # Other token types may be supported eventually
-        return parse_oauth_challenge(field_value[/^OAuth\s+(.*)$/i, 1])
+        parse_oauth_challenge(field_value[/^OAuth\s+(.*)$/i, 1])
       else
         raise ParseError,
               "Parsing non-OAuth WWW-Authenticate headers is out of scope."
@@ -76,9 +76,9 @@ module Signet #:nodoc:
       raise TypeError, "Expected String, got #{body.class}." unless body.is_a? String
       case content_type
       when %r{^application/json.*}
-        return MultiJson.load body
+        MultiJson.load body
       when %r{^application/x-www-form-urlencoded.*}
-        return Hash[Addressable::URI.form_unencode(body)]
+        Hash[Addressable::URI.form_unencode(body)]
       else
         raise ArgumentError, "Invalid content type '#{content_type}'"
       end
@@ -100,9 +100,8 @@ module Signet #:nodoc:
         raise ArgumentError,
               "A client identifier may not contain a ':' character."
       end
-      "Basic " + Base64.encode64(
-        client_id + ":" + client_password
-      ).delete("\n")
+      token = Base64.encode64("#{client_id}:#{client_password}").delete("\n")
+      "Basic #{token}"
     end
 
     ##
@@ -121,11 +120,8 @@ module Signet #:nodoc:
       # TODO: escaping?
       header = "Bearer #{access_token}"
       if auth_params && !auth_params.empty?
-        header += (", " +
-          (auth_params.each_with_object [] do |(key, value), accu|
-            accu << "#{key}=\"#{value}\""
-          end).join(", ")
-                  )
+        additional_headers = auth_params.map { |key, value| "#{key}=\"#{value}\"" }
+        header = ([header] + additional_headers).join ", "
       end
       header
     end

data/lib/signet/version.rb

@@ -13,5 +13,5 @@
 #    limitations under the License.
 
 module Signet
-  VERSION = "0.13.2".freeze
+  VERSION = "0.16.0".freeze
 end

data/lib/signet.rb

@@ -14,9 +14,7 @@
 
 require "signet/version"
 
-module Signet #:nodoc:
-  # rubocop:disable Metrics/AbcSize
-  # rubocop:disable Metrics/MethodLength
+module Signet # :nodoc:
   def self.parse_auth_param_list auth_param_string
     # Production rules from:
     # http://tools.ietf.org/html/draft-ietf-httpbis-p1-messaging-12
@@ -54,11 +52,12 @@ module Signet #:nodoc:
     # Now parse the auth-param pair strings & turn them into key-value pairs.
     (auth_param_pairs.each_with_object [] do |pair, accu|
       name, value = pair.split "=", 2
-      if value =~ /^".*"$/
+      case value
+      when /^".*"$/
         value = value.gsub(/^"(.*)"$/, '\1').gsub(/\\(.)/, '\1')
-      elsif value =~ /^'.*'$/
+      when /^'.*'$/
         value = value.gsub(/^'(.*)'$/, '\1').gsub(/\\(.)/, '\1')
-      elsif value =~ %r{[\(\)<>@,;:\\\"/\[\]?={}]}
+      when %r{[()<>@,;:\\"/\[\]?={}]}
         # Certain special characters are not allowed
         raise ParseError,
               "Unexpected characters in auth param " \
@@ -68,6 +67,4 @@ module Signet #:nodoc:
       accu << [name, value]
     end)
   end
-  # rubocop:enable Metrics/AbcSize
-  # rubocop:enable Metrics/MethodLength
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: signet
 version: !ruby/object:Gem::Version
-  version: 0.13.2
+  version: 0.16.0
 platform: ruby
 authors:
 - Bob Aman
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-26 00:00:00.000000000 Z
+date: 2021-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -17,14 +17,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '2.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '2.8'
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
@@ -85,14 +85,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: 1.25.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: 1.25.1
 - !ruby/object:Gem::Dependency
   name: kramdown
   requirement: !ruby/object:Gem::Requirement
@@ -127,14 +127,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.0'
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -192,11 +206,12 @@ extensions: []
 extra_rdoc_files:
 - README.md
 files:
+- ".yardopts"
 - CHANGELOG.md
-- Gemfile
+- CODE_OF_CONDUCT.md
 - LICENSE
 - README.md
-- Rakefile
+- SECURITY.md
 - lib/signet.rb
 - lib/signet/errors.rb
 - lib/signet/oauth_1.rb
@@ -209,21 +224,6 @@ files:
 - lib/signet/oauth_2.rb
 - lib/signet/oauth_2/client.rb
 - lib/signet/version.rb
-- signet.gemspec
-- spec/signet/oauth_1/client_spec.rb
-- spec/signet/oauth_1/credential_spec.rb
-- spec/signet/oauth_1/server_spec.rb
-- spec/signet/oauth_1/signature_methods/hmac_sha1_spec.rb
-- spec/signet/oauth_1/signature_methods/plaintext_spec.rb
-- spec/signet/oauth_1/signature_methods/rsa_sha1_spec.rb
-- spec/signet/oauth_1_spec.rb
-- spec/signet/oauth_2/client_spec.rb
-- spec/signet/oauth_2_spec.rb
-- spec/signet_spec.rb
-- spec/spec.opts
-- spec/spec_helper.rb
-- spec/spec_helper_spec.rb
-- website/index.html
 homepage: https://github.com/googleapis/signet
 licenses:
 - Apache-2.0
@@ -241,14 +241,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.4.0
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: 1.3.5
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.2.17
 signing_key: 
 specification_version: 4
 summary: Signet is an OAuth 1.0 / OAuth 2.0 implementation.

data/Gemfile

@@ -1,8 +0,0 @@
-source "https://rubygems.org"
-
-gemspec
-
-gem "bundler", ">= 1.15"
-gem "gems", "~> 1.2"
-gem "hurley"
-gem "jruby-openssl", platforms: :jruby

data/Rakefile

@@ -1,112 +0,0 @@
-require "rubygems"
-require "json"
-require "rake"
-require "bundler/gem_tasks"
-
-task :release_gem, :tag do |_t, args|
-  tag = args[:tag]
-  raise "You must provide a tag to release." if tag.nil?
-
-  # Verify the tag format "vVERSION"
-  m = tag.match /v(?<version>\S*)/
-  raise "Tag #{tag} does not match the expected format." if m.nil?
-
-  version = m[:version]
-  raise "You must provide a version." if version.nil?
-
-  api_token = ENV["RUBYGEMS_API_TOKEN"]
-
-  require "gems"
-  if api_token
-    ::Gems.configure do |config|
-      config.key = api_token
-    end
-  end
-
-  Bundler.with_clean_env do
-    sh "rm -rf pkg"
-    sh "bundle update"
-    sh "bundle exec rake build"
-  end
-
-  path_to_be_pushed = "pkg/signet-#{version}.gem"
-  gem_was_published = nil
-  if File.file? path_to_be_pushed
-    begin
-      response = ::Gems.push File.new(path_to_be_pushed)
-      puts response
-      raise unless response.include? "Successfully registered gem:"
-      gem_was_published = true
-      puts "Successfully built and pushed signet for version #{version}"
-    rescue StandardError => e
-      gem_was_published = false
-      puts "Error while releasing signet version #{version}: #{e.message}"
-    end
-  else
-    raise "Cannot build signet for version #{version}"
-  end
-
-  Rake::Task["kokoro:publish_docs"].invoke if gem_was_published
-end
-
-task :ci do
-  header "Using Ruby - #{RUBY_VERSION}"
-  sh "bundle exec rubocop"
-  sh "bundle exec rspec"
-end
-
-namespace :kokoro do
-  task :load_env_vars do
-    service_account = "#{ENV['KOKORO_GFILE_DIR']}/service-account.json"
-    ENV["GOOGLE_APPLICATION_CREDENTIALS"] = service_account
-    filename = "#{ENV['KOKORO_GFILE_DIR']}/env_vars.json"
-    env_vars = JSON.parse File.read(filename)
-    env_vars.each { |k, v| ENV[k] = v }
-  end
-
-  task :presubmit do
-    Rake::Task["ci"].invoke
-  end
-
-  task :continuous do
-    Rake::Task["ci"].invoke
-  end
-
-  task :nightly do
-    Rake::Task["ci"].invoke
-  end
-
-  task :release do
-    version = "0.1.0"
-    Bundler.with_clean_env do
-      version = `bundle exec gem list`
-                .split("\n").select { |line| line.include? "signet" }
-                .first.split("(").last.split(")").first || "0.1.0"
-    end
-    Rake::Task["kokoro:load_env_vars"].invoke
-    Rake::Task["release_gem"].invoke "v#{version}"
-  end
-
-  task :post do
-    require_relative "rakelib/link_checker.rb"
-
-    link_checker = LinkChecker.new
-    link_checker.run
-    exit link_checker.exit_status
-  end
-
-  task :publish_docs do
-    require_relative "rakelib/devsite_builder.rb"
-
-    DevsiteBuilder.new(__dir__).publish
-  end
-end
-
-def header str, token = "#"
-  line_length = str.length + 8
-  puts ""
-  puts token * line_length
-  puts "#{token * 3} #{str} #{token * 3}"
-  puts token * line_length
-  puts ""
-end

data/signet.gemspec

@@ -1,44 +0,0 @@
-$LOAD_PATH.push File.expand_path("lib", __dir__)
-require "signet/version"
-
-Gem::Specification.new do |gem|
-  gem.name = "signet"
-  gem.version = Signet::VERSION
-
-  gem.required_rubygems_version = ">= 1.3.5"
-  gem.require_paths = ["lib"]
-  gem.authors = ["Bob Aman", "Steven Bazyl"]
-  gem.license = "Apache-2.0"
-  gem.description = "Signet is an OAuth 1.0 / OAuth 2.0 implementation.\n"
-  gem.email = "sbazyl@google.com"
-  gem.extra_rdoc_files = ["README.md"]
-  gem.files = ["signet.gemspec", "Rakefile", "LICENSE", "CHANGELOG.md", "README.md", "Gemfile"]
-  gem.files += Dir.glob "lib/**/*.rb"
-  gem.files += Dir.glob "spec/**/*.{rb,opts}"
-  gem.files += Dir.glob "vendor/**/*.rb"
-  gem.files += Dir.glob "tasks/**/*"
-  gem.files += Dir.glob "website/**/*"
-  gem.homepage = "https://github.com/googleapis/signet"
-  gem.rdoc_options = ["--main", "README.md"]
-  gem.summary = "Signet is an OAuth 1.0 / OAuth 2.0 implementation."
-  gem.required_ruby_version = ">= 2.4.0"
-
-  gem.add_runtime_dependency "addressable", "~> 2.3"
-  gem.add_runtime_dependency "faraday", ">= 0.17.3", "< 2.0"
-  gem.add_runtime_dependency "jwt", ">= 1.5", "< 3.0"
-  gem.add_runtime_dependency "multi_json", "~> 1.10"
-
-  gem.add_development_dependency "google-style", "~> 0.3"
-  gem.add_development_dependency "kramdown", "~> 1.5"
-  gem.add_development_dependency "launchy", "~> 2.4"
-  gem.add_development_dependency "rake", "~> 12.0"
-  gem.add_development_dependency "rspec", "~> 3.1"
-  gem.add_development_dependency "simplecov", "~> 0.9"
-  gem.add_development_dependency "yard", "~> 0.9", ">= 0.9.12"
-
-  if gem.respond_to? :metadata
-    gem.metadata["changelog_uri"] = "https://github.com/googleapis/signet/blob/master/CHANGELOG.md"
-    gem.metadata["source_code_uri"] = "https://github.com/googleapis/signet"
-    gem.metadata["bug_tracker_uri"] = "https://github.com/googleapis/signet/issues"
-  end
-end

data/spec/signet/oauth_1/client_spec.rb

@@ -1,810 +0,0 @@
-# Copyright (C) 2010 Google Inc.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-require "spec_helper"
-require "multi_json"
-require "signet/oauth_1/client"
-require "addressable/uri"
-require "stringio"
-
-conn = Faraday.default_connection
-
-def merge_body chunked_body
-  raise ArgumentError, "Expected chunked body, got nil." if chunked_body == nil
-  merged_body = StringIO.new
-  chunked_body.each do |chunk|
-    merged_body.write chunk
-  end
-  merged_body.string
-end
-
-describe Signet::OAuth1::Client, "unconfigured" do
-  before do
-    @client = Signet::OAuth1::Client.new
-  end
-
-  it "should have no temporary_credential_uri" do
-    expect(@client.temporary_credential_uri).to be_nil
-  end
-
-  it "should allow the temporary_credential_uri to be set to a String" do
-    @client.temporary_credential_uri = "http://example.com/"
-    expect(@client.temporary_credential_uri.to_s).to eq "http://example.com/"
-  end
-
-  it "should allow the temporary_credential_uri to be set to a URI" do
-    @client.temporary_credential_uri =
-      Addressable::URI.parse "http://example.com/"
-    expect(@client.temporary_credential_uri.to_s).to eq "http://example.com/"
-  end
-
-  it "should have no authorization_uri" do
-    expect(@client.authorization_uri).to be_nil
-  end
-
-  it "should allow the authorization_uri to be set to a String" do
-    @client.authorization_uri = "http://example.com/authorize"
-    expect(@client.authorization_uri.to_s).to include(
-      "http://example.com/authorize"
-    )
-  end
-
-  it "should allow the authorization_uri to be set to a Hash" do
-    @client.authorization_uri = {
-      scheme: "http", host: "example.com", path: "/authorize"
-    }
-    expect(@client.authorization_uri.to_s).to include(
-      "http://example.com/authorize"
-    )
-  end
-
-  it "should allow the authorization_uri to be set to a URI" do
-    @client.authorization_uri =
-      Addressable::URI.parse "http://example.com/authorize"
-    expect(@client.authorization_uri.to_s).to include(
-      "http://example.com/authorize"
-    )
-  end
-
-  it "should have no token_credential_uri" do
-    expect(@client.token_credential_uri).to be_nil
-  end
-
-  it "should allow the token_credential_uri to be set to a String" do
-    @client.token_credential_uri = "http://example.com/"
-    expect(@client.token_credential_uri.to_s).to eq "http://example.com/"
-  end
-
-  it "should allow the token_credential_uri to be set to a Hash" do
-    @client.token_credential_uri = {
-      scheme: "http", host: "example.com", path: "/token"
-    }
-    expect(@client.token_credential_uri.to_s).to eq "http://example.com/token"
-  end
-
-  it "should allow the token_credential_uri to be set to a URI" do
-    @client.token_credential_uri =
-      Addressable::URI.parse "http://example.com/"
-    expect(@client.token_credential_uri.to_s).to eq "http://example.com/"
-  end
-
-  it "should have no client_credential" do
-    expect(@client.client_credential).to be_nil
-  end
-
-  it "should raise an error for partially set client credentials" do
-    @client.client_credential_key = "12345"
-    @client.client_credential_secret = nil
-    expect(lambda do
-      @client.client_credential
-    end).to raise_error(ArgumentError)
-  end
-
-  it "should raise an error for partially set client credentials" do
-    @client.client_credential_key = nil
-    @client.client_credential_secret = "54321"
-    expect(lambda do
-      @client.client_credential
-    end).to raise_error(ArgumentError)
-  end
-
-  it "should allow the client_credential to be set to a " \
-     "Signet::OAuth1::Credential" do
-    @client.client_credential =
-      Signet::OAuth1::Credential.new "12345", "54321"
-    expect(@client.client_credential_key).to eq "12345"
-    expect(@client.client_credential_secret).to eq "54321"
-    expect(@client.client_credential).to eq Signet::OAuth1::Credential.new("12345", "54321")
-  end
-
-  it "should allow the client_credential to be set to nil" do
-    @client.client_credential_key = "12345"
-    @client.client_credential_secret = "54321"
-    expect(@client.client_credential_key).to eq "12345"
-    expect(@client.client_credential_secret).to eq "54321"
-    @client.client_credential = nil
-    expect(@client.client_credential).to be_nil
-    expect(@client.client_credential_key).to be_nil
-    expect(@client.client_credential_secret).to be_nil
-  end
-
-  it "should not allow the client_credential to be set to a bogus value" do
-    expect(lambda do
-      @client.client_credential = 42
-    end).to raise_error(TypeError)
-  end
-
-  it "should have no client_credential_key" do
-    expect(@client.client_credential_key).to be_nil
-  end
-
-  it "should allow the client_credential_key to be set to a String" do
-    @client.client_credential_key = "12345"
-    expect(@client.client_credential_key).to eq "12345"
-  end
-
-  it "should not allow the client_credential_key to be set to a non-String" do
-    expect(lambda do
-      @client.client_credential_key = 12_345
-    end).to raise_error(TypeError)
-  end
-
-  it "should have no client_credential_secret" do
-    expect(@client.client_credential_secret).to be_nil
-  end
-
-  it "should allow the client_credential_secret to be set to a String" do
-    @client.client_credential_secret = "54321"
-    expect(@client.client_credential_secret).to eq "54321"
-  end
-
-  it "should not allow the client_credential_secret " \
-     "to be set to a non-String" do
-    expect(lambda do
-      @client.client_credential_secret = 54_321
-    end).to raise_error(TypeError)
-  end
-
-  it "should have an out-of-band callback" do
-    expect(@client.callback).to eq ::Signet::OAuth1::OUT_OF_BAND
-  end
-
-  it "should allow the callback to be set to a String" do
-    @client.callback = "http://example.com/callback"
-    expect(@client.callback).to eq "http://example.com/callback"
-  end
-
-  it "should allow the callback to be set to a URI" do
-    @client.callback =
-      Addressable::URI.parse "http://example.com/callback"
-    expect(@client.callback).to eq "http://example.com/callback"
-  end
-
-  it "should not allow the callback to be set to a non-String" do
-    expect(lambda do
-      @client.callback = 12_345
-    end).to raise_error(TypeError)
-  end
-
-  it "should raise an error if the temporary credentials URI is not set" do
-    @client.client_credential_key = "dpf43f3p2l4k3l03"
-    @client.client_credential_secret = "kd94hf93k423kf44"
-    expect(lambda do
-      @client.generate_temporary_credential_request
-    end).to raise_error(ArgumentError)
-  end
-
-  it "should raise an error if the client credential key is not set" do
-    @client.temporary_credential_uri =
-      "http://example.com/temporary_credentials"
-    @client.client_credential_secret = "kd94hf93k423kf44"
-    expect(lambda do
-      @client.generate_temporary_credential_request
-    end).to raise_error(ArgumentError)
-  end
-
-  it "should raise an error if the client credential secret is not set" do
-    @client.temporary_credential_uri =
-      "http://example.com/temporary_credentials"
-    @client.client_credential_key = "dpf43f3p2l4k3l03"
-    expect(lambda do
-      @client.generate_temporary_credential_request
-    end).to raise_error(ArgumentError)
-  end
-
-  it "should have no temporary_credential" do
-    expect(@client.temporary_credential).to be_nil
-  end
-
-  it "should raise an error for partially set temporary credentials" do
-    @client.temporary_credential_key = "12345"
-    @client.temporary_credential_secret = nil
-    expect(lambda do
-      @client.temporary_credential
-    end).to raise_error(ArgumentError)
-  end
-
-  it "should raise an error for partially set temporary credentials" do
-    @client.temporary_credential_key = nil
-    @client.temporary_credential_secret = "54321"
-    expect(lambda do
-      @client.temporary_credential
-    end).to raise_error(ArgumentError)
-  end
-
-  it "should allow the temporary_credential to be set to a " \
-     "Signet::OAuth1::Credential" do
-    @client.temporary_credential =
-      Signet::OAuth1::Credential.new "12345", "54321"
-    expect(@client.temporary_credential_key).to eq "12345"
-    expect(@client.temporary_credential_secret).to eq "54321"
-    expect(@client.temporary_credential).to eq Signet::OAuth1::Credential.new("12345", "54321")
-  end
-
-  it "should allow the temporary_credential to be set to nil" do
-    @client.temporary_credential_key = "12345"
-    @client.temporary_credential_secret = "54321"
-    expect(@client.temporary_credential_key).to eq "12345"
-    expect(@client.temporary_credential_secret).to eq "54321"
-    @client.temporary_credential = nil
-    expect(@client.temporary_credential).to be_nil
-    expect(@client.temporary_credential_key).to be_nil
-    expect(@client.temporary_credential_secret).to be_nil
-  end
-
-  it "should not allow the temporary_credential to be set to a bogus value" do
-    expect(lambda do
-      @client.temporary_credential = 42
-    end).to raise_error(TypeError)
-  end
-
-  it "should have no temporary_credential_key" do
-    expect(@client.temporary_credential_key).to be_nil
-  end
-
-  it "should allow the temporary_credential_key to be set to a String" do
-    @client.temporary_credential_key = "12345"
-    expect(@client.temporary_credential_key).to eq "12345"
-  end
-
-  it "should not allow the temporary_credential_key " \
-     "to be set to a non-String" do
-    expect(lambda do
-      @client.temporary_credential_key = 12_345
-    end).to raise_error(TypeError)
-  end
-
-  it "should have no temporary_credential_secret" do
-    expect(@client.temporary_credential_secret).to be_nil
-  end
-
-  it "should allow the temporary_credential_secret to be set to a String" do
-    @client.temporary_credential_secret = "54321"
-    expect(@client.temporary_credential_secret).to eq "54321"
-  end
-
-  it "should not allow the temporary_credential_secret " \
-     "to be set to a non-String" do
-    expect(lambda do
-      @client.temporary_credential_secret = 54_321
-    end).to raise_error(TypeError)
-  end
-
-  it "should have no token_credential" do
-    expect(@client.token_credential).to be_nil
-  end
-
-  it "should raise an error for partially set token credentials" do
-    @client.token_credential_key = "12345"
-    @client.token_credential_secret = nil
-    expect(lambda do
-      @client.token_credential
-    end).to raise_error(ArgumentError)
-  end
-
-  it "should raise an error for partially set token credentials" do
-    @client.token_credential_key = nil
-    @client.token_credential_secret = "54321"
-    expect(lambda do
-      @client.token_credential
-    end).to raise_error(ArgumentError)
-  end
-
-  it "should allow the token_credential to be set to a " \
-     "Signet::OAuth1::Credential" do
-    @client.token_credential =
-      Signet::OAuth1::Credential.new "12345", "54321"
-    expect(@client.token_credential_key).to eq "12345"
-    expect(@client.token_credential_secret).to eq "54321"
-    expect(@client.token_credential).to eq Signet::OAuth1::Credential.new("12345", "54321")
-  end
-
-  it "should allow the token_credential to be set to nil" do
-    @client.token_credential_key = "12345"
-    @client.token_credential_secret = "54321"
-    expect(@client.token_credential_key).to eq "12345"
-    expect(@client.token_credential_secret).to eq "54321"
-    @client.token_credential = nil
-    expect(@client.token_credential).to be_nil
-    expect(@client.token_credential_key).to be_nil
-    expect(@client.token_credential_secret).to be_nil
-  end
-
-  it "should not allow the token_credential to be set to a bogus value" do
-    expect(lambda do
-      @client.token_credential = 42
-    end).to raise_error(TypeError)
-  end
-
-  it "should have no token_credential_key" do
-    expect(@client.token_credential_key).to be_nil
-  end
-
-  it "should allow the token_credential_key to be set to a String" do
-    @client.token_credential_key = "12345"
-    expect(@client.token_credential_key).to eq "12345"
-  end
-
-  it "should not allow the token_credential_key " \
-     "to be set to a non-String" do
-    expect(lambda do
-      @client.token_credential_key = 12_345
-    end).to raise_error(TypeError)
-  end
-
-  it "should have no token_credential_secret" do
-    expect(@client.token_credential_secret).to be_nil
-  end
-
-  it "should allow the token_credential_secret to be set to a String" do
-    @client.token_credential_secret = "54321"
-    expect(@client.token_credential_secret).to eq "54321"
-  end
-
-  it "should not allow the token_credential_secret " \
-     "to be set to a non-String" do
-    expect(lambda do
-      @client.token_credential_secret = 54_321
-    end).to raise_error(TypeError)
-  end
-
-  it "should not allow the two_legged flag " \
-     "to be set to a non-Boolean" do
-    expect(lambda do
-      @client.two_legged = 42
-    end).to raise_error(TypeError)
-  end
-end
-
-describe Signet::OAuth1::Client, "configured" do
-  before do
-    @client = Signet::OAuth1::Client.new
-    @client.temporary_credential_uri =
-      "http://example.com/temporary_credentials"
-    @client.authorization_uri =
-      "http://example.com/authorize"
-    @client.token_credential_uri =
-      "http://example.com/token_credentials"
-    @client.callback = "http://example.com/callback"
-    @client.client_credential_key = "dpf43f3p2l4k3l03"
-    @client.client_credential_secret = "kd94hf93k423kf44"
-    @client.temporary_credential_key = "hh5s93j4hdidpola"
-    @client.temporary_credential_secret = "hdhd0244k9j7ao03"
-    @client.token_credential_key = "nnch734d00sl2jdk"
-    @client.token_credential_secret = "pfkkdhi9sl3r4s00"
-  end
-
-  it "should generate a JSON representation of the client" do
-    json = @client.to_json
-    expect(json).not_to be_nil
-
-    deserialized = MultiJson.load json
-    expect(deserialized["temporary_credential_uri"]).to eq "http://example.com/temporary_credentials"
-    expect(deserialized["authorization_uri"]).to include(
-      "http://example.com/authorize"
-)
-    expect(deserialized["token_credential_uri"]).to eq "http://example.com/token_credentials"
-    expect(deserialized["callback"]).to eq "http://example.com/callback"
-    expect(deserialized["client_credential_key"]).to eq "dpf43f3p2l4k3l03"
-    expect(deserialized["client_credential_secret"]).to eq "kd94hf93k423kf44"
-    expect(deserialized["temporary_credential_key"]).to eq "hh5s93j4hdidpola"
-    expect(deserialized["temporary_credential_secret"]).to eq "hdhd0244k9j7ao03"
-    expect(deserialized["token_credential_key"]).to eq "nnch734d00sl2jdk"
-    expect(deserialized["token_credential_secret"]).to eq "pfkkdhi9sl3r4s00"
-  end
-
-  it "should generate an authorization URI with a callback" do
-    @client.temporary_credential_key = nil
-    expect(@client.authorization_uri.to_s).to eq "http://example.com/authorize?oauth_callback=http://example.com/callback"
-  end
-
-  it "should generate an authorization URI with a temporary credential" do
-    @client.callback = nil
-    expect(@client.authorization_uri.to_s).to include(
-      "oauth_token=hh5s93j4hdidpola"
-    )
-  end
-
-  it "should generate an authorization URI both a callback and " \
-     "a temporary credential" do
-    expect(@client.authorization_uri.to_s).to include(
-      "oauth_callback=http://example.com/callback"
-    )
-    expect(@client.authorization_uri.to_s).to include(
-      "oauth_token=hh5s93j4hdidpola"
-    )
-  end
-
-  it "should generate an authorization URI with additional parameters" do
-    authorization_uri = @client.authorization_uri(
-      additional_parameters: { domain: "www.example.com" }
-    )
-    expect(authorization_uri.to_s).to include(
-      "oauth_callback=http://example.com/callback"
-    )
-    expect(authorization_uri.to_s).to include(
-      "oauth_token=hh5s93j4hdidpola"
-    )
-    expect(authorization_uri.to_s).to include(
-      "domain=www.example.com"
-    )
-  end
-
-  it "should raise an error if the verifier is not provided" do
-    expect(lambda do
-      @client.generate_token_credential_request
-    end).to raise_error(ArgumentError)
-    expect(lambda do
-      @client.generate_token_credential_request verifier: nil
-    end).to raise_error(ArgumentError)
-  end
-
-  it "should raise an error if the token credentials URI is not set" do
-    @client.token_credential_uri = nil
-    expect(lambda do
-      @client.generate_token_credential_request verifier: "12345"
-    end).to raise_error(ArgumentError)
-  end
-
-  it "should raise an error if the client credential key is not set" do
-    @client.client_credential_key = nil
-    expect(lambda do
-      @client.generate_token_credential_request verifier: "12345"
-    end).to raise_error(ArgumentError)
-  end
-
-  it "should raise an error if the client credential secret is not set" do
-    @client.client_credential_secret = nil
-    expect(lambda do
-      @client.generate_token_credential_request verifier: "12345"
-    end).to raise_error(ArgumentError)
-  end
-
-  it "should raise an error if the temporary credential key is not set" do
-    @client.temporary_credential_key = nil
-    expect(lambda do
-      @client.generate_token_credential_request verifier: "12345"
-    end).to raise_error(ArgumentError)
-  end
-
-  it "should raise an error if the temporary credential secret is not set" do
-    @client.temporary_credential_secret = nil
-    expect(lambda do
-      @client.generate_token_credential_request verifier: "12345"
-    end).to raise_error(ArgumentError)
-  end
-
-  it "should raise an error if the client credential key is not set" do
-    @client.client_credential_key = nil
-    expect(lambda do
-      @client.generate_authenticated_request
-    end).to raise_error(ArgumentError)
-  end
-
-  it "should raise an error if the client credential secret is not set" do
-    @client.client_credential_secret = nil
-    expect(lambda do
-      @client.generate_authenticated_request
-    end).to raise_error(ArgumentError)
-  end
-
-  it "should raise an error if the token credential key is not set" do
-    @client.token_credential_key = nil
-    expect(lambda do
-      @client.generate_authenticated_request
-    end).to raise_error(ArgumentError)
-  end
-
-  it "should raise an error if the token credential secret is not set" do
-    @client.token_credential_secret = nil
-    expect(lambda do
-      @client.generate_authenticated_request
-    end).to raise_error(ArgumentError)
-  end
-
-  it "should raise an error if no request is provided" do
-    expect(lambda do
-      @client.generate_authenticated_request
-    end).to raise_error(ArgumentError)
-  end
-
-  it "should raise an error if a bogus request is provided" do
-    expect do
-        @client.generate_authenticated_request(
-          request: []
-        )
-    end.to raise_error(ArgumentError)
-  end
-
-  it "should not raise an error if a request is "\
-     "provided without a connection" do
-    request = @client.generate_authenticated_request(
-      request: conn.build_request(:get) do |req|
-        req.url "http://www.example.com/"
-      end
-    )
-  end
-
-  it "should raise an error if no URI is provided" do
-    expect(lambda do
-      @client.generate_authenticated_request(
-        :method  => "GET",
-        headers: [],
-        :body    => ""
-      )
-    end).to raise_error(ArgumentError)
-  end
-
-  it "should not raise an error if a request body is chunked" do
-    request = @client.generate_authenticated_request(
-      method: "POST",
-      :uri    => "https://photos.example.net/photos",
-      :body   => ["A chunked body."]
-    )
-    expect(request).to be_kind_of(Faraday::Request)
-    expect(request.body).to eq "A chunked body."
-  end
-
-  it "should not raise an error if a request body is chunked" do
-    chunked_body = StringIO.new
-    chunked_body.write "A chunked body."
-    chunked_body.rewind
-    request = @client.generate_authenticated_request(
-      method: "POST",
-      :uri    => "https://photos.example.net/photos",
-      :body   => chunked_body
-    )
-    expect(request).to be_kind_of(Faraday::Request)
-    expect(request.body).to eq "A chunked body."
-  end
-
-  it "should raise an error if a request body is of a bogus type" do
-    expect(lambda do
-      @client.generate_authenticated_request(
-        method: "POST",
-        :uri    => "https://photos.example.net/photos",
-        :body   => 42
-      )
-    end).to raise_error(TypeError)
-  end
-
-  it "should correctly fetch the temporary credentials" do
-    # Repeat this because signatures change from test to test
-    10.times do
-      request = @client.generate_temporary_credential_request
-      expect(request.method).to eq :post
-      expect(request.path).to eq "http://example.com/temporary_credentials"
-      authorization_header = request.headers["Authorization"]
-      parameters = ::Signet::OAuth1.parse_authorization_header(
-        authorization_header
-      ).inject({}) { |h, (k, v)| h[k] = v; h }
-      expect(parameters).not_to have_key("oauth_client_credential_key")
-      expect(parameters).not_to have_key("oauth_temporary_credential_key")
-      expect(parameters).not_to have_key("oauth_token")
-      expect(parameters["oauth_nonce"]).to match(/^\w+$/)
-      expect(parameters["oauth_callback"]).to eq @client.callback
-      expect(parameters["oauth_timestamp"]).to match(/^\d+$/)
-      expect(parameters["oauth_signature_method"]).to eq "HMAC-SHA1"
-      expect(parameters["oauth_consumer_key"]).to eq @client.client_credential_key
-      expect(parameters["oauth_signature"]).to match(%r{^[a-zA-Z0-9\=/\+]+$})
-      expect(parameters["oauth_version"]).to eq "1.0"
-    end
-  end
-
-  it "should correctly fetch the token credentials" do
-    # Repeat this because signatures change from test to test
-    10.times do
-      request = @client.generate_token_credential_request(
-        verifier: "473f82d3"
-      )
-      expect(request.method).to eq :post
-      expect(request.path).to eq "http://example.com/token_credentials"
-      authorization_header = request.headers["Authorization"]
-      parameters = ::Signet::OAuth1.parse_authorization_header(
-        authorization_header
-      ).inject({}) { |h, (k, v)| h[k] = v; h }
-      expect(parameters).not_to have_key("oauth_client_credential_key")
-      expect(parameters).not_to have_key("oauth_temporary_credential_key")
-      expect(parameters).not_to have_key("oauth_callback")
-      expect(parameters["oauth_nonce"]).to match(/^\w+$/)
-      expect(parameters["oauth_timestamp"]).to match(/^\d+$/)
-      expect(parameters["oauth_signature_method"]).to eq "HMAC-SHA1"
-      expect(parameters["oauth_consumer_key"]).to eq @client.client_credential_key
-      expect(parameters["oauth_token"]).to eq @client.temporary_credential_key
-      expect(parameters["oauth_signature"]).to match(%r{^[a-zA-Z0-9\=/\+]+$})
-      expect(parameters["oauth_verifier"]).to eq "473f82d3"
-      expect(parameters["oauth_version"]).to eq "1.0"
-    end
-  end
-
-  it "should correctly fetch the protected resource" do
-    # Repeat this because signatures change from test to test
-    10.times do
-      original_request = [
-        "GET",
-        "https://photos.example.net/photos?file=vacation.jpg&size=original",
-        [["Host", "photos.example.net"]],
-        [""]
-      ]
-      signed_request = @client.generate_authenticated_request(
-        request: original_request
-      )
-      expect(signed_request.method).to eq :get
-      expect(signed_request.path).to eq "https://photos.example.net/photos"
-      expect(signed_request.params).to eq({ "file" => "vacation.jpg", "size" => "original" })
-      authorization_header = signed_request.headers["Authorization"]
-      expect(signed_request.body).to eq ""
-      parameters = ::Signet::OAuth1.parse_authorization_header(
-        authorization_header
-      ).inject({}) { |h, (k, v)| h[k] = v; h }
-      expect(parameters).not_to have_key("oauth_client_credential_key")
-      expect(parameters).not_to have_key("oauth_temporary_credential_key")
-      expect(parameters).not_to have_key("oauth_token_credential_key")
-      expect(parameters).not_to have_key("oauth_callback")
-      expect(parameters["oauth_nonce"]).to match(/^\w+$/)
-      expect(parameters["oauth_timestamp"]).to match(/^\d+$/)
-      expect(parameters["oauth_signature_method"]).to eq "HMAC-SHA1"
-      expect(parameters["oauth_consumer_key"]).to eq @client.client_credential_key
-      expect(parameters["oauth_token"]).to eq @client.token_credential_key
-      expect(parameters["oauth_signature"]).to match(%r{^[a-zA-Z0-9\=/\+]+$})
-      expect(parameters["oauth_version"]).to eq "1.0"
-    end
-  end
-
-  it "should correctly fetch the protected resource" do
-    # Repeat this because signatures change from test to test
-    10.times do
-      original_request = [
-        "POST",
-        "https://photos.example.net/photos",
-        [
-          ["Host", "photos.example.net"],
-          ["Content-Type", "application/x-www-form-urlencoded; charset=utf-8"],
-          ["Content-Length", "31"]
-        ],
-        ["file=vacation.jpg&size=original"]
-      ]
-      signed_request = @client.generate_authenticated_request(
-        request: original_request
-      )
-      expect(signed_request.method).to eq :post
-      expect(signed_request.path).to eq "https://photos.example.net/photos"
-      authorization_header = signed_request.headers["Authorization"]
-      expect(signed_request.body).to eq "file=vacation.jpg&size=original"
-      parameters = ::Signet::OAuth1.parse_authorization_header(
-        authorization_header
-      ).inject({}) { |h, (k, v)| h[k] = v; h }
-      expect(parameters).not_to have_key("oauth_client_credential_key")
-      expect(parameters).not_to have_key("oauth_temporary_credential_key")
-      expect(parameters).not_to have_key("oauth_token_credential_key")
-      expect(parameters).not_to have_key("oauth_callback")
-      expect(parameters["oauth_nonce"]).to match(/^\w+$/)
-      expect(parameters["oauth_timestamp"]).to match(/^\d+$/)
-      expect(parameters["oauth_signature_method"]).to eq "HMAC-SHA1"
-      expect(parameters["oauth_consumer_key"]).to eq @client.client_credential_key
-      expect(parameters["oauth_token"]).to eq @client.token_credential_key
-      expect(parameters["oauth_signature"]).to match(%r{^[a-zA-Z0-9\=/\+]+$})
-      expect(parameters["oauth_version"]).to eq "1.0"
-    end
-  end
-
-  describe "with Faraday requests" do
-    it "should correctly get the protected resource" do
-      # Repeat this because signatures change from test to test
-      10.times do
-        original_request = conn.build_request :get do |req|
-          req.url(
-            "https://photos.example.net/photos?file=vacation.jpg&size=original"
-          )
-          req.headers = Faraday::Utils::Headers.new(
-            [["Host", "photos.example.net"]]
-          )
-          req.body = ""
-        end
-
-        signed_request = @client.generate_authenticated_request(
-          request: original_request
-        )
-
-        # Should be same request object
-        expect(original_request["Authorization"]).to eq signed_request["Authorization"]
-
-        expect(signed_request.method).to eq :get
-        expect(signed_request.path).to eq "https://photos.example.net/photos"
-        expect(signed_request.params).to eq ({ "file" => "vacation.jpg", "size" => "original" })
-        authorization_header = signed_request.headers["Authorization"]
-        expect(signed_request.body).to eq ""
-        parameters = ::Signet::OAuth1.parse_authorization_header(
-          authorization_header
-        ).inject({}) { |h, (k, v)| h[k] = v; h }
-        expect(parameters).not_to have_key("oauth_client_credential_key")
-        expect(parameters).not_to have_key("oauth_temporary_credential_key")
-        expect(parameters).not_to have_key("oauth_token_credential_key")
-        expect(parameters).not_to have_key("oauth_callback")
-        expect(parameters["oauth_nonce"]).to match(/^\w+$/)
-        expect(parameters["oauth_timestamp"]).to match(/^\d+$/)
-        expect(parameters["oauth_signature_method"]).to eq "HMAC-SHA1"
-        expect(parameters["oauth_consumer_key"]).to eq @client.client_credential_key
-        expect(parameters["oauth_token"]).to eq @client.token_credential_key
-        expect(parameters["oauth_signature"]).to match(%r{^[a-zA-Z0-9\=/\+]+$})
-        expect(parameters["oauth_version"]).to eq "1.0"
-      end
-    end
-
-    it "should correctly post the protected resource" do
-      # Repeat this because signatures change from test to test
-      10.times do
-        original_request = conn.build_request :post do |req|
-          req.url "https://photos.example.net/photos"
-          req.headers = Faraday::Utils::Headers.new([
-                                                      ["Host", "photos.example.net"],
-            ["Content-Type", "application/x-www-form-urlencoded; charset=utf-8"],
-            ["Content-Length", "31"]
-                                                    ])
-          req.body = {
-            "size" => "original",
-            "file" => "vacation.jpg"
-          }
-        end
-
-        signed_request = @client.generate_authenticated_request(
-          request: original_request
-        )
-
-        # Should be same request object
-        expect(original_request["Authorization"]).to eq signed_request["Authorization"]
-
-        expect(signed_request.method).to eq :post
-        expect(signed_request.path).to eq "https://photos.example.net/photos"
-        authorization_header = signed_request.headers["Authorization"]
-        # Can't rely on the order post parameters are encoded in.
-        expect(signed_request.body).to include("file=vacation.jpg")
-        expect(signed_request.body).to include("size=original")
-        parameters = ::Signet::OAuth1.parse_authorization_header(
-          authorization_header
-        ).inject({}) { |h, (k, v)| h[k] = v; h }
-        expect(parameters).not_to have_key("oauth_client_credential_key")
-        expect(parameters).not_to have_key("oauth_temporary_credential_key")
-        expect(parameters).not_to have_key("oauth_token_credential_key")
-        expect(parameters).not_to have_key("oauth_callback")
-        expect(parameters["oauth_nonce"]).to match(/^\w+$/)
-        expect(parameters["oauth_timestamp"]).to match(/^\d+$/)
-        expect(parameters["oauth_signature_method"]).to eq "HMAC-SHA1"
-        expect(parameters["oauth_consumer_key"]).to eq @client.client_credential_key
-        expect(parameters["oauth_token"]).to eq @client.token_credential_key
-        expect(parameters["oauth_signature"]).to match(%r{^[a-zA-Z0-9\=/\+]+$})
-        expect(parameters["oauth_version"]).to eq "1.0"
-      end
-    end
-  end
-end