google-api-client 0.7.1 → 0.8.0

data/spec/google/api_client/service_account_spec.rb

@@ -18,38 +18,42 @@ require 'google/api_client'
 
 fixtures_path = File.expand_path('../../../fixtures', __FILE__)
 
-describe Google::APIClient::KeyUtils do  
+RSpec.describe Google::APIClient::KeyUtils do
   it 'should read PKCS12 files from the filesystem' do
-    pending "Reading from PKCS12 not supported on jruby" if RUBY_PLATFORM == 'java'
+    if RUBY_PLATFORM == 'java' && RUBY_VERSION.start_with?('1.8')
+      pending "Reading from PKCS12 not supported on jruby 1.8.x"
+    end
     path =  File.expand_path('files/privatekey.p12', fixtures_path)
     key = Google::APIClient::KeyUtils.load_from_pkcs12(path, 'notasecret')
-    key.should_not == nil
+    expect(key).not_to eq(nil)
   end
 
   it 'should read PKCS12 files from loaded files' do
-    pending "Reading from PKCS12 not supported on jruby" if RUBY_PLATFORM == 'java'
+    if RUBY_PLATFORM == 'java' && RUBY_VERSION.start_with?('1.8')
+      pending "Reading from PKCS12 not supported on jruby 1.8.x"
+    end
     path =  File.expand_path('files/privatekey.p12', fixtures_path)
     content = File.read(path)
     key = Google::APIClient::KeyUtils.load_from_pkcs12(content, 'notasecret')
-    key.should_not == nil
+    expect(key).not_to eq(nil)
   end
 
   it 'should read PEM files from the filesystem' do
     path =  File.expand_path('files/secret.pem', fixtures_path)
     key = Google::APIClient::KeyUtils.load_from_pem(path, 'notasecret')
-    key.should_not == nil
+    expect(key).not_to eq(nil)
   end
 
   it 'should read PEM files from loaded files' do
     path =  File.expand_path('files/secret.pem', fixtures_path)
     content = File.read(path)
     key = Google::APIClient::KeyUtils.load_from_pem(content, 'notasecret')
-    key.should_not == nil
+    expect(key).not_to eq(nil)
   end
 
 end
 
-describe Google::APIClient::JWTAsserter do
+RSpec.describe Google::APIClient::JWTAsserter do
   include ConnectionHelpers
 
   before do
@@ -59,11 +63,12 @@ describe Google::APIClient::JWTAsserter do
   it 'should generate valid JWTs' do
     asserter = Google::APIClient::JWTAsserter.new('client1', 'scope1 scope2', @key)
     jwt = asserter.to_authorization.to_jwt
-    jwt.should_not == nil
+    expect(jwt).not_to eq(nil)
 
     claim = JWT.decode(jwt, @key.public_key, true)
-    claim["iss"].should == 'client1'
-    claim["scope"].should == 'scope1 scope2'
+    claim = claim[0] if claim[0]
+    expect(claim["iss"]).to eq('client1')
+    expect(claim["scope"]).to eq('scope1 scope2')
   end
 
   it 'should allow impersonation' do
@@ -71,8 +76,8 @@ describe Google::APIClient::JWTAsserter do
       stub.post('/o/oauth2/token') do |env|
         params = Addressable::URI.form_unencode(env[:body])
         JWT.decode(params.assoc("assertion").last, @key.public_key)
-        params.assoc("grant_type").should == ['grant_type','urn:ietf:params:oauth:grant-type:jwt-bearer']
-        [200, {}, '{
+        expect(params.assoc("grant_type")).to eq(['grant_type','urn:ietf:params:oauth:grant-type:jwt-bearer'])
+        [200, {'content-type' => 'application/json'}, '{
           "access_token" : "1/abcdef1234567890",
           "token_type" : "Bearer",
           "expires_in" : 3600
@@ -81,8 +86,8 @@ describe Google::APIClient::JWTAsserter do
     end
     asserter = Google::APIClient::JWTAsserter.new('client1', 'scope1 scope2', @key)
     auth = asserter.authorize('user1@email.com', { :connection => conn })
-    auth.should_not == nil?
-    auth.person.should == 'user1@email.com'
+    expect(auth).not_to eq(nil?)
+    expect(auth.person).to eq('user1@email.com')
     conn.verify
   end
 
@@ -91,8 +96,8 @@ describe Google::APIClient::JWTAsserter do
       stub.post('/o/oauth2/token') do |env|
         params = Addressable::URI.form_unencode(env[:body])
         JWT.decode(params.assoc("assertion").last, @key.public_key)
-        params.assoc("grant_type").should == ['grant_type','urn:ietf:params:oauth:grant-type:jwt-bearer']
-        [200, {}, '{
+        expect(params.assoc("grant_type")).to eq(['grant_type','urn:ietf:params:oauth:grant-type:jwt-bearer'])
+        [200, {'content-type' => 'application/json'}, '{
           "access_token" : "1/abcdef1234567890",
           "token_type" : "Bearer",
           "expires_in" : 3600
@@ -101,18 +106,18 @@ describe Google::APIClient::JWTAsserter do
     end
     asserter = Google::APIClient::JWTAsserter.new('client1', 'scope1 scope2', @key)
     auth = asserter.authorize(nil, { :connection => conn })
-    auth.should_not == nil?
-    auth.access_token.should == "1/abcdef1234567890"
+    expect(auth).not_to eq(nil?)
+    expect(auth.access_token).to eq("1/abcdef1234567890")
     conn.verify
   end
-  
+
   it 'should be refreshable' do
     conn = stub_connection do |stub|
       stub.post('/o/oauth2/token') do |env|
         params = Addressable::URI.form_unencode(env[:body])
         JWT.decode(params.assoc("assertion").last, @key.public_key)
-        params.assoc("grant_type").should == ['grant_type','urn:ietf:params:oauth:grant-type:jwt-bearer']
-        [200, {}, '{
+        expect(params.assoc("grant_type")).to eq(['grant_type','urn:ietf:params:oauth:grant-type:jwt-bearer'])
+        [200, {'content-type' => 'application/json'}, '{
           "access_token" : "1/abcdef1234567890",
           "token_type" : "Bearer",
           "expires_in" : 3600
@@ -121,8 +126,8 @@ describe Google::APIClient::JWTAsserter do
       stub.post('/o/oauth2/token') do |env|
         params = Addressable::URI.form_unencode(env[:body])
         JWT.decode(params.assoc("assertion").last, @key.public_key)
-        params.assoc("grant_type").should == ['grant_type','urn:ietf:params:oauth:grant-type:jwt-bearer']
-        [200, {}, '{
+        expect(params.assoc("grant_type")).to eq(['grant_type','urn:ietf:params:oauth:grant-type:jwt-bearer'])
+        [200, {'content-type' => 'application/json'}, '{
           "access_token" : "1/0987654321fedcba",
           "token_type" : "Bearer",
           "expires_in" : 3600
@@ -131,24 +136,24 @@ describe Google::APIClient::JWTAsserter do
     end
     asserter = Google::APIClient::JWTAsserter.new('client1', 'scope1 scope2', @key)
     auth = asserter.authorize(nil, { :connection => conn })
-    auth.should_not == nil?
-    auth.access_token.should == "1/abcdef1234567890"
-    
+    expect(auth).not_to eq(nil?)
+    expect(auth.access_token).to eq("1/abcdef1234567890")
+
     auth.fetch_access_token!(:connection => conn)
-    auth.access_token.should == "1/0987654321fedcba"
-    
+    expect(auth.access_token).to eq("1/0987654321fedcba")
+
     conn.verify
-  end    
+  end
 end
 
-describe Google::APIClient::ComputeServiceAccount do
+RSpec.describe Google::APIClient::ComputeServiceAccount do
   include ConnectionHelpers
 
   it 'should query metadata server' do
     conn = stub_connection do |stub|
       stub.get('/computeMetadata/v1beta1/instance/service-accounts/default/token') do |env|
-        env.url.host.should == 'metadata'
-        [200, {}, '{
+        expect(env.url.host).to eq('metadata')
+        [200, {'content-type' => 'application/json'}, '{
           "access_token" : "1/abcdef1234567890",
           "token_type" : "Bearer",
           "expires_in" : 3600
@@ -157,8 +162,8 @@ describe Google::APIClient::ComputeServiceAccount do
     end
     service_account = Google::APIClient::ComputeServiceAccount.new
     auth = service_account.fetch_access_token!({ :connection => conn })
-    auth.should_not == nil?
-    auth["access_token"].should == "1/abcdef1234567890"
+    expect(auth).not_to eq(nil?)
+    expect(auth["access_token"]).to eq("1/abcdef1234567890")
     conn.verify
   end
 end

data/spec/google/api_client/service_spec.rb

@@ -21,27 +21,27 @@ require 'google/api_client/service'
 
 fixtures_path = File.expand_path('../../../fixtures', __FILE__)
 
-describe Google::APIClient::Service do
+RSpec.describe Google::APIClient::Service do
   include ConnectionHelpers
 
   APPLICATION_NAME = 'API Client Tests'
 
   it 'should error out when called without an API name or version' do
-    (lambda do
+    expect(lambda do
       Google::APIClient::Service.new
-    end).should raise_error(ArgumentError)
+    end).to raise_error(ArgumentError)
   end
 
   it 'should error out when called without an API version' do
-    (lambda do
+    expect(lambda do
       Google::APIClient::Service.new('foo')
-    end).should raise_error(ArgumentError)
+    end).to raise_error(ArgumentError)
   end
 
   it 'should error out when the options hash is not a hash' do
-    (lambda do
+    expect(lambda do
       Google::APIClient::Service.new('foo', 'v1', 42)
-    end).should raise_error(ArgumentError)
+    end).to raise_error(ArgumentError)
   end
 
   describe 'with the AdSense Management API' do
@@ -112,34 +112,34 @@ describe Google::APIClient::Service do
       end
 
       it 'should return a resource when using a valid resource name' do
-        @adsense.accounts.should be_a(Google::APIClient::Service::Resource)
+        expect(@adsense.accounts).to be_a(Google::APIClient::Service::Resource)
       end
 
       it 'should throw an error when using an invalid resource name' do
-        (lambda do
+        expect(lambda do
            @adsense.invalid_resource
-        end).should raise_error
+        end).to raise_error
       end
 
       it 'should return a request when using a valid method name' do
         req = @adsense.adclients.list
-        req.should be_a(Google::APIClient::Service::Request)
-        req.method.id.should == 'adsense.adclients.list'
-        req.parameters.should be_nil
+        expect(req).to be_a(Google::APIClient::Service::Request)
+        expect(req.method.id).to eq('adsense.adclients.list')
+        expect(req.parameters).to be_nil
       end
 
       it 'should throw an error when using an invalid method name' do
-        (lambda do
+        expect(lambda do
            @adsense.adclients.invalid_method
-        end).should raise_error
+        end).to raise_error
       end
 
       it 'should return a valid request with parameters' do
         req = @adsense.adunits.list(:adClientId => '1')
-        req.should be_a(Google::APIClient::Service::Request)
-        req.method.id.should == 'adsense.adunits.list'
-        req.parameters.should_not be_nil
-        req.parameters[:adClientId].should == '1'
+        expect(req).to be_a(Google::APIClient::Service::Request)
+        expect(req.method.id).to eq('adsense.adunits.list')
+        expect(req.parameters).not_to be_nil
+        expect(req.parameters[:adClientId]).to eq('1')
       end
     end
   end
@@ -149,7 +149,7 @@ describe Google::APIClient::Service do
     it 'should make a valid call with an object body' do
       conn = stub_connection do |stub|
         stub.post('/prediction/v1.5/trainedmodels?project=1') do |env|
-          env.body.should == '{"id":"1"}'
+          expect(env.body).to eq('{"id":"1"}')
           [200, {}, '{}']
         end
       end
@@ -170,7 +170,7 @@ describe Google::APIClient::Service do
     it 'should make a valid call with a text body' do
       conn = stub_connection do |stub|
         stub.post('/prediction/v1.5/trainedmodels?project=1') do |env|
-          env.body.should == '{"id":"1"}'
+          expect(env.body).to eq('{"id":"1"}')
           [200, {}, '{}']
         end
       end
@@ -196,20 +196,20 @@ describe Google::APIClient::Service do
 
       it 'should return a valid request with a body' do
         req = @prediction.trainedmodels.insert(:project => '1').body({'id' => '1'})
-        req.should be_a(Google::APIClient::Service::Request)
-        req.method.id.should == 'prediction.trainedmodels.insert'
-        req.body.should == {'id' => '1'}
-        req.parameters.should_not be_nil
-        req.parameters[:project].should == '1'
+        expect(req).to be_a(Google::APIClient::Service::Request)
+        expect(req.method.id).to eq('prediction.trainedmodels.insert')
+        expect(req.body).to eq({'id' => '1'})
+        expect(req.parameters).not_to be_nil
+        expect(req.parameters[:project]).to eq('1')
       end
 
       it 'should return a valid request with a body when using resource name' do
         req = @prediction.trainedmodels.insert(:project => '1').training({'id' => '1'})
-        req.should be_a(Google::APIClient::Service::Request)
-        req.method.id.should == 'prediction.trainedmodels.insert'
-        req.training.should == {'id' => '1'}
-        req.parameters.should_not be_nil
-        req.parameters[:project].should == '1'
+        expect(req).to be_a(Google::APIClient::Service::Request)
+        expect(req.method.id).to eq('prediction.trainedmodels.insert')
+        expect(req.training).to eq({'id' => '1'})
+        expect(req.parameters).not_to be_nil
+        expect(req.parameters[:project]).to eq('1')
       end
     end
   end
@@ -228,7 +228,7 @@ describe Google::APIClient::Service do
     it 'should make a valid call with an object body and media upload' do
       conn = stub_connection do |stub|
         stub.post('/upload/drive/v1/files?uploadType=multipart') do |env|
-          env.body.should be_a Faraday::CompositeReadIO
+          expect(env.body).to be_a Faraday::CompositeReadIO
           [200, {}, '{}']
         end
       end
@@ -254,22 +254,22 @@ describe Google::APIClient::Service do
 
       it 'should return a valid request with a body and media upload' do
         req = @drive.files.insert(:uploadType => 'multipart').body(@metadata).media(@media)
-        req.should be_a(Google::APIClient::Service::Request)
-        req.method.id.should == 'drive.files.insert'
-        req.body.should == @metadata
-        req.media.should == @media
-        req.parameters.should_not be_nil
-        req.parameters[:uploadType].should == 'multipart'
+        expect(req).to be_a(Google::APIClient::Service::Request)
+        expect(req.method.id).to eq('drive.files.insert')
+        expect(req.body).to eq(@metadata)
+        expect(req.media).to eq(@media)
+        expect(req.parameters).not_to be_nil
+        expect(req.parameters[:uploadType]).to eq('multipart')
       end
 
       it 'should return a valid request with a body and media upload when using resource name' do
         req = @drive.files.insert(:uploadType => 'multipart').file(@metadata).media(@media)
-        req.should be_a(Google::APIClient::Service::Request)
-        req.method.id.should == 'drive.files.insert'
-        req.file.should == @metadata
-        req.media.should == @media
-        req.parameters.should_not be_nil
-        req.parameters[:uploadType].should == 'multipart'
+        expect(req).to be_a(Google::APIClient::Service::Request)
+        expect(req.method.id).to eq('drive.files.insert')
+        expect(req.file).to eq(@metadata)
+        expect(req.media).to eq(@media)
+        expect(req.parameters).not_to be_nil
+        expect(req.parameters[:uploadType]).to eq('multipart')
       end
     end
   end
@@ -280,15 +280,15 @@ describe Google::APIClient::Service do
           {:application_name => APPLICATION_NAME, :authenticated => false,
            :cache_store => nil})
       result = discovery.apis.get_rest(:api => 'discovery', :version => 'v1').execute
-      result.should_not be_nil
-      result.data.name.should == 'discovery'
-      result.data.version.should == 'v1'
+      expect(result).not_to be_nil
+      expect(result.data.name).to eq('discovery')
+      expect(result.data.version).to eq('v1')
     end
   end
 end
 
 
-describe Google::APIClient::Service::Result do
+RSpec.describe Google::APIClient::Service::Result do
 
   describe 'with the plus API' do
     before do
@@ -307,8 +307,8 @@ describe Google::APIClient::Service::Result do
 
       # Response double
       @response = double("response")
-      @response.stub(:status).and_return(200)
-      @response.stub(:headers).and_return({
+      allow(@response).to receive(:status).and_return(200)
+      allow(@response).to receive(:headers).and_return({
         'etag' => '12345',
         'x-google-apiary-auth-scopes' =>
           'https://www.googleapis.com/auth/plus.me',
@@ -335,51 +335,54 @@ describe Google::APIClient::Service::Result do
             "items": []
           }
           END_OF_STRING
-        @response.stub(:body).and_return(@body)
+        allow(@response).to receive(:body).and_return(@body)
         base_result = Google::APIClient::Result.new(@reference, @response)
         @result = Google::APIClient::Service::Result.new(@request, base_result)
       end
 
       it 'should indicate a successful response' do
-        @result.error?.should be_false
+        expect(@result.error?).to be_falsey
       end
 
       it 'should return the correct next page token' do
-        @result.next_page_token.should == 'NEXT+PAGE+TOKEN'
+        expect(@result.next_page_token).to eq('NEXT+PAGE+TOKEN')
       end
 
       it 'generate a correct request when calling next_page' do
         next_page_request = @result.next_page
-        next_page_request.parameters.should include('pageToken')
-        next_page_request.parameters['pageToken'].should == 'NEXT+PAGE+TOKEN'
+        expect(next_page_request.parameters).to include('pageToken')
+        expect(next_page_request.parameters['pageToken']).to eq('NEXT+PAGE+TOKEN')
         @request.parameters.each_pair do |param, value|
-          next_page_request.parameters[param].should == value
+          expect(next_page_request.parameters[param]).to eq(value)
         end
       end
 
       it 'should return content type correctly' do
-        @result.media_type.should == 'application/json'
+        expect(@result.media_type).to eq('application/json')
       end
 
       it 'should return the body correctly' do
-        @result.body.should == @body
+        expect(@result.body).to eq(@body)
       end
 
       it 'should return the result data correctly' do
-        @result.data?.should be_true
-        @result.data.class.to_s.should ==
+        expect(@result.data?).to be_truthy
+        expect(@result.data.class.to_s).to eq(
             'Google::APIClient::Schema::Plus::V1::ActivityFeed'
-        @result.data.kind.should == 'plus#activityFeed'
-        @result.data.etag.should == 'FOO'
-        @result.data.nextPageToken.should == 'NEXT+PAGE+TOKEN'
-        @result.data.selfLink.should ==
+        )
+        expect(@result.data.kind).to eq('plus#activityFeed')
+        expect(@result.data.etag).to eq('FOO')
+        expect(@result.data.nextPageToken).to eq('NEXT+PAGE+TOKEN')
+        expect(@result.data.selfLink).to eq(
             'https://www.googleapis.com/plus/v1/people/foo/activities/public?'
-        @result.data.nextLink.should ==
+        )
+        expect(@result.data.nextLink).to eq(
             'https://www.googleapis.com/plus/v1/people/foo/activities/public?' +
             'maxResults=20&pageToken=NEXT%2BPAGE%2BTOKEN'
-        @result.data.title.should == 'Plus Public Activity Feed for '
-        @result.data.id.should == "123456790"
-        @result.data.items.should be_empty
+        )
+        expect(@result.data.title).to eq('Plus Public Activity Feed for ')
+        expect(@result.data.id).to eq("123456790")
+        expect(@result.data.items).to be_empty
       end
     end
 
@@ -396,34 +399,36 @@ describe Google::APIClient::Service::Result do
             "items": []
           }
           END_OF_STRING
-        @response.stub(:body).and_return(@body)
+        allow(@response).to receive(:body).and_return(@body)
         base_result = Google::APIClient::Result.new(@reference, @response)
         @result = Google::APIClient::Service::Result.new(@request, base_result)
       end
 
       it 'should not return a next page token' do
-        @result.next_page_token.should == nil
+        expect(@result.next_page_token).to eq(nil)
       end
 
       it 'should return content type correctly' do
-        @result.media_type.should == 'application/json'
+        expect(@result.media_type).to eq('application/json')
       end
 
       it 'should return the body correctly' do
-        @result.body.should == @body
+        expect(@result.body).to eq(@body)
       end
 
       it 'should return the result data correctly' do
-        @result.data?.should be_true
-        @result.data.class.to_s.should ==
+        expect(@result.data?).to be_truthy
+        expect(@result.data.class.to_s).to eq(
             'Google::APIClient::Schema::Plus::V1::ActivityFeed'
-        @result.data.kind.should == 'plus#activityFeed'
-        @result.data.etag.should == 'FOO'
-        @result.data.selfLink.should ==
+        )
+        expect(@result.data.kind).to eq('plus#activityFeed')
+        expect(@result.data.etag).to eq('FOO')
+        expect(@result.data.selfLink).to eq(
             'https://www.googleapis.com/plus/v1/people/foo/activities/public?'
-        @result.data.title.should == 'Plus Public Activity Feed for '
-        @result.data.id.should == "123456790"
-        @result.data.items.should be_empty
+        )
+        expect(@result.data.title).to eq('Plus Public Activity Feed for ')
+        expect(@result.data.id).to eq("123456790")
+        expect(@result.data.items).to be_empty
       end
     end
 
@@ -444,50 +449,77 @@ describe Google::APIClient::Service::Result do
           }
          }
          END_OF_STRING
-        @response.stub(:body).and_return(@body)
-        @response.stub(:status).and_return(400)
+        allow(@response).to receive(:body).and_return(@body)
+        allow(@response).to receive(:status).and_return(400)
         base_result = Google::APIClient::Result.new(@reference, @response)
         @result = Google::APIClient::Service::Result.new(@request, base_result)
       end
 
       it 'should return error status correctly' do
-        @result.error?.should be_true
+        expect(@result.error?).to be_truthy
       end
 
       it 'should return the correct error message' do
-        @result.error_message.should == 'Parse Error'
+        expect(@result.error_message).to eq('Parse Error')
       end
 
       it 'should return the body correctly' do
-        @result.body.should == @body
+        expect(@result.body).to eq(@body)
       end
     end
 
     describe 'with 204 No Content response' do
       before do
-        @response.stub(:body).and_return('')
-        @response.stub(:status).and_return(204)
-        @response.stub(:headers).and_return({})
+        allow(@response).to receive(:body).and_return('')
+        allow(@response).to receive(:status).and_return(204)
+        allow(@response).to receive(:headers).and_return({})
         base_result = Google::APIClient::Result.new(@reference, @response)
         @result = Google::APIClient::Service::Result.new(@request, base_result)
       end
 
       it 'should indicate no data is available' do
-        @result.data?.should be_false
+        expect(@result.data?).to be_falsey
       end
 
       it 'should return nil for data' do
-        @result.data.should == nil
+        expect(@result.data).to eq(nil)
       end
 
       it 'should return nil for media_type' do
-        @result.media_type.should == nil
+        expect(@result.media_type).to eq(nil)
       end
     end
   end
 end
 
-describe Google::APIClient::Service::BatchRequest do
+RSpec.describe Google::APIClient::Service::BatchRequest do
+  
+  include ConnectionHelpers
+  
+  context 'with a service connection' do
+    before do
+      @conn = stub_connection do |stub|
+        stub.post('/batch') do |env|
+          [500, {'Content-Type' => 'application/json'}, '{}']
+        end
+      end
+      @discovery = Google::APIClient::Service.new('discovery', 'v1',
+          {:application_name => APPLICATION_NAME, :authorization => nil,
+           :cache_store => nil, :connection => @conn})
+      @calls = [
+        @discovery.apis.get_rest(:api => 'plus', :version => 'v1'),
+        @discovery.apis.get_rest(:api => 'discovery', :version => 'v1')
+      ]
+    end
+
+    it 'should use the service connection' do
+      batch = @discovery.batch(@calls) do
+      end
+      batch.execute
+      @conn.verify
+    end  
+  end
+  
   describe 'with the discovery API' do
     before do
       @discovery = Google::APIClient::Service.new('discovery', 'v1',
@@ -507,11 +539,11 @@ describe Google::APIClient::Service::BatchRequest do
         block_called = 0
         batch = @discovery.batch(@calls) do |result|
           block_called += 1
-          result.status.should == 200
+          expect(result.status).to eq(200)
         end
 
         batch.execute
-        block_called.should == 2
+        expect(block_called).to eq(2)
       end
 
       it 'should execute both when using individual callbacks' do
@@ -520,19 +552,19 @@ describe Google::APIClient::Service::BatchRequest do
 
         batch.add(@calls[0]) do |result|
           call1_returned = true
-          result.status.should == 200
-          result.call_index.should == 0
+          expect(result.status).to eq(200)
+          expect(result.call_index).to eq(0)
         end
 
         batch.add(@calls[1]) do |result|
           call2_returned = true
-          result.status.should == 200
-          result.call_index.should == 1
+          expect(result.status).to eq(200)
+          expect(result.call_index).to eq(1)
         end
 
         batch.execute
-        call1_returned.should == true
-        call2_returned.should == true
+        expect(call1_returned).to eq(true)
+        expect(call2_returned).to eq(true)
       end
     end
 
@@ -549,15 +581,15 @@ describe Google::APIClient::Service::BatchRequest do
         batch = @discovery.batch(@calls) do |result|
           block_called += 1
           if result.call_index == 0
-            result.status.should == 200
+            expect(result.status).to eq(200)
           else
-            result.status.should >= 400
-            result.status.should < 500
+            expect(result.status).to be >= 400
+            expect(result.status).to be < 500
           end
         end
 
         batch.execute
-        block_called.should == 2
+        expect(block_called).to eq(2)
       end
 
       it 'should execute both when using individual callbacks' do
@@ -566,21 +598,21 @@ describe Google::APIClient::Service::BatchRequest do
 
         batch.add(@calls[0]) do |result|
           call1_returned = true
-          result.status.should == 200
-          result.call_index.should == 0
+          expect(result.status).to eq(200)
+          expect(result.call_index).to eq(0)
         end
 
         batch.add(@calls[1]) do |result|
           call2_returned = true
-          result.status.should >= 400
-          result.status.should < 500
-          result.call_index.should == 1
+          expect(result.status).to be >= 400
+          expect(result.status).to be < 500
+          expect(result.call_index).to eq(1)
         end
 
         batch.execute
-        call1_returned.should == true
-        call2_returned.should == true
-      end
+        expect(call1_returned).to eq(true)
+        expect(call2_returned).to eq(true)
+      end      
     end
   end
 end