chiu
/
google-api-ruby-client
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Begin consolidation of request building in reference. Further changes coming to simplify batch + media handling

This commit is contained in:
Steven Bazyl 2012-09-05 14:56:52 -07:00
parent 8e26241e1c
commit 18d3cccd6a
8 changed files with 155 additions and 312 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

179
lib/google/api_client.rb
View File

@ -464,6 +464,31 @@ module Google
return nil
end
def normalize_api_method(options)
method = options[:api_method]
version = options[:version]
if method.kind_of?(Google::APIClient::Method) || method == nil
return method
elsif method.respond_to?(:to_str) || method.kind_of?(Symbol)
# This method of guessing the API is unreliable. This will fail for
# APIs where the first segment of the RPC name does not match the
# service name. However, this is a fallback mechanism anyway.
# Developers should be passing in a reference to the method, rather
# than passing in a string or symbol. This should raise an error
# in the case of a mismatch.
method = method.to_s
api = method[/^([^.]+)\./, 1]
api_method = self.discovered_method(method, api, version)
if api_method.nil?
raise ArgumentError, "API method could not be found."
end
return api_method
else
raise TypeError,
"Expected Google::APIClient::Method, got #{new_api_method.class}."
end
end
##
# Generates a request.
#
@ -482,7 +507,7 @@ module Google
# `true` if the request must be signed or somehow
# authenticated, `false` otherwise.
#
# @return [Faraday::Request] The generated request.
# @return [Google::APIClient::Reference] The generated request.
#
# @example
# request = client.generate_request(
@ -501,36 +526,9 @@ module Google
:user_ip => self.user_ip,
:connection => Faraday.default_connection
}.merge(options)
# The Reference object is going to need this to do method ID lookups.
options[:client] = self
# The default value for the :authenticated option depends on whether an
# authorization mechanism has been set.
if options[:authorization]
options = {:authenticated => true}.merge(options)
else
options = {:authenticated => false}.merge(options)
end
reference = Google::APIClient::Reference.new(options)
request = reference.to_request
if options[:authenticated] && options[:authorization].respond_to?(:generate_authenticated_request)
request = options[:authorization].generate_authenticated_request(
:request => request,
:connection => options[:connection]
)
end
return request
end
##
# Signs a request using the current authorization mechanism.
#
# @param [Hash] options a customizable set of options
#
# @return [Faraday::Request] The signed or otherwise authenticated request.
# @deprecated No longer used internally
def generate_authenticated_request(options={})
return authorization.generate_authenticated_request(options)
options[:api_method] = self.normalize_api_method(options)
return Google::APIClient::Reference.new(options)
end
##
@ -538,81 +536,14 @@ module Google
#
# @option options [Array, Faraday::Request] :request
# The HTTP request to transmit.
# @option options [String, Symbol] :method
# The method for the HTTP request.
# @option options [String, Addressable::URI] :uri
# The URI for the HTTP request.
# @option options [Array, Hash] :headers
# The headers for the HTTP request.
# @option options [String] :body
# The body for the HTTP request.
# @option options [Faraday::Connection] :connection
# The HTTP connection to use.
#
# @return [Faraday::Response] The response from the server.
def transmit(options={})
options[:connection] ||= Faraday.default_connection
if options[:request]
if options[:request].kind_of?(Array)
method, uri, headers, body = options[:request]
elsif options[:request].kind_of?(Faraday::Request)
unless options[:connection]
raise ArgumentError,
"Faraday::Request used, requires a connection to be provided."
end
method = options[:request].method.to_s.downcase.to_sym
uri = options[:connection].build_url(
options[:request].path, options[:request].params
)
headers = options[:request].headers || {}
body = options[:request].body || ''
end
else
method = options[:method] || :get
uri = options[:uri]
headers = options[:headers] || []
body = options[:body] || ''
end
headers = headers.to_a if headers.kind_of?(Hash)
request_components = {
:method => method,
:uri => uri,
:headers => headers,
:body => body
}
# Verify that we have all pieces required to transmit an HTTP request
request_components.each do |(key, value)|
unless value
raise ArgumentError, "Missing :#{key} parameter."
end
end
if self.user_agent != nil
# If there's no User-Agent header, set one.
unless headers.kind_of?(Enumerable)
# We need to use some Enumerable methods, relying on the presence of
# the #each method.
class << headers
include Enumerable
end
end
if self.user_agent.kind_of?(String)
unless headers.any? { |k, v| k.downcase == 'User-Agent'.downcase }
headers = headers.to_a.insert(0, ['User-Agent', self.user_agent])
end
elsif self.user_agent != nil
raise TypeError,
"Expected User-Agent to be String, got #{self.user_agent.class}"
end
end
request = options[:connection].build_request(
method.to_s.downcase.to_sym
) do |req|
req.url(Addressable::URI.parse(uri).normalize.to_s)
req.headers = Faraday::Utils::Headers.new(headers)
req.body = body
end
request = options[:request]
request['User-Agent'] ||= '' + self.user_agent unless self.user_agent.nil?
request_env = request.to_env(options[:connection])
response = options[:connection].app.call(request_env)
return response
@ -662,37 +593,14 @@ module Google
params.size == 1
batch = params.pop
options = batch.options
options[:connection] ||= Faraday.default_connection
http_request = batch.to_http_request
request = nil
if @authorization
method, uri, headers, body = http_request
method = method.to_s.downcase.to_sym
faraday_request = options[:connection].build_request(
method.to_s.downcase.to_sym
) do |req|
req.url(Addressable::URI.parse(uri).normalize.to_s)
req.headers = Faraday::Utils::Headers.new(headers)
req.body = body
end
request = {
:request => self.generate_authenticated_request(
:request => faraday_request,
:connection => options[:connection]
),
:connection => options[:connection]
}
else
request = {
:request => http_request,
:connection => options[:connection]
}
end
response = self.transmit(request)
method, uri, headers, body = batch.to_http_request
reference = self.generate_request({
:uri => uri,
:http_method => method,
:headers => headers,
:body => body
}.merge(options))
response = self.transmit(:request => reference.to_http_request, :connection => options[:connection])
batch.process_response(response)
return nil
else
@ -711,14 +619,13 @@ module Google
options[:body] = params.shift if params.size > 0
options[:headers] = params.shift if params.size > 0
options[:client] = self
options[:connection] ||= Faraday.default_connection
reference = Google::APIClient::Reference.new(options)
request = self.generate_request(reference)
reference = self.generate_request(options)
response = self.transmit(
:request => request,
:request => reference.to_http_request,
:connection => options[:connection]
)
return Google::APIClient::Result.new(reference, request, response)
result = Google::APIClient::Result.new(reference, response)
return result
end
end

4
lib/google/api_client/batch.rb
View File

@ -121,7 +121,7 @@ module Google
call_response = deserialize_call_response(part)
callback = @callbacks[call_response.call_id]
call = @calls[call_response.call_id]
result = Google::APIClient::Result.new(call, nil, call_response)
result = Google::APIClient::Result.new(call, call_response)
callback.call(result) if callback
end
end
@ -196,7 +196,7 @@ module Google
#
# @return [String] The request as a string in application/http format.
def serialize_call(call)
http_request = call.to_request
http_request = call.to_http_request
method = http_request.method.to_s.upcase
path = http_request.path.to_s
status_line = method + " " + path + " HTTP/1.1"

7
lib/google/api_client/discovery/method.rb
View File

@ -224,13 +224,6 @@ module Google
# @return [Array] The generated HTTP request.
def generate_request(parameters={}, body='', headers=[], options={})
options[:connection] ||= Faraday.default_connection
if body.respond_to?(:string)
body = body.string
elsif body.respond_to?(:to_str)
body = body.to_str
else
raise TypeError, "Expected String or StringIO, got #{body.class}."
end
if !headers.kind_of?(Array) && !headers.kind_of?(Hash)
raise TypeError, "Expected Hash or Array, got #{headers.class}."
end

197
lib/google/api_client/reference.rb
View File

@ -12,7 +12,6 @@
# See the License for the specific language governing permissions and
# limitations under the License.
require 'faraday'
require 'faraday/utils'
require 'multi_json'
@ -29,84 +28,20 @@ module Google
MULTIPART_BOUNDARY = "-----------RubyApiMultipartPost".freeze
def initialize(options={})
# We only need this to do lookups on method ID String values
# It's optional, but method ID lookups will fail if the client is
# omitted.
@client = options[:client]
@version = options[:version] || 'v1'
self.connection = options[:connection] || Faraday.default_connection
self.authorization = options[:authorization]
self.api_method = options[:api_method]
self.parameters = options[:parameters] || {}
# These parameters are handled differently because they're not
# parameters to the API method, but rather to the API system.
if self.parameters.kind_of?(Array)
if options[:key]
self.parameters.reject! { |k, _| k == 'key' }
self.parameters << ['key', options[:key]]
end
if options[:user_ip]
self.parameters.reject! { |k, _| k == 'userIp' }
self.parameters << ['userIp', options[:user_ip]]
end
elsif self.parameters.kind_of?(Hash)
self.parameters['key'] ||= options[:key] if options[:key]
self.parameters['userIp'] ||= options[:user_ip] if options[:user_ip]
# Convert to Array, because they're easier to work with when
# repeated parameters are an issue.
self.parameters = self.parameters.to_a
else
raise TypeError,
"Expected Array or Hash, got #{self.parameters.class}."
end
self.parameters['key'] ||= options[:key] if options[:key]
self.parameters['userIp'] ||= options[:user_ip] if options[:user_ip]
self.headers = options[:headers] || {}
if options[:media]
self.media = options[:media]
upload_type = self.parameters.find { |(k, _)| ['uploadType', 'upload_type'].include?(k) }.last
case upload_type
when "media"
if options[:body] || options[:body_object]
raise ArgumentError,
"Can not specify body & body object for simple uploads."
end
self.headers['Content-Type'] ||= self.media.content_type
self.body = self.media
when "multipart"
unless options[:body_object]
raise ArgumentError, "Multipart requested but no body object."
end
# This is all a bit of a hack due to Signet requiring body to be a
# string. Ideally, update Signet to delay serialization so we can
# just pass streams all the way down through to the HTTP library.
metadata = StringIO.new(serialize_body(options[:body_object]))
env = {
:request_headers => {
'Content-Type' =>
"multipart/related;boundary=#{MULTIPART_BOUNDARY}"
},
:request => {:boundary => MULTIPART_BOUNDARY}
}
multipart = Faraday::Request::Multipart.new
self.body = multipart.create_multipart(env, [
[nil, Faraday::UploadIO.new(
metadata, 'application/json', 'file.json'
)],
[nil, self.media]])
self.headers.update(env[:request_headers])
when "resumable"
file_length = self.media.length
self.headers['X-Upload-Content-Type'] = self.media.content_type
self.headers['X-Upload-Content-Length'] = file_length.to_s
if options[:body_object]
self.headers['Content-Type'] ||= 'application/json'
self.body = serialize_body(options[:body_object])
else
self.body = ''
end
else
raise ArgumentError, "Invalid uploadType for media."
end
self.initialize_media_upload
elsif options[:body]
self.body = options[:body]
elsif options[:body_object]
@ -119,15 +54,49 @@ module Google
self.http_method = options[:http_method] || 'GET'
self.uri = options[:uri]
unless self.parameters.empty?
query_values = (self.uri.query_values(Array) || [])
self.uri.query = Addressable::URI.form_encode(
(query_values + self.parameters).sort
)
self.uri.query = nil if self.uri.query == ""
self.uri.query = Addressable::URI.form_encode(self.parameters)
end
end
end
def initialize_media_upload
self.media = options[:media]
case self.upload_type
when "media"
if options[:body] || options[:body_object]
raise ArgumentError, "Can not specify body & body object for simple uploads"
end
self.headers['Content-Type'] ||= self.media.content_type
self.body = self.media
when "multipart"
unless options[:body_object]
raise ArgumentError, "Multipart requested but no body object"
end
metadata = StringIO.new(serialize_body(options[:body_object]))
env = {
:request_headers => {'Content-Type' => "multipart/related;boundary=#{MULTIPART_BOUNDARY}"},
:request => { :boundary => MULTIPART_BOUNDARY }
}
multipart = Faraday::Request::Multipart.new
self.body = multipart.create_multipart(env, [
[nil,Faraday::UploadIO.new(metadata, 'application/json', 'file.json')],
[nil, self.media]])
self.headers.update(env[:request_headers])
when "resumable"
file_length = self.media.length
self.headers['X-Upload-Content-Type'] = self.media.content_type
self.headers['X-Upload-Content-Length'] = file_length.to_s
if options[:body_object]
self.headers['Content-Type'] ||= 'application/json'
self.body = serialize_body(options[:body_object])
else
self.body = ''
end
else
raise ArgumentError, "Invalid uploadType for media"
end
end
def serialize_body(body)
return body.to_json if body.respond_to?(:to_json)
return MultiJson.dump(options[:body_object].to_hash) if body.respond_to?(:to_hash)
@ -142,6 +111,10 @@ module Google
def media=(media)
@media = (media)
end
def upload_type
return self.parameters['uploadType'] || self.parameters['upload_type']
end
def authorization
return @authorization
@ -172,29 +145,6 @@ module Google
if new_api_method.kind_of?(Google::APIClient::Method) ||
new_api_method == nil
@api_method = new_api_method
elsif new_api_method.respond_to?(:to_str) ||
new_api_method.kind_of?(Symbol)
unless @client
raise ArgumentError,
"API method lookup impossible without client instance."
end
new_api_method = new_api_method.to_s
# This method of guessing the API is unreliable. This will fail for
# APIs where the first segment of the RPC name does not match the
# service name. However, this is a fallback mechanism anyway.
# Developers should be passing in a reference to the method, rather
# than passing in a string or symbol. This should raise an error
# in the case of a mismatch.
api = new_api_method[/^([^.]+)\./, 1]
@api_method = @client.discovered_method(
new_api_method, api, @version
)
if @api_method
# Ditch the client reference, we won't need it again.
@client = nil
else
raise ArgumentError, "API method could not be found."
end
else
raise TypeError,
"Expected Google::APIClient::Method, got #{new_api_method.class}."
@ -206,8 +156,7 @@ module Google
end
def parameters=(new_parameters)
# No type-checking needed, the Method class handles this.
@parameters = new_parameters
@parameters = Hash[new_parameters]
end
def body
@ -215,19 +164,7 @@ module Google
end
def body=(new_body)
if new_body.respond_to?(:to_str)
@body = new_body.to_str
elsif new_body.respond_to?(:read)
@body = new_body.read()
elsif new_body.respond_to?(:inject)
@body = (new_body.inject(StringIO.new) do |accu, chunk|
accu.write(chunk)
accu
end).string
else
raise TypeError,
"Expected body to be String, IO, or Enumerable chunks."
end
@body = new_body
end
def headers
@ -248,9 +185,9 @@ module Google
def http_method=(new_http_method)
if new_http_method.kind_of?(Symbol)
@http_method = new_http_method.to_s.upcase
@http_method = new_http_method.to_s.downcase.to_sym
elsif new_http_method.respond_to?(:to_str)
@http_method = new_http_method.to_str.upcase
@http_method = new_http_method.to_s.downcase.to_sym
else
raise TypeError,
"Expected String or Symbol, got #{new_http_method.class}."
@ -265,21 +202,27 @@ module Google
@uri = Addressable::URI.parse(new_uri)
end
def to_request
if self.api_method
return self.api_method.generate_request(
self.parameters, self.body, self.headers,
def to_http_request
request = (
if self.api_method
self.api_method.generate_request(
self.parameters, self.body, self.headers, :connection => self.connection
)
else
self.connection.build_request(self.http_method) do |req|
req.url(self.uri.to_str)
req.headers.update(self.headers)
req.body = self.body
end
end)
if self.authorization.respond_to?(:generate_authenticated_request)
request = self.authorization.generate_authenticated_request(
:request => request,
:connection => self.connection
)
else
return self.connection.build_request(
self.http_method.to_s.downcase.to_sym
) do |req|
req.url(Addressable::URI.parse(self.uri).normalize.to_s)
req.headers = Faraday::Utils::Headers.new(self.headers)
req.body = self.body
end
end
return request
end
def to_hash

5
lib/google/api_client/result.rb
View File

@ -18,16 +18,13 @@ module Google
##
# This class wraps a result returned by an API call.
class Result
def initialize(reference, request, response)
def initialize(reference, response)
@reference = reference
@request = request
@response = response
end
attr_reader :reference
attr_reader :request
attr_reader :response
def status

58
spec/google/api_client/discovery_spec.rb
View File

@ -91,7 +91,7 @@ describe Google::APIClient do
:uri => CLIENT.discovery_uri('prediction', 'v1.2'),
:authenticated => false
)
request.to_env(Faraday.default_connection)[:url].to_s.should === (
request.to_http_request.to_env(Faraday.default_connection)[:url].to_s.should === (
'https://www.googleapis.com/discovery/v1/apis/prediction/v1.2/rest' +
'?userIp=127.0.0.1'
)
@ -104,7 +104,7 @@ describe Google::APIClient do
:uri => CLIENT.discovery_uri('prediction', 'v1.2'),
:authenticated => false
)
request.to_env(Faraday.default_connection)[:url].to_s.should === (
request.to_http_request.to_env(Faraday.default_connection)[:url].to_s.should === (
'https://www.googleapis.com/discovery/v1/apis/prediction/v1.2/rest' +
'?key=qwerty'
)
@ -119,7 +119,7 @@ describe Google::APIClient do
:authenticated => false
)
Addressable::URI.parse(
request.to_env(Faraday.default_connection)[:url]
request.to_http_request.to_env(Faraday.default_connection)[:url]
).query_values.should == {
'key' => 'qwerty',
'userIp' => '127.0.0.1'
@ -183,8 +183,8 @@ describe Google::APIClient do
:api_method => @prediction.training.insert,
:parameters => {'data' => '12345'}
)
request.method.should == :post
request.to_env(Faraday.default_connection)[:url].to_s.should ===
request.to_http_request.method.should == :post
request.to_http_request.to_env(Faraday.default_connection)[:url].to_s.should ===
'https://www.googleapis.com/prediction/v1.2/training?data=12345'
request.headers.should be_empty
request.body.should == ''
@ -195,8 +195,8 @@ describe Google::APIClient do
:api_method => @prediction.training.insert,
:parameters => [['data', '1'], ['data','2']]
)
request.method.should == :post
request.to_env(Faraday.default_connection)[:url].to_s.should ===
request.to_http_request.method.should == :post
request.to_http_request.to_env(Faraday.default_connection)[:url].to_s.should ===
'https://www.googleapis.com/prediction/v1.2/training?data=1&data=2'
end
@ -205,7 +205,7 @@ describe Google::APIClient do
:api_method => @prediction.training.insert,
:parameters => {'data' => '12345'}
)
request.to_env(Faraday.default_connection)[:url].to_s.should ===
request.to_http_request.to_env(Faraday.default_connection)[:url].to_s.should ===
'https://www.googleapis.com/prediction/v1.2/training?data=12345'
end
@ -214,7 +214,7 @@ describe Google::APIClient do
:api_method => @prediction.training.insert,
:parameters => {'data' => '12345'}
)
request.to_env(Faraday.default_connection)[:url].to_s.should ===
request.to_http_request.to_env(Faraday.default_connection)[:url].to_s.should ===
'https://www.googleapis.com/prediction/v1.2/training?data=12345'
end
@ -228,7 +228,7 @@ describe Google::APIClient do
:api_method => prediction_rebase.training.insert,
:parameters => {'data' => '123'}
)
request.to_env(Faraday.default_connection)[:url].to_s.should === (
request.to_http_request.to_env(Faraday.default_connection)[:url].to_s.should === (
'https://testing-domain.example.com/' +
'prediction/v1.2/training?data=123'
)
@ -242,8 +242,9 @@ describe Google::APIClient do
:api_method => @prediction.training.insert,
:parameters => {'data' => '12345'}
)
request.headers.should have_key('Authorization')
request.headers['Authorization'].should =~ /^OAuth/
http_request = request.to_http_request
http_request.headers.should have_key('Authorization')
http_request.headers['Authorization'].should =~ /^OAuth/
end
it 'should generate OAuth 2 requests' do
@ -253,8 +254,9 @@ describe Google::APIClient do
:api_method => @prediction.training.insert,
:parameters => {'data' => '12345'}
)
request.headers.should have_key('Authorization')
request.headers['Authorization'].should =~ /^Bearer/
http_request = request.to_http_request
http_request.headers.should have_key('Authorization')
http_request.headers['Authorization'].should =~ /^Bearer/
end
it 'should not be able to execute improperly authorized requests' do
@ -310,7 +312,7 @@ describe Google::APIClient do
MultiJson.dump({"id" => "bucket/object"}),
{'Content-Type' => 'application/json'}
)
result.request.headers['Content-Type'].should == 'application/json'
result.reference.to_http_request.headers['Content-Type'].should == 'application/json'
end
end
@ -357,7 +359,7 @@ describe Google::APIClient do
},
:authenticated => false
)
request.to_env(Faraday.default_connection)[:url].to_s.should === (
request.to_http_request.to_env(Faraday.default_connection)[:url].to_s.should === (
'https://www.googleapis.com/plus/v1/' +
'people/107807692475771887386/activities/public'
)
@ -369,7 +371,7 @@ describe Google::APIClient do
:api_method => @plus.activities.list,
:parameters => {'alt' => 'json'},
:authenticated => false
)
).to_http_request
end).should raise_error(ArgumentError)
end
@ -381,7 +383,7 @@ describe Google::APIClient do
'userId' => '107807692475771887386', 'collection' => 'bogus'
},
:authenticated => false
)
).to_http_request
end).should raise_error(ArgumentError)
end
end
@ -428,7 +430,7 @@ describe Google::APIClient do
:api_method => 'latitude.currentLocation.get',
:authenticated => false
)
request.to_env(Faraday.default_connection)[:url].to_s.should ===
request.to_http_request.to_env(Faraday.default_connection)[:url].to_s.should ===
'https://www.googleapis.com/latitude/v1/currentLocation'
end
@ -437,7 +439,7 @@ describe Google::APIClient do
:api_method => @latitude.current_location.get,
:authenticated => false
)
request.to_env(Faraday.default_connection)[:url].to_s.should ===
request.to_http_request.to_env(Faraday.default_connection)[:url].to_s.should ===
'https://www.googleapis.com/latitude/v1/currentLocation'
end
@ -492,7 +494,7 @@ describe Google::APIClient do
:api_method => 'moderator.profiles.get',
:authenticated => false
)
request.to_env(Faraday.default_connection)[:url].to_s.should ===
request.to_http_request.to_env(Faraday.default_connection)[:url].to_s.should ===
'https://www.googleapis.com/moderator/v1/profiles/@me'
end
@ -501,7 +503,7 @@ describe Google::APIClient do
:api_method => @moderator.profiles.get,
:authenticated => false
)
request.to_env(Faraday.default_connection)[:url].to_s.should ===
request.to_http_request.to_env(Faraday.default_connection)[:url].to_s.should ===
'https://www.googleapis.com/moderator/v1/profiles/@me'
end
@ -552,7 +554,7 @@ describe Google::APIClient do
:api_method => 'adsense.adclients.list',
:authenticated => false
)
request.to_env(Faraday.default_connection)[:url].to_s.should ===
request.to_http_request.to_env(Faraday.default_connection)[:url].to_s.should ===
'https://www.googleapis.com/adsense/v1/adclients'
end
@ -561,7 +563,7 @@ describe Google::APIClient do
:api_method => @adsense.adclients.list,
:authenticated => false
)
request.to_env(Faraday.default_connection)[:url].to_s.should ===
request.to_http_request.to_env(Faraday.default_connection)[:url].to_s.should ===
'https://www.googleapis.com/adsense/v1/adclients'
end
@ -578,7 +580,7 @@ describe Google::APIClient do
CLIENT.generate_request(
:api_method => @adsense.reports.generate,
:authenticated => false
)
).to_http_request
end).should raise_error(ArgumentError)
end
@ -593,7 +595,7 @@ describe Google::APIClient do
'metric' => 'PAGE_VIEWS'
},
:authenticated => false
)
).to_http_request
end).should_not raise_error
end
@ -608,7 +610,7 @@ describe Google::APIClient do
'metric' => 'PAGE_VIEWS'
},
:authenticated => false
)
).to_http_request
end).should raise_error(ArgumentError)
end
@ -638,7 +640,7 @@ describe Google::APIClient do
'metric' => ['PAGE_VIEWS', 'CLICKS']
},
:authenticated => false
)
).to_http_request
end).should raise_error(ArgumentError)
end
end

10
spec/google/api_client/result_spec.rb
View File

@ -32,7 +32,7 @@ describe Google::APIClient::Result do
'maxResults' => 20
}
})
@request = @reference.to_request
@request = @reference.to_http_request
# Response stub
@response = stub("response")
@ -66,7 +66,7 @@ describe Google::APIClient::Result do
}
END_OF_STRING
)
@result = Google::APIClient::Result.new(@reference, @request, @response)
@result = Google::APIClient::Result.new(@reference, @response)
end
it 'should indicate a successful response' do
@ -81,7 +81,7 @@ describe Google::APIClient::Result do
reference = @result.next_page
Hash[reference.parameters].should include('pageToken')
Hash[reference.parameters]['pageToken'].should == 'NEXT+PAGE+TOKEN'
url = reference.to_request.to_env(Faraday.default_connection)[:url]
url = reference.to_http_request.to_env(Faraday.default_connection)[:url]
url.to_s.should include('pageToken=NEXT%2BPAGE%2BTOKEN')
end
@ -123,7 +123,7 @@ describe Google::APIClient::Result do
}
END_OF_STRING
)
@result = Google::APIClient::Result.new(@reference, @request, @response)
@result = Google::APIClient::Result.new(@reference, @response)
end
it 'should not return a next page token' do
@ -169,7 +169,7 @@ describe Google::APIClient::Result do
END_OF_STRING
)
@response.stub(:status).and_return(400)
@result = Google::APIClient::Result.new(@reference, @request, @response)
@result = Google::APIClient::Result.new(@reference, @response)
end
it 'should return error status correctly' do

7
spec/google/api_client_spec.rb
View File

@ -42,9 +42,7 @@ shared_examples_for 'configurable user agent' do
it 'should transmit a User-Agent header when sending requests' do
client.user_agent = 'Custom User Agent/1.2.3'
request = Faraday::Request.new(:get) do |req|
req.url('http://www.google.com/')
end
stubs = Faraday::Adapter::Test::Stubs.new do |stub|
stub.get('/') do |env|
headers = env[:request_headers]
@ -56,6 +54,9 @@ shared_examples_for 'configurable user agent' do
connection = Faraday.new(:url => 'https://www.google.com') do |builder|
builder.adapter(:test, stubs)
end
request = connection.build_request(:get) do |req|
req.url('http://www.google.com/')
end
client.transmit(:request => request, :connection => connection)
stubs.verify_stubbed_calls
end