google-api-client 0.8.7 → 0.9.pre1

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

@@ -0,0 +1,238 @@
+# 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/http_command'
+require 'hurley/test'
+
+RSpec.describe Google::Apis::Core::HttpCommand do
+  include TestHelpers
+  include_context 'HTTP client'
+
+  context('with credentials') do
+    let(:command) do
+      command = Google::Apis::Core::HttpCommand.new(:get, 'https://www.googleapis.com/zoo/animals')
+      command.options.authorization = authorization
+      command
+    end
+
+    context('that are refreshable') do
+      let(:authorization) do
+        calls = 0
+        auth =  object_double(Signet::OAuth2::Client.new)
+        allow(auth).to receive(:apply!) do |header|
+          header['Authorization'] = sprintf('Bearer a_token_value_%d', calls)
+          calls += 1
+        end
+        auth
+      end
+
+      it 'should send credentials' do
+        stub_request(:get, 'https://www.googleapis.com/zoo/animals').to_return(body: %(Hello world))
+        result = command.execute(client)
+        expect(a_request(:get, 'https://www.googleapis.com/zoo/animals')
+          .with { |req| req.headers['Authorization'] == 'Bearer a_token_value_0' }).to have_been_made
+      end
+
+      context('with authorizaton error') do
+        before(:example) do
+          stub_request(:get, 'https://www.googleapis.com/zoo/animals')
+            .to_return(status: [401, 'Unauthorized'])
+            .to_return(body: %(Hello world))
+        end
+
+        it 'should refresh if auth error received' do
+          result = command.execute(client)
+          expect(a_request(:get, 'https://www.googleapis.com/zoo/animals')
+            .with { |req| req.headers['Authorization'] == 'Bearer a_token_value_1' }).to have_been_made
+        end
+
+        it 'should ignore retry count' do
+          command.options.retries = 0
+          result = command.execute(client)
+          expect(a_request(:get, 'https://www.googleapis.com/zoo/animals')
+            .with { |req| req.headers['Authorization'] == 'Bearer a_token_value_1' }).to have_been_made
+        end
+      end
+    end
+
+    context('that are bare tokens`') do
+      let(:authorization) { 'a_token_value' }
+
+      it 'should send credentials' do
+        stub_request(:get, 'https://www.googleapis.com/zoo/animals').to_return(body: %(Hello world))
+        result = command.execute(client)
+        expect(a_request(:get, 'https://www.googleapis.com/zoo/animals')
+          .with { |req| expect(req.headers['Authorization']).to eql 'Bearer a_token_value' }).to have_been_made
+      end
+
+      it 'should send not refresh' do
+        stub_request(:get, 'https://www.googleapis.com/zoo/animals').to_return(status: [401, 'Unauthorized'])
+        expect { command.execute(client) }.to raise_error(Google::Apis::AuthorizationError)
+      end
+    end
+  end
+
+  context('with a successful response') do
+    let(:command) do
+      Google::Apis::Core::HttpCommand.new(:get, 'https://www.googleapis.com/zoo/animals')
+    end
+
+    before(:example) do
+      stub_request(:get, 'https://www.googleapis.com/zoo/animals').to_return(body: %(Hello world))
+    end
+
+    it 'should return the response body if block not present' do
+      result = command.execute(client)
+      expect(result).to eql 'Hello world'
+    end
+
+    it 'should call block if present' do
+      expect { |b| command.execute(client, &b) }.to yield_with_args('Hello world', nil)
+    end
+  end
+
+  context('with server errors') do
+    let(:command) do
+      Google::Apis::Core::HttpCommand.new(:get, 'https://www.googleapis.com/zoo/animals')
+    end
+
+    before(:example) do
+      stub_request(:get, 'https://www.googleapis.com/zoo/animals')
+        .to_return(status: [500, 'Server error']).times(2)
+        .to_return(body: %(Hello world))
+    end
+
+    it 'should return the response body' do
+      result = command.execute(client)
+      expect(result).to eql 'Hello world'
+    end
+
+    it 'should raise error if retries exceeded' do
+      command.options.retries = 1
+      expect { command.execute(client) }.to raise_error(Google::Apis::ServerError)
+    end
+
+    context('with callbacks') do
+      it 'should return the response body after retries' do
+        expect { |b| command.execute(client, &b) }.to yield_successive_args(
+          [nil, an_instance_of(Google::Apis::ServerError)],
+          [nil, an_instance_of(Google::Apis::ServerError)],
+          ['Hello world', nil])
+      end
+    end
+  end
+
+  context('with options') do
+    let(:command) do
+      command = Google::Apis::Core::HttpCommand.new(:get, 'https://www.googleapis.com/zoo/animals')
+      command.options.header = { 'X-Foo' => 'bar' }
+      command
+    end
+
+    before(:example) do
+      stub_request(:get, 'https://www.googleapis.com/zoo/animals')
+        .to_return(body: %(Hello world))
+    end
+
+    it 'should send user headers' do
+      result = command.execute(client)
+      expect(a_request(:get, 'https://www.googleapis.com/zoo/animals')
+        .with { |req| req.headers['X-Foo'] == 'bar' }).to have_been_made
+    end
+  end
+
+
+  context('with redirects') do
+    let(:command) do
+      Google::Apis::Core::HttpCommand.new(:get, 'https://www.googleapis.com/zoo/animals')
+    end
+
+    before(:example) do
+      stub_request(:get, 'https://www.googleapis.com/zoo/animals')
+        .to_return(status: [302, 'Redirect'], headers: { 'Location' => 'https://zoo.googleapis.com/animals' })
+      stub_request(:get, 'https://zoo.googleapis.com/animals')
+        .to_return(body: %(Hello world))
+    end
+
+    it 'should return the response body' do
+      result = command.execute(client)
+      expect(result).to eql 'Hello world'
+    end
+  end
+
+  context('with too many redirects') do
+    let(:command) do
+      Google::Apis::Core::HttpCommand.new(:get, 'https://www.googleapis.com/zoo/animals')
+    end
+
+    before(:example) do
+      stub_request(:get, 'https://www.googleapis.com/zoo/animals')
+        .to_return(status: [302, 'Redirect'], headers: { 'Location' => 'https://www.googleapis.com/zoo/animals' }).times(6)
+    end
+
+    it 'should raise error if retries exceeded' do
+      expect { command.execute(client) }.to raise_error(Google::Apis::RedirectError)
+    end
+  end
+
+  context('with no server response') do
+    let(:command) do
+      Google::Apis::Core::HttpCommand.new(:get, 'https://www.googleapis.com/zoo/animals')
+    end
+
+    before(:example) do
+      stub_request(:get, 'https://www.googleapis.com/zoo/animals').to_timeout
+    end
+
+    it 'should raise transmission error' do
+      expect { command.execute(client) }.to raise_error(Google::Apis::TransmissionError)
+    end
+  end
+
+  context('with invalid status code') do
+    let(:command) do
+      Google::Apis::Core::HttpCommand.new(:get, 'https://www.googleapis.com/zoo/animals')
+    end
+
+    before(:example) do
+      stub_request(:get, 'https://www.googleapis.com/zoo/animals')
+        .to_return(status: [0, 'Wat!?'])
+    end
+
+    it 'should raise transmission error' do
+      expect { command.execute(client) }.to raise_error(Google::Apis::TransmissionError)
+    end
+  end
+
+  context('with client errors') do
+    let(:command) do
+      Google::Apis::Core::HttpCommand.new(:get, 'https://www.googleapis.com/zoo/animals')
+    end
+
+    before(:example) do
+      stub_request(:get, 'https://www.googleapis.com/zoo/animals')
+        .to_return(status: [400, 'Invalid request'])
+    end
+
+    it 'should raise error without retry' do
+      command.options.retries = 1
+      expect { command.execute(client) }.to raise_error(Google::Apis::ClientError)
+    end
+
+    it 'should call block if present' do
+      expect { |b| command.execute(client, &b) }.to yield_with_args(nil, an_instance_of(Google::Apis::ClientError))
+    end
+  end
+end

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

@@ -0,0 +1,192 @@
+# 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/json_representation'
+
+RSpec.describe Google::Apis::Core::JsonRepresentation do
+  let(:child_class) do
+    Class.new do
+      attr_accessor :value
+    end
+  end
+
+  let(:model_class) do
+    Class.new do
+      attr_accessor :unset_value
+      attr_accessor :nil_value
+      attr_accessor :numeric_value
+      attr_accessor :string_value
+      attr_accessor :boolean_value
+      attr_accessor :date_value
+      attr_accessor :bytes_value
+      attr_accessor :items
+      attr_accessor :child
+      attr_accessor :children
+    end
+  end
+
+  let(:representer_class) do
+    klass = child_class
+    Class.new(Google::Apis::Core::JsonRepresentation) do
+      property :unset_value, as: 'unsetValue'
+      property :nil_value, as: 'nilValue'
+      property :numeric_value, as: 'numericValue'
+      property :string_value, as: 'stringValue'
+      property :boolean_value, as: 'booleanValue'
+      property :date_value, as: 'dateValue', type: DateTime
+      property :bytes_value, as: 'bytesValue', base64: true
+      property :items
+      property :child, class: klass do
+        property :value
+      end
+      collection :children, class: klass do
+        property :value
+      end
+    end
+  end
+
+  shared_examples 'it serializes' do
+    it 'does not serialize unset values' do
+      expect(json).not_to have_json_path('unsetValue')
+    end
+
+    it 'serializes explicit nil values' do
+      expect(json).to be_json_eql(%(null)).at_path('nilValue')
+    end
+
+    it 'serializes numeric values' do
+      expect(json).to be_json_eql(%(123)).at_path('numericValue')
+    end
+
+    it 'serializes string values' do
+      expect(json).to be_json_eql(%("test")).at_path('stringValue')
+    end
+
+    it 'serializes boolean values' do
+      expect(json).to be_json_eql(%(true)).at_path('booleanValue')
+    end
+
+    it 'serializes date values' do
+      expect(json).to be_json_eql(%("2015-05-01T12:00:00+00:00")).at_path('dateValue')
+    end
+
+    it 'serializes byte values to base64' do
+      expect(json).to be_json_eql(%("SGVsbG8gd29ybGQ=")).at_path('bytesValue')
+    end
+
+    it 'serializes basic collections' do
+      expect(json).to be_json_eql(%([1,2,3])).at_path('items')
+    end
+
+    it 'serializes nested objects' do
+      expect(json).to be_json_eql(%({"value" : "child"})).at_path('child')
+    end
+
+    it 'serializes object collections' do
+      expect(json).to be_json_eql(%([{"value" : "child"}])).at_path('children')
+    end
+  end
+
+  context 'with model object' do
+    let(:json) { representer_class.new(model).to_json(skip_undefined: true) }
+    let(:model) do
+      model = model_class.new
+      model.nil_value = nil
+      model.numeric_value = 123
+      model.string_value = 'test'
+      model.date_value = DateTime.new(2015, 5, 1, 12)
+      model.boolean_value = true
+      model.bytes_value = 'Hello world'
+      model.items = [1, 2, 3]
+      model.child = child_class.new
+      model.child.value = 'child'
+      model.children = [model.child]
+      model
+    end
+
+    include_examples 'it serializes'
+  end
+
+  context 'with hash' do
+    let(:json) { representer_class.new(model).to_json(skip_undefined: true) }
+    let(:model) do
+      {
+        nil_value: nil,
+        string_value: 'test',
+        numeric_value: 123,
+        date_value: DateTime.new(2015, 5, 1, 12),
+        boolean_value: true,
+        bytes_value: 'Hello world',
+        items: [1, 2, 3],
+        child: {
+          value: 'child'
+        },
+        children: [{ value: 'child' }]
+      }
+    end
+
+    include_examples 'it serializes'
+  end
+
+  context 'when de-serializing' do
+    let(:model) { representer_class.new(model_class.new).from_json(json) }
+    let(:json) do
+      json = <<EOF
+{ "stringValue": "test",
+  "nilValue": null,
+  "booleanValue": true,
+  "numericValue": 123,
+  "dateValue": "2015-05-01T12:00:00+00:00",
+  "bytesValue": "SGVsbG8gd29ybGQ=",
+  "items": [1,2,3],
+  "child": {"value" : "hello"},
+  "children": [{"value" : "hello"}]
+}
+EOF
+    end
+
+    it 'deserializes string values' do
+      expect(model.string_value).to eql 'test'
+    end
+
+    it 'deserializes null values' do
+      expect(model.nil_value).to be_nil
+    end
+
+    it 'deserializes numeric values' do
+      expect(model.numeric_value).to eql 123
+    end
+
+    it 'deserializes boolean values' do
+      expect(model.boolean_value).to be_truthy
+    end
+
+    it 'deserializes date values' do
+      expect(model.date_value).to eql DateTime.new(2015, 5, 1, 12)
+    end
+
+    it 'deserializes basic collections' do
+      expect(model.items).to contain_exactly(1, 2, 3)
+    end
+
+    it 'deserializes nested objects' do
+      expect(model.child.value).to eql 'hello'
+    end
+
+    it 'serializes object collections' do
+      expect(model.children[0].value).to eql 'hello'
+    end
+  end
+end

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

@@ -0,0 +1,247 @@
+# 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'
+
+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
+  end
+end