google-api-client 0.8.7 → 0.9.pre1

data/spec/google/api_client/gzip_spec.rb

@@ -1,98 +0,0 @@
-# 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

@@ -1,178 +0,0 @@
-# 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/result_spec.rb

@@ -1,207 +0,0 @@
-# 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