google-api-ruby-client/spec/google/apis/core/service_spec.rb

413 lines
13 KiB
Ruby
Raw Normal View History

# 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'
RSpec.describe Google::Apis::Core::BaseService do
include TestHelpers
let(:service) { Google::Apis::Core::BaseService.new('https://www.googleapis.com/', '') }
let(:x_goog_api_client_value) { "gl-ruby/#{RUBY_VERSION} gdcl/#{Google::Apis::VERSION}" }
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 include os version in user agent' do
agent = service.send(:user_agent)
expect(agent).to match /#{Google::Apis::OS_VERSION}/
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 'with proxy' do
after(:example) do
Google::Apis::ClientOptions.default.proxy_url = nil
end
it 'should allow proxy URLs as strings' do
Google::Apis::ClientOptions.default.proxy_url = 'http://gateway.example.com:1234'
service.client
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
it 'should send the command with x-goog-api-client header' do
stub_request(:get, 'https://www.googleapis.com/zoo/animals').to_return(body: '')
service.send(:execute_or_queue_command, command)
expected_headers = {'X-Goog-Api-Client': x_goog_api_client_value}
expect(a_request(:get, 'https://www.googleapis.com/zoo/animals').with(headers: expected_headers)).to have_been_made
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
it 'should prevent mixing services in 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)
service2 = service.dup
command2 = service.send(:make_simple_command, :get, 'zoo/animals', {})
service2.send(:execute_or_queue_command, command2, &b)
end
end.to raise_error
end
end
context 'with batch uploads' do
before(:example) do
2016-08-17 20:51:09 +00:00
allow(SecureRandom).to receive(:uuid).and_return('b1981e17-f622-49af-b2eb-203308b1b17d')
allow(Digest::SHA1).to receive(:hexdigest).and_return('outer', 'inner')
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
2016-08-17 20:51:09 +00:00
it 'should send nested multipart' do
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)
end
expected_body = <<EOF.gsub(/\n/, "\r\n")
--outer
Content-Type: application/http
Content-Id: <b1981e17-f622-49af-b2eb-203308b1b17d+0>
Content-Length: 380
2016-08-17 20:51:09 +00:00
Content-Transfer-Encoding: binary
POST /upload/zoo/animals? HTTP/1.1
X-Goog-Api-Client: #{x_goog_api_client_value}
2016-08-17 20:51:09 +00:00
Content-Type: multipart/related; boundary=inner
X-Goog-Upload-Protocol: multipart
Authorization: Bearer a token
2016-08-17 20:51:09 +00:00
Host: www.googleapis.com
--inner
Content-Type: application/json
--inner
Content-Type: text/plain
Content-Length: 4
Content-Transfer-Encoding: binary
test
--inner--
--outer--
EOF
expect(a_request(:put, 'https://www.googleapis.com/upload/').with(body: expected_body)).to have_been_made
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
2016-03-08 21:26:28 +00:00
context 'with fetch_all' do
let(:responses) do
data = {}
data[nil] = OpenStruct.new(
next_page_token: 'p1', alt_page_token: 'p2', items: ['a', 'b', 'c'], alt_items: [1, 2, 3], singular: 'foo', hash_: { 'foo' => 1, 'bar' => 2 })
data['p1'] = OpenStruct.new(
next_page_token: 'p2', items: ['d', 'e', 'f'], alt_items: [4, 5, 6], singular: 'bar', hash_: nil)
data['p2'] = OpenStruct.new(
next_page_token: nil, alt_page_token: nil, items: ['g', 'h', 'i'], alt_items: [7, 8, 9], singular: 'baz', hash_: { 'baz' => 3 })
2016-03-08 21:26:28 +00:00
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 response page token' do
expect(service.fetch_all(response_page_token: :alt_page_token) { |token| responses[token] }
).to contain_exactly('a', 'b', 'c', 'g', 'h', 'i')
end
it 'should ignore nil collections' do
responses['p1'].items = nil
expect(items).to contain_exactly('a', 'b', 'c', 'g', 'h', 'i')
end
2016-03-08 21:26:28 +00:00
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 iterating over singular items' do
expect(service.fetch_all(items: :singular) { |token| responses[token] } ).to contain_exactly('foo', 'bar', 'baz')
end
it 'should collate hash entries' do
expect(service.fetch_all(items: :hash_) { |token| responses[token] } ).to contain_exactly(['foo', 1], ['bar', 2], ['baz', 3])
end
2016-03-08 21:26:28 +00:00
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
2016-03-08 21:26:28 +00:00
end
end
end