ghost_google-api-client 0.4.7.1

data/lib/google/api_client/result.rb

@@ -0,0 +1,161 @@
+# 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.status
+      end
+
+      def headers
+        return @response.headers
+      end
+
+      def body
+        return @response.body
+      end
+
+      def resumable_upload
+        @media_upload ||= Google::APIClient::ResumableUpload.new(self, reference.media, self.headers['location'])
+      end
+      
+      def media_type
+        _, content_type = self.headers.detect do |h, v|
+          h.downcase == 'Content-Type'.downcase
+        end
+        content_type[/^([^;]*);?.*$/, 1].strip.downcase
+      end
+      
+      def error?
+        return self.response.status >= 400
+      end
+
+      def success?
+        return !self.error?
+      end
+      
+      def error_message
+        if self.data?
+          if self.data.respond_to?(:error) &&
+             self.data.error.respond_to?(:message)
+            # You're going to get a terrible error message if the response isn't
+            # parsed successfully as an error.
+            return self.data.error.message
+          elsif self.data['error'] && self.data['error']['message']
+            return self.data['error']['message']
+          end
+        end
+        return self.body
+      end
+      
+      def data?
+        self.media_type == 'application/json'
+      end
+      
+      def data
+        return @data ||= (begin
+          media_type = self.media_type
+          data = self.body
+          case media_type
+          when 'application/json'
+            data = MultiJson.load(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/service_account.rb

@@ -0,0 +1,134 @@
+# 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 'jwt'
+require 'signet/oauth_2/client'
+
+module Google
+  class APIClient
+    ##
+    # Helper for loading keys from the PKCS12 files downloaded when
+    # setting up service accounts at the APIs Console.
+    module PKCS12
+      
+      ##
+      # Loads a key from PKCS12 file, assuming a single private key
+      # is present.
+      #
+      # @param [String] keyfile
+      #    Path of the PKCS12 file to load. If not a path to an actual file,
+      #    assumes the string is the content of the file itself. 
+      # @param [String] passphrase
+      #   Passphrase for unlocking the private key
+      #
+      # @return [OpenSSL::PKey] The private key for signing assertions.
+      def self.load_key(keyfile, passphrase)
+        begin
+          if File.exists?(keyfile)
+            content = File.read(keyfile)
+          else
+            content = keyfile
+          end  
+          pkcs12 = OpenSSL::PKCS12.new(content, passphrase)
+          return pkcs12.key
+        rescue OpenSSL::PKCS12::PKCS12Error
+          raise ArgumentError.new("Invalid keyfile or passphrase")
+        end
+      end
+    end
+
+    ##
+    # Generates access tokens using the JWT assertion profile. Requires a
+    # service account & access to the private key.
+    class JWTAsserter
+      attr_accessor :issuer, :expiry
+      attr_reader :scope
+      attr_writer :key
+
+      ##
+      # Initializes the asserter for a service account.
+      #
+      # @param [String] issuer
+      #    Name/ID of the client issuing the assertion
+      # @param [String or Array] scope
+      #   Scopes to authorize. May be a space delimited string or array of strings
+      # @param [OpenSSL::PKey]
+      #   RSA private key for signing assertions
+      def initialize(issuer, scope, key)
+        self.issuer = issuer
+        self.scope = scope
+        self.expiry = 60 # 1 min default        
+        self.key = key
+      end
+
+      ##
+      # Set the scopes to authorize
+      #
+      # @param [String or Array] scope
+      #   Scopes to authorize. May be a space delimited string or array of strings
+      def scope=(new_scope)
+        case new_scope
+        when Array
+          @scope = new_scope.join(' ')
+        when String
+          @scope = new_scope
+        when nil
+          @scope = ''
+        else
+          raise TypeError, "Expected Array or String, got #{new_scope.class}"
+        end
+      end
+      
+      ##
+      # Builds & signs the assertion.
+      # 
+      # @param [String] person
+      #   Email address of a user, if requesting a token to act on their behalf
+      # @return [String] Encoded JWT
+      def to_jwt(person=nil)
+        now = Time.new        
+        assertion = {
+          "iss" => @issuer,
+          "scope" => self.scope,
+          "aud" => "https://accounts.google.com/o/oauth2/token",
+          "exp" => (now + expiry).to_i,
+          "iat" => now.to_i
+        }
+        assertion['prn'] = person unless person.nil?
+        return JWT.encode(assertion, @key, "RS256")
+      end
+
+      ##
+      # Request a new access token.
+      # 
+      # @param [String] person
+      #   Email address of a user, if requesting a token to act on their behalf
+      # @param [Hash] options
+      #   Pass through to Signet::OAuth2::Client.fetch_access_token
+      # @return [Signet::OAuth2::Client] Access token 
+      #
+      # @see Signet::OAuth2::Client.fetch_access_token
+      def authorize(person = nil, options={})
+        assertion = self.to_jwt(person)
+        authorization = Signet::OAuth2::Client.new(
+          :token_credential_uri => 'https://accounts.google.com/o/oauth2/token'
+        )
+        authorization.grant_type = 'urn:ietf:params:oauth:grant-type:jwt-bearer'
+        authorization.extension_parameters = { :assertion => assertion }
+        authorization.fetch_access_token!(options)
+        return authorization
+      end
+    end
+  end
+end

data/lib/google/api_client/version.rb

@@ -0,0 +1,31 @@
+# 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.
+
+
+# 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 = 4
+        TINY  = 6
+
+        STRING = [MAJOR, MINOR, TINY].join('.')
+      end
+    end
+  end
+end

data/lib/google/inflection.rb

@@ -0,0 +1,28 @@
+# 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
+  if defined?(ActiveSupport::Inflector)
+    INFLECTOR = ActiveSupport::Inflector
+  else
+    begin
+      require 'extlib/inflection'
+      INFLECTOR = Extlib::Inflection
+    rescue LoadError
+      require 'active_support/inflector'
+      INFLECTOR = ActiveSupport::Inflector
+    end
+  end
+end

data/spec/fixtures/files/sample.txt

@@ -0,0 +1,33 @@
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus posuere urna bibendum diam vulputate fringilla. Fusce elementum fermentum justo id aliquam. Integer vel felis ut arcu elementum lacinia. Duis congue urna eget nisl dapibus tristique molestie turpis sollicitudin. Vivamus in justo quam. Proin condimentum mollis tortor at molestie. Cras luctus, nunc a convallis iaculis, est risus consequat nisi, sit amet sollicitudin metus mi a urna. Aliquam accumsan, massa quis condimentum varius, sapien massa faucibus nibh, a dignissim magna nibh a lacus. Nunc aliquet, nunc ac pulvinar consectetur, sapien lacus hendrerit enim, nec dapibus lorem mi eget risus. Praesent vitae justo eget dolor blandit ullamcorper. Duis id nibh vitae sem aliquam vehicula et ac massa. In neque elit, molestie pulvinar viverra at, vestibulum quis velit.
+
+Mauris sit amet placerat enim. Duis vel tellus ac dui auctor tincidunt id nec augue. Donec ut blandit turpis. Mauris dictum urna id urna vestibulum accumsan. Maecenas sagittis urna vitae erat facilisis gravida. Phasellus tellus augue, commodo ut iaculis vitae, interdum ut dolor. Proin at dictum lorem. Quisque pellentesque neque ante, vitae rutrum elit. Pellentesque sit amet erat orci. Praesent justo diam, tristique eu tempus ut, vestibulum eget dui. Maecenas et elementum justo. Cras a augue a elit porttitor placerat eget ut magna.
+
+Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Nam adipiscing tellus in arcu bibendum volutpat. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Sed laoreet faucibus tristique. Duis metus eros, molestie eget dignissim in, imperdiet fermentum nulla. Vestibulum laoreet lorem eu justo vestibulum lobortis. Praesent pharetra leo vel mauris rhoncus commodo sollicitudin ante auctor. Ut sagittis, tortor nec placerat rutrum, neque ipsum cursus nisl, ut lacinia magna risus ac risus. Sed volutpat commodo orci, sodales fermentum dui accumsan eu. Donec egestas ullamcorper elit at condimentum. In euismod sodales posuere. Nullam lacinia tempus molestie. Etiam vitae ullamcorper dui. Fusce congue suscipit arcu, at consectetur diam gravida id. Quisque augue urna, commodo eleifend volutpat vitae, tincidunt ac ligula. Curabitur eget orci nisl, vel placerat ipsum.
+
+Curabitur rutrum euismod nisi, consectetur varius tortor condimentum non. Pellentesque rhoncus nisi eu purus ultricies suscipit. Morbi ante nisi, varius nec molestie bibendum, pharetra quis enim. Proin eget nunc ante. Cras aliquam enim vel nunc laoreet ut facilisis nunc interdum. Fusce libero ipsum, posuere eget blandit quis, bibendum vitae quam. Integer dictum faucibus lacus eget facilisis. Duis adipiscing tortor magna, vel tincidunt risus. In non augue eu nisl sodales cursus vel eget nisi. Maecenas dignissim lectus elementum eros fermentum gravida et eget leo. Aenean quis cursus arcu. Mauris posuere purus non diam mattis vehicula. Integer nec orci velit.
+
+Integer ac justo ac magna adipiscing condimentum vitae tincidunt dui. Morbi augue arcu, blandit nec interdum sit amet, condimentum vel nisl. Nulla vehicula tincidunt laoreet. Aliquam ornare elementum urna, sed vehicula magna porta id. Vestibulum dictum ultrices tortor sit amet tincidunt. Praesent bibendum, metus vel volutpat interdum, nisl nunc cursus libero, vel congue ligula mi et felis. Nulla mollis elementum nulla, in accumsan risus consequat at. Suspendisse potenti. Vestibulum enim lorem, dignissim ut porta vestibulum, porta eget mi. Fusce a elit ac dui sodales gravida. Pellentesque sed elit at dui dapibus mattis a non arcu.
+
+Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. In nec posuere augue. Praesent non suscipit arcu. Sed nibh risus, lacinia ut molestie vitae, tristique eget turpis. Sed pretium volutpat arcu, non rutrum leo volutpat sed. Maecenas quis neque nisl, sit amet ornare dolor. Nulla pharetra pulvinar tellus sed eleifend. Aliquam eget mattis nulla. Nulla dictum vehicula velit, non facilisis lorem volutpat id. Fusce scelerisque sem vitae purus dapibus lobortis. Mauris ac turpis nec nibh consequat porttitor. Ut sit amet iaculis lorem. Vivamus blandit erat ac odio venenatis fringilla a sit amet ante. Quisque ut urna sed augue laoreet sagittis.
+
+Integer nisl urna, bibendum id lobortis in, tempor non velit. Fusce sed volutpat quam. Suspendisse eu placerat purus. Maecenas quis feugiat lectus. Sed accumsan malesuada dui, a pretium purus facilisis quis. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Nunc ac purus id lacus malesuada placerat et in nunc. Ut imperdiet tincidunt est, at consectetur augue egestas hendrerit. Pellentesque eu erat a dui dignissim adipiscing. Integer quis leo non felis placerat eleifend. Fusce luctus mi a lorem mattis eget accumsan libero posuere. Sed pellentesque, odio id pharetra tempus, enim quam placerat metus, auctor aliquam elit mi facilisis quam. Nam at velit et eros rhoncus accumsan.
+
+Donec tellus diam, fringilla ac viverra fringilla, rhoncus sit amet purus. Cras et ligula sed nibh tempor gravida. Aliquam id tempus mauris. Ut convallis quam sed arcu varius eget mattis magna tincidunt. Aliquam et suscipit est. Sed metus augue, tristique sed accumsan eget, euismod et augue. Nam augue sapien, placerat vel facilisis eu, tempor id risus. Aliquam mollis egestas mi. Fusce scelerisque convallis mauris quis blandit. Mauris nec ante id lacus sagittis tincidunt ornare vehicula dui. Curabitur tristique mattis nunc, vel cursus libero viverra feugiat. Suspendisse at sapien velit, a lacinia dolor. Vivamus in est non odio feugiat lacinia sodales ut magna.
+
+Donec interdum ligula id ipsum dapibus consectetur. Pellentesque vitae posuere ligula. Morbi rhoncus bibendum eleifend. Suspendisse fringilla nunc at elit malesuada vitae ullamcorper lorem laoreet. Suspendisse a ante at ipsum iaculis cursus. Duis accumsan ligula quis nibh luctus pretium. Duis ultrices scelerisque dolor, et vulputate lectus commodo ut.
+
+Vestibulum ac tincidunt lorem. Vestibulum lorem massa, dictum a scelerisque ut, convallis vitae eros. Morbi ipsum nisl, lacinia non tempor nec, lobortis id diam. Fusce quis magna nunc. Proin ultricies congue justo sed mattis. Vestibulum sit amet arcu tellus. Quisque ultricies porta massa iaculis vehicula. Vestibulum sollicitudin tempor urna vel sodales. Pellentesque ultricies tellus vel metus porta nec iaculis sapien mollis. Maecenas ullamcorper, metus eget imperdiet sagittis, odio orci dapibus neque, in vulputate nunc nibh non libero. Donec velit quam, lobortis quis tempus a, hendrerit id arcu.
+
+Donec nec ante at tortor dignissim mattis. Curabitur vehicula tincidunt magna id sagittis. Proin euismod dignissim porta. Curabitur non turpis purus, in rutrum nulla. Nam turpis nulla, tincidunt et hendrerit non, posuere nec enim. Curabitur leo enim, lobortis ut placerat id, condimentum nec massa. In bibendum, lectus sit amet molestie commodo, felis massa rutrum nisl, ac fermentum ligula lacus in ipsum.
+
+Pellentesque mi nulla, scelerisque vitae tempus id, consequat a augue. Quisque vel nisi sit amet ipsum faucibus laoreet sed vitae lorem. Praesent nunc tortor, volutpat ac commodo non, pharetra sed neque. Curabitur nec felis at mi blandit aliquet eu ornare justo. Mauris dignissim purus quis nisl porttitor interdum. Aenean id ipsum enim, blandit commodo justo. Quisque facilisis elit quis velit commodo scelerisque lobortis sapien condimentum. Cras sit amet porttitor velit. Praesent nec tempor arcu.
+
+Donec varius mi adipiscing elit semper vel feugiat ipsum dictum. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Donec non quam nisl, ac mattis justo. Vestibulum sed massa eget velit tristique auctor ut ac sapien. Curabitur aliquet ligula eget dui ornare at scelerisque mauris faucibus. Vestibulum id mauris metus, sed vestibulum nibh. Nulla egestas dictum blandit. Mauris vitae nibh at dui mollis lobortis. Phasellus sem leo, euismod at fringilla quis, mollis in nibh. Aenean vel lacus et elit pharetra elementum. Aliquam at ligula id sem bibendum volutpat. Pellentesque quis elit a massa dapibus viverra ut et lorem. Donec nulla eros, iaculis nec commodo vel, suscipit sit amet tortor. Integer tempor, elit at viverra imperdiet, velit sapien laoreet nunc, id laoreet ligula risus vel risus. Nullam sed tortor metus.
+
+In nunc orci, tempor vulputate pretium vel, suscipit quis risus. Suspendisse accumsan facilisis felis eget posuere. Donec a faucibus felis. Proin nibh erat, sollicitudin quis vestibulum id, tincidunt quis justo. In sed purus eu nisi dignissim condimentum. Sed mattis dapibus lorem id vulputate. Suspendisse nec elit a augue interdum consequat quis id magna. In eleifend aliquam tempor. In in lacus augue.
+
+Ut euismod sollicitudin lorem, id aliquam magna dictum sed. Nunc fringilla lobortis nisi sed consectetur. Nulla facilisi. Aenean nec lobortis augue. Curabitur ullamcorper dapibus libero, vel pellentesque arcu sollicitudin non. Praesent varius, turpis nec sollicitudin bibendum, elit tortor rhoncus lacus, gravida luctus leo nisi in felis. Ut metus eros, molestie non faucibus vel, condimentum ac elit.
+
+Suspendisse nisl justo, lacinia sit amet interdum nec, tincidunt placerat urna. Suspendisse potenti. In et odio sed purus malesuada cursus sed nec lectus. Cras commodo, orci sit amet hendrerit iaculis, nunc urna facilisis tellus, vel laoreet odio nulla quis nibh. Maecenas ut justo ut lacus posuere sodales. Vestibulum facilisis fringilla diam at volutpat. Proin a hendrerit urna. Aenean placerat pulvinar arcu, sit amet lobortis neque eleifend in. Aenean risus nulla, facilisis ut tincidunt vitae, fringilla at ligula. Praesent eleifend est at sem lacinia auctor. Nulla ornare nunc in erat laoreet blandit.
+
+Suspendisse pharetra leo ac est porta consequat. Nunc sem nibh, gravida vel aliquam a, ornare in tortor. Nulla vel sapien et felis placerat pellentesque id scelerisque nisl. Praesent et posuere.

data/spec/google/api_client/batch_spec.rb

@@ -0,0 +1,241 @@
+# Copyright 2012 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/api_client'
+require 'google/api_client/version'
+
+describe Google::APIClient::BatchRequest do
+  CLIENT ||= Google::APIClient.new
+
+  after do
+    # Reset client to not-quite-pristine state
+    CLIENT.key = nil
+    CLIENT.user_ip = nil
+  end
+
+  it 'should raise an error if making an empty batch request' do
+    batch = Google::APIClient::BatchRequest.new
+
+    (lambda do
+      CLIENT.execute(batch)
+    end).should raise_error(Google::APIClient::BatchError)
+  end
+
+  describe 'with the discovery API' do
+    before do
+      CLIENT.authorization = nil
+      @discovery = CLIENT.discovered_api('discovery', 'v1')
+    end
+
+    describe 'with two valid requests' do
+      before do
+        @call1 = {
+          :api_method => @discovery.apis.get_rest,
+          :parameters => {
+            'api' => 'adsense',
+            'version' => 'v1'
+          }
+        }
+
+        @call2 = {
+          :api_method => @discovery.apis.get_rest,
+          :parameters => {
+            'api' => 'discovery',
+            'version' => 'v1'
+          }
+        }
+      end
+
+      it 'should execute both when using a global callback' do
+        block_called = 0
+        ids = ['first_call', 'second_call']
+        expected_ids = ids.clone
+        batch = Google::APIClient::BatchRequest.new do |result|
+          block_called += 1
+          result.status.should == 200
+          expected_ids.should include(result.response.call_id)
+          expected_ids.delete(result.response.call_id)
+        end
+
+        batch.add(@call1, ids[0])
+        batch.add(@call2, ids[1])
+
+        CLIENT.execute(batch)
+        block_called.should == 2
+      end
+
+      it 'should execute both when using individual callbacks' do
+        batch = Google::APIClient::BatchRequest.new
+
+        call1_returned, call2_returned = false, false
+        batch.add(@call1) do |result|
+          call1_returned = true
+          result.status.should == 200
+        end
+        batch.add(@call2) do |result|
+          call2_returned = true
+          result.status.should == 200
+        end
+
+        CLIENT.execute(batch)
+        call1_returned.should == true
+        call2_returned.should == true
+      end
+
+      it 'should raise an error if using the same call ID more than once' do
+        batch = Google::APIClient::BatchRequest.new
+
+        (lambda do
+          batch.add(@call1, 'my_id')
+          batch.add(@call2, 'my_id')
+        end).should raise_error(Google::APIClient::BatchError)
+      end
+    end
+
+    describe 'with a valid request and an invalid one' do
+      before do
+        @call1 = {
+          :api_method => @discovery.apis.get_rest,
+          :parameters => {
+            'api' => 'adsense',
+            'version' => 'v1'
+          }
+        }
+
+        @call2 = {
+          :api_method => @discovery.apis.get_rest,
+          :parameters => {
+            'api' => 0,
+            'version' => 1
+          }
+        }
+      end
+
+      it 'should execute both when using a global callback' do
+        block_called = 0
+        ids = ['first_call', 'second_call']
+        expected_ids = ids.clone
+        batch = Google::APIClient::BatchRequest.new do |result|
+          block_called += 1
+          expected_ids.should include(result.response.call_id)
+          expected_ids.delete(result.response.call_id)
+          if result.response.call_id == ids[0]
+            result.status.should == 200
+          else
+            result.status.should >= 400
+            result.status.should < 500
+          end
+        end
+
+        batch.add(@call1, ids[0])
+        batch.add(@call2, ids[1])
+
+        CLIENT.execute(batch)
+        block_called.should == 2
+      end
+
+      it 'should execute both when using individual callbacks' do
+        batch = Google::APIClient::BatchRequest.new
+
+        call1_returned, call2_returned = false, false
+        batch.add(@call1) do |result|
+          call1_returned = true
+          result.status.should == 200
+        end
+        batch.add(@call2) do |result|
+          call2_returned = true
+          result.status.should >= 400
+          result.status.should < 500
+        end
+
+        CLIENT.execute(batch)
+        call1_returned.should == true
+        call2_returned.should == true
+      end
+    end
+  end
+
+  describe 'with the calendar API' do
+    before do
+      CLIENT.authorization = nil
+      @calendar = CLIENT.discovered_api('calendar', 'v3')
+    end
+
+    describe 'with two valid requests' do
+      before do
+        event1 = {
+          'summary' => 'Appointment 1',
+          'location' => 'Somewhere',
+          'start' => {
+            'dateTime' => '2011-01-01T10:00:00.000-07:00'
+          },
+          'end' => {
+            'dateTime' => '2011-01-01T10:25:00.000-07:00'
+          },
+          'attendees' => [
+            {
+              'email' => 'myemail@mydomain.tld'
+            }
+          ]
+        }
+
+        event2 = {
+          'summary' => 'Appointment 2',
+          'location' => 'Somewhere as well',
+          'start' => {
+            'dateTime' => '2011-01-02T10:00:00.000-07:00'
+          },
+          'end' => {
+            'dateTime' => '2011-01-02T10:25:00.000-07:00'
+          },
+          'attendees' => [
+            {
+              'email' => 'myemail@mydomain.tld'
+            }
+          ]
+        }
+
+        @call1 = {
+          :api_method => @calendar.events.insert,
+          :parameters => {'calendarId' => 'myemail@mydomain.tld'},
+          :body => MultiJson.dump(event1),
+          :headers => {'Content-Type' => 'application/json'}
+        }
+
+        @call2 = {
+          :api_method => @calendar.events.insert,
+          :parameters => {'calendarId' => 'myemail@mydomain.tld'},
+          :body => MultiJson.dump(event2),
+          :headers => {'Content-Type' => 'application/json'}
+        }
+      end
+
+      it 'should convert to a correct HTTP request' do
+        batch = Google::APIClient::BatchRequest.new { |result| }
+        batch.add(@call1, '1').add(@call2, '2')
+        method, uri, headers, body = batch.to_http_request
+        boundary = Google::APIClient::BatchRequest::BATCH_BOUNDARY
+        method.to_s.downcase.should == 'post'
+        uri.to_s.should == 'https://www.googleapis.com/batch'
+        headers.should == {
+          "Content-Type"=>"multipart/mixed; boundary=#{boundary}"
+        }
+        expected_body = /--#{Regexp.escape(boundary)}\nContent-Type: +application\/http\nContent-ID: +<[\w-]+\+1>\n\nPOST +https:\/\/www.googleapis.com\/calendar\/v3\/calendars\/myemail@mydomain.tld\/events +HTTP\/1.1\nContent-Type: +application\/json\n\n#{Regexp.escape(@call1[:body])}\n\n--#{boundary}\nContent-Type: +application\/http\nContent-ID: +<[\w-]+\+2>\n\nPOST +https:\/\/www.googleapis.com\/calendar\/v3\/calendars\/myemail@mydomain.tld\/events HTTP\/1.1\nContent-Type: +application\/json\n\n#{Regexp.escape(@call2[:body])}\n\n--#{Regexp.escape(boundary)}--/
+        body.gsub("\r", "").should =~ expected_body
+      end
+    end
+  end
+end