grpc 1.6.7 → 1.7.0.pre1

data/src/ruby/spec/generic/active_call_spec.rb

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'grpc'
+require 'spec_helper'
 
 include GRPC::Core::StatusCodes
 
@@ -22,6 +22,21 @@ describe GRPC::ActiveCall do
   CallOps = GRPC::Core::CallOps
   WriteFlags = GRPC::Core::WriteFlags
 
+  def ok_status
+    Struct::Status.new(OK, 'OK')
+  end
+
+  def send_and_receive_close_and_status(client_call, server_call)
+    client_call.run_batch(CallOps::SEND_CLOSE_FROM_CLIENT => nil)
+    server_call.run_batch(CallOps::RECV_CLOSE_ON_SERVER => nil,
+                          CallOps::SEND_STATUS_FROM_SERVER => ok_status)
+    client_call.run_batch(CallOps::RECV_STATUS_ON_CLIENT => nil)
+  end
+
+  def inner_call_of_active_call(active_call)
+    active_call.instance_variable_get(:@call)
+  end
+
   before(:each) do
     @pass_through = proc { |x| x }
     host = '0.0.0.0:0'
@@ -67,16 +82,26 @@ describe GRPC::ActiveCall do
         end
       end
     end
+
+    describe '#interceptable' do
+      it 'exposes a fixed subset of the ActiveCall.methods' do
+        want = %w(deadline)
+        v = @client_call.interceptable
+        want.each do |w|
+          expect(v.methods.include?(w))
+        end
+      end
+    end
   end
 
   describe '#remote_send' do
-    it 'allows a client to send a payload to the server' do
+    it 'allows a client to send a payload to the server', test: true do
       call = make_test_call
       ActiveCall.client_invoke(call)
-      @client_call = ActiveCall.new(call, @pass_through,
-                                    @pass_through, deadline)
+      client_call = ActiveCall.new(call, @pass_through,
+                                   @pass_through, deadline)
       msg = 'message is a string'
-      @client_call.remote_send(msg)
+      client_call.remote_send(msg)
 
       # check that server rpc new was received
       recvd_rpc = @server.request_call
@@ -86,8 +111,13 @@ describe GRPC::ActiveCall do
       # Accept the call, and verify that the server reads the response ok.
       server_call = ActiveCall.new(recvd_call, @pass_through,
                                    @pass_through, deadline,
-                                   metadata_received: true)
+                                   metadata_received: true,
+                                   started: false)
       expect(server_call.remote_read).to eq(msg)
+      # finish the call
+      server_call.send_initial_metadata
+      call.run_batch(CallOps::RECV_INITIAL_METADATA => nil)
+      send_and_receive_close_and_status(call, recvd_call)
     end
 
     it 'marshals the payload using the marshal func' do
@@ -109,6 +139,9 @@ describe GRPC::ActiveCall do
                                    @pass_through, deadline,
                                    metadata_received: true)
       expect(server_call.remote_read).to eq('marshalled:' + msg)
+      # finish the call
+      call.run_batch(CallOps::RECV_INITIAL_METADATA => nil)
+      send_and_receive_close_and_status(call, recvd_call)
     end
 
     TEST_WRITE_FLAGS = [WriteFlags::BUFFER_HINT, WriteFlags::NO_COMPRESS]
@@ -136,6 +169,9 @@ describe GRPC::ActiveCall do
                                      @pass_through, deadline,
                                      metadata_received: true)
         expect(server_call.remote_read).to eq('marshalled:' + msg)
+        # finish the call
+        server_call.send_status(OK, '', true)
+        client_call.receive_and_check_status
       end
     end
   end
@@ -177,7 +213,6 @@ describe GRPC::ActiveCall do
                                     @pass_through,
                                     @pass_through,
                                     deadline)
-
       expect(@client_call.metadata_sent).to eql(true)
       expect(call).to(
         receive(:run_batch).with(hash_including(
@@ -291,6 +326,10 @@ describe GRPC::ActiveCall do
       expect(recvd_rpc.metadata).to_not be_nil
       expect(recvd_rpc.metadata['k1']).to eq('v1')
       expect(recvd_rpc.metadata['k2']).to eq('v2')
+      # finish the call
+      recvd_call.run_batch(CallOps::SEND_INITIAL_METADATA => {})
+      call.run_batch(CallOps::RECV_INITIAL_METADATA => nil)
+      send_and_receive_close_and_status(call, recvd_call)
     end
   end
 
@@ -324,6 +363,8 @@ describe GRPC::ActiveCall do
       server_call = expect_server_to_receive(msg)
       server_call.remote_send('server_response')
       expect(client_call.remote_read).to eq('server_response')
+      send_and_receive_close_and_status(
+        call, inner_call_of_active_call(server_call))
     end
 
     it 'saves no metadata when the server adds no metadata' do
@@ -338,6 +379,8 @@ describe GRPC::ActiveCall do
       expect(client_call.metadata).to be_nil
       client_call.remote_read
       expect(client_call.metadata).to eq({})
+      send_and_receive_close_and_status(
+        call, inner_call_of_active_call(server_call))
     end
 
     it 'saves metadata add by the server' do
@@ -353,6 +396,8 @@ describe GRPC::ActiveCall do
       client_call.remote_read
       expected = { 'k1' => 'v1', 'k2' => 'v2' }
       expect(client_call.metadata).to eq(expected)
+      send_and_receive_close_and_status(
+        call, inner_call_of_active_call(server_call))
     end
 
     it 'get a status from server when nothing else sent from server' do
@@ -409,6 +454,8 @@ describe GRPC::ActiveCall do
       server_call = expect_server_to_receive(msg)
       server_call.remote_send('server_response')
       expect(client_call.remote_read).to eq('unmarshalled:server_response')
+      send_and_receive_close_and_status(
+        call, inner_call_of_active_call(server_call))
     end
   end
 
@@ -418,9 +465,11 @@ describe GRPC::ActiveCall do
       client_call = ActiveCall.new(call, @pass_through,
                                    @pass_through, deadline)
       expect(client_call.each_remote_read).to be_a(Enumerator)
+      # finish the call
+      client_call.cancel
     end
 
-    it 'the returns an enumerator that can read n responses' do
+    it 'the returned enumerator can read n responses' do
       call = make_test_call
       ActiveCall.client_invoke(call)
       client_call = ActiveCall.new(call, @pass_through,
@@ -435,6 +484,8 @@ describe GRPC::ActiveCall do
         server_call.remote_send(reply)
         expect(e.next).to eq(reply)
       end
+      send_and_receive_close_and_status(
+        call, inner_call_of_active_call(server_call))
     end
 
     it 'the returns an enumerator that stops after an OK Status' do
@@ -453,7 +504,7 @@ describe GRPC::ActiveCall do
         server_call.remote_send(reply)
         expect(e.next).to eq(reply)
       end
-      server_call.send_status(OK, 'OK')
+      server_call.send_status(OK, 'OK', true)
       expect { e.next }.to raise_error(StopIteration)
     end
   end
@@ -568,9 +619,11 @@ describe GRPC::ActiveCall do
         msgs
       end
 
+      int_ctx = GRPC::InterceptionContext.new
+
       @server_thread = Thread.new do
         @server_call.run_server_bidi(
-          fake_gen_each_reply_with_no_call_param)
+          fake_gen_each_reply_with_no_call_param, int_ctx)
         @server_call.send_status(@server_status)
       end
     end
@@ -583,10 +636,11 @@ describe GRPC::ActiveCall do
         call_param.send_initial_metadata
         msgs
       end
+      int_ctx = GRPC::InterceptionContext.new
 
       @server_thread = Thread.new do
         @server_call.run_server_bidi(
-          fake_gen_each_reply_with_call_param)
+          fake_gen_each_reply_with_call_param, int_ctx)
         @server_call.send_status(@server_status)
       end
     end

data/src/ruby/spec/generic/client_interceptors_spec.rb

@@ -0,0 +1,153 @@
+# Copyright 2017 gRPC authors.
+#
+# 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'
+
+describe 'Client Interceptors' do
+  let(:interceptor) { TestClientInterceptor.new }
+  let(:interceptors_opts) { { interceptors: [interceptor] } }
+  let(:request) { EchoMsg.new }
+  let(:service) { EchoService }
+
+  before(:each) do
+    build_rpc_server
+  end
+
+  context 'when a client interceptor is added' do
+    context 'with a request/response call' do
+      it 'should be called', server: true do
+        expect(interceptor).to receive(:request_response)
+          .once.and_call_original
+
+        run_services_on_server(@server, services: [service]) do
+          stub = build_insecure_stub(EchoStub, opts: interceptors_opts)
+          expect_any_instance_of(GRPC::ActiveCall).to receive(:request_response)
+            .once.and_call_original
+          expect(stub.an_rpc(request)).to be_a(EchoMsg)
+        end
+      end
+
+      it 'can modify outgoing metadata', server: true do
+        expect(interceptor).to receive(:request_response)
+          .once.and_call_original
+
+        run_services_on_server(@server, services: [service]) do
+          stub = build_insecure_stub(EchoStub, opts: interceptors_opts)
+          expect_any_instance_of(GRPC::ActiveCall).to receive(:request_response)
+            .with(request, metadata: { 'foo' => 'bar_from_request_response' })
+            .once.and_call_original
+          expect(stub.an_rpc(request)).to be_a(EchoMsg)
+        end
+      end
+    end
+
+    context 'with a client streaming call' do
+      it 'should be called', server: true do
+        expect(interceptor).to receive(:client_streamer)
+          .once.and_call_original
+
+        run_services_on_server(@server, services: [service]) do
+          stub = build_insecure_stub(EchoStub, opts: interceptors_opts)
+          expect_any_instance_of(GRPC::ActiveCall).to receive(:client_streamer)
+            .once.and_call_original
+          requests = [EchoMsg.new, EchoMsg.new]
+          expect(stub.a_client_streaming_rpc(requests)).to be_a(EchoMsg)
+        end
+      end
+
+      it 'can modify outgoing metadata', server: true do
+        expect(interceptor).to receive(:client_streamer)
+          .once.and_call_original
+
+        run_services_on_server(@server, services: [service]) do
+          stub = build_insecure_stub(EchoStub, opts: interceptors_opts)
+          requests = [EchoMsg.new, EchoMsg.new]
+          expect_any_instance_of(GRPC::ActiveCall).to receive(:client_streamer)
+            .with(requests, metadata: { 'foo' => 'bar_from_client_streamer' })
+            .once.and_call_original
+          expect(stub.a_client_streaming_rpc(requests)).to be_a(EchoMsg)
+        end
+      end
+    end
+
+    context 'with a server streaming call' do
+      it 'should be called', server: true do
+        expect(interceptor).to receive(:server_streamer)
+          .once.and_call_original
+
+        run_services_on_server(@server, services: [service]) do
+          stub = build_insecure_stub(EchoStub, opts: interceptors_opts)
+          request = EchoMsg.new
+          expect_any_instance_of(GRPC::ActiveCall).to receive(:server_streamer)
+            .once.and_call_original
+          responses = stub.a_server_streaming_rpc(request)
+          responses.each do |r|
+            expect(r).to be_a(EchoMsg)
+          end
+        end
+      end
+
+      it 'can modify outgoing metadata', server: true do
+        expect(interceptor).to receive(:server_streamer)
+          .once.and_call_original
+
+        run_services_on_server(@server, services: [service]) do
+          stub = build_insecure_stub(EchoStub, opts: interceptors_opts)
+          request = EchoMsg.new
+          expect_any_instance_of(GRPC::ActiveCall).to receive(:server_streamer)
+            .with(request, metadata: { 'foo' => 'bar_from_server_streamer' })
+            .once.and_call_original
+          responses = stub.a_server_streaming_rpc(request)
+          responses.each do |r|
+            expect(r).to be_a(EchoMsg)
+          end
+        end
+      end
+    end
+
+    context 'with a bidi call' do
+      it 'should be called', server: true do
+        expect(interceptor).to receive(:bidi_streamer)
+          .once.and_call_original
+
+        run_services_on_server(@server, services: [service]) do
+          stub = build_insecure_stub(EchoStub, opts: interceptors_opts)
+          expect_any_instance_of(GRPC::ActiveCall).to receive(:bidi_streamer)
+            .once.and_call_original
+          requests = [EchoMsg.new, EchoMsg.new]
+          responses = stub.a_bidi_rpc(requests)
+          responses.each do |r|
+            expect(r).to be_a(EchoMsg)
+          end
+        end
+      end
+
+      it 'can modify outgoing metadata', server: true do
+        expect(interceptor).to receive(:bidi_streamer)
+          .once.and_call_original
+
+        run_services_on_server(@server, services: [service]) do
+          stub = build_insecure_stub(EchoStub, opts: interceptors_opts)
+          requests = [EchoMsg.new, EchoMsg.new]
+          expect_any_instance_of(GRPC::ActiveCall).to receive(:bidi_streamer)
+            .with(requests, metadata: { 'foo' => 'bar_from_bidi_streamer' })
+            .once.and_call_original
+          responses = stub.a_bidi_rpc(requests)
+          responses.each do |r|
+            expect(r).to be_a(EchoMsg)
+          end
+        end
+      end
+    end
+  end
+end

data/src/ruby/spec/generic/interceptor_registry_spec.rb

@@ -0,0 +1,65 @@
+# Copyright 2017 gRPC authors.
+#
+# 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'
+
+describe GRPC::InterceptorRegistry do
+  let(:server) { RpcServer.new }
+  let(:interceptor) { TestServerInterceptor.new }
+  let(:interceptors) { [interceptor] }
+  let(:registry) { described_class.new(interceptors) }
+
+  describe 'initialization' do
+    subject { registry }
+
+    context 'with an interceptor extending GRPC::ServerInterceptor' do
+      it 'should add the interceptor to the registry' do
+        subject
+        is = registry.instance_variable_get('@interceptors')
+        expect(is.count).to eq 1
+        expect(is.first).to eq interceptor
+      end
+    end
+
+    context 'with multiple interceptors' do
+      let(:interceptor2) { TestServerInterceptor.new }
+      let(:interceptor3) { TestServerInterceptor.new }
+      let(:interceptors) { [interceptor, interceptor2, interceptor3] }
+
+      it 'should maintain order of insertion when iterated against' do
+        subject
+        is = registry.instance_variable_get('@interceptors')
+        expect(is.count).to eq 3
+        is.each_with_index do |i, idx|
+          case idx
+          when 0
+            expect(i).to eq interceptor
+          when 1
+            expect(i).to eq interceptor2
+          when 2
+            expect(i).to eq interceptor3
+          end
+        end
+      end
+    end
+
+    context 'with an interceptor not extending GRPC::ServerInterceptor' do
+      let(:interceptor) { Class }
+      let(:err) { GRPC::InterceptorRegistry::DescendantError }
+
+      it 'should raise an InvalidArgument exception' do
+        expect { subject }.to raise_error(err)
+      end
+    end
+  end
+end

data/src/ruby/spec/generic/rpc_desc_spec.rb

@@ -52,6 +52,13 @@ describe GRPC::RpcDesc do
       this_desc.run_server_method(@call, method(:other_error))
     end
 
+    it 'sends status UNKNOWN if NotImplementedErrors are raised' do
+      expect(@call).to receive(:read_unary_request).once.and_return(Object.new)
+      expect(@call).to receive(:send_status).once.with(
+        UNKNOWN, not_implemented_error_msg, false, metadata: {})
+      this_desc.run_server_method(@call, method(:not_implemented))
+    end
+
     it 'absorbs CallError with no further action' do
       expect(@call).to receive(:read_unary_request).once.and_raise(CallError)
       blk = proc do
@@ -102,6 +109,12 @@ describe GRPC::RpcDesc do
         @client_streamer.run_server_method(@call, method(:other_error_alt))
       end
 
+      it 'sends status UNKNOWN if NotImplementedErrors are raised' do
+        expect(@call).to receive(:send_status).once.with(
+          UNKNOWN, not_implemented_error_msg, false, metadata: {})
+        @client_streamer.run_server_method(@call, method(:not_implemented_alt))
+      end
+
       it 'absorbs CallError with no further action' do
         expect(@call).to receive(:server_unary_response).once.and_raise(
           CallError)
@@ -166,6 +179,14 @@ describe GRPC::RpcDesc do
         @bidi_streamer.run_server_method(@call, method(:other_error_alt))
       end
 
+      it 'sends status UNKNOWN if NotImplementedErrors are raised' do
+        expect(@call).to receive(:run_server_bidi).and_raise(
+          not_implemented_error)
+        expect(@call).to receive(:send_status).once.with(
+          UNKNOWN, not_implemented_error_msg, false, metadata: {})
+        @bidi_streamer.run_server_method(@call, method(:not_implemented_alt))
+      end
+
       it 'closes the stream if there no errors' do
         expect(@call).to receive(:run_server_bidi)
         expect(@call).to receive(:output_metadata).and_return(fake_md)
@@ -329,8 +350,25 @@ describe GRPC::RpcDesc do
     fail(ArgumentError, 'other error')
   end
 
+  def not_implemented(_req, _call)
+    fail not_implemented_error
+  end
+
+  def not_implemented_alt(_call)
+    fail not_implemented_error
+  end
+
   def arg_error_msg(error = nil)
     error ||= ArgumentError.new('other error')
     "#{error.class}: #{error.message}"
   end
+
+  def not_implemented_error
+    NotImplementedError.new('some OS feature not implemented')
+  end
+
+  def not_implemented_error_msg(error = nil)
+    error ||= not_implemented_error
+    "#{error.class}: #{error.message}"
+  end
 end