google-api-client 0.7.1 → 0.8.0

data/spec/google/api_client/gzip_spec.rb

@@ -1,3 +1,4 @@
+# Encoding: utf-8
 # Copyright 2012 Google Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,12 +16,12 @@
 require 'spec_helper'
 
 require 'google/api_client'
-require 'google/api_client/version'
 
-describe Google::APIClient::Gzip do
+RSpec.describe Google::APIClient::Gzip do
 
   def create_connection(&block)
     Faraday.new do |b|
+      b.response :charset
       b.response :gzip
       b.adapter :test do |stub|
         stub.get '/', &block
@@ -33,7 +34,7 @@ describe Google::APIClient::Gzip do
       [200, {}, 'Hello world']
     end
     result = conn.get('/')
-    result.body.should == "Hello world"
+    expect(result.body).to eq("Hello world")
   end
 
   it 'should decompress gziped content' do
@@ -41,9 +42,20 @@ describe Google::APIClient::Gzip do
       [200, { 'Content-Encoding' => 'gzip'}, Base64.decode64('H4sICLVGwlEAA3RtcADzSM3JyVcozy/KSeECANXgObcMAAAA')]
     end
     result = conn.get('/')
-    result.body.should == "Hello world\n"
+    expect(result.body).to eq("Hello world\n")
   end
   
+  it 'should inflate with the correct charset encoding' do
+    conn = create_connection do |env|
+      [200, 
+        { 'Content-Encoding' => 'deflate', 'Content-Type' => 'application/json;charset=BIG5'}, 
+        Base64.decode64('eJxb8nLp7t2VAA8fBCI=')]
+    end
+    result = conn.get('/')
+    expect(result.body.encoding).to eq(Encoding::BIG5)
+    expect(result.body).to eq('日本語'.encode("BIG5"))
+  end
+
   describe 'with API Client' do
 
     before do
@@ -55,8 +67,8 @@ describe Google::APIClient::Gzip do
     it 'should send gzip in user agent' do
       conn = create_connection do |env|
         agent = env[:request_headers]['User-Agent']
-        agent.should_not be_nil
-        agent.should include 'gzip'
+        expect(agent).not_to be_nil
+        expect(agent).to include 'gzip'
         [200, {}, 'Hello world']
       end
       @client.execute(:uri => 'http://www.example.com/', :connection => conn)
@@ -65,8 +77,8 @@ describe Google::APIClient::Gzip do
     it 'should send gzip in accept-encoding' do
       conn = create_connection do |env|
         encoding = env[:request_headers]['Accept-Encoding']
-        encoding.should_not be_nil
-        encoding.should include 'gzip'
+        expect(encoding).not_to be_nil
+        expect(encoding).to include 'gzip'
         [200, {}, 'Hello world']
       end
       @client.execute(:uri => 'http://www.example.com/', :connection => conn)
@@ -75,7 +87,7 @@ describe Google::APIClient::Gzip do
     it 'should not send gzip in accept-encoding if disabled for request' do
       conn = create_connection do |env|
         encoding = env[:request_headers]['Accept-Encoding']
-        encoding.should_not include('gzip') unless encoding.nil?
+        expect(encoding).not_to include('gzip') unless encoding.nil?
         [200, {}, 'Hello world']
       end
       response = @client.execute(:uri => 'http://www.example.com/', :gzip => false, :connection => conn)

data/spec/google/api_client/media_spec.rb

@@ -15,15 +15,14 @@
 require 'spec_helper'
 
 require 'google/api_client'
-require 'google/api_client/version'
 
 fixtures_path = File.expand_path('../../../fixtures', __FILE__)
 
-describe Google::APIClient::UploadIO do
+RSpec.describe Google::APIClient::UploadIO do
   it 'should reject invalid file paths' do
-    (lambda do
+    expect(lambda do
       media = Google::APIClient::UploadIO.new('doesnotexist', 'text/plain')
-    end).should raise_error
+    end).to raise_error
   end
 
   describe 'with a file' do
@@ -33,11 +32,11 @@ describe Google::APIClient::UploadIO do
     end
 
     it 'should report the correct file length' do
-      @media.length.should == File.size(@file)
+      expect(@media.length).to eq(File.size(@file))
     end
 
     it 'should have a mime type' do
-      @media.content_type.should == 'text/plain'
+      expect(@media.content_type).to eq('text/plain')
     end
   end
 
@@ -48,64 +47,64 @@ describe Google::APIClient::UploadIO do
     end
 
     it 'should report the correct file length' do
-      @media.length.should == @content.length
+      expect(@media.length).to eq(@content.length)
     end
 
     it 'should have a mime type' do
-      @media.content_type.should == 'text/plain'
+      expect(@media.content_type).to eq('text/plain')
     end
   end
 end
 
-describe Google::APIClient::RangedIO do
+RSpec.describe Google::APIClient::RangedIO do
   before do
     @source = StringIO.new("1234567890abcdef")
     @io = Google::APIClient::RangedIO.new(@source, 1, 5)
   end
   
   it 'should return the correct range when read entirely' do
-    @io.read.should == "23456"
+    expect(@io.read).to eq("23456")
   end
   
   it 'should maintain position' do
-    @io.read(1).should == '2'
-    @io.read(2).should == '34'
-    @io.read(2).should == '56'
+    expect(@io.read(1)).to eq('2')
+    expect(@io.read(2)).to eq('34')
+    expect(@io.read(2)).to eq('56')
   end
   
   it 'should allow rewinds' do
-    @io.read(2).should == '23'
+    expect(@io.read(2)).to eq('23')
     @io.rewind()
-    @io.read(2).should == '23'
+    expect(@io.read(2)).to eq('23')
   end
   
   it 'should allow setting position' do
     @io.pos = 3
-    @io.read.should == '56'
+    expect(@io.read).to eq('56')
   end
   
   it 'should not allow position to be set beyond range' do
     @io.pos = 10
-    @io.read.should == ''
+    expect(@io.read).to eq('')
   end
   
   it 'should return empty string when read amount is zero' do
-    @io.read(0).should == ''
+    expect(@io.read(0)).to eq('')
   end
   
   it 'should return empty string at EOF if amount is nil' do
     @io.read
-    @io.read.should == ''
+    expect(@io.read).to eq('')
   end
   
   it 'should return nil at EOF if amount is positive int' do
     @io.read
-    @io.read(1).should == nil
+    expect(@io.read(1)).to eq(nil)
   end
     
 end
 
-describe Google::APIClient::ResumableUpload do
+RSpec.describe Google::APIClient::ResumableUpload do
   CLIENT = Google::APIClient.new(:application_name => 'API Client Tests') unless defined?(CLIENT)
 
   after do
@@ -127,26 +126,26 @@ describe Google::APIClient::ResumableUpload do
   it 'should consider 20x status as complete' do
     request = @uploader.to_http_request
     @uploader.process_http_response(mock_result(200))
-    @uploader.complete?.should == true
+    expect(@uploader.complete?).to eq(true)
   end
 
   it 'should consider 30x status as incomplete' do
     request = @uploader.to_http_request
     @uploader.process_http_response(mock_result(308))
-    @uploader.complete?.should == false
-    @uploader.expired?.should == false
+    expect(@uploader.complete?).to eq(false)
+    expect(@uploader.expired?).to eq(false)
   end
 
   it 'should consider 40x status as fatal' do
     request = @uploader.to_http_request
     @uploader.process_http_response(mock_result(404))
-    @uploader.expired?.should == true
+    expect(@uploader.expired?).to eq(true)
   end
 
   it 'should detect changes to location' do
     request = @uploader.to_http_request
     @uploader.process_http_response(mock_result(308, 'location' => 'https://www.googleapis.com/upload/drive/v1/files/abcdef'))
-    @uploader.uri.to_s.should == 'https://www.googleapis.com/upload/drive/v1/files/abcdef'
+    expect(@uploader.uri.to_s).to eq('https://www.googleapis.com/upload/drive/v1/files/abcdef')
   end
 
   it 'should resume from the saved range reported by the server' do    
@@ -154,8 +153,8 @@ describe Google::APIClient::ResumableUpload do
     @uploader.to_http_request # Send bytes 0-199, only 0-99 saved
     @uploader.process_http_response(mock_result(308, 'range' => '0-99'))
     method, url, headers, body = @uploader.to_http_request # Send bytes 100-299
-    headers['Content-Range'].should == "bytes 100-299/#{@media.length}"
-    headers['Content-length'].should == "200"
+    expect(headers['Content-Range']).to eq("bytes 100-299/#{@media.length}")
+    expect(headers['Content-length']).to eq("200")
   end
 
   it 'should resync the offset after 5xx errors' do
@@ -163,12 +162,12 @@ describe Google::APIClient::ResumableUpload do
     @uploader.to_http_request
     @uploader.process_http_response(mock_result(500)) # Invalidates range
     method, url, headers, body = @uploader.to_http_request # Resync
-    headers['Content-Range'].should == "bytes */#{@media.length}"
-    headers['Content-length'].should == "0"
+    expect(headers['Content-Range']).to eq("bytes */#{@media.length}")
+    expect(headers['Content-length']).to eq("0")
     @uploader.process_http_response(mock_result(308, 'range' => '0-99'))
     method, url, headers, body = @uploader.to_http_request # Send next chunk at correct range
-    headers['Content-Range'].should == "bytes 100-299/#{@media.length}"
-    headers['Content-length'].should == "200"
+    expect(headers['Content-Range']).to eq("bytes 100-299/#{@media.length}")
+    expect(headers['Content-length']).to eq("200")
   end
 
   def mock_result(status, headers = {})

data/spec/google/api_client/request_spec.rb

@@ -15,16 +15,15 @@
 require 'spec_helper'
 
 require 'google/api_client'
-require 'google/api_client/version'
 
-describe Google::APIClient::Request do
+RSpec.describe Google::APIClient::Request do
   CLIENT = Google::APIClient.new(:application_name => 'API Client Tests') unless defined?(CLIENT)
 
   it 'should normalize parameter names to strings' do
     request = Google::APIClient::Request.new(:uri => 'https://www.google.com', :parameters => {
       :a => '1', 'b' => '2'
     })
-    request.parameters['a'].should == '1'
-    request.parameters['b'].should == '2'
+    expect(request.parameters['a']).to eq('1')
+    expect(request.parameters['b']).to eq('2')
   end
 end

data/spec/google/api_client/result_spec.rb

@@ -15,9 +15,8 @@
 require 'spec_helper'
 
 require 'google/api_client'
-require 'google/api_client/version'
 
-describe Google::APIClient::Result do
+RSpec.describe Google::APIClient::Result do
   CLIENT = Google::APIClient.new(:application_name => 'API Client Tests') unless defined?(CLIENT)
 
   describe 'with the plus API' do
@@ -36,8 +35,8 @@ describe Google::APIClient::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',
@@ -51,7 +50,7 @@ describe Google::APIClient::Result do
 
     describe 'with a next page token' do
       before do
-        @response.stub(:body).and_return(
+        allow(@response).to receive(:body).and_return(
           <<-END_OF_STRING
           {
             "kind": "plus#activityFeed",
@@ -70,46 +69,49 @@ describe Google::APIClient::Result do
       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 'should escape the next page token when calling next_page' do
         reference = @result.next_page
-        Hash[reference.parameters].should include('pageToken')
-        Hash[reference.parameters]['pageToken'].should == 'NEXT+PAGE+TOKEN'
+        expect(Hash[reference.parameters]).to include('pageToken')
+        expect(Hash[reference.parameters]['pageToken']).to eq('NEXT+PAGE+TOKEN')
         url = reference.to_env(CLIENT.connection)[:url]
-        url.to_s.should include('pageToken=NEXT%2BPAGE%2BTOKEN')
+        expect(url.to_s).to include('pageToken=NEXT%2BPAGE%2BTOKEN')
       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 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
 
     describe 'without a next page token' do
       before do
-        @response.stub(:body).and_return(
+        allow(@response).to receive(:body).and_return(
           <<-END_OF_STRING
           {
             "kind": "plus#activityFeed",
@@ -126,30 +128,32 @@ describe Google::APIClient::Result do
       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 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
-    
+
     describe 'with JSON error response' do
       before do
-        @response.stub(:body).and_return(
+        allow(@response).to receive(:body).and_return(
          <<-END_OF_STRING
          {
           "error": {
@@ -166,37 +170,37 @@ describe Google::APIClient::Result do
          }
          END_OF_STRING
         )
-        @response.stub(:status).and_return(400)
+        allow(@response).to receive(:status).and_return(400)
         @result = Google::APIClient::Result.new(@reference, @response)
       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
     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({})
         @result = Google::APIClient::Result.new(@reference, @response)
       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