google-api-client 0.8.6 → 0.9.3

data/spec/google/apis/options_spec.rb

@@ -0,0 +1,40 @@
+# 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'
+
+RSpec.describe Google::Apis::RequestOptions do
+  let(:options) { Google::Apis::RequestOptions.new }
+
+  it 'should not merge nil values' do
+    options.retries = 1
+    expect(options.merge(authorization: 'foo').retries).to eql 1
+  end
+
+  it 'should merge non-nil values' do
+    options.retries = 1
+    expect(options.merge(authorization: 'foo').authorization).to eql 'foo'
+  end
+
+  it 'should merge from options' do
+    opts = Google::Apis::RequestOptions.new
+    opts.authorization = 'foo'
+    expect(options.merge(opts).authorization).to eql 'foo'
+  end
+
+  it 'should allow nil in merge' do
+    expect(options.merge(nil)).to be_an_instance_of(Google::Apis::RequestOptions)
+  end
+end

data/spec/integration_tests/adsense_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'google/apis/adsense_v1_4'
+require 'googleauth'
+
+Adsense = Google::Apis::AdsenseV1_4
+
+RSpec.describe Google::Apis::AdsenseV1_4, :if => run_integration_tests? do
+
+  before(:context) do
+    #WebMock.allow_net_connect!
+    @adsense = Adsense::AdSenseService.new
+    #@adsense.authorization = Google::Auth.get_application_default([Adsense::AUTH_ADSENSE])
+    #@adsense.authorization.sub = 'cb@travelingnuker.com'
+    #@adsense.authorization.fetch_access_token!
+  end
+
+  it 'should download a report with multiple dimensions' do
+    pending "Not enabled for test account"
+    report = @adsense.generate_report( Date.today.to_s, Date.today.to_s, dimension: ["DATE", "AD_UNIT_NAME"] )
+
+    report_header_names = report.headers.map { |h| h.name }
+    expect(report_header_names).to include('DATE')
+    expect(report_header_names).to include('AD_UNIT_NAME')
+  end
+
+  after(:context) do
+    #WebMock.disable_net_connect!
+  end
+end

data/spec/integration_tests/drive_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'google/apis/drive_v2'
+require 'googleauth'
+require 'fileutils'
+
+Drive = Google::Apis::DriveV2
+
+RSpec.describe Google::Apis::DriveV2, :if => run_integration_tests? do
+
+  before(:context) do
+    WebMock.allow_net_connect!
+    @drive = Drive::DriveService.new
+    @drive.authorization = Google::Auth.get_application_default([Drive::AUTH_DRIVE])
+  end
+
+  it 'should upload and download files' do
+    # Insert a file
+    content_path = File.join(FIXTURES_DIR, 'files', 'test_api.json')
+    file = @drive.insert_file({title: 'test_file.txt'}, upload_source: content_path)
+    puts "Created file #{file.title} (#{file.id})"
+
+    # Read it back
+    tmp = @drive.get_file(file.id, download_dest: Tempfile.new('drive'))
+
+    # Delete it
+    @drive.delete_file(file.id)
+    puts "File deleted"
+
+    expect(FileUtils.compare_file(content_path, tmp)).to be_truthy
+  end
+
+  after(:context) do
+    WebMock.disable_net_connect!
+  end
+end

data/spec/integration_tests/pubsub_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'google/apis/pubsub_v1'
+require 'googleauth'
+
+Pubsub = Google::Apis::PubsubV1
+
+RSpec.describe Google::Apis::PubsubV1, :if => run_integration_tests? do
+
+  before(:context) do
+    WebMock.allow_net_connect!
+    project = ENV['GOOGLE_PROJECT_ID']
+    @topic_name = "projects/#{project}/topics/test"
+    @subscription_name = "projects/#{project}/subscriptions/test"
+
+    @pubsub = Pubsub::PubsubService.new
+    @pubsub.authorization = Google::Auth.get_application_default([Pubsub::AUTH_PUBSUB])
+    @pubsub.create_topic(@topic_name)
+    @pubsub.create_subscription(@subscription_name, Pubsub::Subscription.new(topic: @topic_name))
+  end
+
+  it 'should publish & receive messages' do
+    # Publish messages
+    request = Pubsub::PublishRequest.new(messages: [])
+    request.messages << Pubsub::Message.new(attributes: { "language" => "en" }, data: 'Hello')
+    request.messages << Pubsub::Message.new(attributes: { "language" => "en" }, data: 'World')
+    @pubsub.publish_topic(@topic_name, request)
+
+    # Pull messages
+    response = @pubsub.pull_subscription(@subscription_name, Pubsub::PullRequest.new(max_messages: 5))
+    response.received_messages.each do |received_message|
+      data = received_message.message.data
+      puts "Received #{data}"
+    end
+
+    # Acknowledge receipt
+    ack_ids = response.received_messages.map{ |msg| msg.ack_id }
+    @pubsub.acknowledge_subscription(@subscription_name, Pubsub::AcknowledgeRequest.new(ack_ids: ack_ids))
+
+    expect(response.received_messages.length).to eq 2
+  end
+
+  after(:context) do
+    @pubsub.delete_subscription(@subscription_name)
+    @pubsub.delete_topic(@topic_name)
+    WebMock.disable_net_connect!
+  end
+
+end

data/spec/integration_tests/url_shortener_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/urlshortener_v1'
+require 'googleauth'
+
+Urlshortener = Google::Apis::UrlshortenerV1
+
+RSpec.describe Google::Apis::UrlshortenerV1, :if => run_integration_tests? do
+
+  before(:context) do
+    WebMock.allow_net_connect!
+    @shortener = Urlshortener::UrlshortenerService.new
+    @shortener.authorization = Google::Auth.get_application_default([Urlshortener::AUTH_URLSHORTENER])
+  end
+
+  it 'should shorten URLs in a batch' do
+    @urls = []
+    callback = lambda { |url, err| @urls << url unless url.nil? }
+    @shortener.batch do |shortener|
+      shortener.insert_url(Urlshortener::Url.new(long_url: 'https://example.com/foo'), &callback)
+      shortener.insert_url(Urlshortener::Url.new(long_url: 'https://example.com/bar'), &callback)
+      shortener.insert_url(Urlshortener::Url.new(long_url: 'https://example.com/baz'), &callback)
+    end
+    puts @urls.inspect
+    expect(@urls.length).to eq 3
+  end
+
+  after(:context) do
+    WebMock.disable_net_connect!
+  end
+
+end

data/spec/spec_helper/load_path_spec.rb

@@ -0,0 +1,33 @@
+# 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'
+
+RSpec.describe $LOAD_PATH do
+  it('should contain SPEC_DIR') do
+    expect($LOAD_PATH).to include(SPEC_DIR)
+  end
+
+  it('should contain LIB_DIR') do
+    expect($LOAD_PATH).to include(LIB_DIR)
+  end
+
+  it('should contain GENERATED_DIR') do
+    expect($LOAD_PATH).to include(GENERATED_DIR)
+  end
+
+  it('should contain THIRD_PARTY_DIR') do
+    expect($LOAD_PATH).to include(THIRD_PARTY_DIR)
+  end
+end

data/spec/spec_helper.rb

@@ -1,66 +1,153 @@
-$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
-$LOAD_PATH.uniq!
+# 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 'rspec'
-require 'faraday'
+SPEC_DIR = File.expand_path(File.dirname(__FILE__))
+ROOT_DIR = File.expand_path(File.join(SPEC_DIR, '..'))
+LIB_DIR = File.expand_path(File.join(ROOT_DIR, 'lib'))
+GENERATED_DIR = File.expand_path(File.join(ROOT_DIR, 'generated'))
+THIRD_PARTY_DIR = File.expand_path(File.join(ROOT_DIR, 'third_party'))
+FIXTURES_DIR = File.expand_path(File.join(SPEC_DIR, 'fixtures'))
+
+$LOAD_PATH.uniq!
 
-begin
+if defined?(JRUBY_VERSION)
+  puts 'Skipping coverage on JRuby'
+else
+  # set up coverage
   require 'simplecov'
   require 'coveralls'
 
-  SimpleCov.formatter = Coveralls::SimpleCov::Formatter
-  SimpleCov.start
-rescue LoadError
-  # SimpleCov missing, so just run specs with no coverage.
+  SimpleCov.formatters = [
+    Coveralls::SimpleCov::Formatter,
+    SimpleCov::Formatter::HTMLFormatter
+  ]
+  SimpleCov.start do
+    add_filter '/spec/'
+    add_filter '/generated/'
+  end
 end
 
-Faraday::Adapter.load_middleware(:test)
+require 'rspec'
+require 'webmock/rspec'
+require 'fakefs/spec_helpers'
+require 'json_spec'
+require 'logging'
+require 'rspec/logging_helper'
+require 'google/apis'
+require 'google/apis/core/base_service'
 
-module Faraday
-  class Connection
-    def verify
-      if app.kind_of?(Faraday::Adapter::Test)
-        app.stubs.verify_stubbed_calls
-      else
-        raise TypeError, "Expected test adapter"
-      end
-    end
+# Configure RSpec to capture log messages for each test. The output from the
+# logs will be stored in the @log_output variable. It is a StringIO instance.
+RSpec.configure do |config|
+  include RSpec::LoggingHelper
+  config.include FakeFS::SpecHelpers, fakefs: true
+  config.include JsonSpec::Helpers
+  config.include WebMock::API
+  config.capture_log_messages
+
+  Google::Apis.logger.level = Logger::DEBUG
+  WebMock::Config.instance.query_values_notation = :flat_array
+end
+
+[JsonSpec::Matchers::BeJsonEql,
+ JsonSpec::Matchers::IncludeJson,
+ JsonSpec::Matchers::HaveJsonType,
+ JsonSpec::Matchers::HaveJsonSize,
+ JsonSpec::Matchers::HaveJsonPath].each do |klass|
+  klass.send(:alias_method, :===, :matches?)
+end
+
+RSpec.shared_context 'HTTP client' do
+  let(:client) do
+    Google::Apis::Core::BaseService.new('', '').client
   end
 end
 
-module ConnectionHelpers
-  def stub_connection(&block)
-    stubs = Faraday::Adapter::Test::Stubs.new do |stub|
-      block.call(stub)
+module TestHelpers
+  include WebMock::API
+  include WebMock::Matchers
+end
+
+# Enable retries for tests
+Google::Apis::RequestOptions.default.retries = 5
+
+# Allow testing different adapters
+Google::Apis::ClientOptions.default.use_net_http = true if ENV['USE_NET_HTTP']
+# Temporarily patch WebMock to allow chunked responses for Net::HTTP
+module Net
+  module WebMockHTTPResponse
+    def eval_chunk(chunk)
+      chunk if chunk.is_a?(String)
+      chunk.read if chunk.is_a?(IO)
+      chunk.call if chunk.is_a?(Proc)
+      fail chunk if chunk.is_a?(Class)
+      chunk
     end
-    connection = Faraday.new do |builder|
-      builder.options.params_encoder = Faraday::FlatParamsEncoder
-      builder.adapter(:test, stubs)
+
+    def read_body(dest = nil, &block)
+      if !(defined?(@__read_body_previously_called).nil?) && @__read_body_previously_called
+        return super
+      end
+      return @body if dest.nil? && block.nil?
+      fail ArgumentError.new('both arg and block given for HTTP method') if dest && block
+      return nil if @body.nil?
+
+      dest ||= ::Net::ReadAdapter.new(block)
+      body_parts = Array(@body)
+      body_parts.each do |chunk|
+        chunk = eval_chunk(chunk)
+        dest << chunk
+      end
+      @body = dest
+    ensure
+      # allow subsequent calls to #read_body to proceed as normal, without our hack...
+      @__read_body_previously_called = true
     end
   end
 end
 
-module JSONMatchers
-  class EqualsJson
-    def initialize(expected)
-      @expected = JSON.parse(expected)
-    end
-    def matches?(target)
-      @target = JSON.parse(target)
-      @target.eql?(@expected)
-    end
-    def failure_message
-      "expected #{@target.inspect} to be #{@expected}"
-    end
-    def negative_failure_message
-      "expected #{@target.inspect} not to be #{@expected}"
-    end
+class WebMockHTTPClient
+  def eval_chunk(chunk)
+    chunk if chunk.is_a?(String)
+    chunk.read if chunk.is_a?(IO)
+    chunk.call if chunk.is_a?(Proc)
+    fail HTTPClient::TimeoutError if chunk == ::Timeout::Error
+    fail chunk if chunk.is_a?(Class)
+    chunk
   end
 
-  def be_json(expected)
-    EqualsJson.new(expected)
+  def build_httpclient_response(webmock_response, stream = false, req_header = nil, &block)
+    body = stream ? StringIO.new(webmock_response.body) : webmock_response.body
+    response = HTTP::Message.new_response(body, req_header)
+    response.header.init_response(webmock_response.status[0])
+    response.reason = webmock_response.status[1]
+    webmock_response.headers.to_a.each { |name, value| response.header.set(name, value) }
+
+    raise HTTPClient::TimeoutError if webmock_response.should_timeout
+    webmock_response.raise_error_if_any
+
+    body_parts = Array(webmock_response.body)
+    body_parts.each do |chunk|
+      chunk = eval_chunk(chunk)
+      block.call(response, chunk) if block
+    end
+
+    response
   end
 end
 
-RSpec.configure do |config|
+
+def run_integration_tests?
+  ENV['GOOGLE_APPLICATION_CREDENTIALS'] && ENV['GOOGLE_PROJECT_ID']
 end

data/third_party/hurley_patches.rb

@@ -0,0 +1,103 @@
+#
+# Copyright (c) 2015 Rick Olson
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+require 'hurley'
+require 'hurley/client'
+require 'hurley/connection'
+require 'net/https'
+
+# Temporary monkey patch for streaming downloads. These are fixed in HEAD,
+# but pending a 0.3 release.
+if Hurley::VERSION == '0.2'
+  module Hurley
+    class Response
+      def location
+        @location ||= begin
+          return unless loc = @header[:location]
+          verb = STATUS_FORCE_GET.include?(status_code) ? :get : request.verb
+          statuses, receiver = request.send(:body_receiver)
+          new_request = Request.new(verb, request.url.join(Url.parse(loc)), request.header, request.body, request.options, request.ssl_options)
+          new_request.on_body(*statuses, &receiver) unless receiver.is_a?(Hurley::BodyReceiver)
+          new_request
+        end
+      end
+    end
+
+    class Connection
+      def call(request)
+        net_http_connection(request) do |http|
+          begin
+            Response.new(request) do |res|
+              perform_request(http, request, res)
+
+              # net/http only raises exception on 407 with ssl...?
+              if res.status_code == 407
+                raise ConnectionFailed, %(407 "Proxy Authentication Required")
+              end
+            end
+          rescue *NET_HTTP_EXCEPTIONS => err
+            if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
+              raise SSLError, err
+            else
+              raise ConnectionFailed, err
+            end
+          end
+        end
+
+      rescue ::Timeout::Error => err
+        raise Timeout, err
+      end
+
+      private
+
+      def net_http_request(request)
+        http_req = Net::HTTPGenericRequest.new(
+          request.verb.to_s.upcase, # request method
+          !!request.body,           # is there a request body
+          :head != request.verb,    # is there a response body
+          request.url.request_uri,  # request uri path
+          request.header,           # request headers
+        )
+
+        if body = request.body_io
+          http_req.body_stream = body
+        end
+
+        http_req
+      end
+
+      def perform_request(http, request, res)
+        http.request(net_http_request(request)) do |http_res|
+          res.status_code = http_res.code.to_i
+          http_res.each_header do |key, value|
+            res.header[key] = value
+          end
+
+          if :get == request.verb
+            http_res.read_body { |chunk| res.receive_body(chunk) }
+          else
+            res.receive_body(http_res.body)
+          end
+        end
+      end
+    end
+  end
+end