arvados-google-api-client 0.8.7.2

data/spec/google/api_client/gzip_spec.rb

@@ -0,0 +1,98 @@
+# Encoding: utf-8
+# Copyright 2012 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'spec_helper'
+
+require 'google/api_client'
+
+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
+      end
+    end
+  end  
+
+  it 'should ignore non-zipped content' do
+    conn = create_connection do |env|
+      [200, {}, 'Hello world']
+    end
+    result = conn.get('/')
+    expect(result.body).to eq("Hello world")
+  end
+
+  it 'should decompress gziped content' do
+    conn = create_connection do |env|
+      [200, { 'Content-Encoding' => 'gzip'}, Base64.decode64('H4sICLVGwlEAA3RtcADzSM3JyVcozy/KSeECANXgObcMAAAA')]
+    end
+    result = conn.get('/')
+    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
+      @client = Google::APIClient.new(:application_name => 'test')
+      @client.authorization = nil
+    end
+    
+    
+    it 'should send gzip in user agent' do
+      conn = create_connection do |env|
+        agent = env[:request_headers]['User-Agent']
+        expect(agent).not_to be_nil
+        expect(agent).to include 'gzip'
+        [200, {}, 'Hello world']
+      end
+      @client.execute(:uri => 'http://www.example.com/', :connection => conn)
+    end
+
+    it 'should send gzip in accept-encoding' do
+      conn = create_connection do |env|
+        encoding = env[:request_headers]['Accept-Encoding']
+        expect(encoding).not_to be_nil
+        expect(encoding).to include 'gzip'
+        [200, {}, 'Hello world']
+      end
+      @client.execute(:uri => 'http://www.example.com/', :connection => conn)
+    end
+    
+    it 'should not send gzip in accept-encoding if disabled for request' do
+      conn = create_connection do |env|
+        encoding = env[:request_headers]['Accept-Encoding']
+        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)
+      puts response.status
+    end
+    
+  end
+end

data/spec/google/api_client/media_spec.rb

@@ -0,0 +1,178 @@
+# Copyright 2012 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'spec_helper'
+
+require 'google/api_client'
+
+fixtures_path = File.expand_path('../../../fixtures', __FILE__)
+
+RSpec.describe Google::APIClient::UploadIO do
+  it 'should reject invalid file paths' do
+    expect(lambda do
+      media = Google::APIClient::UploadIO.new('doesnotexist', 'text/plain')
+    end).to raise_error
+  end
+
+  describe 'with a file' do
+    before do
+      @file = File.expand_path('files/sample.txt', fixtures_path)
+      @media = Google::APIClient::UploadIO.new(@file, 'text/plain')
+    end
+
+    it 'should report the correct file length' do
+      expect(@media.length).to eq(File.size(@file))
+    end
+
+    it 'should have a mime type' do
+      expect(@media.content_type).to eq('text/plain')
+    end
+  end
+
+  describe 'with StringIO' do
+    before do
+      @content = "hello world"
+      @media = Google::APIClient::UploadIO.new(StringIO.new(@content), 'text/plain', 'test.txt')
+    end
+
+    it 'should report the correct file length' do
+      expect(@media.length).to eq(@content.length)
+    end
+
+    it 'should have a mime type' do
+      expect(@media.content_type).to eq('text/plain')
+    end
+  end
+end
+
+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
+    expect(@io.read).to eq("23456")
+  end
+  
+  it 'should maintain position' do
+    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
+    expect(@io.read(2)).to eq('23')
+    @io.rewind()
+    expect(@io.read(2)).to eq('23')
+  end
+  
+  it 'should allow setting position' do
+    @io.pos = 3
+    expect(@io.read).to eq('56')
+  end
+  
+  it 'should not allow position to be set beyond range' do
+    @io.pos = 10
+    expect(@io.read).to eq('')
+  end
+  
+  it 'should return empty string when read amount is zero' do
+    expect(@io.read(0)).to eq('')
+  end
+  
+  it 'should return empty string at EOF if amount is nil' do
+    @io.read
+    expect(@io.read).to eq('')
+  end
+  
+  it 'should return nil at EOF if amount is positive int' do
+    @io.read
+    expect(@io.read(1)).to eq(nil)
+  end
+    
+end
+
+RSpec.describe Google::APIClient::ResumableUpload do
+  CLIENT = Google::APIClient.new(:application_name => 'API Client Tests') unless defined?(CLIENT)
+
+  after do
+    # Reset client to not-quite-pristine state
+    CLIENT.key = nil
+    CLIENT.user_ip = nil
+  end
+
+  before do
+    @drive = CLIENT.discovered_api('drive', 'v2')
+    @file = File.expand_path('files/sample.txt', fixtures_path)
+    @media = Google::APIClient::UploadIO.new(@file, 'text/plain')
+    @uploader = Google::APIClient::ResumableUpload.new(
+      :media => @media,
+      :api_method => @drive.files.insert,
+      :uri => 'https://www.googleapis.com/upload/drive/v1/files/12345')
+  end
+
+  it 'should consider 20x status as complete' do
+    request = @uploader.to_http_request
+    @uploader.process_http_response(mock_result(200))
+    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))
+    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))
+    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'))
+    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    
+    @uploader.chunk_size = 200
+    @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
+    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
+    @uploader.chunk_size = 200
+    @uploader.to_http_request
+    @uploader.process_http_response(mock_result(500)) # Invalidates range
+    method, url, headers, body = @uploader.to_http_request # Resync
+    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
+    expect(headers['Content-Range']).to eq("bytes 100-299/#{@media.length}")
+    expect(headers['Content-length']).to eq("200")
+  end
+
+  def mock_result(status, headers = {})
+    reference = Google::APIClient::Reference.new(:api_method => @drive.files.insert)
+    double('result', :status => status, :headers => headers, :reference => reference)
+  end
+
+end

data/spec/google/api_client/request_spec.rb

@@ -0,0 +1,29 @@
+# Copyright 2012 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'spec_helper'
+
+require 'google/api_client'
+
+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'
+    })
+    expect(request.parameters['a']).to eq('1')
+    expect(request.parameters['b']).to eq('2')
+  end
+end

data/spec/google/api_client/result_spec.rb

@@ -0,0 +1,207 @@
+# Copyright 2012 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'spec_helper'
+
+require 'google/api_client'
+
+RSpec.describe Google::APIClient::Result do
+  CLIENT = Google::APIClient.new(:application_name => 'API Client Tests') unless defined?(CLIENT)
+
+  describe 'with the plus API' do
+    before do
+      CLIENT.authorization = nil
+      @plus = CLIENT.discovered_api('plus', 'v1')
+      @reference = Google::APIClient::Reference.new({
+        :api_method => @plus.activities.list,
+        :parameters => {
+          'userId' => 'me',
+          'collection' => 'public',
+          'maxResults' => 20
+        }
+      })
+      @request = @reference.to_http_request
+
+      # Response double
+      @response = double("response")
+      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',
+        'content-type' => 'application/json; charset=UTF-8',
+        'date' => 'Mon, 23 Apr 2012 00:00:00 GMT',
+        'cache-control' => 'private, max-age=0, must-revalidate, no-transform',
+        'server' => 'GSE',
+        'connection' => 'close'
+      })
+    end
+
+    describe 'with a next page token' do
+      before do
+        allow(@response).to receive(:body).and_return(
+          <<-END_OF_STRING
+          {
+            "kind": "plus#activityFeed",
+            "etag": "FOO",
+            "nextPageToken": "NEXT+PAGE+TOKEN",
+            "selfLink": "https://www.googleapis.com/plus/v1/people/foo/activities/public?",
+            "nextLink": "https://www.googleapis.com/plus/v1/people/foo/activities/public?maxResults=20&pageToken=NEXT%2BPAGE%2BTOKEN",
+            "title": "Plus Public Activity Feed for ",
+            "updated": "2012-04-23T00:00:00.000Z",
+            "id": "123456790",
+            "items": []
+          }
+          END_OF_STRING
+        )
+        @result = Google::APIClient::Result.new(@reference, @response)
+      end
+
+      it 'should indicate a successful response' do
+        expect(@result.error?).to be_falsey
+      end
+
+      it 'should return the correct next page token' do
+        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
+        expect(Hash[reference.parameters]).to include('pageToken')
+        expect(Hash[reference.parameters]['pageToken']).to eq('NEXT+PAGE+TOKEN')
+        url = reference.to_env(CLIENT.connection)[:url]
+        expect(url.to_s).to include('pageToken=NEXT%2BPAGE%2BTOKEN')
+      end
+
+      it 'should return content type correctly' do
+        expect(@result.media_type).to eq('application/json')
+      end
+
+      it 'should return the result data correctly' do
+        expect(@result.data?).to be_truthy
+        expect(@result.data.class.to_s).to eq(
+            'Google::APIClient::Schema::Plus::V1::ActivityFeed'
+        )
+        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?'
+        )
+        expect(@result.data.nextLink).to eq(
+            'https://www.googleapis.com/plus/v1/people/foo/activities/public?' +
+            'maxResults=20&pageToken=NEXT%2BPAGE%2BTOKEN'
+        )
+        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
+        allow(@response).to receive(:body).and_return(
+          <<-END_OF_STRING
+          {
+            "kind": "plus#activityFeed",
+            "etag": "FOO",
+            "selfLink": "https://www.googleapis.com/plus/v1/people/foo/activities/public?",
+            "title": "Plus Public Activity Feed for ",
+            "updated": "2012-04-23T00:00:00.000Z",
+            "id": "123456790",
+            "items": []
+          }
+          END_OF_STRING
+        )
+        @result = Google::APIClient::Result.new(@reference, @response)
+      end
+
+      it 'should not return a next page token' do
+        expect(@result.next_page_token).to eq(nil)
+      end
+
+      it 'should return content type correctly' do
+        expect(@result.media_type).to eq('application/json')
+      end
+
+      it 'should return the result data correctly' do
+        expect(@result.data?).to be_truthy
+        expect(@result.data.class.to_s).to eq(
+            'Google::APIClient::Schema::Plus::V1::ActivityFeed'
+        )
+        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?'
+        )
+        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
+        allow(@response).to receive(:body).and_return(
+         <<-END_OF_STRING
+         {
+          "error": {
+           "errors": [
+            {
+             "domain": "global",
+             "reason": "parseError",
+             "message": "Parse Error"
+            }
+           ],
+           "code": 400,
+           "message": "Parse Error"
+          }
+         }
+         END_OF_STRING
+        )
+        allow(@response).to receive(:status).and_return(400)
+        @result = Google::APIClient::Result.new(@reference, @response)
+      end
+
+      it 'should return error status correctly' do
+        expect(@result.error?).to be_truthy
+      end
+
+      it 'should return the correct error message' do
+        expect(@result.error_message).to eq('Parse Error')
+      end
+    end
+
+    describe 'with 204 No Content response' do
+      before do
+        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
+        expect(@result.data?).to be_falsey
+      end
+
+      it 'should return nil for data' do
+        expect(@result.data).to eq(nil)
+      end
+
+      it 'should return nil for media_type' do
+        expect(@result.media_type).to eq(nil)
+      end
+    end
+  end
+end