signet 0.11.0 → 0.12.0

data/lib/signet/version.rb

@@ -12,77 +12,6 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 
-# Used to prevent the class/module from being loaded more than once
-unless defined? Signet::VERSION
-  module Signet
-    module VERSION
-      MAJOR = 0
-      MINOR = 11
-      TINY  = 0
-      PRE   = nil
-
-      STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
-
-      # On March 31, 2019, set supported version to 2.4 and recommended to 2.6.
-      # Thereafter, follow the MRI support schedule: supported means non-EOL,
-      # and recommended means in normal (rather than security) maintenance.
-      # See https://www.ruby-lang.org/en/downloads/branches/
-      ##
-      # Minimum "supported" Ruby version (non-EOL)
-      # @private
-      #
-      SUPPORTED_VERSION_THRESHOLD = '1.9'.freeze
-      ##
-      # Minimum "recommended" Ruby version (normal maintenance)
-      # @private
-      #
-      RECOMMENDED_VERSION_THRESHOLD = '2.4'.freeze
-      ##
-      # Check Ruby version and emit a warning if it is old
-      # @private
-      #
-      def self.warn_on_old_ruby_version
-        return if ENV['GOOGLE_CLOUD_SUPPRESS_RUBY_WARNINGS']
-        cur_version = Gem::Version.new RUBY_VERSION
-        if cur_version < Gem::Version.new(SUPPORTED_VERSION_THRESHOLD)
-          warn_unsupported_ruby cur_version, RECOMMENDED_VERSION_THRESHOLD
-        elsif cur_version < Gem::Version.new(RECOMMENDED_VERSION_THRESHOLD)
-          warn_nonrecommended_ruby cur_version, RECOMMENDED_VERSION_THRESHOLD
-        end
-      rescue ArgumentError
-        'Unable to determine current Ruby version.'
-      end
-
-      ##
-      # Print a warning for an EOL version of Ruby
-      # @private
-      #
-      def self.warn_unsupported_ruby cur_version, recommended_version
-        "WARNING: You are running Ruby #{cur_version}, which has reached" \
-          " end-of-life and is no longer supported by Ruby Core.\n" \
-          'Signet works best on supported versions of' \
-          ' Ruby. It is strongly recommended that you upgrade to Ruby' \
-          " #{recommended_version} or later. \n" \
-          'See https://www.ruby-lang.org/en/downloads/branches/ for more' \
-          " info on the Ruby maintenance schedule.\n" \
-          'To suppress this message, set the' \
-          ' GOOGLE_CLOUD_SUPPRESS_RUBY_WARNINGS environment variable.'
-      end
-
-      ##
-      # Print a warning for a supported but nearing EOL version of Ruby
-      # @private
-      #
-      def self.warn_nonrecommended_ruby cur_version, recommended_version
-        "WARNING: You are running Ruby #{cur_version}, which is nearing" \
-          " end-of-life.\n" \
-          'Signet works best on supported versions of' \
-          " Ruby. Consider upgrading to Ruby #{recommended_version} or later.\n" \
-          'See https://www.ruby-lang.org/en/downloads/branches/ for more' \
-          " info on the Ruby maintenance schedule.\n" \
-          'To suppress this message, set the' \
-          ' GOOGLE_CLOUD_SUPPRESS_RUBY_WARNINGS environment variable.'
-      end
-    end
-  end
+module Signet
+  VERSION = "0.12.0".freeze
 end

data/signet.gemspec

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

data/spec/signet/oauth_1/client_spec.rb

@@ -11,100 +11,98 @@
 #    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'
+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)
-  if chunked_body == nil
-    raise ArgumentError, "Expected chunked body, got nil."
-  end
+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)
+    merged_body.write chunk
   end
-  return merged_body.string
+  merged_body.string
 end
 
-describe Signet::OAuth1::Client, 'unconfigured' do
+describe Signet::OAuth1::Client, "unconfigured" do
   before do
     @client = Signet::OAuth1::Client.new
   end
 
-  it 'should have no temporary_credential_uri' do
+  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
+  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
+  it "should allow the temporary_credential_uri to be set to a URI" do
     @client.temporary_credential_uri =
-      Addressable::URI.parse("http://example.com/")
+      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
+  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'
+  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'
+      "http://example.com/authorize"
     )
   end
 
-  it 'should allow the authorization_uri to be set to a Hash' do
+  it "should allow the authorization_uri to be set to a Hash" do
     @client.authorization_uri = {
-      :scheme => 'http', :host => 'example.com', :path => '/authorize'
+      scheme: "http", host: "example.com", path: "/authorize"
     }
     expect(@client.authorization_uri.to_s).to include(
-      'http://example.com/authorize'
+      "http://example.com/authorize"
     )
   end
 
-  it 'should allow the authorization_uri to be set to a URI' do
+  it "should allow the authorization_uri to be set to a URI" do
     @client.authorization_uri =
-      Addressable::URI.parse('http://example.com/authorize')
+      Addressable::URI.parse "http://example.com/authorize"
     expect(@client.authorization_uri.to_s).to include(
-      'http://example.com/authorize'
+      "http://example.com/authorize"
     )
   end
 
-  it 'should have no token_credential_uri' do
+  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
+  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
+  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'
+      scheme: "http", host: "example.com", path: "/token"
     }
-    expect(@client.token_credential_uri.to_s).to eq 'http://example.com/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
+  it "should allow the token_credential_uri to be set to a URI" do
     @client.token_credential_uri =
-      Addressable::URI.parse("http://example.com/")
+      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
+  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
+  it "should raise an error for partially set client credentials" do
     @client.client_credential_key = "12345"
     @client.client_credential_secret = nil
     expect(lambda do
@@ -112,7 +110,7 @@ describe Signet::OAuth1::Client, 'unconfigured' do
     end).to raise_error(ArgumentError)
   end
 
-  it 'should raise an error for partially set client credentials' do
+  it "should raise an error for partially set client credentials" do
     @client.client_credential_key = nil
     @client.client_credential_secret = "54321"
     expect(lambda do
@@ -120,16 +118,16 @@ describe Signet::OAuth1::Client, 'unconfigured' do
     end).to raise_error(ArgumentError)
   end
 
-  it 'should allow the client_credential to be set to a ' +
-      'Signet::OAuth1::Credential' do
+  it "should allow the client_credential to be set to a " \
+     "Signet::OAuth1::Credential" do
     @client.client_credential =
-      Signet::OAuth1::Credential.new("12345", "54321")
+      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
+  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"
@@ -140,95 +138,95 @@ describe Signet::OAuth1::Client, 'unconfigured' do
     expect(@client.client_credential_secret).to be_nil
   end
 
-  it 'should not allow the client_credential to be set to a bogus value' do
+  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
+  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
+  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
+  it "should not allow the client_credential_key to be set to a non-String" do
     expect(lambda do
-      @client.client_credential_key = 12345
+      @client.client_credential_key = 12_345
     end).to raise_error(TypeError)
   end
 
-  it 'should have no client_credential_secret' do
+  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
+  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
+  it "should not allow the client_credential_secret " \
+     "to be set to a non-String" do
     expect(lambda do
-      @client.client_credential_secret = 54321
+      @client.client_credential_secret = 54_321
     end).to raise_error(TypeError)
   end
 
-  it 'should have an out-of-band callback' do
+  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
+  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
+  it "should allow the callback to be set to a URI" do
     @client.callback =
-      Addressable::URI.parse("http://example.com/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
+  it "should not allow the callback to be set to a non-String" do
     expect(lambda do
-      @client.callback = 12345
+      @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'
+  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
+  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'
+      "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
+  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'
+      "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
+  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
+  it "should raise an error for partially set temporary credentials" do
     @client.temporary_credential_key = "12345"
     @client.temporary_credential_secret = nil
     expect(lambda do
@@ -236,7 +234,7 @@ describe Signet::OAuth1::Client, 'unconfigured' do
     end).to raise_error(ArgumentError)
   end
 
-  it 'should raise an error for partially set temporary credentials' do
+  it "should raise an error for partially set temporary credentials" do
     @client.temporary_credential_key = nil
     @client.temporary_credential_secret = "54321"
     expect(lambda do
@@ -244,16 +242,16 @@ describe Signet::OAuth1::Client, 'unconfigured' do
     end).to raise_error(ArgumentError)
   end
 
-  it 'should allow the temporary_credential to be set to a ' +
-      'Signet::OAuth1::Credential' do
+  it "should allow the temporary_credential to be set to a " \
+     "Signet::OAuth1::Credential" do
     @client.temporary_credential =
-      Signet::OAuth1::Credential.new("12345", "54321")
+      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")
+    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
+  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"
@@ -264,49 +262,49 @@ describe Signet::OAuth1::Client, 'unconfigured' do
     expect(@client.temporary_credential_secret).to be_nil
   end
 
-  it 'should not allow the temporary_credential to be set to a bogus value' do
+  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
+  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
+  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
+  it "should not allow the temporary_credential_key " \
+     "to be set to a non-String" do
     expect(lambda do
-      @client.temporary_credential_key = 12345
+      @client.temporary_credential_key = 12_345
     end).to raise_error(TypeError)
   end
 
-  it 'should have no temporary_credential_secret' do
+  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
+  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
+  it "should not allow the temporary_credential_secret " \
+     "to be set to a non-String" do
     expect(lambda do
-      @client.temporary_credential_secret = 54321
+      @client.temporary_credential_secret = 54_321
     end).to raise_error(TypeError)
   end
 
-  it 'should have no token_credential' do
+  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
+  it "should raise an error for partially set token credentials" do
     @client.token_credential_key = "12345"
     @client.token_credential_secret = nil
     expect(lambda do
@@ -314,7 +312,7 @@ describe Signet::OAuth1::Client, 'unconfigured' do
     end).to raise_error(ArgumentError)
   end
 
-  it 'should raise an error for partially set token credentials' do
+  it "should raise an error for partially set token credentials" do
     @client.token_credential_key = nil
     @client.token_credential_secret = "54321"
     expect(lambda do
@@ -322,16 +320,16 @@ describe Signet::OAuth1::Client, 'unconfigured' do
     end).to raise_error(ArgumentError)
   end
 
-  it 'should allow the token_credential to be set to a ' +
-      'Signet::OAuth1::Credential' do
+  it "should allow the token_credential to be set to a " \
+     "Signet::OAuth1::Credential" do
     @client.token_credential =
-      Signet::OAuth1::Credential.new("12345", "54321")
+      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
+  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"
@@ -342,470 +340,470 @@ describe Signet::OAuth1::Client, 'unconfigured' do
     expect(@client.token_credential_secret).to be_nil
   end
 
-  it 'should not allow the token_credential to be set to a bogus value' do
+  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
+  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
+  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
+  it "should not allow the token_credential_key " \
+     "to be set to a non-String" do
     expect(lambda do
-      @client.token_credential_key = 12345
+      @client.token_credential_key = 12_345
     end).to raise_error(TypeError)
   end
 
-  it 'should have no token_credential_secret' do
+  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
+  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
+  it "should not allow the token_credential_secret " \
+     "to be set to a non-String" do
     expect(lambda do
-      @client.token_credential_secret = 54321
+      @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
+  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
+describe Signet::OAuth1::Client, "configured" do
   before do
     @client = Signet::OAuth1::Client.new
     @client.temporary_credential_uri =
-      'http://example.com/temporary_credentials'
+      "http://example.com/temporary_credentials"
     @client.authorization_uri =
-      'http://example.com/authorize'
+      "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'
+      "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
+  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'
+    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
+      "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'
+    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
+  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'
+      "oauth_token=hh5s93j4hdidpola"
     )
   end
 
-  it 'should generate an authorization URI both a callback and ' +
-      'a temporary credential' do
+  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'
+      "oauth_callback=http://example.com/callback"
     )
     expect(@client.authorization_uri.to_s).to include(
-      'oauth_token=hh5s93j4hdidpola'
+      "oauth_token=hh5s93j4hdidpola"
     )
   end
 
-  it 'should generate an authorization URI with additional parameters' do
+  it "should generate an authorization URI with additional parameters" do
     authorization_uri = @client.authorization_uri(
-      :additional_parameters => {:domain => 'www.example.com'}
+      additional_parameters: { domain: "www.example.com" }
     )
     expect(authorization_uri.to_s).to include(
-      'oauth_callback=http://example.com/callback'
+      "oauth_callback=http://example.com/callback"
     )
     expect(authorization_uri.to_s).to include(
-      'oauth_token=hh5s93j4hdidpola'
+      "oauth_token=hh5s93j4hdidpola"
     )
     expect(authorization_uri.to_s).to include(
-      'domain=www.example.com'
+      "domain=www.example.com"
     )
   end
 
-  it 'should raise an error if the verifier is not provided' do
+  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)
+      @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
+  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')
+      @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
+  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')
+      @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
+  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')
+      @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
+  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')
+      @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
+  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')
+      @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
+  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
+  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
+  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
+  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
+  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 {
-      @client.generate_authenticated_request(
-        :request => []
-      )
-      }.to raise_error(ArgumentError)
+  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
+  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/')
+      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
+  it "should raise an error if no URI is provided" do
     expect(lambda do
       @client.generate_authenticated_request(
-        :method => 'GET',
-        :headers => [],
-        :body => ''
+        :method  => "GET",
+        headers: [],
+        :body    => ""
       )
     end).to raise_error(ArgumentError)
   end
 
-  it 'should not raise an error if a request body is chunked' do
+  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.']
+      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.'
+    expect(request.body).to eq "A chunked body."
   end
 
-  it 'should not raise an error if a request body is chunked' do
+  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.write "A chunked body."
     chunked_body.rewind
     request = @client.generate_authenticated_request(
-      :method => 'POST',
-      :uri => 'https://photos.example.net/photos',
-      :body => chunked_body
+      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.'
+    expect(request.body).to eq "A chunked body."
   end
 
-  it 'should raise an error if a request body is of a bogus type' do
+  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
+        method: "POST",
+        :uri    => "https://photos.example.net/photos",
+        :body   => 42
       )
     end).to raise_error(TypeError)
   end
 
-  it 'should correctly fetch the temporary credentials' do
+  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']
+      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(/^[a-zA-Z0-9\=\/\+]+$/)
-      expect(parameters['oauth_version']).to eq '1.0'
+      ).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
+  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'
+        verifier: "473f82d3"
       )
       expect(request.method).to eq :post
-      expect(request.path).to eq 'http://example.com/token_credentials'
-      authorization_header = request.headers['Authorization']
+      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(/^[a-zA-Z0-9\=\/\+]+$/)
-      expect(parameters['oauth_verifier']).to eq '473f82d3'
-      expect(parameters['oauth_version']).to eq '1.0'
+      ).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
+  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']],
-        ['']
+        "GET",
+        "https://photos.example.net/photos?file=vacation.jpg&size=original",
+        [["Host", "photos.example.net"]],
+        [""]
       ]
       signed_request = @client.generate_authenticated_request(
-        :request => original_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 ''
+      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(/^[a-zA-Z0-9\=\/\+]+$/)
-      expect(parameters['oauth_version']).to eq '1.0'
+      ).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
+  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',
+        "POST",
+        "https://photos.example.net/photos",
         [
-          ['Host', 'photos.example.net'],
-          ['Content-Type', 'application/x-www-form-urlencoded; charset=utf-8'],
-          ['Content-Length', '31'],
+          ["Host", "photos.example.net"],
+          ["Content-Type", "application/x-www-form-urlencoded; charset=utf-8"],
+          ["Content-Length", "31"]
         ],
-        ['file=vacation.jpg&size=original']
+        ["file=vacation.jpg&size=original"]
       ]
       signed_request = @client.generate_authenticated_request(
-        :request => original_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'
+      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(/^[a-zA-Z0-9\=\/\+]+$/)
-      expect(parameters['oauth_version']).to eq '1.0'
+      ).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
+  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|
+        original_request = conn.build_request :get do |req|
           req.url(
-            'https://photos.example.net/photos?file=vacation.jpg&size=original'
+            "https://photos.example.net/photos?file=vacation.jpg&size=original"
           )
           req.headers = Faraday::Utils::Headers.new(
-            [['Host', 'photos.example.net']]
+            [["Host", "photos.example.net"]]
           )
-          req.body = ''
+          req.body = ""
         end
 
         signed_request = @client.generate_authenticated_request(
-          :request => original_request
+          request: original_request
         )
 
         # Should be same request object
-        expect(original_request['Authorization']).to eq signed_request['Authorization']
+        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 ''
+        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(/^[a-zA-Z0-9\=\/\+]+$/)
-        expect(parameters['oauth_version']).to eq '1.0'
+        ).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
+    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')
+        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'],
-          ])
+                                                      ["Host", "photos.example.net"],
+            ["Content-Type", "application/x-www-form-urlencoded; charset=utf-8"],
+            ["Content-Length", "31"]
+                                                    ])
           req.body = {
-            'size' => 'original',
-            'file' => 'vacation.jpg'
+            "size" => "original",
+            "file" => "vacation.jpg"
           }
         end
 
         signed_request = @client.generate_authenticated_request(
-          :request => original_request
+          request: original_request
         )
 
         # Should be same request object
-        expect(original_request['Authorization']).to eq signed_request['Authorization']
+        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']
+        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')
+        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(/^[a-zA-Z0-9\=\/\+]+$/)
-        expect(parameters['oauth_version']).to eq '1.0'
+        ).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