google-api-client 0.8.3 → 0.9

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