google-api-client 0.7.0.rc2 → 0.7.0

data/spec/google/api_client/simple_file_store_spec.rb

@@ -0,0 +1,137 @@
+# encoding:utf-8
+
+# 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 'spec_helper'
+
+require 'google/api_client/service/simple_file_store'
+
+describe Google::APIClient::Service::SimpleFileStore do
+
+  FILE_NAME = 'test.cache'
+
+  before(:all) do
+    File.delete(FILE_NAME) if File.exists?(FILE_NAME)
+  end
+
+  describe 'with no cache file' do
+    before(:each) do
+      File.delete(FILE_NAME) if File.exists?(FILE_NAME)
+      @cache = Google::APIClient::Service::SimpleFileStore.new(FILE_NAME)
+    end
+
+    it 'should return nil when asked if a key exists' do
+      @cache.exist?('invalid').should be_nil
+      File.exists?(FILE_NAME).should be_false
+    end
+
+    it 'should return nil when asked to read a key' do
+      @cache.read('invalid').should be_nil
+      File.exists?(FILE_NAME).should be_false
+    end
+
+    it 'should return nil when asked to fetch a key' do
+      @cache.fetch('invalid').should be_nil
+      File.exists?(FILE_NAME).should be_false
+    end
+
+    it 'should create a cache file when asked to fetch a key with a default' do
+      @cache.fetch('new_key') do
+        'value'
+      end.should == 'value'
+      File.exists?(FILE_NAME).should be_true
+    end
+
+    it 'should create a cache file when asked to write a key' do
+      @cache.write('new_key', 'value')
+      File.exists?(FILE_NAME).should be_true
+    end
+
+    it 'should return nil when asked to delete a key' do
+      @cache.delete('invalid').should be_nil
+      File.exists?(FILE_NAME).should be_false
+    end
+  end
+
+  describe 'with an existing cache' do
+    before(:each) do
+      File.delete(FILE_NAME) if File.exists?(FILE_NAME)
+      @cache = Google::APIClient::Service::SimpleFileStore.new(FILE_NAME)
+      @cache.write('existing_key', 'existing_value')
+    end
+
+    it 'should return true when asked if an existing key exists' do
+      @cache.exist?('existing_key').should be_true
+    end
+
+    it 'should return false when asked if a nonexistent key exists' do
+      @cache.exist?('invalid').should be_false
+    end
+
+    it 'should return the value for an existing key when asked to read it' do
+      @cache.read('existing_key').should == 'existing_value'
+    end
+
+    it 'should return nil for a nonexistent key when asked to read it' do
+      @cache.read('invalid').should be_nil
+    end
+
+    it 'should return the value for an existing key when asked to read it' do
+      @cache.read('existing_key').should == 'existing_value'
+    end
+
+    it 'should return nil for a nonexistent key when asked to fetch it' do
+      @cache.fetch('invalid').should be_nil
+    end
+
+    it 'should return and save the default value for a nonexistent key when asked to fetch it with a default' do
+      @cache.fetch('new_key') do
+        'value'
+      end.should == 'value'
+      @cache.read('new_key').should == 'value'
+    end
+
+    it 'should remove an existing value and return true when asked to delete it' do
+      @cache.delete('existing_key').should be_true
+      @cache.read('existing_key').should be_nil
+    end
+
+    it 'should return false when asked to delete a nonexistent key' do
+      @cache.delete('invalid').should be_false
+    end
+
+    it 'should convert keys to strings when storing them' do
+      @cache.write(:symbol_key, 'value')
+      @cache.read('symbol_key').should == 'value'
+    end
+
+    it 'should convert keys to strings when reading them' do
+      @cache.read(:existing_key).should == 'existing_value'
+    end
+
+    it 'should convert keys to strings when fetching them' do
+      @cache.fetch(:existing_key).should == 'existing_value'
+    end
+
+    it 'should convert keys to strings when deleting them' do
+      @cache.delete(:existing_key).should be_true
+      @cache.read('existing_key').should be_nil
+    end
+  end
+
+  after(:all) do
+    File.delete(FILE_NAME) if File.exists?(FILE_NAME)
+  end
+end

data/spec/google/api_client_spec.rb

@@ -114,6 +114,7 @@ describe Google::APIClient do
       @connection = stub_connection do |stub|
         stub.post('/prediction/v1.2/training?data=12345') do |env|
           env[:request_headers]['Authorization'].should == 'Bearer 12345'
+          [200, {}, '{}']
         end
       end
     end
@@ -166,4 +167,87 @@ describe Google::APIClient do
        )
      end
   end  
+
+  describe 'when retiries enabled' do
+    before do
+      client.retries = 2
+    end
+
+    after do
+      @connection.verify
+    end
+    
+    it 'should follow redirects' do
+      client.authorization = nil
+      @connection = stub_connection do |stub|
+        stub.get('/foo') do |env|
+          [302, {'location' => 'https://www.google.com/bar'}, '{}']
+        end
+        stub.get('/bar') do |env|
+          [200, {}, '{}']
+        end
+      end
+
+      client.execute(  
+        :uri => 'https://www.gogole.com/foo',
+        :connection => @connection
+      )
+    end
+
+    it 'should refresh tokens on 401 tokens' do
+      client.authorization.access_token = '12345'
+      expect(client.authorization).to receive(:fetch_access_token!)
+
+      @connection = stub_connection do |stub|
+        stub.get('/foo') do |env|
+          [401, {}, '{}']
+        end
+        stub.get('/foo') do |env|
+          [200, {}, '{}']
+        end
+      end
+
+      client.execute(  
+        :uri => 'https://www.gogole.com/foo',
+        :connection => @connection
+      )
+    end
+
+    it 'should retry on 500 errors' do
+      client.authorization = nil
+
+      @connection = stub_connection do |stub|
+        stub.get('/foo') do |env|
+          [500, {}, '{}']
+        end
+        stub.get('/foo') do |env|
+          [200, {}, '{}']
+        end
+      end
+
+      client.execute(  
+        :uri => 'https://www.gogole.com/foo',
+        :connection => @connection
+      ).status.should == 200
+
+    end
+
+    it 'should fail after max retries' do
+      client.authorization = nil
+      count = 0
+      @connection = stub_connection do |stub|
+        stub.get('/foo') do |env|
+          count += 1
+          [500, {}, '{}']
+        end
+      end
+
+      client.execute(  
+        :uri => 'https://www.gogole.com/foo',
+        :connection => @connection
+      ).status.should == 500
+      count.should == 3
+    end
+
+  end  
 end

data/tasks/gem.rake

@@ -18,7 +18,6 @@ namespace :gem do
     s.description = PKG_DESCRIPTION
     s.license = 'Apache 2.0'
     s.files = PKG_FILES.to_a
-    s.executables << 'google-api'
 
     s.extra_rdoc_files = %w( README.md )
     s.rdoc_options.concat ['--main',  'README.md']
@@ -28,7 +27,7 @@ namespace :gem do
     s.add_runtime_dependency('addressable', '>= 2.3.2')
     s.add_runtime_dependency('uuidtools', '>= 2.1.0')
     s.add_runtime_dependency('autoparse', '>= 0.3.3')
-    s.add_runtime_dependency('faraday', '>= 0.9.0.rc5')
+    s.add_runtime_dependency('faraday', '>= 0.9.0')
     s.add_runtime_dependency('multi_json', '>= 1.0.0')
     s.add_runtime_dependency('extlib', '>= 0.9.15')
     s.add_runtime_dependency('jwt', '>= 0.1.5')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: google-api-client
 version: !ruby/object:Gem::Version
-  version: 0.7.0.rc2
+  version: 0.7.0
 platform: ruby
 authors:
 - Bob Aman
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-09 00:00:00.000000000 Z
+date: 2014-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: signet
@@ -73,14 +73,14 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.9.0.rc5
+        version: 0.9.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.9.0.rc5
+        version: 0.9.0
 - !ruby/object:Gem::Dependency
   name: multi_json
   requirement: !ruby/object:Gem::Requirement
@@ -172,8 +172,7 @@ description: ! 'The Google API Ruby Client makes it trivial to discover and acce
 
 '
 email: sbazyl@google.com
-executables:
-- google-api
+executables: []
 extensions: []
 extra_rdoc_files:
 - README.md
@@ -204,6 +203,13 @@ files:
 - lib/google/api_client/reference.rb
 - lib/google/api_client/request.rb
 - lib/google/api_client/result.rb
+- lib/google/api_client/service.rb
+- lib/google/api_client/service/batch.rb
+- lib/google/api_client/service/request.rb
+- lib/google/api_client/service/resource.rb
+- lib/google/api_client/service/result.rb
+- lib/google/api_client/service/simple_file_store.rb
+- lib/google/api_client/service/stub_generator.rb
 - lib/google/api_client/service_account.rb
 - lib/google/api_client/version.rb
 - lib/google/inflection.rb
@@ -217,6 +223,8 @@ files:
 - spec/google/api_client/request_spec.rb
 - spec/google/api_client/result_spec.rb
 - spec/google/api_client/service_account_spec.rb
+- spec/google/api_client/service_spec.rb
+- spec/google/api_client/simple_file_store_spec.rb
 - spec/google/api_client_spec.rb
 - spec/spec_helper.rb
 - tasks/gem.rake
@@ -231,8 +239,7 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- bin/google-api
-homepage: http://code.google.com/p/google-api-ruby-client/
+homepage: https://github.com/google/google-api-ruby-client
 licenses:
 - Apache 2.0
 metadata: {}
@@ -249,9 +256,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>'
+  - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.0.7

data/bin/google-api

@@ -1,390 +0,0 @@
-#!/usr/bin/env ruby
-
-bin_dir = File.expand_path("..", __FILE__)
-lib_dir = File.expand_path("../lib", bin_dir)
-
-$LOAD_PATH.unshift(lib_dir)
-$LOAD_PATH.uniq!
-
-OAUTH_SERVER_PORT = 12736
-
-require 'rubygems'
-require 'optparse'
-require 'faraday'
-require 'webrick'
-require 'google/api_client/version'
-require 'google/api_client'
-require 'google/api_client/auth/installed_app'
-require 'irb'
-
-ARGV.unshift('--help') if ARGV.empty?
-
-module Google
-  class APIClient
-    class CLI
-
-      # Initialize with default parameter values
-      def initialize(argv)
-        @options = {
-          :command => 'execute',
-          :rpcname => nil,
-          :verbose => false
-        }
-        @argv = argv.clone
-        if @argv.first =~ /^[a-z0-9][a-z0-9_-]*$/i
-          self.options[:command] = @argv.shift
-        end
-        if @argv.first =~ /^[a-z0-9_-]+\.[a-z0-9_\.-]+$/i
-          self.options[:rpcname] = @argv.shift
-        end
-      end
-
-      attr_reader :options
-      attr_reader :argv
-
-      def command
-        return self.options[:command]
-      end
-
-      def rpcname
-        return self.options[:rpcname]
-      end
-
-      def parser
-        @parser ||= OptionParser.new do |opts|
-          opts.banner = "Usage: google-api " +
-            "(execute <rpcname> | [command]) [options] [-- <parameters>]"
-
-          opts.separator "\nAvailable options:"
-
-          opts.on(
-              "--scope <scope>", String, "Set the OAuth scope") do |s|
-            options[:scope] = s
-          end
-          opts.on(
-              "--client-id <key>", String,
-                "Set the OAuth client id or key") do |k|
-            options[:client_credential_key] = k
-          end
-          opts.on(
-              "--client-secret <secret>", String,
-                "Set the OAuth client secret") do |s|
-            options[:client_credential_secret] = s
-          end
-          opts.on(
-              "--api <name>", String,
-              "Perform discovery on API") do |s|
-            options[:api] = s
-          end
-          opts.on(
-              "--api-version <id>", String,
-              "Select api version") do |id|
-            options[:version] = id
-          end
-          opts.on(
-              "--content-type <format>", String,
-              "Content-Type for request") do |f|
-            # Resolve content type shortcuts
-            case f
-            when 'json'
-              f = 'application/json'
-            when 'xml'
-              f = 'application/xml'
-            when 'atom'
-              f = 'application/atom+xml'
-            when 'rss'
-              f = 'application/rss+xml'
-            end
-            options[:content_type] = f
-          end
-          opts.on(
-              "-u", "--uri <uri>", String,
-              "Sets the URI to perform a request against") do |u|
-            options[:uri] = u
-          end
-          opts.on(
-              "--discovery-uri <uri>", String,
-              "Sets the URI to perform discovery") do |u|
-            options[:discovery_uri] = u
-          end
-          opts.on(
-              "-m", "--method <method>", String,
-              "Sets the HTTP method to use for the request") do |m|
-            options[:http_method] = m
-          end
-          opts.on(
-              "--requestor-id <email>", String,
-              "Sets the email address of the requestor") do |e|
-            options[:requestor_id] = e
-          end
-
-          opts.on("-v", "--verbose", "Run verbosely") do |v|
-            options[:verbose] = v
-          end
-          opts.on("-h", "--help", "Show this message") do
-            puts opts
-            exit
-          end
-          opts.on("--version", "Show version") do
-            puts "google-api-client (#{Google::APIClient::VERSION::STRING})"
-            exit
-          end
-
-          opts.separator(
-            "\nAvailable commands:\n" +
-            "    oauth-2-login   Log a user into an API with OAuth 2.0\n" +
-            "    list            List the methods available for an API\n" +
-            "    execute         Execute a method on the API\n" +
-            "    irb             Start an interactive client session"
-          )
-        end
-      end
-
-      def parse!
-        self.parser.parse!(self.argv)
-        symbol = self.command.gsub(/-/, "_").to_sym
-        if !COMMANDS.include?(symbol)
-          STDERR.puts("Invalid command: #{self.command}")
-          exit(1)
-        end
-        self.send(symbol)
-      end
-
-      def client
-        require 'yaml'
-        config_file = File.expand_path('~/.google-api.yaml')
-        authorization = nil
-        if File.exist?(config_file)
-          config = open(config_file, 'r') { |file| YAML.load(file.read) }
-        else
-          config = {}
-        end
-        if config["mechanism"]
-          authorization = config["mechanism"].to_sym
-        end
-
-        client = Google::APIClient.new(
-          :application_name => 'Ruby CLI', 
-          :application_version => Google::APIClient::VERSION::STRING,
-          :authorization => authorization)
-
-        case authorization
-        when :oauth_1
-          STDERR.puts('OAuth 1 is deprecated. Please reauthorize with OAuth 2.')
-          client.authorization.client_credential_key =
-            config["client_credential_key"]
-          client.authorization.client_credential_secret =
-            config["client_credential_secret"]
-          client.authorization.token_credential_key =
-            config["token_credential_key"]
-          client.authorization.token_credential_secret =
-            config["token_credential_secret"]
-        when :oauth_2
-          client.authorization.scope = options[:scope]
-          client.authorization.client_id = config["client_id"]
-          client.authorization.client_secret = config["client_secret"]
-          client.authorization.access_token = config["access_token"]
-          client.authorization.refresh_token = config["refresh_token"]
-        else
-          # Dunno?
-        end
-
-        if options[:discovery_uri]
-          if options[:api] && options[:version]
-            client.register_discovery_uri(
-              options[:api], options[:version], options[:discovery_uri]
-            )
-          else
-            STDERR.puts(
-              'Cannot register a discovery URI without ' +
-              'specifying an API and version.'
-            )
-            exit(1)
-          end
-        end
-
-        return client
-      end
-
-      def api_version(api_name, version)
-        v = version
-        if !version
-          if client.preferred_version(api_name)
-            v = client.preferred_version(api_name).version
-          else
-            v = 'v1'
-          end
-        end
-        return v
-      end
-
-      COMMANDS = [
-        :oauth_2_login,
-        :list,
-        :execute,
-        :irb,
-      ]
-
-      def oauth_2_login
-        require 'signet/oauth_2/client'
-        require 'yaml'
-        if !options[:client_credential_key] ||
-            !options[:client_credential_secret]
-          STDERR.puts('No client ID and secret supplied.')
-          exit(1)
-        end
-        if options[:access_token]
-          config = {
-            "mechanism" => "oauth_2",
-            "scope" => options[:scope],
-            "client_id" => options[:client_credential_key],
-            "client_secret" => options[:client_credential_secret],
-            "access_token" => options[:access_token],
-            "refresh_token" => options[:refresh_token]
-          }
-          config_file = File.expand_path('~/.google-api.yaml')
-          open(config_file, 'w') { |file| file.write(YAML.dump(config)) }
-          exit(0)
-        else
-          flow = Google::APIClient::InstalledAppFlow.new(
-            :port => OAUTH_SERVER_PORT,
-            :client_id => options[:client_credential_key],
-            :client_secret => options[:client_credential_secret],
-            :scope => options[:scope]
-          )
-          
-          oauth_client = flow.authorize
-          if oauth_client
-            config = {
-              "mechanism" => "oauth_2",
-              "scope" => options[:scope],
-              "client_id" => oauth_client.client_id,
-              "client_secret" => oauth_client.client_secret,
-              "access_token" => oauth_client.access_token,
-              "refresh_token" => oauth_client.refresh_token
-            }
-            config_file = File.expand_path('~/.google-api.yaml')
-            open(config_file, 'w') { |file| file.write(YAML.dump(config)) }
-          end
-          exit(0)
-        end
-      end
-
-      def list
-        api_name = options[:api]
-        unless api_name
-          STDERR.puts('No API name supplied.')
-          exit(1)
-        end
-        #client = Google::APIClient.new(:authorization => nil)
-        if options[:discovery_uri]
-          if options[:api] && options[:version]
-            client.register_discovery_uri(
-              options[:api], options[:version], options[:discovery_uri]
-            )
-          else
-            STDERR.puts(
-              'Cannot register a discovery URI without ' +
-              'specifying an API and version.'
-            )
-            exit(1)
-          end
-        end
-        version = api_version(api_name, options[:version])
-        api = client.discovered_api(api_name, version)
-        rpcnames = api.to_h.keys
-        puts rpcnames.sort.join("\n")
-        exit(0)
-      end
-
-      def execute
-        client = self.client
-
-        # Setup HTTP request data
-        request_body = ''
-        input_streams, _, _ = IO.select([STDIN], [], [], 0)
-        request_body = STDIN.read || '' if input_streams
-        headers = []
-        if options[:content_type]
-          headers << ['Content-Type', options[:content_type]]
-        elsif request_body
-          # Default to JSON
-          headers << ['Content-Type', 'application/json']
-        end
-
-        if options[:uri]
-          # Make request with URI manually specified
-          uri = Addressable::URI.parse(options[:uri])
-          if uri.relative?
-            STDERR.puts('URI may not be relative.')
-            exit(1)
-          end
-          if options[:requestor_id]
-            uri.query_values = uri.query_values.merge(
-              'xoauth_requestor_id' => options[:requestor_id]
-            )
-          end
-          method = options[:http_method]
-          method ||= request_body == '' ? 'GET' : 'POST'
-          method.upcase!
-          response = client.execute(:http_method => method, :uri => uri.to_str, 
-            :headers => headers, :body => request_body)
-          puts response.body
-          exit(0)
-        else
-          # Make request with URI generated from template and parameters
-          if !self.rpcname
-            STDERR.puts('No rpcname supplied.')
-            exit(1)
-          end
-          api_name = options[:api] || self.rpcname[/^([^\.]+)\./, 1]
-          version = api_version(api_name, options[:version])
-          api = client.discovered_api(api_name, version)
-          method = api.to_h[self.rpcname]
-          if !method
-            STDERR.puts(
-              "Method #{self.rpcname} does not exist for " +
-              "#{api_name}-#{version}."
-            )
-            exit(1)
-          end
-          parameters = self.argv.inject({}) do |accu, pair|
-            name, value = pair.split('=', 2)
-            accu[name] = value
-            accu
-          end
-          if options[:requestor_id]
-            parameters['xoauth_requestor_id'] = options[:requestor_id]
-          end
-          begin
-            result = client.execute(
-              :api_method => method,
-              :parameters => parameters,
-              :merged_body => request_body,
-              :headers => headers
-            )
-            puts result.response.body
-            exit(0)
-          rescue ArgumentError => e
-            puts e.message
-            exit(1)
-          end
-        end
-      end
-
-      def irb
-        $client = self.client
-        # Otherwise IRB will misinterpret command-line options
-        ARGV.clear
-        IRB.start(__FILE__)
-      end
-
-      def help
-        puts self.parser
-        exit(0)
-      end
-    end
-  end
-end
-
-Google::APIClient::CLI.new(ARGV).parse!