google-gax 0.6.0 → 0.7.0

data/spec/google/gax/operation_spec.rb

@@ -0,0 +1,338 @@
+# Copyright 2016, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+require 'time'
+
+require 'google/gax/operation'
+require 'google/gax/settings'
+require 'google/gax/constants'
+require 'google/protobuf/any_pb'
+require 'google/rpc/status_pb'
+require 'google/longrunning/operations_pb'
+
+GrpcOp = Google::Longrunning::Operation
+GaxOp = Google::Gax::Operation
+
+MILLIS_PER_SECOND = Google::Gax::MILLIS_PER_SECOND
+
+class MockLroClient
+  def initialize(get_method: nil, cancel_method: nil)
+    @get_method = get_method
+    @cancel_method = cancel_method
+  end
+
+  def get_operation(grpc_method, options: nil)
+    @get_method.call(grpc_method, options)
+  end
+
+  def cancel_operation(name)
+    @cancel_method.call(name)
+  end
+end
+
+# TODO: This is from google/protobuf/well_known_types.rb.
+# Using google/protobuf in gax-ruby is currently causing a dependency
+# conflict with grpc. When grpc depends on google-protobuf v3.1.0
+# remove this function and use Google::Protobuf::Any#pack.
+def pack(any_pb, msg, type_url_prefix = 'type.googleapis.com/')
+  if type_url_prefix.empty? || type_url_prefix[-1] != '/'
+    any_pb.type_url = "#{type_url_prefix}/#{msg.class.descriptor.name}"
+  else
+    any_pb.type_url = "#{type_url_prefix}#{msg.class.descriptor.name}"
+  end
+  any_pb.value = msg.to_proto
+end
+
+RESULT_ANY = Google::Protobuf::Any.new
+RESULT = Google::Rpc::Status.new(code: 1, message: 'Result')
+pack(RESULT_ANY, RESULT)
+
+METADATA_ANY = Google::Protobuf::Any.new
+METADATA = Google::Rpc::Status.new(code: 2, message: 'Metadata')
+pack(METADATA_ANY, METADATA)
+
+DONE_GET_METHOD = proc do
+  GrpcOp.new(done: true, response: RESULT_ANY, metadata: METADATA_ANY)
+end
+DONE_ON_GET_CLIENT = MockLroClient.new(get_method: DONE_GET_METHOD)
+
+def create_op(operation, client: nil, call_options: nil)
+  GaxOp.new(
+    operation,
+    client || DONE_ON_GET_CLIENT,
+    Google::Rpc::Status,
+    Google::Rpc::Status,
+    call_options: call_options
+  )
+end
+
+describe Google::Gax::Operation do
+  context 'method `results`' do
+    it 'should return nil on unfinished operation.' do
+      op = create_op(GrpcOp.new(done: false))
+      expect(op.results).to be_nil
+    end
+
+    it 'should return the error on errored operation.' do
+      error = Google::Rpc::Status.new
+      op = create_op(GrpcOp.new(done: true, error: error))
+      expect(op.results).to eq(error)
+    end
+
+    it 'should unpack the response' do
+      op = create_op(GrpcOp.new(done: true, response: RESULT_ANY))
+      expect(op.results).to eq(RESULT)
+    end
+  end
+
+  context 'method `metadata`' do
+    it 'should unpack the metadata' do
+      op = create_op(GrpcOp.new(done: true, metadata: METADATA_ANY))
+      expect(op.metadata).to eq(METADATA)
+    end
+  end
+
+  context 'method `done?`' do
+    it 'should return the status of an operation correctly.' do
+      expect(create_op(GrpcOp.new(done: false)).done?).to eq(false)
+      expect(create_op(GrpcOp.new(done: true)).done?).to eq(true)
+    end
+  end
+
+  context 'method `error?`' do
+    it 'should return false on unfinished operation.' do
+      expect(create_op(GrpcOp.new(done: false)).error?).to eq(false)
+    end
+
+    it 'should return true on error.' do
+      error = Google::Rpc::Status.new
+      op = create_op(GrpcOp.new(done: true, error: error))
+      expect(op.error?).to eq(true)
+    end
+
+    it 'should return true on finished operation.' do
+      op = create_op(GrpcOp.new(done: true, response: RESULT_ANY))
+      expect(op.error?).to eq(false)
+    end
+  end
+
+  context 'method `cancel`' do
+    it 'should call the clients cancel_operation' do
+      op_name = 'test_name'
+      called = false
+      cancel_method = proc do |name|
+        expect(name).to eq(op_name)
+        called = true
+      end
+      mock_client = MockLroClient.new(cancel_method: cancel_method)
+      create_op(GrpcOp.new(name: op_name), client: mock_client).cancel
+      expect(called).to eq(true)
+    end
+  end
+
+  context 'method `reload!`' do
+    it 'should call the get_operation of the client' do
+      called = false
+      get_method = proc do
+        called = true
+        GrpcOp.new(done: true, response: RESULT_ANY)
+      end
+      mock_client = MockLroClient.new(get_method: get_method)
+      op = create_op(GrpcOp.new(done: false), client: mock_client)
+      expect(called).to eq(false)
+      op.reload!
+      expect(called).to eq(true)
+    end
+
+    it 'should use call_options attribute when reloading' do
+      backoff_settings = Google::Gax::BackoffSettings.new(1, 2, 3, 4, 5, 6, 7)
+      call_options = Google::Gax::CallOptions.new(
+        retry_options: Google::Gax::RetryOptions.new(nil, backoff_settings)
+      )
+      called = false
+      get_method = proc do |_, options|
+        called = true
+        expect(options).to be_a(Google::Gax::CallOptions)
+        expect(options).to eq(call_options)
+        GrpcOp.new(done: true, response: RESULT_ANY)
+      end
+      mock_client = MockLroClient.new(get_method: get_method)
+
+      op = create_op(
+        GrpcOp.new(done: false, name: 'name'),
+        client: mock_client,
+        call_options: call_options
+      )
+      expect(called).to eq(false)
+      op.reload!
+      expect(called).to eq(true)
+    end
+
+    it 'should yield the registered callback after the operation completes' do
+      op = create_op(GrpcOp.new(done: false), client: DONE_ON_GET_CLIENT)
+      called = false
+      op.on_done do |operation|
+        expect(operation.results).to eq(RESULT)
+        expect(operation.metadata).to eq(METADATA)
+        called = true
+      end
+      expect(called).to eq(false)
+      expect(op.done?).to eq(false)
+      op.reload!
+      expect(called).to eq(true)
+      expect(op.done?).to eq(true)
+    end
+
+    it 'should yield the registered callbacks in order they were called.' do
+      op = create_op(GrpcOp.new(done: false), client: DONE_ON_GET_CLIENT)
+      expected_order = [1, 2, 3]
+      called_order = []
+      expected_order.each do |i|
+        op.on_done do |operation|
+          expect(operation.results).to eq(RESULT)
+          expect(operation.metadata).to eq(METADATA)
+          called_order.push(i)
+        end
+      end
+      expect(called_order).to eq([])
+      expect(op.done?).to eq(false)
+      op.reload!
+      expect(called_order).to eq(expected_order)
+      expect(op.done?).to eq(true)
+    end
+  end
+
+  context 'method `wait_until_done!`' do
+    it 'should retry until the operation is done' do
+      to_call = 3
+      get_method = proc do
+        to_call -= 1
+        done = to_call == 0
+        GrpcOp.new(done: done, response: RESULT_ANY)
+      end
+      mock_client = MockLroClient.new(get_method: get_method)
+      op = create_op(GrpcOp.new(done: false), client: mock_client)
+      time_now = Time.now
+      allow(Time).to receive(:now) { time_now }
+      expect(op).to receive(:sleep).exactly(3).times { |secs| time_now += secs }
+      op.wait_until_done!
+      expect(to_call).to eq(0)
+    end
+
+    it 'should wait until the operation is done' do
+      to_call = 3
+      get_method = proc do
+        to_call -= 1
+        done = to_call == 0
+        GrpcOp.new(done: done, response: RESULT_ANY)
+      end
+      mock_client = MockLroClient.new(get_method: get_method)
+      op = create_op(GrpcOp.new(done: false), client: mock_client)
+
+      time_now = Time.now
+      allow(Time).to receive(:now) { time_now }
+      expect(op).to receive(:sleep).exactly(3).times { |secs| time_now += secs }
+
+      op.wait_until_done!
+      expect(to_call).to eq(0)
+    end
+
+    it 'times out' do
+      backoff_settings = BackoffSettings.new(1, 1, 10, 0, 0, 0, 100)
+      get_method = proc { GrpcOp.new(done: false) }
+      mock_client = MockLroClient.new(get_method: get_method)
+      op = create_op(GrpcOp.new(done: false), client: mock_client)
+
+      time_now = Time.now
+      allow(Time).to receive(:now) { time_now }
+      allow(op).to receive(:sleep) { |secs| time_now += secs }
+
+      begin
+        op.wait_until_done!(backoff_settings: backoff_settings)
+      rescue Google::Gax::RetryError => exc
+        expect(exc).to be_a(Google::Gax::RetryError)
+      end
+    end
+
+    it 'retries with exponential backoff' do
+      call_count = 0
+      get_method = proc do
+        call_count += 1
+        GrpcOp.new(done: false, response: RESULT_ANY)
+      end
+      mock_client = MockLroClient.new(get_method: get_method)
+      op = create_op(GrpcOp.new(done: false), client: mock_client)
+
+      time_now = Time.now
+      start_time = time_now
+      allow(Time).to receive(:now) { time_now }
+      allow(op).to receive(:sleep) { |secs| time_now += secs }
+
+      initial_delay = 10 * MILLIS_PER_SECOND
+      delay_multiplier = 1.5
+      max_delay = 5 * 60 * MILLIS_PER_SECOND
+      total_timeout = 60 * 60 * MILLIS_PER_SECOND
+      backoff = BackoffSettings.new(
+        initial_delay,
+        delay_multiplier,
+        max_delay,
+        0,
+        0,
+        0,
+        total_timeout
+      )
+      begin
+        op.wait_until_done!(backoff_settings: backoff)
+      rescue Google::Gax::RetryError => exc
+        expect(exc).to be_a(Google::Gax::RetryError)
+      end
+      expect(time_now - start_time).to be >= (total_timeout / MILLIS_PER_SECOND)
+
+      calls_lower_bound = total_timeout / max_delay
+      calls_upper_bound = total_timeout / initial_delay
+      expect(call_count).to be > calls_lower_bound
+      expect(call_count).to be < calls_upper_bound
+    end
+  end
+
+  context 'method `on_done`' do
+    it 'should yield immediately when the operation is already finished' do
+      op = create_op(
+        GrpcOp.new(done: true, response: RESULT_ANY, metadata: METADATA_ANY)
+      )
+      called = false
+      op.on_done do |operation|
+        expect(operation.results).to eq(RESULT)
+        expect(operation.metadata).to eq(METADATA)
+        called = true
+      end
+      expect(called).to eq(true)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: google-gax
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Google API Authors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-13 00:00:00.000000000 Z
+date: 2017-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: googleauth
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.3.1
+- !ruby/object:Gem::Dependency
+  name: google-protobuf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.2
 - !ruby/object:Gem::Dependency
   name: rly
   requirement: !ruby/object:Gem::Requirement
@@ -147,15 +161,18 @@ files:
 - lib/google/gax.rb
 - lib/google/gax/api_callable.rb
 - lib/google/gax/bundling.rb
+- lib/google/gax/constants.rb
 - lib/google/gax/errors.rb
 - lib/google/gax/grpc.rb
+- lib/google/gax/operation.rb
 - lib/google/gax/path_template.rb
 - lib/google/gax/settings.rb
 - lib/google/gax/version.rb
-- lib/google/longrunning/operations_api.rb
+- lib/google/longrunning/operations_client.rb
 - lib/google/longrunning/operations_client_config.json
 - spec/google/gax/api_callable_spec.rb
 - spec/google/gax/bundling_spec.rb
+- spec/google/gax/operation_spec.rb
 - spec/google/gax/path_template_spec.rb
 - spec/google/gax/settings_spec.rb
 - spec/spec_helper.rb
@@ -179,7 +196,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Aids the development of APIs for clients and servers based on GRPC and Google