google-api-client 0.9.5 → 0.9.6

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

@@ -1,60 +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/hashable'
-
-RSpec.describe Google::Apis::Core::Hashable do
-  let(:child_class) do
-    Class.new do
-      include Google::Apis::Core::Hashable
-      attr_accessor :value
-    end
-  end
-
-  let(:model_class) do
-    Class.new do
-      include Google::Apis::Core::Hashable
-      attr_accessor :value
-      attr_accessor :value2
-      attr_accessor :children
-    end
-  end
-
-  let(:model) do
-    obj = model_class.new
-    obj.value = 'hello'
-    obj.value2 = {
-      a: 'a'
-    }
-    child = child_class.new
-    child.value = 'goodbye'
-    obj.children = [child]
-    obj
-  end
-
-  let(:hash) { model.to_h }
-
-  it 'should serialize attributes' do
-    expect(hash).to include(value: 'hello')
-  end
-
-  it 'should serialize collections' do
-    expect(hash).to include(children: [{ value: 'goodbye' }])
-  end
-
-  it 'should serialize hashes' do
-    expect(hash[:value2]).to include(a: 'a')
-  end
-end

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

@@ -1,303 +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/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 retries exceeded') do
-      before(:example) do
-        command.options.retries = 1
-      end
-
-      let(:err) do
-        begin
-          command.execute(client)
-        rescue Google::Apis::Error => e
-          e
-        end
-      end
-
-      it 'should raise error with HTTP status code' do
-        expect(err.status_code).to eq 500
-      end
-
-    end
-
-    context('with callbacks') do
-      it 'should return the response body after retries' do
-        expect { |b| command.execute(client, &b) }.to yield_with_args('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
-
-    it 'should not swallow errors raised in block' do
-      expect { command.execute(client) { raise "Potatoes detected in tailpipe" } }.to raise_error("Potatoes detected in tailpipe")
-    end
-  end
-
-  it 'should send repeated query parameters' do
-    stub_request(:get, 'https://www.googleapis.com/zoo/animals?a=1&a=2&a=3')
-      .to_return(status: [200, ''])
-    command = Google::Apis::Core::HttpCommand.new(:get, 'https://www.googleapis.com/zoo/animals')
-    command.query['a'] = [1,2,3]
-    command.execute(client)
-  end
-
-  it 'should not remove initial query parameters' do
-    stub_request(:get, 'https://www.googleapis.com/zoo/animals?a=1&a=2&a=3&foo=bar')
-      .to_return(status: [200, ''])
-    command = Google::Apis::Core::HttpCommand.new(:get, 'https://www.googleapis.com/zoo/animals?foo=bar')
-    command.query['a'] = [1,2,3]
-    command.execute(client)
-  end
-
-  it 'should send falsey query parameters' do
-    stub_request(:get, 'https://www.googleapis.com/zoo/animals?a=0&b=false')
-      .to_return(status: [200, ''])
-    command = Google::Apis::Core::HttpCommand.new(:get, 'https://www.googleapis.com/zoo/animals')
-    command.query['a'] = 0
-    command.query['b'] = false
-    command.execute(client)
-  end
-
-  it 'should form encode parameters when method is POST and no body present' do
-    stub_request(:post, 'https://www.googleapis.com/zoo/animals')
-        .with(body: 'a=1&a=2&a=3&b=hello&c=&d=0')
-        .to_return(status: [200, ''])
-    command = Google::Apis::Core::HttpCommand.new(:post, 'https://www.googleapis.com/zoo/animals')
-    command.query['a'] = [1,2,3]
-    command.query['b'] = 'hello'
-    command.query['c'] = nil
-    command.query['d'] = 0
-    command.execute(client)
-  end
-
-  it 'should raise transmission error instead of socket error' do
-    stub_request(:get, 'https://www.googleapis.com/zoo/animals').to_raise(SocketError)
-    command = Google::Apis::Core::HttpCommand.new(:get, 'https://www.googleapis.com/zoo/animals')
-    command.options.retries = 0
-    expect { command.execute(client) }.to raise_error(Google::Apis::TransmissionError)
-  end
-end

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

@@ -1,199 +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/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_true
-      attr_accessor :boolean_value_false
-      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_true, as: 'booleanValueTrue'
-      property :boolean_value_false, as: 'booleanValueFalse'
-      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('booleanValueTrue')
-      expect(json).to be_json_eql(%(false)).at_path('booleanValueFalse')
-    end
-
-    it 'serializes date values' do
-      expect(json).to be_json_eql(%("2015-05-01T12:00:00.000+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 = true
-      model.boolean_value_false = false
-      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: true,
-        boolean_value_false: false,
-        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,
-  "booleanValueTrue": true,
-  "booleanValueFalse": false,
-  "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_true).to be_truthy
-      expect(model.boolean_value_false).to be_falsey
-    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