google-api-client 0.2.0 → 0.3.0

data/lib/google/api_client/reference.rb

@@ -0,0 +1,202 @@
+# Copyright 2010 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 'stringio'
+require 'json'
+require 'addressable/uri'
+require 'google/api_client/discovery'
+
+module Google
+  class APIClient
+    class Reference
+      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.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.
+        self.parameters['key'] ||= options[:key] if options[:key]
+        self.parameters['userIp'] ||= options[:user_ip] if options[:user_ip]
+        self.headers = options[:headers] || []
+        if options[:body]
+          self.body = options[:body]
+        elsif options[:merged_body]
+          self.merged_body = options[:merged_body]
+        elsif options[:body_object]
+          if options[:body_object].respond_to?(:to_json)
+            serialized_body = options[:body_object].to_json
+          elsif options[:body_object].respond_to?(:to_hash)
+            serialized_body = JSON.generate(options[:body_object].to_hash)
+          else
+            raise TypeError,
+              'Could not convert body object to JSON.' +
+              'Must respond to :to_json or :to_hash.'
+          end
+          self.merged_body = serialized_body
+        else
+          self.merged_body = ''
+        end
+        unless self.api_method
+          self.http_method = options[:http_method] || 'GET'
+          self.uri = options[:uri]
+          unless self.parameters.empty?
+            self.uri.query_values =
+              (self.uri.query_values || {}).merge(self.parameters)
+          end
+        end
+      end
+
+      def api_method
+        return @api_method
+      end
+
+      def api_method=(new_api_method)
+        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}."
+        end
+      end
+
+      def parameters
+        return @parameters
+      end
+
+      def parameters=(new_parameters)
+        # No type-checking needed, the Method class handles this.
+        @parameters = new_parameters
+      end
+
+      def body
+        return @body
+      end
+
+      def body=(new_body)
+        if new_body.respond_to?(:each)
+          @body = new_body
+        else
+          raise TypeError, "Expected body to respond to :each."
+        end
+      end
+
+      def merged_body
+        return (self.body.inject(StringIO.new) do |accu, chunk|
+          accu.write(chunk)
+          accu
+        end).string
+      end
+
+      def merged_body=(new_merged_body)
+        if new_merged_body.respond_to?(:string)
+          new_merged_body = new_merged_body.string
+        elsif new_merged_body.respond_to?(:to_str)
+          new_merged_body = new_merged_body.to_str
+        else
+          raise TypeError,
+            "Expected String or StringIO, got #{new_merged_body.class}."
+        end
+        self.body = [new_merged_body]
+      end
+
+      def headers
+        return @headers ||= []
+      end
+
+      def headers=(new_headers)
+        if new_headers.kind_of?(Array) || new_headers.kind_of?(Hash)
+          @headers = new_headers
+        else
+          raise TypeError, "Expected Hash or Array, got #{new_headers.class}."
+        end
+      end
+
+      def http_method
+        return @http_method ||= self.api_method.http_method
+      end
+
+      def http_method=(new_http_method)
+        if new_http_method.kind_of?(Symbol)
+          @http_method = new_http_method.to_s.upcase
+        elsif new_http_method.respond_to?(:to_str)
+          @http_method = new_http_method.to_str.upcase
+        else
+          raise TypeError,
+            "Expected String or Symbol, got #{new_http_method.class}."
+        end
+      end
+
+      def uri
+        return @uri ||= self.api_method.generate_uri(self.parameters)
+      end
+
+      def uri=(new_uri)
+        @uri = Addressable::URI.parse(new_uri)
+      end
+
+      def to_request
+        if self.api_method
+          return self.api_method.generate_request(
+            self.parameters, self.merged_body, self.headers
+          )
+        else
+          return [self.http_method, self.uri, self.headers, self.body]
+        end
+      end
+
+      def to_hash
+        options = {}
+        if self.api_method
+          options[:api_method] = self.api_method
+          options[:parameters] = self.parameters
+        else
+          options[:http_method] = self.http_method
+          options[:uri] = self.uri
+        end
+        options[:headers] = self.headers
+        options[:body] = self.body
+        return options
+      end
+    end
+  end
+end

data/lib/google/api_client/result.rb

@@ -0,0 +1,132 @@
+# Copyright 2010 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.
+
+module Google
+  class APIClient
+    ##
+    # This class wraps a result returned by an API call.
+    class Result
+      def initialize(reference, request, response)
+        @reference = reference
+        @request = request
+        @response = response
+      end
+
+      attr_reader :reference
+
+      attr_reader :request
+
+      attr_reader :response
+
+      def status
+        return @response[0]
+      end
+
+      def headers
+        return @response[1]
+      end
+
+      def body
+        return @body ||= (begin
+          response_body = @response[2]
+          merged_body = (response_body.inject(StringIO.new) do |accu, chunk|
+            accu.write(chunk)
+            accu
+          end).string
+        end)
+      end
+
+      def data
+        return @data ||= (begin
+          _, content_type = self.headers.detect do |h, v|
+            h.downcase == 'Content-Type'.downcase
+          end
+          media_type = content_type[/^([^;]*);?.*$/, 1].strip.downcase
+          data = self.body
+          case media_type
+          when 'application/json'
+            data = ::JSON.parse(data)
+            # Strip data wrapper, if present
+            data = data['data'] if data.has_key?('data')
+          else
+            raise ArgumentError,
+              "Content-Type not supported for parsing: #{media_type}"
+          end
+          if @reference.api_method && @reference.api_method.response_schema
+            # Automatically parse using the schema designated for the
+            # response of this API method.
+            data = @reference.api_method.response_schema.new(data)
+            data
+          else
+            # Otherwise, return the raw unparsed value.
+            # This value must be indexable like a Hash.
+            data
+          end
+        end)
+      end
+
+      def pagination_type
+        return :token
+      end
+
+      def page_token_param
+        return "pageToken"
+      end
+
+      def next_page_token
+        if self.data.respond_to?(:next_page_token)
+          return self.data.next_page_token
+        elsif self.data.respond_to?(:[])
+          return self.data["nextPageToken"]
+        else
+          raise TypeError, "Data object did not respond to #next_page_token."
+        end
+      end
+
+      def next_page
+        merged_parameters = Hash[self.reference.parameters].merge({
+          self.page_token_param => self.next_page_token
+        })
+        # Because References can be coerced to Hashes, we can merge them,
+        # preserving all context except the API method parameters that we're
+        # using for pagination.
+        return Google::APIClient::Reference.new(
+          Hash[self.reference].merge(:parameters => merged_parameters)
+        )
+      end
+
+      def prev_page_token
+        if self.data.respond_to?(:prev_page_token)
+          return self.data.prev_page_token
+        elsif self.data.respond_to?(:[])
+          return self.data["prevPageToken"]
+        else
+          raise TypeError, "Data object did not respond to #next_page_token."
+        end
+      end
+
+      def prev_page
+        merged_parameters = Hash[self.reference.parameters].merge({
+          self.page_token_param => self.prev_page_token
+        })
+        # Because References can be coerced to Hashes, we can merge them,
+        # preserving all context except the API method parameters that we're
+        # using for pagination.
+        return Google::APIClient::Reference.new(
+          Hash[self.reference].merge(:parameters => merged_parameters)
+        )
+      end
+    end
+  end
+end

data/lib/google/api_client/version.rb

@@ -13,14 +13,17 @@
 # limitations under the License.
 
 
-module Google
-  class APIClient
-    module VERSION
-      MAJOR = 0
-      MINOR = 2
-      TINY  = 0
+# Used to prevent the class/module from being loaded more than once
+if !defined?(::Google::APIClient::VERSION)
+  module Google
+    class APIClient
+      module VERSION
+        MAJOR = 0
+        MINOR = 3
+        TINY  = 0
 
-      STRING = [MAJOR, MINOR, TINY].join('.')
+        STRING = [MAJOR, MINOR, TINY].join('.')
+      end
     end
   end
 end

data/lib/google/inflection.rb

@@ -17,7 +17,12 @@ module Google
   if defined?(ActiveSupport::Inflector)
     INFLECTOR = ActiveSupport::Inflector
   else
-    require 'extlib/inflection'
-    INFLECTOR = Extlib::Inflection
+    begin
+      require 'extlib/inflection'
+      INFLECTOR = Extlib::Inflection
+    rescue LoadError
+      require 'active_support/inflector'
+      INFLECTOR = ActiveSupport::Inflector
+    end
   end
 end

data/spec/google/api_client/discovery_spec.rb

@@ -14,6 +14,7 @@
 
 require 'spec_helper'
 
+require 'json'
 require 'signet/oauth_1/client'
 require 'httpadapter/adapters/net_http'
 
@@ -66,6 +67,9 @@ describe Google::APIClient do
   describe 'with the prediction API' do
     before do
       @client.authorization = nil
+      # The prediction API no longer exposes a v1, so we have to be
+      # careful about looking up the wrong API version.
+      @prediction = @client.discovered_api('prediction', 'v1.2')
     end
 
     it 'should correctly determine the discovery URI' do
@@ -73,46 +77,83 @@ describe Google::APIClient do
         'https://www.googleapis.com/discovery/v1/apis/prediction/v1/rest'
     end
 
+    it 'should correctly determine the discovery URI if :user_ip is set' do
+      @client.user_ip = '127.0.0.1'
+      request = @client.generate_request(
+        :http_method => 'GET',
+        :uri => @client.discovery_uri('prediction', 'v1.2'),
+        :authenticated => false
+      )
+      http_method, uri, headers, body = request
+      uri.should === (
+        'https://www.googleapis.com/discovery/v1/apis/prediction/v1.2/rest' +
+        '?userIp=127.0.0.1'
+      )
+    end
+
+    it 'should correctly determine the discovery URI if :key is set' do
+      @client.key = 'qwerty'
+      request = @client.generate_request(
+        :http_method => 'GET',
+        :uri => @client.discovery_uri('prediction', 'v1.2'),
+        :authenticated => false
+      )
+      http_method, uri, headers, body = request
+      uri.should === (
+        'https://www.googleapis.com/discovery/v1/apis/prediction/v1.2/rest' +
+        '?key=qwerty'
+      )
+    end
+
+    it 'should correctly determine the discovery URI if both are set' do
+      @client.key = 'qwerty'
+      @client.user_ip = '127.0.0.1'
+      request = @client.generate_request(
+        :http_method => 'GET',
+        :uri => @client.discovery_uri('prediction', 'v1.2'),
+        :authenticated => false
+      )
+      http_method, uri, headers, body = request
+      uri.should === (
+        'https://www.googleapis.com/discovery/v1/apis/prediction/v1.2/rest' +
+        '?key=qwerty&userIp=127.0.0.1'
+      )
+    end
+
     it 'should correctly generate API objects' do
-      @client.discovered_api('prediction').name.should == 'prediction'
-      @client.discovered_api('prediction').version.should == 'v1'
-      @client.discovered_api(:prediction).name.should == 'prediction'
-      @client.discovered_api(:prediction).version.should == 'v1'
+      @client.discovered_api('prediction', 'v1.2').name.should == 'prediction'
+      @client.discovered_api('prediction', 'v1.2').version.should == 'v1.2'
+      @client.discovered_api(:prediction, 'v1.2').name.should == 'prediction'
+      @client.discovered_api(:prediction, 'v1.2').version.should == 'v1.2'
     end
 
     it 'should discover methods' do
       @client.discovered_method(
-        'prediction.training.insert', 'prediction'
+        'prediction.training.insert', 'prediction', 'v1.2'
       ).name.should == 'insert'
       @client.discovered_method(
-        :'prediction.training.insert', :prediction
+        :'prediction.training.insert', :prediction, 'v1.2'
       ).name.should == 'insert'
-    end
-
-    it 'should discover methods' do
       @client.discovered_method(
-        'prediction.training.delete', 'prediction', 'v1.1'
+        'prediction.training.delete', 'prediction', 'v1.2'
       ).name.should == 'delete'
     end
 
     it 'should not find methods that are not in the discovery document' do
       @client.discovered_method(
-        'prediction.training.delete', 'prediction', 'v1'
-      ).should == nil
-      @client.discovered_method(
-        'prediction.bogus', 'prediction', 'v1'
+        'prediction.bogus', 'prediction', 'v1.2'
       ).should == nil
     end
 
     it 'should raise an error for bogus methods' do
       (lambda do
-        @client.discovered_method(42, 'prediction', 'v1')
+        @client.discovered_method(42, 'prediction', 'v1.2')
       end).should raise_error(TypeError)
     end
 
     it 'should raise an error for bogus methods' do
       (lambda do
-        @client.generate_request(@client.discovered_api('prediction'))
+        @client.generate_request(@client.discovered_api('prediction', 'v1.2'))
       end).should raise_error(TypeError)
     end
 
@@ -123,49 +164,50 @@ describe Google::APIClient do
 
     it 'should generate valid requests' do
       request = @client.generate_request(
-        'prediction.training.insert',
-        {'data' => '12345', }
+        :api_method => @prediction.training.insert,
+        :parameters => {'data' => '12345', }
       )
       method, uri, headers, body = request
       method.should == 'POST'
       uri.should ==
-        'https://www.googleapis.com/prediction/v1/training?data=12345'
+        'https://www.googleapis.com/prediction/v1.2/training?data=12345'
       (headers.inject({}) { |h,(k,v)| h[k]=v; h }).should == {}
       body.should respond_to(:each)
     end
 
     it 'should generate requests against the correct URIs' do
       request = @client.generate_request(
-        :'prediction.training.insert',
-        {'data' => '12345'}
+        :api_method => @prediction.training.insert,
+        :parameters => {'data' => '12345'}
       )
       method, uri, headers, body = request
       uri.should ==
-        'https://www.googleapis.com/prediction/v1/training?data=12345'
+        'https://www.googleapis.com/prediction/v1.2/training?data=12345'
     end
 
     it 'should generate requests against the correct URIs' do
-      prediction = @client.discovered_api('prediction', 'v1')
       request = @client.generate_request(
-        prediction.training.insert,
-        {'data' => '12345'}
+        :api_method => @prediction.training.insert,
+        :parameters => {'data' => '12345'}
       )
       method, uri, headers, body = request
       uri.should ==
-        'https://www.googleapis.com/prediction/v1/training?data=12345'
+        'https://www.googleapis.com/prediction/v1.2/training?data=12345'
     end
 
     it 'should allow modification to the base URIs for testing purposes' do
-      prediction = @client.discovered_api('prediction', 'v1')
+      prediction = @client.discovered_api('prediction', 'v1.2')
       prediction.method_base =
-        'https://testing-domain.googleapis.com/prediction/v1/'
+        'https://testing-domain.googleapis.com/prediction/v1.2/'
       request = @client.generate_request(
-        prediction.training.insert,
-        {'data' => '123'}
+        :api_method => prediction.training.insert,
+        :parameters => {'data' => '123'}
       )
       method, uri, headers, body = request
-      uri.should ==
-        'https://testing-domain.googleapis.com/prediction/v1/training?data=123'
+      uri.should == (
+        'https://testing-domain.googleapis.com/' +
+        'prediction/v1.2/training?data=123'
+      )
     end
 
     it 'should generate OAuth 1 requests' do
@@ -173,8 +215,8 @@ describe Google::APIClient do
       @client.authorization.token_credential_key = '12345'
       @client.authorization.token_credential_secret = '12345'
       request = @client.generate_request(
-        'prediction.training.insert',
-        {'data' => '12345'}
+        :api_method => @prediction.training.insert,
+        :parameters => {'data' => '12345'}
       )
       method, uri, headers, body = request
       headers = headers.inject({}) { |h,(k,v)| h[k]=v; h }
@@ -186,8 +228,8 @@ describe Google::APIClient do
       @client.authorization = :oauth_2
       @client.authorization.access_token = '12345'
       request = @client.generate_request(
-        'prediction.training.insert',
-        {'data' => '12345'}
+        :api_method => @prediction.training.insert,
+        :parameters => {'data' => '12345'}
       )
       method, uri, headers, body = request
       headers = headers.inject({}) { |h,(k,v)| h[k]=v; h }
@@ -199,88 +241,112 @@ describe Google::APIClient do
       @client.authorization = :oauth_1
       @client.authorization.token_credential_key = '12345'
       @client.authorization.token_credential_secret = '12345'
-      response = @client.execute(
-        'prediction.training.insert',
+      result = @client.execute(
+        @prediction.training.insert,
         {'data' => '12345'}
       )
-      status, headers, body = response
+      status, headers, body = result.response
       status.should == 401
     end
 
     it 'should not be able to execute improperly authorized requests' do
       @client.authorization = :oauth_2
       @client.authorization.access_token = '12345'
-      response = @client.execute(
-        'prediction.training.insert',
+      result = @client.execute(
+        @prediction.training.insert,
         {'data' => '12345'}
       )
-      status, headers, body = response
+      status, headers, body = result.response
       status.should == 401
     end
+
+    it 'should not be able to execute improperly authorized requests' do
+      (lambda do
+        @client.authorization = :oauth_1
+        @client.authorization.token_credential_key = '12345'
+        @client.authorization.token_credential_secret = '12345'
+        result = @client.execute!(
+          @prediction.training.insert,
+          {'data' => '12345'}
+        )
+      end).should raise_error(Google::APIClient::ClientError)
+    end
+
+    it 'should not be able to execute improperly authorized requests' do
+      (lambda do
+        @client.authorization = :oauth_2
+        @client.authorization.access_token = '12345'
+        result = @client.execute!(
+          @prediction.training.insert,
+          {'data' => '12345'}
+        )
+      end).should raise_error(Google::APIClient::ClientError)
+    end
+
+    it 'should correctly handle unnamed parameters' do
+      @client.authorization = :oauth_2
+      @client.authorization.access_token = '12345'
+      result = @client.execute(
+        @prediction.training.insert,
+        {},
+        JSON.generate({"id" => "bucket/object"}),
+        {'Content-Type' => 'application/json'}
+      )
+      method, uri, headers, body = result.request
+      Hash[headers]['Content-Type'].should == 'application/json'
+    end
   end
 
-  describe 'with the buzz API' do
+  describe 'with the plus API' do
     before do
       @client.authorization = nil
-      @buzz = @client.discovered_api('buzz')
+      @plus = @client.discovered_api('plus')
     end
 
     it 'should correctly determine the discovery URI' do
-      @client.discovery_uri('buzz').should ===
-        'https://www.googleapis.com/discovery/v1/apis/buzz/v1/rest'
+      @client.discovery_uri('plus').should ===
+        'https://www.googleapis.com/discovery/v1/apis/plus/v1/rest'
     end
 
     it 'should find APIs that are in the discovery document' do
-      @client.discovered_api('buzz').name.should == 'buzz'
-      @client.discovered_api('buzz').version.should == 'v1'
-      @client.discovered_api(:buzz).name.should == 'buzz'
-      @client.discovered_api(:buzz).version.should == 'v1'
+      @client.discovered_api('plus').name.should == 'plus'
+      @client.discovered_api('plus').version.should == 'v1'
+      @client.discovered_api(:plus).name.should == 'plus'
+      @client.discovered_api(:plus).version.should == 'v1'
     end
 
     it 'should find methods that are in the discovery document' do
       # TODO(bobaman) Fix this when the RPC names are correct
       @client.discovered_method(
-        'chili.activities.list', 'buzz'
+        'plus.activities.list', 'plus'
       ).name.should == 'list'
     end
 
     it 'should not find methods that are not in the discovery document' do
-      @client.discovered_method('buzz.bogus', 'buzz').should == nil
-    end
-
-    it 'should fail for string RPC names that do not match API name' do
-      (lambda do
-        @client.generate_request(
-          'chili.activities.list',
-          {'alt' => 'json'},
-          '',
-          [],
-          {:signed => false}
-        )
-      end).should raise_error(Google::APIClient::TransmissionError)
+      @client.discovered_method('plus.bogus', 'plus').should == nil
     end
 
     it 'should generate requests against the correct URIs' do
       request = @client.generate_request(
-        @buzz.activities.list,
-        {'userId' => 'hikingfan', 'scope' => '@public'},
-        '',
-        [],
-        {:signed => false}
+        :api_method => @plus.activities.list,
+        :parameters => {
+          'userId' => '107807692475771887386', 'collection' => 'public'
+        },
+        :authenticated => false
       )
       method, uri, headers, body = request
-      uri.should ==
-        'https://www.googleapis.com/buzz/v1/activities/hikingfan/@public'
+      uri.should == (
+        'https://www.googleapis.com/plus/v1/' +
+        'people/107807692475771887386/activities/public'
+      )
     end
 
     it 'should correctly validate parameters' do
       (lambda do
         @client.generate_request(
-          @buzz.activities.list,
-          {'alt' => 'json'},
-          '',
-          [],
-          {:signed => false}
+          :api_method => @plus.activities.list,
+          :parameters => {'alt' => 'json'},
+          :authenticated => false
         )
       end).should raise_error(ArgumentError)
     end
@@ -288,26 +354,14 @@ describe Google::APIClient do
     it 'should correctly validate parameters' do
       (lambda do
         @client.generate_request(
-          @buzz.activities.list,
-          {'userId' => 'hikingfan', 'scope' => '@bogus'},
-          '',
-          [],
-          {:signed => false}
+          :api_method => @plus.activities.list,
+          :parameters => {
+            'userId' => '107807692475771887386', 'collection' => 'bogus'
+          },
+          :authenticated => false
         )
       end).should raise_error(ArgumentError)
     end
-
-    it 'should be able to execute requests without authorization' do
-      response = @client.execute(
-        @buzz.activities.list,
-        {'alt' => 'json', 'userId' => 'hikingfan', 'scope' => '@public'},
-        '',
-        [],
-        {:signed => false}
-      )
-      status, headers, body = response
-      status.should == 200
-    end
   end
 
   describe 'with the latitude API' do
@@ -338,11 +392,8 @@ describe Google::APIClient do
 
     it 'should generate requests against the correct URIs' do
       request = @client.generate_request(
-        'latitude.currentLocation.get',
-        {},
-        '',
-        [],
-        {:signed => false}
+        :api_method => 'latitude.currentLocation.get',
+        :authenticated => false
       )
       method, uri, headers, body = request
       uri.should ==
@@ -351,11 +402,8 @@ describe Google::APIClient do
 
     it 'should generate requests against the correct URIs' do
       request = @client.generate_request(
-        @latitude.current_location.get,
-        {},
-        '',
-        [],
-        {:signed => false}
+        :api_method => @latitude.current_location.get,
+        :authenticated => false
       )
       method, uri, headers, body = request
       uri.should ==
@@ -363,14 +411,11 @@ describe Google::APIClient do
     end
 
     it 'should not be able to execute requests without authorization' do
-      response = @client.execute(
-        'latitude.currentLocation.get',
-        {},
-        '',
-        [],
-        {:signed => false}
+      result = @client.execute(
+        :api_method => 'latitude.currentLocation.get',
+        :authenticated => false
       )
-      status, headers, body = response
+      status, headers, body = result.response
       status.should == 401
     end
   end
@@ -403,11 +448,8 @@ describe Google::APIClient do
 
     it 'should generate requests against the correct URIs' do
       request = @client.generate_request(
-        'moderator.profiles.get',
-        {},
-        '',
-        [],
-        {:signed => false}
+        :api_method => 'moderator.profiles.get',
+        :authenticated => false
       )
       method, uri, headers, body = request
       uri.should ==
@@ -416,11 +458,8 @@ describe Google::APIClient do
 
     it 'should generate requests against the correct URIs' do
       request = @client.generate_request(
-        @moderator.profiles.get,
-        {},
-        '',
-        [],
-        {:signed => false}
+        :api_method => @moderator.profiles.get,
+        :authenticated => false
       )
       method, uri, headers, body = request
       uri.should ==
@@ -428,14 +467,14 @@ describe Google::APIClient do
     end
 
     it 'should not be able to execute requests without authorization' do
-      response = @client.execute(
+      result = @client.execute(
         'moderator.profiles.get',
         {},
         '',
         [],
-        {:signed => false}
+        {:authenticated => false}
       )
-      status, headers, body = response
+      status, headers, body = result.response
       status.should == 401
     end
   end