google-api-client 0.8.6 → 0.9

data/lib/google/api_client/service/resource.rb

@@ -1,40 +0,0 @@
-# Copyright 2013 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
-    class Service
-      ##
-      # Handles an API resource.
-      # Simple class that contains API methods and/or child resources.
-      class Resource
-        include Google::APIClient::Service::StubGenerator
-
-        ##
-        # Build a resource.
-        # This class should not be directly instantiated in user code; resources
-        # are instantiated by the stub generation mechanism on Service creation.
-        #
-        # @param [Google::APIClient::Service] service
-        #   The Service instance this resource belongs to.
-        # @param [Google::APIClient::API, Google::APIClient::Resource] root
-        #   The node corresponding to this resource.
-        def initialize(service, root)
-          @service = service
-          generate_call_stubs(service, root)
-        end
-      end
-    end
-  end
-end

data/lib/google/api_client/service/result.rb

@@ -1,162 +0,0 @@
-# Copyright 2013 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
-    class Service
-      ##
-      # Handles an API result.
-      # Wraps around the Google::APIClient::Result class, making it easier to
-      # handle the result (e.g. pagination) and keeping it in line with the rest
-      # of the Service programming interface.
-      class Result
-        extend Forwardable
-
-        ##
-        # Init the result.
-        #
-        # @param [Google::APIClient::Service::Request] request
-        #   The original request
-        # @param [Google::APIClient::Result] base_result
-        #   The base result to be wrapped
-        def initialize(request, base_result)
-          @request = request
-          @base_result = base_result
-        end
-
-        # @!attribute [r] status
-        #   @return [Fixnum] HTTP status code
-        # @!attribute [r] headers
-        #   @return [Hash] HTTP response headers
-        # @!attribute [r] body
-        #   @return [String] HTTP response body
-        def_delegators :@base_result, :status, :headers, :body
-
-        # @return [Google::APIClient::Service::Request] Original request object
-        attr_reader :request
-
-        ##
-        # Get the content type of the response
-        # @!attribute [r] media_type
-        # @return [String]
-        #  Value of content-type header
-        def_delegators :@base_result, :media_type
-
-        ##
-        # Check if request failed
-        #
-        # @!attribute [r] error?
-        # @return [TrueClass, FalseClass]
-        #   true if result of operation is an error
-        def_delegators :@base_result, :error?
-
-        ##
-        # Check if request was successful
-        #
-        # @!attribute [r] success?
-        # @return [TrueClass, FalseClass]
-        #   true if result of operation was successful
-        def_delegators :@base_result, :success?
-
-        ##
-        # Extracts error messages from the response body
-        #
-        # @!attribute [r] error_message
-        # @return [String]
-        #   error message, if available
-        def_delegators :@base_result, :error_message
-
-        ##
-        # Check for parsable data in response
-        #
-        # @!attribute [r] data?
-        # @return [TrueClass, FalseClass]
-        #   true if body can be parsed
-        def_delegators :@base_result, :data?
-
-        ##
-        # Return parsed version of the response body.
-        #
-        # @!attribute [r] data
-        # @return [Object, Hash, String]
-        #   Object if body parsable from API schema, Hash if JSON, raw body if unable to parse
-        def_delegators :@base_result, :data
-
-        ##
-        # Pagination scheme used by this request/response
-        #
-        # @!attribute [r] pagination_type
-        # @return [Symbol]
-        #  currently always :token
-        def_delegators :@base_result, :pagination_type
-
-        ##
-        # Name of the field that contains the pagination token
-        #
-        # @!attribute [r] page_token_param
-        # @return [String]
-        #  currently always 'pageToken'
-        def_delegators :@base_result, :page_token_param
-
-        ##
-        # Get the token used for requesting the next page of data
-        #
-        # @!attribute [r] next_page_token
-        # @return [String]
-        #   next page tokenx =
-        def_delegators :@base_result, :next_page_token
-
-        ##
-        # Get the token used for requesting the previous page of data
-        #
-        # @!attribute [r] prev_page_token
-        # @return [String]
-        #   previous page token
-        def_delegators :@base_result, :prev_page_token
-
-        # @!attribute [r] resumable_upload
-        def resumable_upload
-          # TODO(sgomes): implement resumable_upload for Service::Result
-          raise NotImplementedError
-        end
-
-        ##
-        # Build a request for fetching the next page of data
-        #
-        # @return [Google::APIClient::Service::Request]
-        #   API request for retrieving next page
-        def next_page
-          request = @request.clone
-          # Make a deep copy of the parameters.
-          request.parameters = Marshal.load(Marshal.dump(request.parameters))
-          request.parameters[page_token_param] = self.next_page_token
-          return request
-        end
-
-        ##
-        # Build a request for fetching the previous page of data
-        #
-        # @return [Google::APIClient::Service::Request]
-        #   API request for retrieving previous page
-        def prev_page
-          request = @request.clone
-          # Make a deep copy of the parameters.
-          request.parameters = Marshal.load(Marshal.dump(request.parameters))
-          request.parameters[page_token_param] = self.prev_page_token
-          return request
-        end
-      end
-    end
-  end
-end

data/lib/google/api_client/service/simple_file_store.rb

@@ -1,151 +0,0 @@
-# Copyright 2013 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
-    class Service
-
-      # Simple file store to be used in the event no ActiveSupport cache store
-      # is provided. This is not thread-safe, and does not support a number of
-      # features (such as expiration), but it's useful for the simple purpose of
-      # caching discovery documents to disk.
-      # Implements the basic cache methods of ActiveSupport::Cache::Store in a
-      # limited fashion.
-      class SimpleFileStore
-
-        # Creates a new SimpleFileStore.
-        #
-        # @param [String] file_path
-        #   The path to the cache file on disk.
-        # @param [Object] options
-        #   The options to be used with this SimpleFileStore. Not implemented.
-        def initialize(file_path, options = nil)
-          @file_path = file_path.to_s
-        end
-
-        # Returns true if a key exists in the cache.
-        #
-        # @param [String] name
-        #   The name of the key. Will always be converted to a string.
-        # @param [Object] options
-        #   The options to be used with this query. Not implemented.
-        def exist?(name, options = nil)
-          read_file
-          @cache.nil? ? nil : @cache.include?(name.to_s)
-        end
-
-        # Fetches data from the cache and returns it, using the given key.
-        # If the key is missing and no block is passed, returns nil.
-        # If the key is missing and a block is passed, executes the block, sets
-        # the key to its value, and returns it.
-        #
-        # @param [String] name
-        #   The name of the key. Will always be converted to a string.
-        # @param [Object] options
-        #   The options to be used with this query. Not implemented.
-        # @yield [String]
-        #   optional block with the default value if the key is missing
-        def fetch(name, options = nil)
-          read_file
-          if block_given?
-            entry = read(name.to_s, options)
-            if entry.nil?
-              value = yield name.to_s
-              write(name.to_s, value)
-              return value
-            else
-              return entry
-            end
-          else
-            return read(name.to_s, options)
-          end
-        end
-
-        # Fetches data from the cache, using the given key.
-        # Returns nil if the key is missing.
-        #
-        # @param [String] name
-        #   The name of the key. Will always be converted to a string.
-        # @param [Object] options
-        #   The options to be used with this query. Not implemented.
-        def read(name, options = nil)
-          read_file
-          @cache.nil? ? nil : @cache[name.to_s]
-        end
-
-        # Writes the value to the cache, with the key.
-        #
-        # @param [String] name
-        #   The name of the key. Will always be converted to a string.
-        # @param [Object] value
-        #   The value to be written.
-        # @param [Object] options
-        #   The options to be used with this query. Not implemented.
-        def write(name, value, options = nil)
-          read_file
-          @cache = {} if @cache.nil?
-          @cache[name.to_s] = value
-          write_file
-          return nil
-        end
-
-        # Deletes an entry in the cache.
-        # Returns true if an entry is deleted.
-        #
-        # @param [String] name
-        #   The name of the key. Will always be converted to a string.
-        # @param [Object] options
-        #   The options to be used with this query. Not implemented.
-        def delete(name, options = nil)
-          read_file
-          return nil if @cache.nil?
-          if @cache.include? name.to_s
-            @cache.delete name.to_s
-            write_file
-            return true
-          else
-            return nil
-          end
-        end
-
-        protected
-
-        # Read the entire cache file from disk.
-        # Will avoid reading if there have been no changes.
-        def read_file
-          if !File.exist? @file_path
-            @cache = nil
-          else
-            # Check for changes after our last read or write.
-            if @last_change.nil? || File.mtime(@file_path) > @last_change
-              File.open(@file_path) do |file|
-                @cache = Marshal.load(file)
-                @last_change = file.mtime
-              end
-            end
-          end
-          return @cache
-        end
-
-        # Write the entire cache contents to disk.
-        def write_file
-          File.open(@file_path, 'w') do |file|
-            Marshal.dump(@cache, file)
-          end
-          @last_change = File.mtime(@file_path)
-        end
-      end
-    end
-  end
-end

data/lib/google/api_client/service/stub_generator.rb

@@ -1,61 +0,0 @@
-# Copyright 2013 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 'active_support/inflector'
-
-module Google
-  class APIClient
-    class Service
-      ##
-      # Auxiliary mixin to generate resource and method stubs.
-      # Used by the Service and Service::Resource classes to generate both
-      # top-level and nested resources and methods.
-      module StubGenerator
-        def generate_call_stubs(service, root)
-          metaclass = (class << self; self; end)
-
-          # Handle resources.
-          root.discovered_resources.each do |resource|
-            method_name = ActiveSupport::Inflector.underscore(resource.name).to_sym
-            if !self.respond_to?(method_name)
-              metaclass.send(:define_method, method_name) do
-                Google::APIClient::Service::Resource.new(service, resource)
-              end
-            end
-          end
-
-          # Handle methods.
-          root.discovered_methods.each do |method|
-            method_name = ActiveSupport::Inflector.underscore(method.name).to_sym
-            if !self.respond_to?(method_name)
-              metaclass.send(:define_method, method_name) do |*args|
-                if args.length > 1
-                  raise ArgumentError,
-                    "wrong number of arguments (#{args.length} for 1)"
-                elsif !args.first.respond_to?(:to_hash) && !args.first.nil?
-                  raise ArgumentError,
-                    "expected parameter Hash, got #{args.first.class}"
-                else
-                  return Google::APIClient::Service::Request.new(
-                    service, method, args.first
-                  )
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/google/api_client/batch_spec.rb

@@ -1,248 +0,0 @@
-# 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'
-
-RSpec.describe Google::APIClient::BatchRequest do
-  CLIENT = Google::APIClient.new(:application_name => 'API Client Tests') unless defined?(CLIENT)
-
-  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
-
-    expect(lambda do
-      CLIENT.execute(batch)
-    end).to raise_error(Google::APIClient::BatchError)
-  end
-
-  it 'should allow query parameters in batch requests' do
-    batch = Google::APIClient::BatchRequest.new
-    batch.add(:uri => 'https://example.com', :parameters => {
-      'a' => '12345'
-    })
-    method, uri, headers, body = batch.to_http_request
-    expect(body.read).to include("/?a=12345")
-  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' => 'plus',
-            '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
-          expect(result.status).to eq(200)
-          expect(expected_ids).to 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)
-        expect(block_called).to eq(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
-          expect(result.status).to eq(200)
-        end
-        batch.add(@call2) do |result|
-          call2_returned = true
-          expect(result.status).to eq(200)
-        end
-
-        CLIENT.execute(batch)
-        expect(call1_returned).to be_truthy
-        expect(call2_returned).to be_truthy
-      end
-
-      it 'should raise an error if using the same call ID more than once' do
-        batch = Google::APIClient::BatchRequest.new
-
-        expect(lambda do
-          batch.add(@call1, 'my_id')
-          batch.add(@call2, 'my_id')
-        end).to 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' => 'plus',
-            '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
-          expect(expected_ids).to include(result.response.call_id)
-          expected_ids.delete(result.response.call_id)
-          if result.response.call_id == ids[0]
-            expect(result.status).to eq(200)
-          else
-            expect(result.status).to be >= 400
-            expect(result.status).to be < 500
-          end
-        end
-
-        batch.add(@call1, ids[0])
-        batch.add(@call2, ids[1])
-
-        CLIENT.execute(batch)
-        expect(block_called).to eq(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
-          expect(result.status).to eq(200)
-        end
-        batch.add(@call2) do |result|
-          call2_returned = true
-          expect(result.status).to be >= 400
-          expect(result.status).to be < 500
-        end
-
-        CLIENT.execute(batch)
-        expect(call1_returned).to be_truthy
-        expect(call2_returned).to be_truthy
-      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')
-        request = batch.to_env(CLIENT.connection)
-        boundary = Google::APIClient::BatchRequest::BATCH_BOUNDARY
-        expect(request[:method].to_s.downcase).to eq('post')
-        expect(request[:url].to_s).to eq('https://www.googleapis.com/batch')
-        expect(request[:request_headers]['Content-Type']).to eq("multipart/mixed;boundary=#{boundary}")
-        body = request[:body].read
-        expect(body).to include(@call1[:body])
-        expect(body).to include(@call2[:body])
-      end
-    end
-
-  end
-end