google-api-client 0.8.6 → 0.9.3

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

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

data/{lib/google/api_client/discovery.rb → spec/google/apis/generated_spec.rb}

@@ -1,4 +1,4 @@
-# Copyright 2010 Google Inc.
+# 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.
@@ -12,8 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require 'spec_helper'
 
-require 'google/api_client/discovery/api'
-require 'google/api_client/discovery/resource'
-require 'google/api_client/discovery/method'
-require 'google/api_client/discovery/schema'
+RSpec.describe Google::Apis do
+  # Minimal test just to ensure no syntax errors in generated code
+  it 'should load all APIs' do
+    expect do
+      Dir.glob(File.join(ROOT_DIR, 'generated', 'google', 'apis', '*.rb')) do |file|
+        base = File.basename(file, '.rb')
+        require sprintf('google/apis/%s', base)
+      end
+    end.not_to raise_error
+  end
+end

data/spec/google/apis/generator/generator_spec.rb

@@ -0,0 +1,324 @@
+# 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/generator'
+require 'tmpdir'
+require 'fileutils'
+
+# TODO - Naked arrays in method requests/responses
+
+RSpec.describe Google::Apis::Generator do
+  include TestHelpers
+
+  context 'with test API' do
+    before(:context) do
+      generator = Google::Apis::Generator.new(api_names: File.join(FIXTURES_DIR, 'files', 'api_names.yaml'))
+      discovery = File.read(File.join(FIXTURES_DIR, 'files', 'test_api.json'))
+      generated_files = generator.render(discovery)
+      puts generator.dump_api_names
+      tempdir = Dir.mktmpdir
+      generated_files.each do |key, content|
+        path = File.join(tempdir, key)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.open(path, 'w') do |f|
+          f.write(content)
+        end
+      end
+      $LOAD_PATH.unshift(tempdir)
+      require 'google/apis/test_v1'
+    end
+
+    let(:service) { Google::Apis::TestV1::TestService.new }
+
+    context 'with the generated service' do
+      it 'should set the base URL' do
+        expect(service.root_url.to_s).to eql('https://www.googleapis.com/')
+      end
+
+      it 'should define global methods from discovery' do
+        expect(service.method(:query)).to_not be_nil
+      end
+
+      it 'should define parameters on methods' do
+        parameters = service.method(:query).parameters.map { |(_k, v)| v }
+        expect(parameters).to include(:s, :i, :n, :b, :a, :e, :er, :sr)
+      end
+
+      it 'should modify parameter names that are ruby keywords' do
+        parameters = service.method(:query).parameters.map { |(_k, v)| v }
+        expect(parameters).to include(:do_)
+      end
+
+      it 'should define global parameters on methods' do
+        parameters = service.method(:query).parameters.map { |(_k, v)| v }
+        expect(parameters).to include(:fields, :quota_user, :user_ip)
+      end
+
+      it 'should include standard options & block' do
+        parameters = service.method(:query).parameters.map { |(_k, v)| v }
+        expect(parameters).to include(:options, :block)
+      end
+
+      it 'should define AUTH_TEST scope' do
+        expect(Google::Apis::TestV1::AUTH_TEST).to eql ('https://www.googleapis.com/auth/test')
+      end
+
+      it 'should define AUTH_TEST_READONLY scope' do
+        expect(Google::Apis::TestV1::AUTH_TEST_READONLY).to eql ('https://www.googleapis.com/auth/test.readonly')
+      end
+
+      context 'when simplifying class names' do
+        it 'should simplify the TestAnotherThing name' do
+          expect { Google::Apis::TestV1::AnotherThing.new }.not_to raise_error
+        end
+
+        it 'should not simplify the TestThing name' do
+          expect { Google::Apis::TestV1::TestThing.new }.not_to raise_error
+        end
+      end
+
+
+      context 'with the Thing resource' do
+        it 'should define the create method`' do
+          expect(service.method(:create_thing)).to_not be_nil
+        end
+
+        it 'should define the list method`' do
+          expect(service.method(:list_things)).to_not be_nil
+        end
+
+        it 'should define the get method`' do
+          expect(service.method(:get_thing)).to_not be_nil
+        end
+
+        it 'should include the download_dest parameter for get_thing' do
+          parameters = service.method(:get_thing).parameters.map { |(_k, v)| v }
+          expect(parameters).to include(:download_dest)
+        end
+
+        it 'should define the update method`' do
+          expect(service.method(:update_thing)).to_not be_nil
+        end
+
+        it 'should include the upload_source parameter for update_thing' do
+          parameters = service.method(:update_thing).parameters.map { |(_k, v)| v }
+          expect(parameters).to include(:upload_source)
+        end
+
+        it 'should define subresource methods' do
+          expect(service.method(:list_thing_subthings)).to_not be_nil
+        end
+
+        context 'With the from_json method' do
+          let(:json) do
+            <<EOF
+{
+  "name" : "A thing",
+  "properties": {
+    "prop_a" : "value_a"
+  },
+  "photo": {
+    "filename": "image.jpg"
+  },
+  "hat": {
+    "type": "topHat",
+    "height": 100
+  }
+}
+EOF
+          end
+
+          let(:thing) { Google::Apis::TestV1::Thing.from_json(json) }
+
+          it 'should return a thing' do
+            expect(thing).to be_instance_of(Google::Apis::TestV1::Thing)
+          end
+
+          it 'should parse properties' do
+            expect(thing.name).to eq 'A thing'
+          end
+
+          it 'should parse subtypes' do
+            expect(thing.photo.filename).to eq "image.jpg"
+          end
+        end
+
+        context 'With the to_json method' do
+          let(:thing) do
+            Google::Apis::TestV1::Thing.new(
+                name: "A thing",
+                properties: {
+                    prop_a: "value_a"
+                },
+                photo: {
+                    filename: "image.jpg"
+                },
+                hat: {
+                    type: "topHat",
+                    height: 100
+                }
+            )
+          end
+        end
+      end
+
+      context 'with the get_thing method' do
+        before(:example) do
+          json = <<EOF
+{
+  "id" : "123",
+  "name" : "A thing",
+  "enabled": true,
+  "properties": {
+    "prop_a" : "value_a",
+    "prop_b" : "value_b"
+  },
+  "photo": {
+    "filename": "image.jpg"
+  },
+  "hat": {
+    "type": "baseballHat",
+    "color": "red"
+  }
+}
+EOF
+          stub_request(:get, 'https://www.googleapis.com/test/v1/things/123')
+            .to_return(headers: { 'Content-Type' => 'application/json' }, body: json)
+        end
+
+        let(:thing) { service.get_thing('123') }
+
+        it 'should return a Thing' do
+          expect(thing).to be_instance_of(Google::Apis::TestV1::Thing)
+        end
+
+        it 'should set attributes' do
+          expect(thing.id).to eql '123'
+        end
+
+        it 'should alias boolean methods on Thing' do
+          expect(thing.enabled?).to be true
+        end
+
+        it 'should return a Hash for properties' do
+          expect(thing.properties).to be_instance_of(Hash)
+        end
+
+        it 'should set hash elements' do
+          expect(thing.properties).to include('prop_a' => 'value_a')
+        end
+
+        it 'should return the correct variant type for hat' do
+          expect(thing.hat).to be_instance_of(Google::Apis::TestV1::BaseballHat)
+        end
+
+        it 'should return the correct variant properties for hat' do
+          expect(thing.hat.color).to eql 'red'
+        end
+
+        it 'should return a photo' do
+          expect(thing.photo).to be_instance_of(Google::Apis::TestV1::Thing::Photo)
+        end
+
+        it 'should return photo properties' do
+          expect(thing.photo.filename).to eql 'image.jpg'
+        end
+      end
+
+      context 'with the create_thing method' do
+        before(:example) do
+          json = <<EOF
+{
+  "id" : "123",
+  "name" : "A thing",
+  "properties": {
+    "prop_a" : "value_a"
+  },
+  "photo": {
+    "filename": "image.jpg"
+  },
+  "hat": {
+    "type": "topHat",
+    "height": 100
+  }
+}
+EOF
+          stub_request(:post, 'https://www.googleapis.com/test/v1/things')
+            .to_return(headers: { 'Content-Type' => 'application/json' }, body: json)
+        end
+
+        let(:thing) do
+          thing = Google::Apis::TestV1::Thing.new(name: 'A thing', properties: { 'prop_a' => 'value_a' })
+          thing.photo = Google::Apis::TestV1::Thing::Photo.new(filename: 'image.jpg')
+          thing.hat = Google::Apis::TestV1::TopHat.new(type: 'topHat', height: 100)
+          service.create_thing(thing)
+        end
+
+        it 'should serialize the thing' do
+          expected_body = <<EOF
+{
+  "name" : "A thing",
+  "properties": {
+    "prop_a" : "value_a"
+  },
+  "photo": {
+    "filename": "image.jpg"
+  },
+  "hat": {
+    "type": "topHat",
+    "height": 100
+  }
+}
+EOF
+          expect(thing).to be_instance_of(Google::Apis::TestV1::Thing)
+          expect(a_request(:post, 'https://www.googleapis.com/test/v1/things')
+            .with { |req| expect(req.body).to be_json_eql(expected_body) }).to have_been_made
+        end
+
+        it 'should an updated id' do
+          expect(thing.id).to eql '123'
+        end
+      end
+
+      context 'with the query method' do
+        before(:example) do
+          body = %({"rows": [{"value": "hello"}, {"value": "world"}]})
+          stub_request(:get, 'https://www.googleapis.com/test/v1/query')
+            .to_return(headers: { 'Content-Type' => 'application/json' }, body: body)
+        end
+
+        it 'should return query results' do
+          results = service.query
+          expect(results).to be_instance_of(Google::Apis::TestV1::QueryResults)
+        end
+
+        it 'should return an array for items' do
+          results = service.query
+          expect(results.rows).to be_instance_of(Array)
+        end
+
+        it 'should return items of type Row' do
+          results = service.query
+          expect(results.rows.first).to be_instance_of(Google::Apis::TestV1::Row)
+        end
+
+        it 'should return values for rows' do
+          results = service.query
+          expect(results.rows[1].value).to eql('world')
+        end
+      end
+    end
+  end
+end

data/spec/google/apis/logging_spec.rb

@@ -0,0 +1,45 @@
+# 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'
+require 'google/apis/core/logging'
+
+RSpec.describe Google::Apis do
+  it 'should have a default logger' do
+    expect(Google::Apis.logger).to be_an_instance_of(Logger)
+  end
+
+  context 'with service' do
+    let(:service) do
+      Class.new do
+        include Google::Apis::Core::Logging
+      end.new
+    end
+
+    it 'should have a logger' do
+      expect(service.logger).to be_an_instance_of(Logger)
+    end
+
+    it 'should use the default logger' do
+      expect(service.logger).to be Google::Apis.logger
+    end
+
+    it 'should allow custom loggers' do
+      Google::Apis.logger = Logger.new(STDERR)
+      expect(service.logger).to be Google::Apis.logger
+    end
+
+  end
+end