google-api-client 0.9.5 → 0.9.6

data/spec/google/apis/core/service_spec.rb

@@ -1,313 +0,0 @@
-# Copyright 2015 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/apis/options'
-require 'google/apis/core/base_service'
-require 'google/apis/core/json_representation'
-require 'hurley/test'
-require 'ostruct'
-
-RSpec.describe Google::Apis::Core::BaseService do
-  include TestHelpers
-
-  let(:service) { Google::Apis::Core::BaseService.new('https://www.googleapis.com/', '') }
-
-  before do
-    Google::Apis::ClientOptions.default.application_name = 'test'
-    Google::Apis::ClientOptions.default.application_version = '1.0'
-  end
-
-  it 'should inherit default options' do
-    expect(service.client_options.application_name).to eql 'test'
-  end
-
-  it 'should include application in user agent' do
-    agent = service.send(:user_agent)
-    expect(agent).to match /^test\/1.0/
-  end
-
-  it 'should inherit authorization' do
-    Google::Apis::RequestOptions.default.authorization = 'a token'
-    expect(service.authorization).to eql 'a token'
-  end
-
-  it 'should allow overiding authorization' do
-    Google::Apis::RequestOptions.default.authorization = 'a token'
-    service.authorization = 'another token'
-    expect(service.authorization).to eql 'another token'
-  end
-
-  shared_examples 'with options' do
-    it 'should inherit service options' do
-      service.request_options.retries = 2
-      expect(command.options.retries).to eql 2
-    end
-
-    it 'should include per-request options' do
-      expect(command.options.authorization).to eql 'foo'
-    end
-
-    it 'should allow per-request options to override service options' do
-      service.request_options.authorization = 'bar'
-      expect(command.options.authorization).to eql 'foo'
-    end
-  end
-
-  context 'when making raw http requests' do
-    context 'with :get methods' do
-      before(:example) do
-        stub_request(:get, 'https://www.googleapis.com/zoo/animals').to_return(body: 'hello world')
-      end
-
-      it 'should return body for get' do
-        response = service.http(:get, 'https://www.googleapis.com/zoo/animals')
-        expect(response).to eq 'hello world'
-      end
-
-      it 'should return allow downloads' do
-        response = service.http(:get, 'https://www.googleapis.com/zoo/animals', download_dest: StringIO.new)
-        expect(response.string).to eq 'hello world'
-      end
-    end
-
-    context 'with :post methods' do
-      before(:example) do
-        stub_request(:post, 'https://www.googleapis.com/zoo/animals').to_return(body: '')
-      end
-
-      it 'should post body' do
-        service.http(:post, 'https://www.googleapis.com/zoo/animals', body: 'hello')
-        expect(a_request(:post, 'https://www.googleapis.com/zoo/animals')
-          .with(body: 'hello')).to have_been_made
-      end
-    end
-  end
-
-  context 'when making simple commands' do
-    let(:command) { service.send(:make_simple_command, :get, 'zoo/animals', authorization: 'foo') }
-
-    it 'should return the correct command type' do
-      expect(command).to be_an_instance_of(Google::Apis::Core::ApiCommand)
-    end
-
-    it 'should build a correct URL' do
-      url = command.url.expand({}).to_s
-      expect(url).to eql 'https://www.googleapis.com/zoo/animals'
-    end
-
-    include_examples 'with options'
-  end
-
-  context 'when making download commands' do
-    let(:command) { service.send(:make_download_command, :get, 'zoo/animals', authorization: 'foo') }
-
-    it 'should return the correct command type' do
-      expect(command).to be_an_instance_of(Google::Apis::Core::DownloadCommand)
-    end
-
-    it 'should build a correct URL' do
-      url = command.url.expand({}).to_s
-      expect(url).to eql 'https://www.googleapis.com/zoo/animals'
-    end
-
-    it 'should include alt=media in params' do
-      expect(command.query).to include('alt' => 'media')
-    end
-
-    include_examples 'with options'
-  end
-
-  context 'when making upload commands' do
-    let(:command) { service.send(:make_upload_command, :post, 'zoo/animals', authorization: 'foo') }
-
-    it 'should return the correct command type' do
-      expect(command).to be_an_instance_of(Google::Apis::Core::ResumableUploadCommand)
-    end
-
-    it 'should build a correct URL' do
-      url = command.url.expand({}).to_s
-      expect(url).to eql 'https://www.googleapis.com/upload/zoo/animals'
-    end
-
-    include_examples 'with options'
-  end
-
-  context 'with batch' do
-    before(:example) do
-      response = <<EOF.gsub(/\n/, "\r\n")
---batch123
-Content-Type: application/http
-
-HTTP/1.1 200 OK
-Content-Type: text/plain; charset=UTF-8
-
-Hello
---batch123--
-EOF
-      stub_request(:post, 'https://www.googleapis.com/batch')
-        .to_return(headers: { 'Content-Type' => 'multipart/mixed; boundary=batch123' }, body: response)
-    end
-
-    it 'should add commands to a batch' do
-      expect do |b|
-        service.batch do |service|
-          command = service.send(:make_simple_command, :get, 'zoo/animals', {})
-          service.send(:execute_or_queue_command, command, &b)
-        end
-      end.to yield_with_args('Hello', nil)
-    end
-
-    it 'should disallow uploads in batch' do
-      expect do |b|
-        service.batch do |service|
-          command = service.send(:make_upload_command, :post, 'zoo/animals', {})
-          service.send(:execute_or_queue_command, command, &b)
-        end
-      end.to raise_error(Google::Apis::ClientError)
-    end
-
-    it 'should disallow downloads in batch' do
-      expect do |b|
-        service.batch do |service|
-          command = service.send(:make_download_command, :get, 'zoo/animals', {})
-          service.send(:execute_or_queue_command, command, &b)
-        end
-      end.to raise_error(Google::Apis::ClientError)
-    end
-  end
-
-  context 'with batch uploads' do
-    before(:example) do
-      response = <<EOF.gsub(/\n/, "\r\n")
---batch123
-Content-Type: application/http
-
-HTTP/1.1 200 OK
-Content-Type: text/plain; charset=UTF-8
-
-Hello
---batch123--
-EOF
-      stub_request(:put, 'https://www.googleapis.com/upload/')
-        .to_return(headers: { 'Content-Type' => 'multipart/mixed; boundary=batch123' }, body: response)
-    end
-
-    it 'should add upload to a batch' do
-      expect do |b|
-        service.batch_upload do |service|
-          command = service.send(:make_upload_command, :post, 'zoo/animals', {})
-          command.upload_source = StringIO.new('test')
-          command.upload_content_type = 'text/plain'
-          service.send(:execute_or_queue_command, command, &b)
-        end
-      end.to yield_with_args('Hello', nil)
-    end
-
-    it 'should use multipart upload' do
-      expect do |b|
-        service.batch_upload do |service|
-          command = service.send(:make_upload_command, :post, 'zoo/animals', {})
-          command.upload_source = StringIO.new('test')
-          command.upload_content_type = 'text/plain'
-          expect(command).to be_an_instance_of(Google::Apis::Core::MultipartUploadCommand)
-          service.send(:execute_or_queue_command, command, &b)
-        end
-      end.to yield_with_args('Hello', nil)
-    end
-
-    it 'should disallow downloads in batch' do
-      expect do |b|
-        service.batch_upload do |service|
-          command = service.send(:make_download_command, :get, 'zoo/animals', {})
-          service.send(:execute_or_queue_command, command, &b)
-        end
-      end.to raise_error(Google::Apis::ClientError)
-    end
-
-    it 'should disallow simple commands in batch' do
-      expect do |b|
-        service.batch_upload do |service|
-          command = service.send(:make_simple_command, :get, 'zoo/animals', {})
-          service.send(:execute_or_queue_command, command, &b)
-        end
-      end.to raise_error(Google::Apis::ClientError)
-    end
-
-    context 'with fetch_all' do
-      let(:responses) do
-        data = {}
-        data[nil] = OpenStruct.new(next_page_token: 'p1', items: ['a', 'b', 'c'], alt_items: [1, 2 , 3])
-        data['p1'] = OpenStruct.new(next_page_token: 'p2', items: ['d', 'e', 'f'], alt_items: [4, 5, 6])
-        data['p2'] = OpenStruct.new(next_page_token: nil, items: ['g', 'h', 'i'], alt_items: [7,8, 9])
-        data
-      end
-
-      let(:items) { service.fetch_all { |token| responses[token] } }
-
-      it 'should fetch pages until next page token is nil' do
-        expect(items).to contain_exactly('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i')
-      end
-
-      it 'should stop on repeated page token' do
-        responses['p2'].next_page_token = 'p2'
-        expect(items).to contain_exactly('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i')
-      end
-
-      it 'should allow selecting another field for items' do
-        expect(service.fetch_all(items: :alt_items) { |token| responses[token] } ).to contain_exactly(1, 2, 3, 4, 5, 6, 7, 8, 9)
-      end
-
-      it 'should allow limiting the number of items to fetch' do
-        expect(service.fetch_all(max: 5) { |token| responses[token] } ).to contain_exactly('a', 'b', 'c', 'd', 'e')
-      end
-
-      it 'should yield the next token' do
-        expect do |b|
-          service.fetch_all do |token|
-            b.to_proc.call(token)
-            responses[token]
-          end.count
-        end.to yield_successive_args(nil, 'p1', 'p2')
-      end
-
-      it 'should cache results' do
-        count = 0
-        items = service.fetch_all do |token|
-          count = count + 1
-          responses[token]
-        end
-
-        items.each{ |i| puts i }
-        items.each{ |i| puts i }
-
-        expect(count).to eq 3
-      end
-
-      it 'should allow disabling caching' do
-        count = 0
-        items = service.fetch_all(cache: false) do |token|
-          count = count + 1
-          responses[token]
-        end
-
-        items.each{ |i| puts i }
-        items.each{ |i| puts i }
-
-        expect(count).to eq 6
-      end
-
-    end
-  end
-end

data/spec/google/apis/core/upload_spec.rb

@@ -1,300 +0,0 @@
-# Copyright 2015 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/apis/core/upload'
-require 'google/apis/core/json_representation'
-require 'hurley/test'
-
-# TODO: JSON Response decoding
-# TODO: Upload from IO
-# TODO: Upload from file
-
-RSpec.describe Google::Apis::Core::UploadIO do
-  context 'from_file' do
-    let(:upload_io) { Google::Apis::Core::UploadIO.from_file(file) }
-
-    context 'with text file' do
-      let(:file) { File.join(FIXTURES_DIR, 'files', 'test.txt') }
-      it 'should infer content type from file' do
-        expect(upload_io.content_type).to eql('text/plain')
-      end
-
-      it 'should allow overriding the mime type' do
-        io = Google::Apis::Core::UploadIO.from_file(file, content_type: 'application/json')
-        expect(io.content_type).to eql('application/json')
-      end
-    end
-
-    context 'with unknown type' do
-      let(:file) { File.join(FIXTURES_DIR, 'files', 'test.blah') }
-      it 'should use the default mime type' do
-        expect(upload_io.content_type).to eql('application/octet-stream')
-      end
-
-      it 'should allow overriding the mime type' do
-        io = Google::Apis::Core::UploadIO.from_file(file, content_type: 'application/json')
-        expect(io.content_type).to eql('application/json')
-      end
-
-      it 'should setup length of the stream' do
-        upload_io = Google::Apis::Core::UploadIO.from_file(file)
-        expect(upload_io.length).to eq File.size(file)
-      end
-
-    end
-  end
-
-  context 'from_io' do
-
-    context 'with i/o stream' do
-      let(:io) { StringIO.new 'Hello google' }
-
-      it 'should setup default content-type' do
-        upload_io = Google::Apis::Core::UploadIO.from_io(io)
-        expect(upload_io.content_type).to eql Google::Apis::Core::UploadIO::OCTET_STREAM_CONTENT_TYPE
-      end
-
-      it 'should allow overring the mime type' do
-        upload_io = Google::Apis::Core::UploadIO.from_io(io, content_type: 'application/x-gzip')
-        expect(upload_io.content_type).to eq('application/x-gzip')
-      end
-
-      it 'should setup length of the stream' do
-        upload_io = Google::Apis::Core::UploadIO.from_io(io)
-        expect(upload_io.length).to eq 'Hello google'.length
-      end
-    end
-
-  end
-end
-
-RSpec.describe Google::Apis::Core::RawUploadCommand do
-  include TestHelpers
-  include_context 'HTTP client'
-
-  let(:command) do
-    command = Google::Apis::Core::RawUploadCommand.new(:post, 'https://www.googleapis.com/zoo/animals')
-    command.upload_source = file
-    command.upload_content_type = 'text/plain'
-    command
-  end
-
-  shared_examples 'should upload' do
-    before(:example) do
-      stub_request(:post, 'https://www.googleapis.com/zoo/animals').to_return(body: '')
-    end
-
-    it 'should send content' do
-      command.execute(client)
-      expect(a_request(:post, 'https://www.googleapis.com/zoo/animals')
-        .with(body: "Hello world\n")).to have_been_made
-    end
-
-    it 'should send upload protocol' do
-      command.execute(client)
-      expect(a_request(:post, 'https://www.googleapis.com/zoo/animals')
-        .with { |req| req.headers['X-Goog-Upload-Protocol'] == 'raw' }).to have_been_made
-    end
-
-    it 'should send content-type header' do
-      command.execute(client)
-      expect(a_request(:post, 'https://www.googleapis.com/zoo/animals')
-        .with { |req| req.headers['X-Goog-Upload-Header-Content-Type'] == 'text/plain' }).to have_been_made
-    end
-  end
-
-  context('with StringIO input') do
-    let(:file) { StringIO.new("Hello world\n") }
-    include_examples 'should upload'
-  end
-
-  context('with IO input') do
-    let(:file) { File.open(File.join(FIXTURES_DIR, 'files', 'test.txt'), 'r') }
-    include_examples 'should upload'
-
-    it 'should not close stream' do
-      expect(file.closed?).to be false
-    end
-  end
-
-  context('with Tempfile input') do
-    let(:file) do
-      temp_file = Tempfile.new("tempfile")
-      temp_file.write("Hello world\n")
-      temp_file.rewind
-      temp_file
-    end
-    include_examples 'should upload'
-
-    it 'should not close stream' do
-      expect(file.closed?).to be false
-    end
-  end
-
-  context('with file path input') do
-    let(:file) { File.join(FIXTURES_DIR, 'files', 'test.txt') }
-    include_examples 'should upload'
-  end
-
-  context('with invalid input') do
-    let(:file) { -> {} }
-    it 'should raise client error' do
-      expect { command.execute(client) }.to raise_error(Google::Apis::ClientError)
-    end
-  end
-end
-
-RSpec.describe Google::Apis::Core::MultipartUploadCommand do
-  include TestHelpers
-  include_context 'HTTP client'
-
-  let(:command) do
-    command = Google::Apis::Core::MultipartUploadCommand.new(:post, 'https://www.googleapis.com/zoo/animals')
-    command.upload_source = StringIO.new('Hello world')
-    command.upload_content_type = 'text/plain'
-    command.body = 'metadata'
-    command
-  end
-
-  before(:example) do
-    stub_request(:post, 'https://www.googleapis.com/zoo/animals').to_return(body: %(Hello world))
-  end
-
-  it 'should send content' do
-    expected_body = <<EOF.gsub(/\n/, "\r\n")
---RubyApiClientUpload
-Content-Type: application/json
-
-metadata
---RubyApiClientUpload
-Content-Length: 11
-Content-Type: text/plain
-Content-Transfer-Encoding: binary
-
-Hello world
---RubyApiClientUpload--
-
-EOF
-    command.execute(client)
-    expect(a_request(:post, 'https://www.googleapis.com/zoo/animals')
-      .with(body: expected_body)).to have_been_made
-  end
-
-  it 'should send upload protocol' do
-    command.execute(client)
-    expect(a_request(:post, 'https://www.googleapis.com/zoo/animals')
-      .with { |req| req.headers['X-Goog-Upload-Protocol'] == 'multipart' }).to have_been_made
-  end
-end
-
-RSpec.describe Google::Apis::Core::ResumableUploadCommand do
-  include TestHelpers
-  include_context 'HTTP client'
-
-  let(:command) do
-    command = Google::Apis::Core::ResumableUploadCommand.new(:post, 'https://www.googleapis.com/zoo/animals')
-    command.upload_source = StringIO.new('Hello world')
-    command.upload_content_type = 'text/plain'
-    command
-  end
-
-  context 'with uninterrupted upload' do
-    before(:example) do
-      stub_request(:post, 'https://www.googleapis.com/zoo/animals')
-        .to_return(headers: { 'X-Goog-Upload-Status' => 'active', 'X-Goog-Upload-URL' => 'https://www.googleapis.com/zoo/animals' })
-        .to_return(headers: { 'X-Goog-Upload-Status' => 'final' }, body: %(OK))
-    end
-
-    it 'should send upload protocol' do
-      command.execute(client)
-      expect(a_request(:post, 'https://www.googleapis.com/zoo/animals')
-        .with { |req| req.headers['X-Goog-Upload-Protocol'] == 'resumable' }).to have_been_made
-    end
-
-    it 'should send start command' do
-      command.execute(client)
-      expect(a_request(:post, 'https://www.googleapis.com/zoo/animals')
-        .with { |req| req.headers['X-Goog-Upload-Command'] == 'start' }).to have_been_made
-    end
-
-    it 'should send upload command' do
-      command.execute(client)
-      expect(a_request(:post, 'https://www.googleapis.com/zoo/animals')
-        .with { |req| req.headers['X-Goog-Upload-Command'].include?('upload') }).to have_been_made
-    end
-
-    it 'should send upload content' do
-      command.execute(client)
-      expect(a_request(:post, 'https://www.googleapis.com/zoo/animals')
-        .with(body: 'Hello world')).to have_been_made
-    end
-  end
-
-  context 'with retriable error on start' do
-    before(:example) do
-      stub_request(:post, 'https://www.googleapis.com/zoo/animals')
-        .to_timeout
-        .to_return(headers: { 'X-Goog-Upload-Status' => 'active', 'X-Goog-Upload-URL' => 'https://www.googleapis.com/zoo/animals' })
-        .to_return(headers: { 'X-Goog-Upload-Status' => 'active', 'X-Goog-Upload-Size-Received' => '6' })
-        .to_return(headers: { 'X-Goog-Upload-Status' => 'final' }, body: %(OK))
-    end
-
-    it 'should retry start command and continue' do
-      command.execute(client)
-      expect(a_request(:post, 'https://www.googleapis.com/zoo/animals')
-        .with(body: 'Hello world')).to have_been_made
-    end
-  end
-
-  context 'with non-retriable authorization error on start' do
-    before(:example) do
-      stub_request(:post, 'https://www.googleapis.com/zoo/animals')
-        .to_return(status: [401, 'unauthorized'], headers: { 'X-Goog-Upload-Status' => 'final' }, body: %(unauthorized))
-    end
-
-    it 'should propagate the original error' do
-      expect { command.execute(client) }.to raise_error Google::Apis::AuthorizationError
-    end
-  end
-
-  context 'with interruption' do
-    before(:example) do
-      stub_request(:post, 'https://www.googleapis.com/zoo/animals')
-        .to_return(headers: { 'X-Goog-Upload-Status' => 'active', 'X-Goog-Upload-URL' => 'https://www.googleapis.com/zoo/animals' })
-        .to_return(status: [500, 'Server error'])
-        .to_return(headers: { 'X-Goog-Upload-Status' => 'active', 'X-Goog-Upload-Size-Received' => '6' })
-        .to_return(headers: { 'X-Goog-Upload-Status' => 'final' }, body: %(OK))
-    end
-
-    it 'should send remaining upload content after failure' do
-      command.execute(client)
-      expect(a_request(:post, 'https://www.googleapis.com/zoo/animals')
-        .with(body: 'world')).to have_been_made
-    end
-  end
-
-  context 'with cancelled upload' do
-    before(:example) do
-      stub_request(:post, 'https://www.googleapis.com/zoo/animals')
-        .to_return(headers: { 'X-Goog-Upload-Status' => 'active', 'X-Goog-Upload-URL' => 'https://www.googleapis.com/zoo/animals' })
-        .to_return(status: [500, 'Server error'])
-        .to_return(headers: { 'X-Goog-Upload-Status' => 'cancelled' })
-    end
-
-    it 'should raise error' do
-      expect { command.execute(client) }.to raise_error Google::Apis::ClientError
-    end
-  end
-end