grpc 1.28.0 → 1.42.0

data/src/ruby/pb/src/proto/grpc/testing/test_services_pb.rb

@@ -29,38 +29,38 @@ module Grpc
       # performance with various types of payload.
       class Service
 
-        include GRPC::GenericService
+        include ::GRPC::GenericService
 
         self.marshal_class_method = :encode
         self.unmarshal_class_method = :decode
         self.service_name = 'grpc.testing.TestService'
 
         # One empty request followed by one empty response.
-        rpc :EmptyCall, Empty, Empty
+        rpc :EmptyCall, ::Grpc::Testing::Empty, ::Grpc::Testing::Empty
         # One request followed by one response.
-        rpc :UnaryCall, SimpleRequest, SimpleResponse
+        rpc :UnaryCall, ::Grpc::Testing::SimpleRequest, ::Grpc::Testing::SimpleResponse
         # One request followed by one response. Response has cache control
         # headers set such that a caching HTTP proxy (such as GFE) can
         # satisfy subsequent requests.
-        rpc :CacheableUnaryCall, SimpleRequest, SimpleResponse
+        rpc :CacheableUnaryCall, ::Grpc::Testing::SimpleRequest, ::Grpc::Testing::SimpleResponse
         # One request followed by a sequence of responses (streamed download).
         # The server returns the payload with client desired type and sizes.
-        rpc :StreamingOutputCall, StreamingOutputCallRequest, stream(StreamingOutputCallResponse)
+        rpc :StreamingOutputCall, ::Grpc::Testing::StreamingOutputCallRequest, stream(::Grpc::Testing::StreamingOutputCallResponse)
         # A sequence of requests followed by one response (streamed upload).
         # The server returns the aggregated size of client payload as the result.
-        rpc :StreamingInputCall, stream(StreamingInputCallRequest), StreamingInputCallResponse
+        rpc :StreamingInputCall, stream(::Grpc::Testing::StreamingInputCallRequest), ::Grpc::Testing::StreamingInputCallResponse
         # A sequence of requests with each request served by the server immediately.
         # As one request could lead to multiple responses, this interface
         # demonstrates the idea of full duplexing.
-        rpc :FullDuplexCall, stream(StreamingOutputCallRequest), stream(StreamingOutputCallResponse)
+        rpc :FullDuplexCall, stream(::Grpc::Testing::StreamingOutputCallRequest), stream(::Grpc::Testing::StreamingOutputCallResponse)
         # A sequence of requests followed by a sequence of responses.
         # The server buffers all the client requests and then serves them in order. A
         # stream of responses are returned to the client when the server starts with
         # first request.
-        rpc :HalfDuplexCall, stream(StreamingOutputCallRequest), stream(StreamingOutputCallResponse)
+        rpc :HalfDuplexCall, stream(::Grpc::Testing::StreamingOutputCallRequest), stream(::Grpc::Testing::StreamingOutputCallResponse)
         # The test server will not implement this method. It will be used
         # to test the behavior when clients call unimplemented methods.
-        rpc :UnimplementedCall, Empty, Empty
+        rpc :UnimplementedCall, ::Grpc::Testing::Empty, ::Grpc::Testing::Empty
       end
 
       Stub = Service.rpc_stub_class
@@ -70,14 +70,14 @@ module Grpc
       # that case.
       class Service
 
-        include GRPC::GenericService
+        include ::GRPC::GenericService
 
         self.marshal_class_method = :encode
         self.unmarshal_class_method = :decode
         self.service_name = 'grpc.testing.UnimplementedService'
 
         # A call that no server should implement
-        rpc :UnimplementedCall, Empty, Empty
+        rpc :UnimplementedCall, ::Grpc::Testing::Empty, ::Grpc::Testing::Empty
       end
 
       Stub = Service.rpc_stub_class
@@ -86,14 +86,64 @@ module Grpc
       # A service used to control reconnect server.
       class Service
 
-        include GRPC::GenericService
+        include ::GRPC::GenericService
 
         self.marshal_class_method = :encode
         self.unmarshal_class_method = :decode
         self.service_name = 'grpc.testing.ReconnectService'
 
-        rpc :Start, ReconnectParams, Empty
-        rpc :Stop, Empty, ReconnectInfo
+        rpc :Start, ::Grpc::Testing::ReconnectParams, ::Grpc::Testing::Empty
+        rpc :Stop, ::Grpc::Testing::Empty, ::Grpc::Testing::ReconnectInfo
+      end
+
+      Stub = Service.rpc_stub_class
+    end
+    module LoadBalancerStatsService
+      # A service used to obtain stats for verifying LB behavior.
+      class Service
+
+        include ::GRPC::GenericService
+
+        self.marshal_class_method = :encode
+        self.unmarshal_class_method = :decode
+        self.service_name = 'grpc.testing.LoadBalancerStatsService'
+
+        # Gets the backend distribution for RPCs sent by a test client.
+        rpc :GetClientStats, ::Grpc::Testing::LoadBalancerStatsRequest, ::Grpc::Testing::LoadBalancerStatsResponse
+        # Gets the accumulated stats for RPCs sent by a test client.
+        rpc :GetClientAccumulatedStats, ::Grpc::Testing::LoadBalancerAccumulatedStatsRequest, ::Grpc::Testing::LoadBalancerAccumulatedStatsResponse
+      end
+
+      Stub = Service.rpc_stub_class
+    end
+    module XdsUpdateHealthService
+      # A service to remotely control health status of an xDS test server.
+      class Service
+
+        include ::GRPC::GenericService
+
+        self.marshal_class_method = :encode
+        self.unmarshal_class_method = :decode
+        self.service_name = 'grpc.testing.XdsUpdateHealthService'
+
+        rpc :SetServing, ::Grpc::Testing::Empty, ::Grpc::Testing::Empty
+        rpc :SetNotServing, ::Grpc::Testing::Empty, ::Grpc::Testing::Empty
+      end
+
+      Stub = Service.rpc_stub_class
+    end
+    module XdsUpdateClientConfigureService
+      # A service to dynamically update the configuration of an xDS test client.
+      class Service
+
+        include ::GRPC::GenericService
+
+        self.marshal_class_method = :encode
+        self.unmarshal_class_method = :decode
+        self.service_name = 'grpc.testing.XdsUpdateClientConfigureService'
+
+        # Update the tes client's configuration.
+        rpc :Configure, ::Grpc::Testing::ClientConfigureRequest, ::Grpc::Testing::ClientConfigureResponse
       end
 
       Stub = Service.rpc_stub_class

data/src/ruby/spec/call_spec.rb

@@ -171,7 +171,7 @@ describe GRPC::Core::Call do
   end
 
   def make_test_call
-    @ch.create_call(nil, nil, 'dummy_method', nil, deadline)
+    @ch.create_call(nil, nil, 'phony_method', nil, deadline)
   end
 
   def deadline

data/src/ruby/spec/channel_credentials_spec.rb

@@ -50,6 +50,48 @@ describe GRPC::Core::ChannelCredentials do
       blk = proc { ChannelCredentials.new(nil) }
       expect(&blk).not_to raise_error
     end
+
+    it 'fails gracefully with constructed with a nil private key' do
+      blk = proc { GRPC::Core::ChannelCredentials.new(nil, nil, '') }
+      expect(&blk).to raise_error
+    end
+
+    it 'fails gracefully with constructed with a nil cert chain' do
+      blk = proc { GRPC::Core::ChannelCredentials.new(nil, '', nil) }
+      expect(&blk).to raise_error
+    end
+
+    it 'can be constructed with a fallback credential' do
+      blk = proc {
+        fallback = GRPC::Core::ChannelCredentials.new
+        GRPC::Core::XdsChannelCredentials.new(fallback)
+      }
+      expect(&blk).not_to raise_error
+    end
+
+    it 'fails gracefully constructed with nil' do
+      blk = proc {
+        GRPC::Core::XdsChannelCredentials.new(nil)
+      }
+      expect(&blk).to raise_error TypeError, /expected grpc_channel_credentials/
+    end
+
+    it 'fails gracefully constructed with a non-C-extension object' do
+      blk = proc {
+        not_a_fallback = 100
+        GRPC::Core::XdsChannelCredentials.new(not_a_fallback)
+      }
+      expect(&blk).to raise_error TypeError, /expected grpc_channel_credentials/
+    end
+
+    it 'fails gracefully constructed with a non-ChannelCredentials object' do
+      blk = proc {
+        not_a_fallback = GRPC::Core::Channel.new('dummy_host', nil,
+                                                 :this_channel_is_insecure)
+        GRPC::Core::XdsChannelCredentials.new(not_a_fallback)
+      }
+      expect(&blk).to raise_error TypeError, /expected grpc_channel_credentials/
+    end
   end
 
   describe '#compose' do

data/src/ruby/spec/channel_spec.rb

@@ -53,7 +53,7 @@ describe GRPC::Core::Channel do
   shared_examples '#new' do
     it 'take a host name without channel args' do
       blk = proc do
-        GRPC::Core::Channel.new('dummy_host', nil, :this_channel_is_insecure)
+        GRPC::Core::Channel.new('phony_host', nil, :this_channel_is_insecure)
       end
       expect(&blk).not_to raise_error
     end
@@ -114,7 +114,7 @@ describe GRPC::Core::Channel do
 
   describe '#new for secure channels' do
     def construct_with_args(a)
-      proc { GRPC::Core::Channel.new('dummy_host', a, create_test_cert) }
+      proc { GRPC::Core::Channel.new('phony_host', a, create_test_cert) }
     end
 
     it_behaves_like '#new'
@@ -125,7 +125,18 @@ describe GRPC::Core::Channel do
 
     def construct_with_args(a)
       proc do
-        GRPC::Core::Channel.new('dummy_host', a, :this_channel_is_insecure)
+        GRPC::Core::Channel.new('phony_host', a, :this_channel_is_insecure)
+      end
+    end
+  end
+
+  describe '#new for XDS channels' do
+    it_behaves_like '#new'
+
+    def construct_with_args(a)
+      proc do
+        xds_creds = GRPC::Core::XdsChannelCredentials.new(create_test_cert)
+        GRPC::Core::Channel.new('dummy_host', a, xds_creds)
       end
     end
   end
@@ -137,7 +148,7 @@ describe GRPC::Core::Channel do
       deadline = Time.now + 5
 
       blk = proc do
-        ch.create_call(nil, nil, 'dummy_method', nil, deadline)
+        ch.create_call(nil, nil, 'phony_method', nil, deadline)
       end
       expect(&blk).to_not raise_error
     end
@@ -148,7 +159,7 @@ describe GRPC::Core::Channel do
 
       deadline = Time.now + 5
       blk = proc do
-        ch.create_call(nil, nil, 'dummy_method', nil, deadline)
+        ch.create_call(nil, nil, 'phony_method', nil, deadline)
       end
       expect(&blk).to raise_error(RuntimeError)
     end
@@ -160,7 +171,7 @@ describe GRPC::Core::Channel do
 
       blk = proc do
         fork_with_propagated_error_message do
-          ch.create_call(nil, nil, 'dummy_method', nil, deadline)
+          ch.create_call(nil, nil, 'phony_method', nil, deadline)
         end
       end
       expect(&blk).to raise_error(RuntimeError, 'grpc cannot be used before and after forking')

data/src/ruby/spec/client_auth_spec.rb

@@ -85,7 +85,10 @@ describe 'client-server auth' do
       poll_period: 1
     }
     @srv = new_rpc_server_for_testing(**server_opts)
-    port = @srv.add_http2_port('0.0.0.0:0', create_server_creds)
+    ssl_creds = create_server_creds
+    xds_creds = GRPC::Core::XdsServerCredentials.new(ssl_creds)
+    port = @srv.add_http2_port('0.0.0.0:0', ssl_creds)
+    xds_port = @srv.add_http2_port('0.0.0.0:0', xds_creds)
     @srv.handle(SslTestService)
     @srv_thd = Thread.new { @srv.run }
     @srv.wait_till_running
@@ -98,6 +101,11 @@ describe 'client-server auth' do
     @stub = SslTestServiceStub.new("localhost:#{port}",
                                    create_channel_creds,
                                    **client_opts)
+    # auth should success as the fallback creds wil be used
+    xds_channel_creds = GRPC::Core::XdsChannelCredentials.new(create_channel_creds)
+    @xds_stub = SslTestServiceStub.new("localhost:#{xds_port}",
+                                       xds_channel_creds,
+                                       **client_opts)
   end
 
   after(:all) do
@@ -123,4 +131,22 @@ describe 'client-server auth' do
     responses = @stub.a_bidi_rpc([EchoMsg.new, EchoMsg.new])
     responses.each { |r| GRPC.logger.info(r) }
   end
+
+  it 'xds_client-xds_server ssl fallback auth with unary RPCs' do
+    @xds_stub.an_rpc(EchoMsg.new)
+  end
+
+  it 'xds_client-xds_server ssl fallback auth with client streaming RPCs' do
+    @xds_stub.a_client_streaming_rpc([EchoMsg.new, EchoMsg.new])
+  end
+
+  it 'xds_client-xds_server ssl fallback auth with server streaming RPCs' do
+    responses = @xds_stub.a_server_streaming_rpc(EchoMsg.new)
+    responses.each { |r| GRPC.logger.info(r) }
+  end
+
+  it 'xds_client-xds_server ssl fallback auth with bidi RPCs' do
+    responses = @xds_stub.a_bidi_rpc([EchoMsg.new, EchoMsg.new])
+    responses.each { |r| GRPC.logger.info(r) }
+  end
 end

data/src/ruby/spec/client_server_spec.rb

@@ -311,7 +311,7 @@ shared_examples 'basic GRPC message delivery is OK' do
 
   it 'clients can cancel a call on the server' do
     expected_code = StatusCodes::CANCELLED
-    expected_details = 'Cancelled'
+    expected_details = 'CANCELLED'
     cancel_proc = proc { |call| call.cancel }
     client_cancel_test(cancel_proc, expected_code, expected_details)
   end

data/src/ruby/spec/debug_message_spec.rb

@@ -0,0 +1,134 @@
+# Copyright 2015 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'
+
+TEST_DEBUG_MESSAGE = 'raised by test server'.freeze
+
+# a test service that checks the cert of its peer
+class DebugMessageTestService
+  include GRPC::GenericService
+  rpc :an_rpc_raises_abort, EchoMsg, EchoMsg
+  rpc :an_rpc_raises_standarderror, EchoMsg, EchoMsg
+
+  def an_rpc_raises_abort(_req, _call)
+    fail GRPC::Aborted.new(
+      'aborted',
+      {},
+      TEST_DEBUG_MESSAGE)
+  end
+
+  def an_rpc_raises_standarderror(_req, _call)
+    fail(StandardError, TEST_DEBUG_MESSAGE)
+  end
+end
+
+DebugMessageTestServiceStub = DebugMessageTestService.rpc_stub_class
+
+describe 'surfacing and transmitting of debug messages' do
+  RpcServer = GRPC::RpcServer
+
+  before(:all) do
+    server_opts = {
+      poll_period: 1
+    }
+    @srv = new_rpc_server_for_testing(**server_opts)
+    @port = @srv.add_http2_port('0.0.0.0:0', :this_port_is_insecure)
+    @srv.handle(DebugMessageTestService)
+    @srv_thd = Thread.new { @srv.run }
+    @srv.wait_till_running
+  end
+
+  after(:all) do
+    expect(@srv.stopped?).to be(false)
+    @srv.stop
+    @srv_thd.join
+  end
+
+  it 'debug error message is not present BadStatus exceptions that dont set it' do
+    exception_message = ''
+    begin
+      fail GRPC::Unavailable('unavailable', {})
+    rescue StandardError => e
+      p "Got exception: #{e.message}"
+      exception_message = e.message
+    end
+    expect(exception_message.empty?).to be(false)
+    expect(exception_message.include?('debug_error_string')).to be(false)
+  end
+
+  it 'debug error message is present in locally generated errors' do
+    # Create a secure channel. This is just one way to force a
+    # connection handshake error, which shoud result in C-core
+    # generating a status and error message and surfacing them up.
+    test_root = File.join(File.dirname(__FILE__), 'testdata')
+    files = ['ca.pem', 'client.key', 'client.pem']
+    creds = files.map { |f| File.open(File.join(test_root, f)).read }
+    creds = GRPC::Core::ChannelCredentials.new(creds[0], creds[1], creds[2])
+    stub = DebugMessageTestServiceStub.new(
+      "localhost:#{@port}", creds)
+    begin
+      stub.an_rpc_raises_abort(EchoMsg.new)
+    rescue StandardError => e
+      p "Got exception: #{e.message}"
+      exception_message = e.message
+      # check that the RPC did actually result in a BadStatus exception
+      expect(e.is_a?(GRPC::BadStatus)).to be(true)
+    end
+    # just check that the debug_error_string is non-empty (we know that
+    # it's a JSON object, so the first character is '{').
+    expect(exception_message.include?('. debug_error_string:{')).to be(true)
+  end
+
+  it 'debug message is not transmitted from server to client' do
+    # in order to not accidentally leak internal details about a
+    # server to untrusted clients, avoid including the debug_error_string
+    # field of a BadStatusException raised at a server in the
+    # RPC status that it sends to clients.
+    stub = DebugMessageTestServiceStub.new(
+      "localhost:#{@port}", :this_channel_is_insecure)
+    exception_message = ''
+    begin
+      stub.an_rpc_raises_abort(EchoMsg.new)
+    rescue StandardError => e
+      p "Got exception: #{e.message}"
+      exception_message = e.message
+      # check that the status was aborted is an indirect way to
+      # tell that the RPC did actually get handled by the server
+      expect(e.is_a?(GRPC::Aborted)).to be(true)
+    end
+    # just assert that the contents of the server-side BadStatus
+    # debug_error_string field were *not* propagated to the client.
+    expect(exception_message.include?('. debug_error_string:{')).to be(true)
+    expect(exception_message.include?(TEST_DEBUG_MESSAGE)).to be(false)
+  end
+
+  it 'standard_error messages are transmitted from server to client' do
+    # this test exists mostly in order to understand the test case
+    # above, by comparison.
+    stub = DebugMessageTestServiceStub.new(
+      "localhost:#{@port}", :this_channel_is_insecure)
+    exception_message = ''
+    begin
+      stub.an_rpc_raises_standarderror(EchoMsg.new)
+    rescue StandardError => e
+      p "Got exception: #{e.message}"
+      exception_message = e.message
+      expect(e.is_a?(GRPC::BadStatus)).to be(true)
+    end
+    # assert that the contents of the StandardError exception message
+    # are propagated to the client.
+    expect(exception_message.include?(TEST_DEBUG_MESSAGE)).to be(true)
+  end
+end

data/src/ruby/spec/errors_spec.rb

@@ -131,7 +131,7 @@ describe GRPC::BadStatus do
 
       error_msg = 'parse error: to_rpc_status failed'
       error_desc = '<Google::Protobuf::ParseError> ' \
-        'Error occurred during parsing: Invalid wire type'
+        'Error occurred during parsing'
 
       # Check that the parse error was logged correctly
       log_contents = @log_output.read

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

@@ -43,6 +43,16 @@ describe GRPC::ActiveCall do
     @server = new_core_server_for_testing(nil)
     server_port = @server.add_http2_port(host, :this_port_is_insecure)
     @server.start
+    @received_rpcs_queue = Queue.new
+    @server_thread = Thread.new do
+      begin
+        received_rpc = @server.request_call
+      rescue GRPC::Core::CallError, StandardError => e
+        # enqueue the exception in this case as a way to indicate the error
+        received_rpc = e
+      end
+      @received_rpcs_queue.push(received_rpc)
+    end
     @ch = GRPC::Core::Channel.new("0.0.0.0:#{server_port}", nil,
                                   :this_channel_is_insecure)
   end
@@ -50,6 +60,7 @@ describe GRPC::ActiveCall do
   after(:each) do
     @server.shutdown_and_notify(deadline)
     @server.close
+    @server_thread.join
   end
 
   describe 'restricted view methods' do
@@ -105,7 +116,7 @@ describe GRPC::ActiveCall do
       client_call.remote_send(msg)
 
       # check that server rpc new was received
-      recvd_rpc = @server.request_call
+      recvd_rpc = @received_rpcs_queue.pop
       expect(recvd_rpc).to_not eq nil
       recvd_call = recvd_rpc.call
 
@@ -130,7 +141,7 @@ describe GRPC::ActiveCall do
       client_call.remote_send(msg)
 
       # confirm that the message was marshalled
-      recvd_rpc =  @server.request_call
+      recvd_rpc =  @received_rpcs_queue.pop
       recvd_call = recvd_rpc.call
       server_ops = {
         CallOps::SEND_INITIAL_METADATA => nil
@@ -160,7 +171,7 @@ describe GRPC::ActiveCall do
         call.run_batch(CallOps::SEND_CLOSE_FROM_CLIENT => nil) if f == 1
 
         # confirm that the message was marshalled
-        recvd_rpc =  @server.request_call
+        recvd_rpc =  @received_rpcs_queue.pop
         recvd_call = recvd_rpc.call
         server_ops = {
           CallOps::SEND_INITIAL_METADATA => nil
@@ -187,11 +198,11 @@ describe GRPC::ActiveCall do
         deadline,
         started: false)
 
-      metadata = { key: 'dummy_val', other: 'other_val' }
+      metadata = { key: 'phony_val', other: 'other_val' }
       expect(@client_call.metadata_sent).to eq(false)
       @client_call.merge_metadata_to_send(metadata)
 
-      message = 'dummy message'
+      message = 'phony message'
 
       expect(call).to(
         receive(:run_batch)
@@ -321,7 +332,7 @@ describe GRPC::ActiveCall do
       call = make_test_call
       metadata = { k1: 'v1', k2: 'v2' }
       ActiveCall.client_invoke(call, metadata)
-      recvd_rpc =  @server.request_call
+      recvd_rpc =  @received_rpcs_queue.pop
       recvd_call = recvd_rpc.call
       expect(recvd_call).to_not be_nil
       expect(recvd_rpc.metadata).to_not be_nil
@@ -339,7 +350,7 @@ describe GRPC::ActiveCall do
       call = make_test_call
       ActiveCall.client_invoke(call)
 
-      recvd_rpc = @server.request_call
+      recvd_rpc = @received_rpcs_queue.pop
       server_call = ActiveCall.new(
         recvd_rpc.call,
         @pass_through,
@@ -405,7 +416,7 @@ describe GRPC::ActiveCall do
       client_call = make_test_call
       ActiveCall.client_invoke(client_call)
 
-      recvd_rpc = @server.request_call
+      recvd_rpc = @received_rpcs_queue.pop
       recvd_call = recvd_rpc.call
 
       server_call = ActiveCall.new(
@@ -575,7 +586,7 @@ describe GRPC::ActiveCall do
       @client_call = make_test_call
       @client_call.run_batch(CallOps::SEND_INITIAL_METADATA => {})
 
-      recvd_rpc = @server.request_call
+      recvd_rpc = @received_rpcs_queue.pop
       recvd_call = recvd_rpc.call
       @server_call = ActiveCall.new(
         recvd_call,
@@ -654,7 +665,7 @@ describe GRPC::ActiveCall do
   end
 
   def expect_server_to_be_invoked(**kw)
-    recvd_rpc =  @server.request_call
+    recvd_rpc =  @received_rpcs_queue.pop
     expect(recvd_rpc).to_not eq nil
     recvd_call = recvd_rpc.call
     recvd_call.run_batch(CallOps::SEND_INITIAL_METADATA => kw)

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

@@ -304,7 +304,7 @@ describe 'ClientStub' do  # rubocop:disable Metrics/BlockLength
 
     describe 'via a call operation' do
       after(:each) do
-        # make sure op.wait doesn't hang, even if there's a bad status
+        # make sure op.wait doesn't freeze, even if there's a bad status
         @op.wait
       end
       def get_response(stub, run_start_call_first: false, credentials: nil)
@@ -406,7 +406,7 @@ describe 'ClientStub' do  # rubocop:disable Metrics/BlockLength
 
     describe 'via a call operation' do
       after(:each) do
-        # make sure op.wait doesn't hang, even if there's a bad status
+        # make sure op.wait doesn't freeze, even if there's a bad status
         @op.wait
       end
       def get_response(stub, run_start_call_first: false)
@@ -547,7 +547,7 @@ describe 'ClientStub' do  # rubocop:disable Metrics/BlockLength
 
     describe 'via a call operation' do
       after(:each) do
-        @op.wait # make sure wait doesn't hang
+        @op.wait # make sure wait doesn't freeze
       end
       def get_responses(stub, run_start_call_first: false, unmarshal: noop)
         @op = stub.server_streamer(@method, @sent_msg, noop, unmarshal,
@@ -865,7 +865,7 @@ describe 'ClientStub' do  # rubocop:disable Metrics/BlockLength
 
     describe 'via a call operation' do
       after(:each) do
-        @op.wait # make sure wait doesn't hang
+        @op.wait # make sure wait doesn't freeze
       end
       def get_responses(stub, run_start_call_first: false, deadline: nil,
                         marshal_proc: noop)

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

@@ -104,7 +104,7 @@ end
 
 SynchronizedCancellationStub = SynchronizedCancellationService.rpc_stub_class
 
-# a test service that hangs onto call objects
+# a test service that holds onto call objects
 # and uses them after the server-side call has been
 # finished
 class CheckCallAfterFinishedService

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

@@ -55,6 +55,8 @@ describe GenericService do
       expect(GenericService.underscore('AMethod')).to eq('a_method')
       expect(GenericService.underscore('PrintHTML')).to eq('print_html')
       expect(GenericService.underscore('SeeHTMLBooks')).to eq('see_html_books')
+
+      expect(GenericService.underscore('SeeHTMLBooks'.freeze)).to eq('see_html_books')
     end
   end
 

data/src/ruby/spec/pb/codegen/grpc/testing/package_options_import2.proto

@@ -0,0 +1,23 @@
+// Copyright 2020 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.
+
+syntax = "proto3";
+
+package grpc.foo;
+
+option ruby_package = "B::Other";
+
+message Foo {
+  message Bar { }
+}

data/src/ruby/spec/pb/codegen/grpc/testing/package_options_ruby_style.proto

@@ -17,6 +17,7 @@ syntax = "proto3";
 package grpc.testing;
 
 import "grpc/testing/package_options_import.proto";
+import "grpc/testing/package_options_import2.proto";
 
 // For sanity checking package definitions
 option ruby_package = "RPC::Test::New::Package::Options";
@@ -27,8 +28,14 @@ message AnotherTestResponse { }
 
 message Foo { }
 
+message Bar {
+  message Baz { }
+}
+
 service AnotherTestService {
   rpc GetTest(AnotherTestRequest) returns (AnotherTestResponse) { }
   rpc OtherTest(Thing) returns (Thing) { }
+  rpc PackageTest(grpc.testing.Thing) returns (grpc.foo.Foo.Bar) { }
   rpc FooTest(Foo) returns (Foo) { }
+  rpc NestedMessageTest(Foo) returns (Bar.Baz) { }
 }