googleauth 0.8.0 → 0.8.1

data/spec/googleauth/client_id_spec.rb

@@ -27,131 +27,131 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-spec_dir = File.expand_path(File.join(File.dirname(__FILE__)))
-$LOAD_PATH.unshift(spec_dir)
+spec_dir = File.expand_path File.join(File.dirname(__FILE__))
+$LOAD_PATH.unshift spec_dir
 $LOAD_PATH.uniq!
 
-require 'spec_helper'
-require 'fakefs/safe'
-require 'googleauth'
+require "spec_helper"
+require "fakefs/safe"
+require "googleauth"
 
 describe Google::Auth::ClientId do
-  shared_examples 'it has a valid config' do
-    it 'should include a valid id' do
-      expect(client_id.id).to eql 'abc@example.com'
+  shared_examples "it has a valid config" do
+    it "should include a valid id" do
+      expect(client_id.id).to eql "abc@example.com"
     end
 
-    it 'should include a valid secret' do
-      expect(client_id.secret).to eql 'notasecret'
+    it "should include a valid secret" do
+      expect(client_id.secret).to eql "notasecret"
     end
   end
 
-  shared_examples 'it can successfully load client_id' do
-    context 'loaded from hash' do
+  shared_examples "it can successfully load client_id" do
+    context "loaded from hash" do
       let(:client_id) { Google::Auth::ClientId.from_hash config }
 
-      it_behaves_like 'it has a valid config'
+      it_behaves_like "it has a valid config"
     end
 
-    context 'loaded from file' do
-      file_path = '/client_secrets.json'
+    context "loaded from file" do
+      file_path = "/client_secrets.json"
 
-      let(:client_id) do
+      let :client_id do
         FakeFS do
-          content = MultiJson.dump(config)
-          File.write(file_path, content)
-          Google::Auth::ClientId.from_file(file_path)
+          content = MultiJson.dump config
+          File.write file_path, content
+          Google::Auth::ClientId.from_file file_path
         end
       end
 
-      it_behaves_like 'it has a valid config'
+      it_behaves_like "it has a valid config"
     end
   end
 
-  describe 'with web config' do
-    let(:config) do
+  describe "with web config" do
+    let :config do
       {
-        'web' => {
-          'client_id' => 'abc@example.com',
-          'client_secret' => 'notasecret'
+        "web" => {
+          "client_id"     => "abc@example.com",
+          "client_secret" => "notasecret"
         }
       }
     end
-    it_behaves_like 'it can successfully load client_id'
+    it_behaves_like "it can successfully load client_id"
   end
 
-  describe 'with installed app config' do
-    let(:config) do
+  describe "with installed app config" do
+    let :config do
       {
-        'installed' => {
-          'client_id' => 'abc@example.com',
-          'client_secret' => 'notasecret'
+        "installed" => {
+          "client_id"     => "abc@example.com",
+          "client_secret" => "notasecret"
         }
       }
     end
-    it_behaves_like 'it can successfully load client_id'
+    it_behaves_like "it can successfully load client_id"
   end
 
-  context 'with missing top level property' do
-    let(:config) do
+  context "with missing top level property" do
+    let :config do
       {
-        'notvalid' => {
-          'client_id' => 'abc@example.com',
-          'client_secret' => 'notasecret'
+        "notvalid" => {
+          "client_id"     => "abc@example.com",
+          "client_secret" => "notasecret"
         }
       }
     end
 
-    it 'should raise error' do
+    it "should raise error" do
       expect { Google::Auth::ClientId.from_hash config }.to raise_error(
         /Expected top level property/
       )
     end
   end
 
-  context 'with missing client id' do
-    let(:config) do
+  context "with missing client id" do
+    let :config do
       {
-        'web' => {
-          'client_secret' => 'notasecret'
+        "web" => {
+          "client_secret" => "notasecret"
         }
       }
     end
 
-    it 'should raise error' do
+    it "should raise error" do
       expect { Google::Auth::ClientId.from_hash config }.to raise_error(
         /Client id can not be nil/
       )
     end
   end
 
-  context 'with missing client secret' do
-    let(:config) do
+  context "with missing client secret" do
+    let :config do
       {
-        'web' => {
-          'client_id' => 'abc@example.com'
+        "web" => {
+          "client_id" => "abc@example.com"
         }
       }
     end
 
-    it 'should raise error' do
+    it "should raise error" do
       expect { Google::Auth::ClientId.from_hash config }.to raise_error(
         /Client secret can not be nil/
       )
     end
   end
 
-  context 'with cloud sdk credentials' do
-    let(:config) do
+  context "with cloud sdk credentials" do
+    let :config do
       {
-        'web' => {
-          'client_id' => Google::Auth::CredentialsLoader::CLOUD_SDK_CLIENT_ID,
-          'client_secret' => 'notasecret'
+        "web" => {
+          "client_id"     => Google::Auth::CredentialsLoader::CLOUD_SDK_CLIENT_ID,
+          "client_secret" => "notasecret"
         }
       }
     end
 
-    it 'should raise warning' do
+    it "should raise warning" do
       expect { Google::Auth::ClientId.from_hash config }.to output(
         Google::Auth::CredentialsLoader::CLOUD_SDK_CREDENTIALS_WARNING + "\n"
       ).to_stderr

data/spec/googleauth/compute_engine_spec.rb

@@ -27,65 +27,65 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-spec_dir = File.expand_path(File.join(File.dirname(__FILE__)))
-$LOAD_PATH.unshift(spec_dir)
+spec_dir = File.expand_path File.join(File.dirname(__FILE__))
+$LOAD_PATH.unshift spec_dir
 $LOAD_PATH.uniq!
 
-require 'apply_auth_examples'
-require 'faraday'
-require 'googleauth/compute_engine'
-require 'spec_helper'
+require "apply_auth_examples"
+require "faraday"
+require "googleauth/compute_engine"
+require "spec_helper"
 
 describe Google::Auth::GCECredentials do
-  MD_URI = 'http://169.254.169.254/computeMetadata/v1/instance/service-accounts/default/token'.freeze
+  MD_URI = "http://169.254.169.254/computeMetadata/v1/instance/service-accounts/default/token".freeze
   GCECredentials = Google::Auth::GCECredentials
 
-  before(:example) do
+  before :example do
     @client = GCECredentials.new
   end
 
-  def make_auth_stubs(opts = {})
-    access_token = opts[:access_token] || ''
-    body = MultiJson.dump('access_token' => access_token,
-                          'token_type' => 'Bearer',
-                          'expires_in' => 3600)
+  def make_auth_stubs opts = {}
+    access_token = opts[:access_token] || ""
+    body = MultiJson.dump("access_token" => access_token,
+                          "token_type"   => "Bearer",
+                          "expires_in"   => 3600)
     stub_request(:get, MD_URI)
-      .with(headers: { 'Metadata-Flavor' => 'Google' })
-      .to_return(body: body,
-                 status: 200,
-                 headers: { 'Content-Type' => 'application/json' })
+      .with(headers: { "Metadata-Flavor" => "Google" })
+      .to_return(body:    body,
+                 status:  200,
+                 headers: { "Content-Type" => "application/json" })
   end
 
-  it_behaves_like 'apply/apply! are OK'
+  it_behaves_like "apply/apply! are OK"
 
-  context 'metadata is unavailable' do
-    describe '#fetch_access_token' do
-      it 'should fail if the metadata request returns a 404' do
+  context "metadata is unavailable" do
+    describe "#fetch_access_token" do
+      it "should fail if the metadata request returns a 404" do
         stub = stub_request(:get, MD_URI)
-               .to_return(status: 404,
-                          headers: { 'Metadata-Flavor' => 'Google' })
+               .to_return(status:  404,
+                          headers: { "Metadata-Flavor" => "Google" })
         expect { @client.fetch_access_token! }
           .to raise_error Signet::AuthorizationError
         expect(stub).to have_been_requested
       end
 
-      it 'should fail if the metadata request returns an unexpected code' do
+      it "should fail if the metadata request returns an unexpected code" do
         stub = stub_request(:get, MD_URI)
-               .to_return(status: 503,
-                          headers: { 'Metadata-Flavor' => 'Google' })
+               .to_return(status:  503,
+                          headers: { "Metadata-Flavor" => "Google" })
         expect { @client.fetch_access_token! }
           .to raise_error Signet::AuthorizationError
         expect(stub).to have_been_requested
       end
 
-      it 'should fail with Signet::AuthorizationError if request times out' do
+      it "should fail with Signet::AuthorizationError if request times out" do
         allow_any_instance_of(Faraday::Connection).to receive(:get)
           .and_raise(Faraday::TimeoutError)
         expect { @client.fetch_access_token! }
           .to raise_error Signet::AuthorizationError
       end
 
-      it 'should fail with Signet::AuthorizationError if request fails' do
+      it "should fail with Signet::AuthorizationError if request fails" do
         allow_any_instance_of(Faraday::Connection).to receive(:get)
           .and_raise(Faraday::ConnectionFailed, nil)
         expect { @client.fetch_access_token! }
@@ -94,27 +94,27 @@ describe Google::Auth::GCECredentials do
     end
   end
 
-  describe '#on_gce?' do
-    it 'should be true when Metadata-Flavor is Google' do
-      stub = stub_request(:get, 'http://169.254.169.254')
-             .to_return(status: 200,
-                        headers: { 'Metadata-Flavor' => 'Google' })
+  describe "#on_gce?" do
+    it "should be true when Metadata-Flavor is Google" do
+      stub = stub_request(:get, "http://169.254.169.254")
+             .to_return(status:  200,
+                        headers: { "Metadata-Flavor" => "Google" })
       expect(GCECredentials.on_gce?({}, true)).to eq(true)
       expect(stub).to have_been_requested
     end
 
-    it 'should be false when Metadata-Flavor is not Google' do
-      stub = stub_request(:get, 'http://169.254.169.254')
-             .to_return(status: 200,
-                        headers: { 'Metadata-Flavor' => 'NotGoogle' })
+    it "should be false when Metadata-Flavor is not Google" do
+      stub = stub_request(:get, "http://169.254.169.254")
+             .to_return(status:  200,
+                        headers: { "Metadata-Flavor" => "NotGoogle" })
       expect(GCECredentials.on_gce?({}, true)).to eq(false)
       expect(stub).to have_been_requested
     end
 
-    it 'should be false if the response is not 200' do
-      stub = stub_request(:get, 'http://169.254.169.254')
-             .to_return(status: 404,
-                        headers: { 'Metadata-Flavor' => 'NotGoogle' })
+    it "should be false if the response is not 200" do
+      stub = stub_request(:get, "http://169.254.169.254")
+             .to_return(status:  404,
+                        headers: { "Metadata-Flavor" => "NotGoogle" })
       expect(GCECredentials.on_gce?({}, true)).to eq(false)
       expect(stub).to have_been_requested
     end

data/spec/googleauth/credentials_spec.rb

@@ -27,34 +27,34 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-require 'googleauth'
+require "googleauth"
 
 
 # This test is testing the private class Google::Auth::Credentials. We want to
 # make sure that the passed in scope propogates to the Signet object. This means
 # testing the private API, which is generally frowned on.
 describe Google::Auth::Credentials, :private do
-  let(:default_keyfile_hash) do
+  let :default_keyfile_hash do
     {
-      'private_key_id' => 'testabc1234567890xyz',
-      'private_key' => "-----BEGIN RSA PRIVATE KEY-----\nMIIBOwIBAAJBAOyi0Hy1l4Ym2m2o71Q0TF4O9E81isZEsX0bb+Bqz1SXEaSxLiXM\nUZE8wu0eEXivXuZg6QVCW/5l+f2+9UPrdNUCAwEAAQJAJkqubA/Chj3RSL92guy3\nktzeodarLyw8gF8pOmpuRGSiEo/OLTeRUMKKD1/kX4f9sxf3qDhB4e7dulXR1co/\nIQIhAPx8kMW4XTTL6lJYd2K5GrH8uBMp8qL5ya3/XHrBgw3dAiEA7+3Iw3ULTn2I\n1J34WlJ2D5fbzMzB4FAHUNEV7Ys3f1kCIQDtUahCMChrl7+H5t9QS+xrn77lRGhs\nB50pjvy95WXpgQIhAI2joW6JzTfz8fAapb+kiJ/h9Vcs1ZN3iyoRlNFb61JZAiA8\nNy5NyNrMVwtB/lfJf1dAK/p/Bwd8LZLtgM6PapRfgw==\n-----END RSA PRIVATE KEY-----\n",
-      'client_email' => 'credz-testabc1234567890xyz@developer.gserviceaccount.com',
-      'client_id' => 'credz-testabc1234567890xyz.apps.googleusercontent.com',
-      'type' => 'service_account',
-      'project_id' => 'a_project_id'
+      "private_key_id" => "testabc1234567890xyz",
+      "private_key"    => "-----BEGIN RSA PRIVATE KEY-----\nMIIBOwIBAAJBAOyi0Hy1l4Ym2m2o71Q0TF4O9E81isZEsX0bb+Bqz1SXEaSxLiXM\nUZE8wu0eEXivXuZg6QVCW/5l+f2+9UPrdNUCAwEAAQJAJkqubA/Chj3RSL92guy3\nktzeodarLyw8gF8pOmpuRGSiEo/OLTeRUMKKD1/kX4f9sxf3qDhB4e7dulXR1co/\nIQIhAPx8kMW4XTTL6lJYd2K5GrH8uBMp8qL5ya3/XHrBgw3dAiEA7+3Iw3ULTn2I\n1J34WlJ2D5fbzMzB4FAHUNEV7Ys3f1kCIQDtUahCMChrl7+H5t9QS+xrn77lRGhs\nB50pjvy95WXpgQIhAI2joW6JzTfz8fAapb+kiJ/h9Vcs1ZN3iyoRlNFb61JZAiA8\nNy5NyNrMVwtB/lfJf1dAK/p/Bwd8LZLtgM6PapRfgw==\n-----END RSA PRIVATE KEY-----\n",
+      "client_email"   => "credz-testabc1234567890xyz@developer.gserviceaccount.com",
+      "client_id"      => "credz-testabc1234567890xyz.apps.googleusercontent.com",
+      "type"           => "service_account",
+      "project_id"     => "a_project_id"
     }
   end
 
-  it 'uses a default scope' do
-    mocked_signet = double('Signet::OAuth2::Client')
+  it "uses a default scope" do
+    mocked_signet = double "Signet::OAuth2::Client"
     allow(mocked_signet).to receive(:configure_connection).and_return(mocked_signet)
     allow(mocked_signet).to receive(:fetch_access_token!).and_return(true)
     allow(mocked_signet).to receive(:client_id)
     allow(Signet::OAuth2::Client).to receive(:new) do |options|
-      expect(options[:token_credential_uri]).to eq('https://oauth2.googleapis.com/token')
-      expect(options[:audience]).to eq('https://oauth2.googleapis.com/token')
+      expect(options[:token_credential_uri]).to eq("https://oauth2.googleapis.com/token")
+      expect(options[:audience]).to eq("https://oauth2.googleapis.com/token")
       expect(options[:scope]).to eq([])
-      expect(options[:issuer]).to eq(default_keyfile_hash['client_email'])
+      expect(options[:issuer]).to eq(default_keyfile_hash["client_email"])
       expect(options[:signing_key]).to be_a_kind_of(OpenSSL::PKey::RSA)
 
       mocked_signet
@@ -63,49 +63,49 @@ describe Google::Auth::Credentials, :private do
     Google::Auth::Credentials.new default_keyfile_hash
   end
 
-  it 'uses a custom scope' do
-    mocked_signet = double('Signet::OAuth2::Client')
+  it "uses a custom scope" do
+    mocked_signet = double "Signet::OAuth2::Client"
     allow(mocked_signet).to receive(:configure_connection).and_return(mocked_signet)
     allow(mocked_signet).to receive(:fetch_access_token!).and_return(true)
     allow(mocked_signet).to receive(:client_id)
     allow(Signet::OAuth2::Client).to receive(:new) do |options|
-      expect(options[:token_credential_uri]).to eq('https://oauth2.googleapis.com/token')
-      expect(options[:audience]).to eq('https://oauth2.googleapis.com/token')
-      expect(options[:scope]).to eq(['http://example.com/scope'])
-      expect(options[:issuer]).to eq(default_keyfile_hash['client_email'])
+      expect(options[:token_credential_uri]).to eq("https://oauth2.googleapis.com/token")
+      expect(options[:audience]).to eq("https://oauth2.googleapis.com/token")
+      expect(options[:scope]).to eq(["http://example.com/scope"])
+      expect(options[:issuer]).to eq(default_keyfile_hash["client_email"])
       expect(options[:signing_key]).to be_a_kind_of(OpenSSL::PKey::RSA)
 
       mocked_signet
     end
 
-    Google::Auth::Credentials.new default_keyfile_hash, scope: 'http://example.com/scope'
+    Google::Auth::Credentials.new default_keyfile_hash, scope: "http://example.com/scope"
   end
 
-  it 'can be subclassed to pass in other env paths' do
-    TEST_PATH_ENV_VAR = 'TEST_PATH'.freeze
-    TEST_PATH_ENV_VAL = '/unknown/path/to/file.txt'.freeze
-    TEST_JSON_ENV_VAR = 'TEST_JSON_VARS'.freeze
+  it "can be subclassed to pass in other env paths" do
+    TEST_PATH_ENV_VAR = "TEST_PATH".freeze
+    TEST_PATH_ENV_VAL = "/unknown/path/to/file.txt".freeze
+    TEST_JSON_ENV_VAR = "TEST_JSON_VARS".freeze
 
     ENV[TEST_PATH_ENV_VAR] = TEST_PATH_ENV_VAL
-    ENV[TEST_JSON_ENV_VAR] = JSON.generate(default_keyfile_hash)
+    ENV[TEST_JSON_ENV_VAR] = JSON.generate default_keyfile_hash
 
     class TestCredentials < Google::Auth::Credentials
-      SCOPE = 'http://example.com/scope'.freeze
+      SCOPE = "http://example.com/scope".freeze
       PATH_ENV_VARS = [TEST_PATH_ENV_VAR].freeze
       JSON_ENV_VARS = [TEST_JSON_ENV_VAR].freeze
     end
 
     allow(::File).to receive(:file?).with(TEST_PATH_ENV_VAL) { false }
 
-    mocked_signet = double('Signet::OAuth2::Client')
+    mocked_signet = double "Signet::OAuth2::Client"
     allow(mocked_signet).to receive(:configure_connection).and_return(mocked_signet)
     allow(mocked_signet).to receive(:fetch_access_token!).and_return(true)
     allow(mocked_signet).to receive(:client_id)
     allow(Signet::OAuth2::Client).to receive(:new) do |options|
-      expect(options[:token_credential_uri]).to eq('https://oauth2.googleapis.com/token')
-      expect(options[:audience]).to eq('https://oauth2.googleapis.com/token')
-      expect(options[:scope]).to eq(['http://example.com/scope'])
-      expect(options[:issuer]).to eq(default_keyfile_hash['client_email'])
+      expect(options[:token_credential_uri]).to eq("https://oauth2.googleapis.com/token")
+      expect(options[:audience]).to eq("https://oauth2.googleapis.com/token")
+      expect(options[:scope]).to eq(["http://example.com/scope"])
+      expect(options[:issuer]).to eq(default_keyfile_hash["client_email"])
       expect(options[:signing_key]).to be_a_kind_of(OpenSSL::PKey::RSA)
 
       mocked_signet
@@ -114,32 +114,32 @@ describe Google::Auth::Credentials, :private do
     creds = TestCredentials.default
     expect(creds).to be_a_kind_of(TestCredentials)
     expect(creds.client).to eq(mocked_signet)
-    expect(creds.project_id).to eq(default_keyfile_hash['project_id'])
+    expect(creds.project_id).to eq(default_keyfile_hash["project_id"])
   end
 
-  it 'subclasses can use PATH_ENV_VARS to get keyfile path' do
+  it "subclasses can use PATH_ENV_VARS to get keyfile path" do
     class TestCredentials < Google::Auth::Credentials
-      SCOPE = 'http://example.com/scope'.freeze
-      PATH_ENV_VARS = ['PATH_ENV_DUMMY', 'PATH_ENV_TEST'].freeze
-      JSON_ENV_VARS = ['JSON_ENV_DUMMY'].freeze
-      DEFAULT_PATHS = ['~/default/path/to/file.txt'].freeze
+      SCOPE = "http://example.com/scope".freeze
+      PATH_ENV_VARS = %w[PATH_ENV_DUMMY PATH_ENV_TEST].freeze
+      JSON_ENV_VARS = ["JSON_ENV_DUMMY"].freeze
+      DEFAULT_PATHS = ["~/default/path/to/file.txt"].freeze
     end
 
-    allow(::ENV).to receive(:[]).with('PATH_ENV_DUMMY') { '/fake/path/to/file.txt' }
-    allow(::File).to receive(:file?).with('/fake/path/to/file.txt') { false }
-    allow(::ENV).to receive(:[]).with('PATH_ENV_TEST') { '/unknown/path/to/file.txt' }
-    allow(::File).to receive(:file?).with('/unknown/path/to/file.txt') { true }
-    allow(::File).to receive(:read).with('/unknown/path/to/file.txt') { JSON.generate(default_keyfile_hash) }
+    allow(::ENV).to receive(:[]).with("PATH_ENV_DUMMY") { "/fake/path/to/file.txt" }
+    allow(::File).to receive(:file?).with("/fake/path/to/file.txt") { false }
+    allow(::ENV).to receive(:[]).with("PATH_ENV_TEST") { "/unknown/path/to/file.txt" }
+    allow(::File).to receive(:file?).with("/unknown/path/to/file.txt") { true }
+    allow(::File).to receive(:read).with("/unknown/path/to/file.txt") { JSON.generate default_keyfile_hash }
 
-    mocked_signet = double('Signet::OAuth2::Client')
+    mocked_signet = double "Signet::OAuth2::Client"
     allow(mocked_signet).to receive(:configure_connection).and_return(mocked_signet)
     allow(mocked_signet).to receive(:fetch_access_token!).and_return(true)
     allow(mocked_signet).to receive(:client_id)
     allow(Signet::OAuth2::Client).to receive(:new) do |options|
-      expect(options[:token_credential_uri]).to eq('https://oauth2.googleapis.com/token')
-      expect(options[:audience]).to eq('https://oauth2.googleapis.com/token')
-      expect(options[:scope]).to eq(['http://example.com/scope'])
-      expect(options[:issuer]).to eq(default_keyfile_hash['client_email'])
+      expect(options[:token_credential_uri]).to eq("https://oauth2.googleapis.com/token")
+      expect(options[:audience]).to eq("https://oauth2.googleapis.com/token")
+      expect(options[:scope]).to eq(["http://example.com/scope"])
+      expect(options[:issuer]).to eq(default_keyfile_hash["client_email"])
       expect(options[:signing_key]).to be_a_kind_of(OpenSSL::PKey::RSA)
 
       mocked_signet
@@ -148,31 +148,31 @@ describe Google::Auth::Credentials, :private do
     creds = TestCredentials.default
     expect(creds).to be_a_kind_of(TestCredentials)
     expect(creds.client).to eq(mocked_signet)
-    expect(creds.project_id).to eq(default_keyfile_hash['project_id'])
+    expect(creds.project_id).to eq(default_keyfile_hash["project_id"])
   end
 
-  it 'subclasses can use JSON_ENV_VARS to get keyfile contents' do
+  it "subclasses can use JSON_ENV_VARS to get keyfile contents" do
     class TestCredentials < Google::Auth::Credentials
-      SCOPE = 'http://example.com/scope'.freeze
-      PATH_ENV_VARS = ['PATH_ENV_DUMMY'].freeze
-      JSON_ENV_VARS = ['JSON_ENV_DUMMY', 'JSON_ENV_TEST'].freeze
-      DEFAULT_PATHS = ['~/default/path/to/file.txt'].freeze
+      SCOPE = "http://example.com/scope".freeze
+      PATH_ENV_VARS = ["PATH_ENV_DUMMY"].freeze
+      JSON_ENV_VARS = %w[JSON_ENV_DUMMY JSON_ENV_TEST].freeze
+      DEFAULT_PATHS = ["~/default/path/to/file.txt"].freeze
     end
 
-    allow(::ENV).to receive(:[]).with('PATH_ENV_DUMMY') { '/fake/path/to/file.txt' }
-    allow(::File).to receive(:file?).with('/fake/path/to/file.txt') { false }
-    allow(::ENV).to receive(:[]).with('JSON_ENV_DUMMY') { nil }
-    allow(::ENV).to receive(:[]).with('JSON_ENV_TEST') { JSON.generate(default_keyfile_hash) }
+    allow(::ENV).to receive(:[]).with("PATH_ENV_DUMMY") { "/fake/path/to/file.txt" }
+    allow(::File).to receive(:file?).with("/fake/path/to/file.txt") { false }
+    allow(::ENV).to receive(:[]).with("JSON_ENV_DUMMY") { nil }
+    allow(::ENV).to receive(:[]).with("JSON_ENV_TEST") { JSON.generate default_keyfile_hash }
 
-    mocked_signet = double('Signet::OAuth2::Client')
+    mocked_signet = double "Signet::OAuth2::Client"
     allow(mocked_signet).to receive(:configure_connection).and_return(mocked_signet)
     allow(mocked_signet).to receive(:fetch_access_token!).and_return(true)
     allow(mocked_signet).to receive(:client_id)
     allow(Signet::OAuth2::Client).to receive(:new) do |options|
-      expect(options[:token_credential_uri]).to eq('https://oauth2.googleapis.com/token')
-      expect(options[:audience]).to eq('https://oauth2.googleapis.com/token')
-      expect(options[:scope]).to eq(['http://example.com/scope'])
-      expect(options[:issuer]).to eq(default_keyfile_hash['client_email'])
+      expect(options[:token_credential_uri]).to eq("https://oauth2.googleapis.com/token")
+      expect(options[:audience]).to eq("https://oauth2.googleapis.com/token")
+      expect(options[:scope]).to eq(["http://example.com/scope"])
+      expect(options[:issuer]).to eq(default_keyfile_hash["client_email"])
       expect(options[:signing_key]).to be_a_kind_of(OpenSSL::PKey::RSA)
 
       mocked_signet
@@ -181,32 +181,32 @@ describe Google::Auth::Credentials, :private do
     creds = TestCredentials.default
     expect(creds).to be_a_kind_of(TestCredentials)
     expect(creds.client).to eq(mocked_signet)
-    expect(creds.project_id).to eq(default_keyfile_hash['project_id'])
+    expect(creds.project_id).to eq(default_keyfile_hash["project_id"])
   end
 
-  it 'subclasses can use DEFAULT_PATHS to get keyfile path' do
+  it "subclasses can use DEFAULT_PATHS to get keyfile path" do
     class TestCredentials < Google::Auth::Credentials
-      SCOPE = 'http://example.com/scope'.freeze
-      PATH_ENV_VARS = ['PATH_ENV_DUMMY'].freeze
-      JSON_ENV_VARS = ['JSON_ENV_DUMMY'].freeze
-      DEFAULT_PATHS = ['~/default/path/to/file.txt'].freeze
+      SCOPE = "http://example.com/scope".freeze
+      PATH_ENV_VARS = ["PATH_ENV_DUMMY"].freeze
+      JSON_ENV_VARS = ["JSON_ENV_DUMMY"].freeze
+      DEFAULT_PATHS = ["~/default/path/to/file.txt"].freeze
     end
 
-    allow(::ENV).to receive(:[]).with('PATH_ENV_DUMMY') { '/fake/path/to/file.txt' }
-    allow(::File).to receive(:file?).with('/fake/path/to/file.txt') { false }
-    allow(::ENV).to receive(:[]).with('JSON_ENV_DUMMY') { nil }
-    allow(::File).to receive(:file?).with('~/default/path/to/file.txt') { true }
-    allow(::File).to receive(:read).with('~/default/path/to/file.txt') { JSON.generate(default_keyfile_hash) }
+    allow(::ENV).to receive(:[]).with("PATH_ENV_DUMMY") { "/fake/path/to/file.txt" }
+    allow(::File).to receive(:file?).with("/fake/path/to/file.txt") { false }
+    allow(::ENV).to receive(:[]).with("JSON_ENV_DUMMY") { nil }
+    allow(::File).to receive(:file?).with("~/default/path/to/file.txt") { true }
+    allow(::File).to receive(:read).with("~/default/path/to/file.txt") { JSON.generate default_keyfile_hash }
 
-    mocked_signet = double('Signet::OAuth2::Client')
+    mocked_signet = double "Signet::OAuth2::Client"
     allow(mocked_signet).to receive(:configure_connection).and_return(mocked_signet)
     allow(mocked_signet).to receive(:fetch_access_token!).and_return(true)
     allow(mocked_signet).to receive(:client_id)
     allow(Signet::OAuth2::Client).to receive(:new) do |options|
-      expect(options[:token_credential_uri]).to eq('https://oauth2.googleapis.com/token')
-      expect(options[:audience]).to eq('https://oauth2.googleapis.com/token')
-      expect(options[:scope]).to eq(['http://example.com/scope'])
-      expect(options[:issuer]).to eq(default_keyfile_hash['client_email'])
+      expect(options[:token_credential_uri]).to eq("https://oauth2.googleapis.com/token")
+      expect(options[:audience]).to eq("https://oauth2.googleapis.com/token")
+      expect(options[:scope]).to eq(["http://example.com/scope"])
+      expect(options[:issuer]).to eq(default_keyfile_hash["client_email"])
       expect(options[:signing_key]).to be_a_kind_of(OpenSSL::PKey::RSA)
 
       mocked_signet
@@ -215,23 +215,23 @@ describe Google::Auth::Credentials, :private do
     creds = TestCredentials.default
     expect(creds).to be_a_kind_of(TestCredentials)
     expect(creds.client).to eq(mocked_signet)
-    expect(creds.project_id).to eq(default_keyfile_hash['project_id'])
+    expect(creds.project_id).to eq(default_keyfile_hash["project_id"])
   end
 
-  it 'subclasses that find no matches default to Google::Auth.get_application_default' do
+  it "subclasses that find no matches default to Google::Auth.get_application_default" do
     class TestCredentials < Google::Auth::Credentials
-      SCOPE = 'http://example.com/scope'.freeze
-      PATH_ENV_VARS = ['PATH_ENV_DUMMY'].freeze
-      JSON_ENV_VARS = ['JSON_ENV_DUMMY'].freeze
-      DEFAULT_PATHS = ['~/default/path/to/file.txt'].freeze
+      SCOPE = "http://example.com/scope".freeze
+      PATH_ENV_VARS = ["PATH_ENV_DUMMY"].freeze
+      JSON_ENV_VARS = ["JSON_ENV_DUMMY"].freeze
+      DEFAULT_PATHS = ["~/default/path/to/file.txt"].freeze
     end
 
-    allow(::ENV).to receive(:[]).with('PATH_ENV_DUMMY') { '/fake/path/to/file.txt' }
-    allow(::File).to receive(:file?).with('/fake/path/to/file.txt') { false }
-    allow(::ENV).to receive(:[]).with('JSON_ENV_DUMMY') { nil }
-    allow(::File).to receive(:file?).with('~/default/path/to/file.txt') { false }
+    allow(::ENV).to receive(:[]).with("PATH_ENV_DUMMY") { "/fake/path/to/file.txt" }
+    allow(::File).to receive(:file?).with("/fake/path/to/file.txt") { false }
+    allow(::ENV).to receive(:[]).with("JSON_ENV_DUMMY") { nil }
+    allow(::File).to receive(:file?).with("~/default/path/to/file.txt") { false }
 
-    mocked_signet = double('Signet::OAuth2::Client')
+    mocked_signet = double "Signet::OAuth2::Client"
     allow(mocked_signet).to receive(:configure_connection).and_return(mocked_signet)
     allow(mocked_signet).to receive(:fetch_access_token!).and_return(true)
     allow(mocked_signet).to receive(:client_id)
@@ -243,10 +243,10 @@ describe Google::Auth::Credentials, :private do
       default_keyfile_hash
     end
     allow(Signet::OAuth2::Client).to receive(:new) do |options|
-      expect(options[:token_credential_uri]).to eq('https://oauth2.googleapis.com/token')
-      expect(options[:audience]).to eq('https://oauth2.googleapis.com/token')
-      expect(options[:scope]).to eq(['http://example.com/scope'])
-      expect(options[:issuer]).to eq(default_keyfile_hash['client_email'])
+      expect(options[:token_credential_uri]).to eq("https://oauth2.googleapis.com/token")
+      expect(options[:audience]).to eq("https://oauth2.googleapis.com/token")
+      expect(options[:scope]).to eq(["http://example.com/scope"])
+      expect(options[:issuer]).to eq(default_keyfile_hash["client_email"])
       expect(options[:signing_key]).to be_a_kind_of(OpenSSL::PKey::RSA)
 
       mocked_signet
@@ -255,14 +255,14 @@ describe Google::Auth::Credentials, :private do
     creds = TestCredentials.default
     expect(creds).to be_a_kind_of(TestCredentials)
     expect(creds.client).to eq(mocked_signet)
-    expect(creds.project_id).to eq(default_keyfile_hash['project_id'])
+    expect(creds.project_id).to eq(default_keyfile_hash["project_id"])
   end
 
-  it 'warns when cloud sdk credentials are used' do
-    mocked_signet = double('Signet::OAuth2::Client')
+  it "warns when cloud sdk credentials are used" do
+    mocked_signet = double "Signet::OAuth2::Client"
     allow(mocked_signet).to receive(:configure_connection).and_return(mocked_signet)
     allow(mocked_signet).to receive(:fetch_access_token!).and_return(true)
-    allow(Signet::OAuth2::Client).to receive(:new) do |options|
+    allow(Signet::OAuth2::Client).to receive(:new) do |_options|
       mocked_signet
     end
     allow(mocked_signet).to receive(:client_id).and_return(Google::Auth::CredentialsLoader::CLOUD_SDK_CLIENT_ID)