grpc 0.13.0.pre1.1-x64-mingw32

data/src/ruby/spec/completion_queue_spec.rb

@@ -0,0 +1,42 @@
+# Copyright 2015, 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 'grpc'
+
+describe GRPC::Core::CompletionQueue do
+  before(:example) do
+    @cq = GRPC::Core::CompletionQueue.new
+  end
+
+  describe '#new' do
+    it 'is constructed successufully' do
+      expect { GRPC::Core::CompletionQueue.new }.not_to raise_error
+    end
+  end
+end

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

@@ -0,0 +1,373 @@
+# Copyright 2015, 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 'grpc'
+
+include GRPC::Core::StatusCodes
+
+describe GRPC::ActiveCall do
+  ActiveCall = GRPC::ActiveCall
+  Call = GRPC::Core::Call
+  CallOps = GRPC::Core::CallOps
+  WriteFlags = GRPC::Core::WriteFlags
+
+  before(:each) do
+    @pass_through = proc { |x| x }
+    @server_tag = Object.new
+    @tag = Object.new
+
+    @client_queue = GRPC::Core::CompletionQueue.new
+    @server_queue = GRPC::Core::CompletionQueue.new
+    host = '0.0.0.0:0'
+    @server = GRPC::Core::Server.new(@server_queue, nil)
+    server_port = @server.add_http2_port(host, :this_port_is_insecure)
+    @server.start
+    @ch = GRPC::Core::Channel.new("0.0.0.0:#{server_port}", nil,
+                                  :this_channel_is_insecure)
+  end
+
+  after(:each) do
+    @server.close(@server_queue, deadline)
+  end
+
+  describe 'restricted view methods' do
+    before(:each) do
+      call = make_test_call
+      md_tag = ActiveCall.client_invoke(call, @client_queue)
+      @client_call = ActiveCall.new(call, @client_queue, @pass_through,
+                                    @pass_through, deadline,
+                                    metadata_tag: md_tag)
+    end
+
+    describe '#multi_req_view' do
+      it 'exposes a fixed subset of the ActiveCall methods' do
+        want = %w(cancelled, deadline, each_remote_read, metadata, shutdown)
+        v = @client_call.multi_req_view
+        want.each do |w|
+          expect(v.methods.include?(w))
+        end
+      end
+    end
+
+    describe '#single_req_view' do
+      it 'exposes a fixed subset of the ActiveCall methods' do
+        want = %w(cancelled, deadline, metadata, shutdown)
+        v = @client_call.single_req_view
+        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
+      call = make_test_call
+      md_tag = ActiveCall.client_invoke(call, @client_queue)
+      @client_call = ActiveCall.new(call, @client_queue, @pass_through,
+                                    @pass_through, deadline,
+                                    metadata_tag: md_tag)
+      msg = 'message is a string'
+      @client_call.remote_send(msg)
+
+      # check that server rpc new was received
+      recvd_rpc = @server.request_call(@server_queue, @server_tag, deadline)
+      expect(recvd_rpc).to_not eq nil
+      recvd_call = recvd_rpc.call
+
+      # Accept the call, and verify that the server reads the response ok.
+      server_ops = {
+        CallOps::SEND_INITIAL_METADATA => {}
+      }
+      recvd_call.run_batch(@server_queue, @server_tag, deadline, server_ops)
+      server_call = ActiveCall.new(recvd_call, @server_queue, @pass_through,
+                                   @pass_through, deadline)
+      expect(server_call.remote_read).to eq(msg)
+    end
+
+    it 'marshals the payload using the marshal func' do
+      call = make_test_call
+      ActiveCall.client_invoke(call, @client_queue)
+      marshal = proc { |x| 'marshalled:' + x }
+      client_call = ActiveCall.new(call, @client_queue, marshal,
+                                   @pass_through, deadline)
+      msg = 'message is a string'
+      client_call.remote_send(msg)
+
+      # confirm that the message was marshalled
+      recvd_rpc =  @server.request_call(@server_queue, @server_tag, deadline)
+      recvd_call = recvd_rpc.call
+      server_ops = {
+        CallOps::SEND_INITIAL_METADATA => nil
+      }
+      recvd_call.run_batch(@server_queue, @server_tag, deadline, server_ops)
+      server_call = ActiveCall.new(recvd_call, @server_queue, @pass_through,
+                                   @pass_through, deadline)
+      expect(server_call.remote_read).to eq('marshalled:' + msg)
+    end
+
+    TEST_WRITE_FLAGS = [WriteFlags::BUFFER_HINT, WriteFlags::NO_COMPRESS]
+    TEST_WRITE_FLAGS.each do |f|
+      it "successfully makes calls with write_flag set to #{f}" do
+        call = make_test_call
+        ActiveCall.client_invoke(call, @client_queue)
+        marshal = proc { |x| 'marshalled:' + x }
+        client_call = ActiveCall.new(call, @client_queue, marshal,
+                                     @pass_through, deadline)
+        msg = 'message is a string'
+        client_call.write_flag = f
+        client_call.remote_send(msg)
+
+        # confirm that the message was marshalled
+        recvd_rpc =  @server.request_call(@server_queue, @server_tag, deadline)
+        recvd_call = recvd_rpc.call
+        server_ops = {
+          CallOps::SEND_INITIAL_METADATA => nil
+        }
+        recvd_call.run_batch(@server_queue, @server_tag, deadline, server_ops)
+        server_call = ActiveCall.new(recvd_call, @server_queue, @pass_through,
+                                     @pass_through, deadline)
+        expect(server_call.remote_read).to eq('marshalled:' + msg)
+      end
+    end
+  end
+
+  describe '#client_invoke' do
+    it 'sends keywords as metadata to the server when the are present' do
+      call = make_test_call
+      ActiveCall.client_invoke(call, @client_queue, k1: 'v1', k2: 'v2')
+      recvd_rpc =  @server.request_call(@server_queue, @server_tag, deadline)
+      recvd_call = recvd_rpc.call
+      expect(recvd_call).to_not be_nil
+      expect(recvd_rpc.metadata).to_not be_nil
+      expect(recvd_rpc.metadata['k1']).to eq('v1')
+      expect(recvd_rpc.metadata['k2']).to eq('v2')
+    end
+  end
+
+  describe '#remote_read' do
+    it 'reads the response sent by a server' do
+      call = make_test_call
+      md_tag = ActiveCall.client_invoke(call, @client_queue)
+      client_call = ActiveCall.new(call, @client_queue, @pass_through,
+                                   @pass_through, deadline,
+                                   metadata_tag: md_tag)
+      msg = 'message is a string'
+      client_call.remote_send(msg)
+      server_call = expect_server_to_receive(msg)
+      server_call.remote_send('server_response')
+      expect(client_call.remote_read).to eq('server_response')
+    end
+
+    it 'saves no metadata when the server adds no metadata' do
+      call = make_test_call
+      md_tag = ActiveCall.client_invoke(call, @client_queue)
+      client_call = ActiveCall.new(call, @client_queue, @pass_through,
+                                   @pass_through, deadline,
+                                   metadata_tag: md_tag)
+      msg = 'message is a string'
+      client_call.remote_send(msg)
+      server_call = expect_server_to_receive(msg)
+      server_call.remote_send('ignore me')
+      expect(client_call.metadata).to be_nil
+      client_call.remote_read
+      expect(client_call.metadata).to eq({})
+    end
+
+    it 'saves metadata add by the server' do
+      call = make_test_call
+      md_tag = ActiveCall.client_invoke(call, @client_queue)
+      client_call = ActiveCall.new(call, @client_queue, @pass_through,
+                                   @pass_through, deadline,
+                                   metadata_tag: md_tag)
+      msg = 'message is a string'
+      client_call.remote_send(msg)
+      server_call = expect_server_to_receive(msg, k1: 'v1', k2: 'v2')
+      server_call.remote_send('ignore me')
+      expect(client_call.metadata).to be_nil
+      client_call.remote_read
+      expected = { 'k1' => 'v1', 'k2' => 'v2' }
+      expect(client_call.metadata).to eq(expected)
+    end
+
+    it 'get a nil msg before a status when an OK status is sent' do
+      call = make_test_call
+      md_tag = ActiveCall.client_invoke(call, @client_queue)
+      client_call = ActiveCall.new(call, @client_queue, @pass_through,
+                                   @pass_through, deadline,
+                                   metadata_tag: md_tag)
+      msg = 'message is a string'
+      client_call.remote_send(msg)
+      client_call.writes_done(false)
+      server_call = expect_server_to_receive(msg)
+      server_call.remote_send('server_response')
+      server_call.send_status(OK, 'OK')
+      expect(client_call.remote_read).to eq('server_response')
+      res = client_call.remote_read
+      expect(res).to be_nil
+    end
+
+    it 'unmarshals the response using the unmarshal func' do
+      call = make_test_call
+      md_tag = ActiveCall.client_invoke(call, @client_queue)
+      unmarshal = proc { |x| 'unmarshalled:' + x }
+      client_call = ActiveCall.new(call, @client_queue, @pass_through,
+                                   unmarshal, deadline,
+                                   metadata_tag: md_tag)
+
+      # confirm the client receives the unmarshalled message
+      msg = 'message is a string'
+      client_call.remote_send(msg)
+      server_call = expect_server_to_receive(msg)
+      server_call.remote_send('server_response')
+      expect(client_call.remote_read).to eq('unmarshalled:server_response')
+    end
+  end
+
+  describe '#each_remote_read' do
+    it 'creates an Enumerator' do
+      call = make_test_call
+      client_call = ActiveCall.new(call, @client_queue, @pass_through,
+                                   @pass_through, deadline)
+      expect(client_call.each_remote_read).to be_a(Enumerator)
+    end
+
+    it 'the returns an enumerator that can read n responses' do
+      call = make_test_call
+      md_tag = ActiveCall.client_invoke(call, @client_queue)
+      client_call = ActiveCall.new(call, @client_queue, @pass_through,
+                                   @pass_through, deadline,
+                                   metadata_tag: md_tag)
+      msg = 'message is a string'
+      reply = 'server_response'
+      client_call.remote_send(msg)
+      server_call = expect_server_to_receive(msg)
+      e = client_call.each_remote_read
+      n = 3  # arbitrary value > 1
+      n.times do
+        server_call.remote_send(reply)
+        expect(e.next).to eq(reply)
+      end
+    end
+
+    it 'the returns an enumerator that stops after an OK Status' do
+      call = make_test_call
+      md_tag = ActiveCall.client_invoke(call, @client_queue)
+      client_call = ActiveCall.new(call, @client_queue, @pass_through,
+                                   @pass_through, deadline,
+                                   metadata_tag: md_tag)
+      msg = 'message is a string'
+      reply = 'server_response'
+      client_call.remote_send(msg)
+      client_call.writes_done(false)
+      server_call = expect_server_to_receive(msg)
+      e = client_call.each_remote_read
+      n = 3 # arbitrary value > 1
+      n.times do
+        server_call.remote_send(reply)
+        expect(e.next).to eq(reply)
+      end
+      server_call.send_status(OK, 'OK')
+      expect { e.next }.to raise_error(StopIteration)
+    end
+  end
+
+  describe '#writes_done' do
+    it 'finishes ok if the server sends a status response' do
+      call = make_test_call
+      md_tag = ActiveCall.client_invoke(call, @client_queue)
+      client_call = ActiveCall.new(call, @client_queue, @pass_through,
+                                   @pass_through, deadline,
+                                   metadata_tag: md_tag)
+      msg = 'message is a string'
+      client_call.remote_send(msg)
+      expect { client_call.writes_done(false) }.to_not raise_error
+      server_call = expect_server_to_receive(msg)
+      server_call.remote_send('server_response')
+      expect(client_call.remote_read).to eq('server_response')
+      server_call.send_status(OK, 'status code is OK')
+      expect { client_call.finished }.to_not raise_error
+    end
+
+    it 'finishes ok if the server sends an early status response' do
+      call = make_test_call
+      md_tag = ActiveCall.client_invoke(call, @client_queue)
+      client_call = ActiveCall.new(call, @client_queue, @pass_through,
+                                   @pass_through, deadline,
+                                   metadata_tag: md_tag)
+      msg = 'message is a string'
+      client_call.remote_send(msg)
+      server_call = expect_server_to_receive(msg)
+      server_call.remote_send('server_response')
+      server_call.send_status(OK, 'status code is OK')
+      expect(client_call.remote_read).to eq('server_response')
+      expect { client_call.writes_done(false) }.to_not raise_error
+      expect { client_call.finished }.to_not raise_error
+    end
+
+    it 'finishes ok if writes_done is true' do
+      call = make_test_call
+      md_tag = ActiveCall.client_invoke(call, @client_queue)
+      client_call = ActiveCall.new(call, @client_queue, @pass_through,
+                                   @pass_through, deadline,
+                                   metadata_tag: md_tag)
+      msg = 'message is a string'
+      client_call.remote_send(msg)
+      server_call = expect_server_to_receive(msg)
+      server_call.remote_send('server_response')
+      server_call.send_status(OK, 'status code is OK')
+      expect(client_call.remote_read).to eq('server_response')
+      expect { client_call.writes_done(true) }.to_not raise_error
+    end
+  end
+
+  def expect_server_to_receive(sent_text, **kw)
+    c = expect_server_to_be_invoked(**kw)
+    expect(c.remote_read).to eq(sent_text)
+    c
+  end
+
+  def expect_server_to_be_invoked(**kw)
+    recvd_rpc =  @server.request_call(@server_queue, @server_tag, deadline)
+    expect(recvd_rpc).to_not eq nil
+    recvd_call = recvd_rpc.call
+    recvd_call.run_batch(@server_queue, @server_tag, deadline,
+                         CallOps::SEND_INITIAL_METADATA => kw)
+    ActiveCall.new(recvd_call, @server_queue, @pass_through,
+                   @pass_through, deadline)
+  end
+
+  def make_test_call
+    @ch.create_call(@client_queue, nil, nil, '/method', nil, deadline)
+  end
+
+  def deadline
+    Time.now + 2  # in 2 seconds; arbitrary
+  end
+end

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

@@ -0,0 +1,476 @@
+# Copyright 2015, 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 'grpc'
+
+def wakey_thread(&blk)
+  n = GRPC::Notifier.new
+  t = Thread.new do
+    blk.call(n)
+  end
+  n.wait
+  t
+end
+
+def load_test_certs
+  test_root = File.join(File.dirname(File.dirname(__FILE__)), 'testdata')
+  files = ['ca.pem', 'server1.key', 'server1.pem']
+  files.map { |f| File.open(File.join(test_root, f)).read }
+end
+
+include GRPC::Core::StatusCodes
+include GRPC::Core::TimeConsts
+include GRPC::Core::CallOps
+
+describe 'ClientStub' do
+  let(:noop) { proc { |x| x } }
+
+  before(:each) do
+    Thread.abort_on_exception = true
+    @server = nil
+    @server_queue = nil
+    @method = 'an_rpc_method'
+    @pass = OK
+    @fail = INTERNAL
+    @cq = GRPC::Core::CompletionQueue.new
+  end
+
+  after(:each) do
+    @server.close(@server_queue) unless @server_queue.nil?
+  end
+
+  describe '#new' do
+    let(:fake_host) { 'localhost:0' }
+    it 'can be created from a host and args' do
+      opts = { a_channel_arg: 'an_arg' }
+      blk = proc do
+        GRPC::ClientStub.new(fake_host, @cq, :this_channel_is_insecure, **opts)
+      end
+      expect(&blk).not_to raise_error
+    end
+
+    it 'can be created with a default deadline' do
+      opts = { a_channel_arg: 'an_arg', deadline: 5 }
+      blk = proc do
+        GRPC::ClientStub.new(fake_host, @cq, :this_channel_is_insecure, **opts)
+      end
+      expect(&blk).not_to raise_error
+    end
+
+    it 'can be created with an channel override' do
+      opts = { a_channel_arg: 'an_arg', channel_override: @ch }
+      blk = proc do
+        GRPC::ClientStub.new(fake_host, @cq, :this_channel_is_insecure, **opts)
+      end
+      expect(&blk).not_to raise_error
+    end
+
+    it 'cannot be created with a bad channel override' do
+      blk = proc do
+        opts = { a_channel_arg: 'an_arg', channel_override: Object.new }
+        GRPC::ClientStub.new(fake_host, @cq, :this_channel_is_insecure, **opts)
+      end
+      expect(&blk).to raise_error
+    end
+
+    it 'cannot be created with bad credentials' do
+      blk = proc do
+        opts = { a_channel_arg: 'an_arg' }
+        GRPC::ClientStub.new(fake_host, @cq, Object.new, **opts)
+      end
+      expect(&blk).to raise_error
+    end
+
+    it 'can be created with test test credentials' do
+      certs = load_test_certs
+      blk = proc do
+        opts = {
+          GRPC::Core::Channel::SSL_TARGET => 'foo.test.google.fr',
+          a_channel_arg: 'an_arg'
+        }
+        creds = GRPC::Core::ChannelCredentials.new(certs[0], nil, nil)
+        GRPC::ClientStub.new(fake_host, @cq, creds,  **opts)
+      end
+      expect(&blk).to_not raise_error
+    end
+  end
+
+  describe '#request_response' do
+    before(:each) do
+      @sent_msg, @resp = 'a_msg', 'a_reply'
+    end
+
+    shared_examples 'request response' do
+      it 'should send a request to/receive a reply from a server' do
+        server_port = create_test_server
+        th = run_request_response(@sent_msg, @resp, @pass)
+        stub = GRPC::ClientStub.new("localhost:#{server_port}", @cq,
+                                    :this_channel_is_insecure)
+        expect(get_response(stub)).to eq(@resp)
+        th.join
+      end
+
+      it 'should send metadata to the server ok' do
+        server_port = create_test_server
+        host = "localhost:#{server_port}"
+        th = run_request_response(@sent_msg, @resp, @pass,
+                                  k1: 'v1', k2: 'v2')
+        stub = GRPC::ClientStub.new(host, @cq, :this_channel_is_insecure)
+        expect(get_response(stub)).to eq(@resp)
+        th.join
+      end
+
+      it 'should send a request when configured using an override channel' do
+        server_port = create_test_server
+        alt_host = "localhost:#{server_port}"
+        th = run_request_response(@sent_msg, @resp, @pass)
+        ch = GRPC::Core::Channel.new(alt_host, nil, :this_channel_is_insecure)
+        stub = GRPC::ClientStub.new('ignored-host', @cq,
+                                    :this_channel_is_insecure,
+                                    channel_override: ch)
+        expect(get_response(stub)).to eq(@resp)
+        th.join
+      end
+
+      it 'should raise an error if the status is not OK' do
+        server_port = create_test_server
+        host = "localhost:#{server_port}"
+        th = run_request_response(@sent_msg, @resp, @fail)
+        stub = GRPC::ClientStub.new(host, @cq, :this_channel_is_insecure)
+        blk = proc { get_response(stub) }
+        expect(&blk).to raise_error(GRPC::BadStatus)
+        th.join
+      end
+    end
+
+    describe 'without a call operation' do
+      def get_response(stub)
+        stub.request_response(@method, @sent_msg, noop, noop,
+                              k1: 'v1', k2: 'v2')
+      end
+
+      it_behaves_like 'request response'
+    end
+
+    describe 'via a call operation' do
+      def get_response(stub)
+        op = stub.request_response(@method, @sent_msg, noop, noop,
+                                   return_op: true, k1: 'v1', k2: 'v2')
+        expect(op).to be_a(GRPC::ActiveCall::Operation)
+        op.execute
+      end
+
+      it_behaves_like 'request response'
+    end
+  end
+
+  describe '#client_streamer' do
+    shared_examples 'client streaming' do
+      before(:each) do
+        @sent_msgs = Array.new(3) { |i| 'msg_' + (i + 1).to_s }
+        @resp = 'a_reply'
+      end
+
+      it 'should send requests to/receive a reply from a server' do
+        server_port = create_test_server
+        host = "localhost:#{server_port}"
+        th = run_client_streamer(@sent_msgs, @resp, @pass)
+        stub = GRPC::ClientStub.new(host, @cq, :this_channel_is_insecure)
+        expect(get_response(stub)).to eq(@resp)
+        th.join
+      end
+
+      it 'should send metadata to the server ok' do
+        server_port = create_test_server
+        host = "localhost:#{server_port}"
+        th = run_client_streamer(@sent_msgs, @resp, @pass,
+                                 k1: 'v1', k2: 'v2')
+        stub = GRPC::ClientStub.new(host, @cq, :this_channel_is_insecure)
+        expect(get_response(stub)).to eq(@resp)
+        th.join
+      end
+
+      it 'should raise an error if the status is not ok' do
+        server_port = create_test_server
+        host = "localhost:#{server_port}"
+        th = run_client_streamer(@sent_msgs, @resp, @fail)
+        stub = GRPC::ClientStub.new(host, @cq, :this_channel_is_insecure)
+        blk = proc { get_response(stub) }
+        expect(&blk).to raise_error(GRPC::BadStatus)
+        th.join
+      end
+    end
+
+    describe 'without a call operation' do
+      def get_response(stub)
+        stub.client_streamer(@method, @sent_msgs, noop, noop,
+                             k1: 'v1', k2: 'v2')
+      end
+
+      it_behaves_like 'client streaming'
+    end
+
+    describe 'via a call operation' do
+      def get_response(stub)
+        op = stub.client_streamer(@method, @sent_msgs, noop, noop,
+                                  return_op: true, k1: 'v1', k2: 'v2')
+        expect(op).to be_a(GRPC::ActiveCall::Operation)
+        op.execute
+      end
+
+      it_behaves_like 'client streaming'
+    end
+  end
+
+  describe '#server_streamer' do
+    shared_examples 'server streaming' do
+      before(:each) do
+        @sent_msg = 'a_msg'
+        @replys = Array.new(3) { |i| 'reply_' + (i + 1).to_s }
+      end
+
+      it 'should send a request to/receive replies from a server' do
+        server_port = create_test_server
+        host = "localhost:#{server_port}"
+        th = run_server_streamer(@sent_msg, @replys, @pass)
+        stub = GRPC::ClientStub.new(host, @cq, :this_channel_is_insecure)
+        expect(get_responses(stub).collect { |r| r }).to eq(@replys)
+        th.join
+      end
+
+      it 'should raise an error if the status is not ok' do
+        server_port = create_test_server
+        host = "localhost:#{server_port}"
+        th = run_server_streamer(@sent_msg, @replys, @fail)
+        stub = GRPC::ClientStub.new(host, @cq, :this_channel_is_insecure)
+        e = get_responses(stub)
+        expect { e.collect { |r| r } }.to raise_error(GRPC::BadStatus)
+        th.join
+      end
+
+      it 'should send metadata to the server ok' do
+        server_port = create_test_server
+        host = "localhost:#{server_port}"
+        th = run_server_streamer(@sent_msg, @replys, @fail,
+                                 k1: 'v1', k2: 'v2')
+        stub = GRPC::ClientStub.new(host, @cq, :this_channel_is_insecure)
+        e = get_responses(stub)
+        expect { e.collect { |r| r } }.to raise_error(GRPC::BadStatus)
+        th.join
+      end
+    end
+
+    describe 'without a call operation' do
+      def get_responses(stub)
+        e = stub.server_streamer(@method, @sent_msg, noop, noop,
+                                 k1: 'v1', k2: 'v2')
+        expect(e).to be_a(Enumerator)
+        e
+      end
+
+      it_behaves_like 'server streaming'
+    end
+
+    describe 'via a call operation' do
+      def get_responses(stub)
+        op = stub.server_streamer(@method, @sent_msg, noop, noop,
+                                  return_op: true, k1: 'v1', k2: 'v2')
+        expect(op).to be_a(GRPC::ActiveCall::Operation)
+        e = op.execute
+        expect(e).to be_a(Enumerator)
+        e
+      end
+
+      it_behaves_like 'server streaming'
+    end
+  end
+
+  describe '#bidi_streamer' do
+    shared_examples 'bidi streaming' do
+      before(:each) do
+        @sent_msgs = Array.new(3) { |i| 'msg_' + (i + 1).to_s }
+        @replys = Array.new(3) { |i| 'reply_' + (i + 1).to_s }
+        server_port = create_test_server
+        @host = "localhost:#{server_port}"
+      end
+
+      it 'supports sending all the requests first', bidi: true do
+        th = run_bidi_streamer_handle_inputs_first(@sent_msgs, @replys,
+                                                   @pass)
+        stub = GRPC::ClientStub.new(@host, @cq, :this_channel_is_insecure)
+        e = get_responses(stub)
+        expect(e.collect { |r| r }).to eq(@replys)
+        th.join
+      end
+
+      it 'supports client-initiated ping pong', bidi: true do
+        th = run_bidi_streamer_echo_ping_pong(@sent_msgs, @pass, true)
+        stub = GRPC::ClientStub.new(@host, @cq, :this_channel_is_insecure)
+        e = get_responses(stub)
+        expect(e.collect { |r| r }).to eq(@sent_msgs)
+        th.join
+      end
+
+      it 'supports a server-initiated ping pong', bidi: true do
+        th = run_bidi_streamer_echo_ping_pong(@sent_msgs, @pass, false)
+        stub = GRPC::ClientStub.new(@host, @cq, :this_channel_is_insecure)
+        e = get_responses(stub)
+        expect(e.collect { |r| r }).to eq(@sent_msgs)
+        th.join
+      end
+    end
+
+    describe 'without a call operation' do
+      def get_responses(stub)
+        e = stub.bidi_streamer(@method, @sent_msgs, noop, noop)
+        expect(e).to be_a(Enumerator)
+        e
+      end
+
+      it_behaves_like 'bidi streaming'
+    end
+
+    describe 'via a call operation' do
+      def get_responses(stub)
+        op = stub.bidi_streamer(@method, @sent_msgs, noop, noop,
+                                return_op: true)
+        expect(op).to be_a(GRPC::ActiveCall::Operation)
+        e = op.execute
+        expect(e).to be_a(Enumerator)
+        e
+      end
+
+      it_behaves_like 'bidi streaming'
+    end
+
+    describe 'without enough time to run' do
+      before(:each) do
+        @sent_msgs = Array.new(3) { |i| 'msg_' + (i + 1).to_s }
+        @replys = Array.new(3) { |i| 'reply_' + (i + 1).to_s }
+        server_port = create_test_server
+        @host = "localhost:#{server_port}"
+      end
+
+      it 'should fail with DeadlineExceeded', bidi: true do
+        @server.start
+        stub = GRPC::ClientStub.new(@host, @cq, :this_channel_is_insecure)
+        blk = proc do
+          e = stub.bidi_streamer(@method, @sent_msgs, noop, noop,
+                                 timeout: 0.001)
+          e.collect { |r| r }
+        end
+        expect(&blk).to raise_error GRPC::BadStatus, /Deadline Exceeded/
+      end
+    end
+  end
+
+  def run_server_streamer(expected_input, replys, status, **kw)
+    wanted_metadata = kw.clone
+    wakey_thread do |notifier|
+      c = expect_server_to_be_invoked(notifier)
+      wanted_metadata.each do |k, v|
+        expect(c.metadata[k.to_s]).to eq(v)
+      end
+      expect(c.remote_read).to eq(expected_input)
+      replys.each { |r| c.remote_send(r) }
+      c.send_status(status, status == @pass ? 'OK' : 'NOK', true)
+    end
+  end
+
+  def run_bidi_streamer_handle_inputs_first(expected_inputs, replys,
+                                            status)
+    wakey_thread do |notifier|
+      c = expect_server_to_be_invoked(notifier)
+      expected_inputs.each { |i| expect(c.remote_read).to eq(i) }
+      replys.each { |r| c.remote_send(r) }
+      c.send_status(status, status == @pass ? 'OK' : 'NOK', true)
+    end
+  end
+
+  def run_bidi_streamer_echo_ping_pong(expected_inputs, status, client_starts)
+    wakey_thread do |notifier|
+      c = expect_server_to_be_invoked(notifier)
+      expected_inputs.each do |i|
+        if client_starts
+          expect(c.remote_read).to eq(i)
+          c.remote_send(i)
+        else
+          c.remote_send(i)
+          expect(c.remote_read).to eq(i)
+        end
+      end
+      c.send_status(status, status == @pass ? 'OK' : 'NOK', true)
+    end
+  end
+
+  def run_client_streamer(expected_inputs, resp, status, **kw)
+    wanted_metadata = kw.clone
+    wakey_thread do |notifier|
+      c = expect_server_to_be_invoked(notifier)
+      expected_inputs.each { |i| expect(c.remote_read).to eq(i) }
+      wanted_metadata.each do |k, v|
+        expect(c.metadata[k.to_s]).to eq(v)
+      end
+      c.remote_send(resp)
+      c.send_status(status, status == @pass ? 'OK' : 'NOK', true)
+    end
+  end
+
+  def run_request_response(expected_input, resp, status, **kw)
+    wanted_metadata = kw.clone
+    wakey_thread do |notifier|
+      c = expect_server_to_be_invoked(notifier)
+      expect(c.remote_read).to eq(expected_input)
+      wanted_metadata.each do |k, v|
+        expect(c.metadata[k.to_s]).to eq(v)
+      end
+      c.remote_send(resp)
+      c.send_status(status, status == @pass ? 'OK' : 'NOK', true)
+    end
+  end
+
+  def create_test_server
+    @server_queue = GRPC::Core::CompletionQueue.new
+    @server = GRPC::Core::Server.new(@server_queue, nil)
+    @server.add_http2_port('0.0.0.0:0', :this_port_is_insecure)
+  end
+
+  def expect_server_to_be_invoked(notifier)
+    @server.start
+    notifier.notify(nil)
+    server_tag = Object.new
+    recvd_rpc = @server.request_call(@server_queue, server_tag,
+                                     INFINITE_FUTURE)
+    recvd_call = recvd_rpc.call
+    recvd_call.metadata = recvd_rpc.metadata
+    recvd_call.run_batch(@server_queue, server_tag, Time.now + 2,
+                         SEND_INITIAL_METADATA => nil)
+    GRPC::ActiveCall.new(recvd_call, @server_queue, noop, noop, INFINITE_FUTURE)
+  end
+end