grpc 0.13.0.pre1.1-x86-linux

data/src/ruby/spec/call_spec.rb

@@ -0,0 +1,163 @@
+# 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::Core::WriteFlags do
+  it 'should define the known write flag values' do
+    m = GRPC::Core::WriteFlags
+    expect(m.const_get(:BUFFER_HINT)).to_not be_nil
+    expect(m.const_get(:NO_COMPRESS)).to_not be_nil
+  end
+end
+
+describe GRPC::Core::RpcErrors do
+  before(:each) do
+    @known_types = {
+      OK: 0,
+      ERROR: 1,
+      NOT_ON_SERVER: 2,
+      NOT_ON_CLIENT: 3,
+      ALREADY_ACCEPTED: 4,
+      ALREADY_INVOKED: 5,
+      NOT_INVOKED: 6,
+      ALREADY_FINISHED: 7,
+      TOO_MANY_OPERATIONS: 8,
+      INVALID_FLAGS: 9,
+      ErrorMessages: {
+        0 => 'ok',
+        1 => 'unknown error',
+        2 => 'not available on a server',
+        3 => 'not available on a client',
+        4 => 'call is already accepted',
+        5 => 'call is already invoked',
+        6 => 'call is not yet invoked',
+        7 => 'call is already finished',
+        8 => 'outstanding read or write present',
+        9 => 'a bad flag was given'
+      }
+    }
+  end
+
+  it 'should have symbols for all the known error codes' do
+    m = GRPC::Core::RpcErrors
+    syms_and_codes = m.constants.collect { |c| [c, m.const_get(c)] }
+    expect(Hash[syms_and_codes]).to eq(@known_types)
+  end
+end
+
+describe GRPC::Core::CallOps do
+  before(:each) do
+    @known_types = {
+      SEND_INITIAL_METADATA: 0,
+      SEND_MESSAGE: 1,
+      SEND_CLOSE_FROM_CLIENT: 2,
+      SEND_STATUS_FROM_SERVER: 3,
+      RECV_INITIAL_METADATA: 4,
+      RECV_MESSAGE: 5,
+      RECV_STATUS_ON_CLIENT: 6,
+      RECV_CLOSE_ON_SERVER: 7
+    }
+  end
+
+  it 'should have symbols for all the known operation types' do
+    m = GRPC::Core::CallOps
+    syms_and_codes = m.constants.collect { |c| [c, m.const_get(c)] }
+    expect(Hash[syms_and_codes]).to eq(@known_types)
+  end
+end
+
+describe GRPC::Core::Call do
+  let(:client_queue) { GRPC::Core::CompletionQueue.new }
+  let(:test_tag)  { Object.new }
+  let(:fake_host) { 'localhost:10101' }
+
+  before(:each) do
+    @ch = GRPC::Core::Channel.new(fake_host, nil, :this_channel_is_insecure)
+  end
+
+  describe '#status' do
+    it 'can save the status and read it back' do
+      call = make_test_call
+      sts = Struct::Status.new(OK, 'OK')
+      expect { call.status = sts }.not_to raise_error
+      expect(call.status).to eq(sts)
+    end
+
+    it 'must be set to a status' do
+      call = make_test_call
+      bad_sts = Object.new
+      expect { call.status = bad_sts }.to raise_error(TypeError)
+    end
+
+    it 'can be set to nil' do
+      call = make_test_call
+      expect { call.status = nil }.not_to raise_error
+    end
+  end
+
+  describe '#metadata' do
+    it 'can save the metadata hash and read it back' do
+      call = make_test_call
+      md = { 'k1' => 'v1',  'k2' => 'v2' }
+      expect { call.metadata = md }.not_to raise_error
+      expect(call.metadata).to be(md)
+    end
+
+    it 'must be set with a hash' do
+      call = make_test_call
+      bad_md = Object.new
+      expect { call.metadata = bad_md }.to raise_error(TypeError)
+    end
+
+    it 'can be set to nil' do
+      call = make_test_call
+      expect { call.metadata = nil }.not_to raise_error
+    end
+  end
+
+  describe '#set_credentials!' do
+    it 'can set a valid CallCredentials object' do
+      call = make_test_call
+      auth_proc = proc { { 'plugin_key' => 'plugin_value' } }
+      creds = GRPC::Core::CallCredentials.new auth_proc
+      expect { call.set_credentials! creds }.not_to raise_error
+    end
+  end
+
+  def make_test_call
+    @ch.create_call(client_queue, nil, nil, 'dummy_method', nil, deadline)
+  end
+
+  def deadline
+    Time.now + 2  # in 2 seconds; arbitrary
+  end
+end

data/src/ruby/spec/channel_credentials_spec.rb

@@ -0,0 +1,97 @@
+# 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::ChannelCredentials do
+  ChannelCredentials = GRPC::Core::ChannelCredentials
+  CallCredentials = GRPC::Core::CallCredentials
+
+  def load_test_certs
+    test_root = File.join(File.dirname(__FILE__), 'testdata')
+    files = ['ca.pem', 'server1.pem', 'server1.key']
+    files.map { |f| File.open(File.join(test_root, f)).read }
+  end
+
+  describe '#new' do
+    it 'can be constructed with fake inputs' do
+      blk = proc  { ChannelCredentials.new('root_certs', 'key', 'cert') }
+      expect(&blk).not_to raise_error
+    end
+
+    it 'it can be constructed using specific test certificates' do
+      certs = load_test_certs
+      expect { ChannelCredentials.new(*certs) }.not_to raise_error
+    end
+
+    it 'can be constructed with server roots certs only' do
+      root_cert, _, _ = load_test_certs
+      expect { ChannelCredentials.new(root_cert) }.not_to raise_error
+    end
+
+    it 'can be constructed with a nil server roots' do
+      _, client_key, client_chain = load_test_certs
+      blk = proc { ChannelCredentials.new(nil, client_key, client_chain) }
+      expect(&blk).not_to raise_error
+    end
+
+    it 'can be constructed with no params' do
+      blk = proc { ChannelCredentials.new(nil) }
+      expect(&blk).not_to raise_error
+    end
+  end
+
+  describe '#compose' do
+    it 'can compose with a CallCredentials' do
+      certs = load_test_certs
+      channel_creds = ChannelCredentials.new(*certs)
+      auth_proc = proc { { 'plugin_key' => 'plugin_value' } }
+      call_creds = CallCredentials.new auth_proc
+      expect { channel_creds.compose call_creds }.not_to raise_error
+    end
+
+    it 'can compose with multiple CallCredentials' do
+      certs = load_test_certs
+      channel_creds = ChannelCredentials.new(*certs)
+      auth_proc = proc { { 'plugin_key' => 'plugin_value' } }
+      call_creds1 = CallCredentials.new auth_proc
+      call_creds2 = CallCredentials.new auth_proc
+      expect do
+        channel_creds.compose(call_creds1, call_creds2)
+      end.not_to raise_error
+    end
+
+    it 'cannot compose with ChannelCredentials' do
+      certs = load_test_certs
+      channel_creds1 = ChannelCredentials.new(*certs)
+      channel_creds2 = ChannelCredentials.new(*certs)
+      expect { channel_creds1.compose channel_creds2 }.to raise_error(TypeError)
+    end
+  end
+end

data/src/ruby/spec/channel_spec.rb

@@ -0,0 +1,177 @@
+# 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 load_test_certs
+  test_root = File.join(File.dirname(__FILE__), 'testdata')
+  files = ['ca.pem', 'server1.key', 'server1.pem']
+  files.map { |f| File.open(File.join(test_root, f)).read }
+end
+
+describe GRPC::Core::Channel do
+  let(:fake_host) { 'localhost:0' }
+  let(:cq) { GRPC::Core::CompletionQueue.new }
+
+  def create_test_cert
+    GRPC::Core::ChannelCredentials.new(load_test_certs[0])
+  end
+
+  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)
+      end
+      expect(&blk).not_to raise_error
+    end
+
+    it 'does not take a hash with bad keys as channel args' do
+      blk = construct_with_args(Object.new => 1)
+      expect(&blk).to raise_error TypeError
+      blk = construct_with_args(1 => 1)
+      expect(&blk).to raise_error TypeError
+    end
+
+    it 'does not take a hash with bad values as channel args' do
+      blk = construct_with_args(symbol: Object.new)
+      expect(&blk).to raise_error TypeError
+      blk = construct_with_args('1' => {})
+      expect(&blk).to raise_error TypeError
+    end
+
+    it 'can take a hash with a symbol key as channel args' do
+      blk = construct_with_args(a_symbol: 1)
+      expect(&blk).to_not raise_error
+    end
+
+    it 'can take a hash with a string key as channel args' do
+      blk = construct_with_args('a_symbol' => 1)
+      expect(&blk).to_not raise_error
+    end
+
+    it 'can take a hash with a string value as channel args' do
+      blk = construct_with_args(a_symbol: '1')
+      expect(&blk).to_not raise_error
+    end
+
+    it 'can take a hash with a symbol value as channel args' do
+      blk = construct_with_args(a_symbol: :another_symbol)
+      expect(&blk).to_not raise_error
+    end
+
+    it 'can take a hash with a numeric value as channel args' do
+      blk = construct_with_args(a_symbol: 1)
+      expect(&blk).to_not raise_error
+    end
+
+    it 'can take a hash with many args as channel args' do
+      args = Hash[127.times.collect { |x| [x.to_s, x] }]
+      blk = construct_with_args(args)
+      expect(&blk).to_not raise_error
+    end
+  end
+
+  describe '#new for secure channels' do
+    def construct_with_args(a)
+      proc { GRPC::Core::Channel.new('dummy_host', a, create_test_cert) }
+    end
+
+    it_behaves_like '#new'
+  end
+
+  describe '#new for insecure channels' do
+    it_behaves_like '#new'
+
+    def construct_with_args(a)
+      proc do
+        GRPC::Core::Channel.new('dummy_host', a, :this_channel_is_insecure)
+      end
+    end
+  end
+
+  describe '#create_call' do
+    it 'creates a call OK' do
+      ch = GRPC::Core::Channel.new(fake_host, nil, :this_channel_is_insecure)
+
+      deadline = Time.now + 5
+
+      blk = proc do
+        ch.create_call(cq, nil, nil, 'dummy_method', nil, deadline)
+      end
+      expect(&blk).to_not raise_error
+    end
+
+    it 'raises an error if called on a closed channel' do
+      ch = GRPC::Core::Channel.new(fake_host, nil, :this_channel_is_insecure)
+      ch.close
+
+      deadline = Time.now + 5
+      blk = proc do
+        ch.create_call(cq, nil, nil, 'dummy_method', nil, deadline)
+      end
+      expect(&blk).to raise_error(RuntimeError)
+    end
+  end
+
+  describe '#destroy' do
+    it 'destroys a channel ok' do
+      ch = GRPC::Core::Channel.new(fake_host, nil, :this_channel_is_insecure)
+      blk = proc { ch.destroy }
+      expect(&blk).to_not raise_error
+    end
+
+    it 'can be called more than once without error' do
+      ch = GRPC::Core::Channel.new(fake_host, nil, :this_channel_is_insecure)
+      blk = proc { ch.destroy }
+      blk.call
+      expect(&blk).to_not raise_error
+    end
+  end
+
+  describe '::SSL_TARGET' do
+    it 'is a symbol' do
+      expect(GRPC::Core::Channel::SSL_TARGET).to be_a(Symbol)
+    end
+  end
+
+  describe '#close' do
+    it 'closes a channel ok' do
+      ch = GRPC::Core::Channel.new(fake_host, nil, :this_channel_is_insecure)
+      blk = proc { ch.close }
+      expect(&blk).to_not raise_error
+    end
+
+    it 'can be called more than once without error' do
+      ch = GRPC::Core::Channel.new(fake_host, nil, :this_channel_is_insecure)
+      blk = proc { ch.close }
+      blk.call
+      expect(&blk).to_not raise_error
+    end
+  end
+end

data/src/ruby/spec/client_server_spec.rb

@@ -0,0 +1,475 @@
+# 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
+
+shared_context 'setup: tags' do
+  let(:sent_message) { 'sent message' }
+  let(:reply_text) { 'the reply' }
+  before(:example) do
+    @client_tag = Object.new
+    @server_tag = Object.new
+  end
+
+  def deadline
+    Time.now + 5
+  end
+
+  def server_allows_client_to_proceed
+    recvd_rpc = @server.request_call(@server_queue, @server_tag, deadline)
+    expect(recvd_rpc).to_not eq nil
+    server_call = recvd_rpc.call
+    ops = { CallOps::SEND_INITIAL_METADATA => {} }
+    svr_batch = server_call.run_batch(@server_queue, @server_tag, deadline, ops)
+    expect(svr_batch.send_metadata).to be true
+    server_call
+  end
+
+  def new_client_call
+    @ch.create_call(@client_queue, nil, nil, '/method', nil, deadline)
+  end
+end
+
+shared_examples 'basic GRPC message delivery is OK' do
+  include GRPC::Core
+  include_context 'setup: tags'
+
+  context 'the test channel' do
+    it 'should have a target' do
+      expect(@ch.target).to be_a(String)
+    end
+  end
+
+  context 'a client call' do
+    it 'should have a peer' do
+      expect(new_client_call.peer).to be_a(String)
+    end
+  end
+
+  it 'calls have peer info' do
+    call = new_client_call
+    expect(call.peer).to be_a(String)
+  end
+
+  it 'servers receive requests from clients and can respond' do
+    call = new_client_call
+    server_call = nil
+
+    server_thread = Thread.new do
+      server_call = server_allows_client_to_proceed
+    end
+
+    client_ops = {
+      CallOps::SEND_INITIAL_METADATA => {},
+      CallOps::SEND_MESSAGE => sent_message
+    }
+    batch_result = call.run_batch(@client_queue, @client_tag, deadline,
+                                  client_ops)
+    expect(batch_result.send_metadata).to be true
+    expect(batch_result.send_message).to be true
+
+    # confirm the server can read the inbound message
+    server_thread.join
+    server_ops = {
+      CallOps::RECV_MESSAGE => nil
+    }
+    svr_batch = server_call.run_batch(@server_queue, @server_tag, deadline,
+                                      server_ops)
+    expect(svr_batch.message).to eq(sent_message)
+  end
+
+  it 'responses written by servers are received by the client' do
+    call = new_client_call
+    server_call = nil
+
+    server_thread = Thread.new do
+      server_call = server_allows_client_to_proceed
+    end
+
+    client_ops = {
+      CallOps::SEND_INITIAL_METADATA => {},
+      CallOps::SEND_MESSAGE => sent_message
+    }
+    batch_result = call.run_batch(@client_queue, @client_tag, deadline,
+                                  client_ops)
+    expect(batch_result.send_metadata).to be true
+    expect(batch_result.send_message).to be true
+
+    # confirm the server can read the inbound message
+    server_thread.join
+    server_ops = {
+      CallOps::RECV_MESSAGE => nil,
+      CallOps::SEND_MESSAGE => reply_text
+    }
+    svr_batch = server_call.run_batch(@server_queue, @server_tag, deadline,
+                                      server_ops)
+    expect(svr_batch.message).to eq(sent_message)
+    expect(svr_batch.send_message).to be true
+  end
+
+  it 'servers can ignore a client write and send a status' do
+    call = new_client_call
+    server_call = nil
+
+    server_thread = Thread.new do
+      server_call = server_allows_client_to_proceed
+    end
+
+    client_ops = {
+      CallOps::SEND_INITIAL_METADATA => {},
+      CallOps::SEND_MESSAGE => sent_message
+    }
+    batch_result = call.run_batch(@client_queue, @client_tag, deadline,
+                                  client_ops)
+    expect(batch_result.send_metadata).to be true
+    expect(batch_result.send_message).to be true
+
+    # confirm the server can read the inbound message
+    the_status = Struct::Status.new(StatusCodes::OK, 'OK')
+    server_thread.join
+    server_ops = {
+      CallOps::SEND_STATUS_FROM_SERVER => the_status
+    }
+    svr_batch = server_call.run_batch(@server_queue, @server_tag, deadline,
+                                      server_ops)
+    expect(svr_batch.message).to eq nil
+    expect(svr_batch.send_status).to be true
+  end
+
+  it 'completes calls by sending status to client and server' do
+    call = new_client_call
+    server_call = nil
+
+    server_thread = Thread.new do
+      server_call = server_allows_client_to_proceed
+    end
+
+    client_ops = {
+      CallOps::SEND_INITIAL_METADATA => {},
+      CallOps::SEND_MESSAGE => sent_message
+    }
+    batch_result = call.run_batch(@client_queue, @client_tag, deadline,
+                                  client_ops)
+    expect(batch_result.send_metadata).to be true
+    expect(batch_result.send_message).to be true
+
+    # confirm the server can read the inbound message and respond
+    the_status = Struct::Status.new(StatusCodes::OK, 'OK', {})
+    server_thread.join
+    server_ops = {
+      CallOps::RECV_MESSAGE => nil,
+      CallOps::SEND_MESSAGE => reply_text,
+      CallOps::SEND_STATUS_FROM_SERVER => the_status
+    }
+    svr_batch = server_call.run_batch(@server_queue, @server_tag, deadline,
+                                      server_ops)
+    expect(svr_batch.message).to eq sent_message
+    expect(svr_batch.send_status).to be true
+    expect(svr_batch.send_message).to be true
+
+    # confirm the client can receive the server response and status.
+    client_ops = {
+      CallOps::SEND_CLOSE_FROM_CLIENT => nil,
+      CallOps::RECV_MESSAGE => nil,
+      CallOps::RECV_STATUS_ON_CLIENT => nil
+    }
+    batch_result = call.run_batch(@client_queue, @client_tag, deadline,
+                                  client_ops)
+    expect(batch_result.send_close).to be true
+    expect(batch_result.message).to eq reply_text
+    expect(batch_result.status).to eq the_status
+
+    # confirm the server can receive the client close.
+    server_ops = {
+      CallOps::RECV_CLOSE_ON_SERVER => nil
+    }
+    svr_batch = server_call.run_batch(@server_queue, @server_tag, deadline,
+                                      server_ops)
+    expect(svr_batch.send_close).to be true
+  end
+end
+
+shared_examples 'GRPC metadata delivery works OK' do
+  include_context 'setup: tags'
+
+  describe 'from client => server' do
+    before(:example) do
+      n = 7  # arbitrary number of metadata
+      diff_keys_fn = proc { |i| [format('k%d', i), format('v%d', i)] }
+      diff_keys = Hash[n.times.collect { |x| diff_keys_fn.call x }]
+      null_vals_fn = proc { |i| [format('k%d', i), format('v\0%d', i)] }
+      null_vals = Hash[n.times.collect { |x| null_vals_fn.call x }]
+      same_keys_fn = proc { |i| [format('k%d', i), [format('v%d', i)] * n] }
+      same_keys = Hash[n.times.collect { |x| same_keys_fn.call x }]
+      symbol_key = { a_key: 'a val' }
+      @valid_metadata = [diff_keys, same_keys, null_vals, symbol_key]
+      @bad_keys = []
+      @bad_keys << { Object.new => 'a value' }
+      @bad_keys << { 1 => 'a value' }
+    end
+
+    it 'raises an exception if a metadata key is invalid' do
+      @bad_keys.each do |md|
+        call = new_client_call
+        client_ops = {
+          CallOps::SEND_INITIAL_METADATA => md
+        }
+        blk = proc do
+          call.run_batch(@client_queue, @client_tag, deadline,
+                         client_ops)
+        end
+        expect(&blk).to raise_error
+      end
+    end
+
+    it 'sends all the metadata pairs when keys and values are valid' do
+      @valid_metadata.each do |md|
+        recvd_rpc = nil
+        rcv_thread = Thread.new do
+          recvd_rpc = @server.request_call(@server_queue, @server_tag, deadline)
+        end
+
+        call = new_client_call
+        client_ops = {
+          CallOps::SEND_INITIAL_METADATA => md
+        }
+        batch_result = call.run_batch(@client_queue, @client_tag, deadline,
+                                      client_ops)
+        expect(batch_result.send_metadata).to be true
+
+        # confirm the server can receive the client metadata
+        rcv_thread.join
+        expect(recvd_rpc).to_not eq nil
+        recvd_md = recvd_rpc.metadata
+        replace_symbols = Hash[md.each_pair.collect { |x, y| [x.to_s, y] }]
+        expect(recvd_md).to eq(recvd_md.merge(replace_symbols))
+      end
+    end
+  end
+
+  describe 'from server => client' do
+    before(:example) do
+      n = 7  # arbitrary number of metadata
+      diff_keys_fn = proc { |i| [format('k%d', i), format('v%d', i)] }
+      diff_keys = Hash[n.times.collect { |x| diff_keys_fn.call x }]
+      null_vals_fn = proc { |i| [format('k%d', i), format('v\0%d', i)] }
+      null_vals = Hash[n.times.collect { |x| null_vals_fn.call x }]
+      same_keys_fn = proc { |i| [format('k%d', i), [format('v%d', i)] * n] }
+      same_keys = Hash[n.times.collect { |x| same_keys_fn.call x }]
+      symbol_key = { a_key: 'a val' }
+      @valid_metadata = [diff_keys, same_keys, null_vals, symbol_key]
+      @bad_keys = []
+      @bad_keys << { Object.new => 'a value' }
+      @bad_keys << { 1 => 'a value' }
+    end
+
+    it 'raises an exception if a metadata key is invalid' do
+      @bad_keys.each do |md|
+        recvd_rpc = nil
+        rcv_thread = Thread.new do
+          recvd_rpc = @server.request_call(@server_queue, @server_tag, deadline)
+        end
+
+        call = new_client_call
+        # client signals that it's done sending metadata to allow server to
+        # respond
+        client_ops = {
+          CallOps::SEND_INITIAL_METADATA => nil
+        }
+        call.run_batch(@client_queue, @client_tag, deadline, client_ops)
+
+        # server gets the invocation
+        rcv_thread.join
+        expect(recvd_rpc).to_not eq nil
+        server_ops = {
+          CallOps::SEND_INITIAL_METADATA => md
+        }
+        blk = proc do
+          recvd_rpc.call.run_batch(@server_queue, @server_tag, deadline,
+                                   server_ops)
+        end
+        expect(&blk).to raise_error
+      end
+    end
+
+    it 'sends an empty hash if no metadata is added' do
+      recvd_rpc = nil
+      rcv_thread = Thread.new do
+        recvd_rpc = @server.request_call(@server_queue, @server_tag, deadline)
+      end
+
+      call = new_client_call
+      # client signals that it's done sending metadata to allow server to
+      # respond
+      client_ops = {
+        CallOps::SEND_INITIAL_METADATA => nil
+      }
+      call.run_batch(@client_queue, @client_tag, deadline, client_ops)
+
+      # server gets the invocation but sends no metadata back
+      rcv_thread.join
+      expect(recvd_rpc).to_not eq nil
+      server_call = recvd_rpc.call
+      server_ops = {
+        CallOps::SEND_INITIAL_METADATA => nil
+      }
+      server_call.run_batch(@server_queue, @server_tag, deadline, server_ops)
+
+      # client receives nothing as expected
+      client_ops = {
+        CallOps::RECV_INITIAL_METADATA => nil
+      }
+      batch_result = call.run_batch(@client_queue, @client_tag, deadline,
+                                    client_ops)
+      expect(batch_result.metadata).to eq({})
+    end
+
+    it 'sends all the pairs when keys and values are valid' do
+      @valid_metadata.each do |md|
+        recvd_rpc = nil
+        rcv_thread = Thread.new do
+          recvd_rpc = @server.request_call(@server_queue, @server_tag, deadline)
+        end
+
+        call = new_client_call
+        # client signals that it's done sending metadata to allow server to
+        # respond
+        client_ops = {
+          CallOps::SEND_INITIAL_METADATA => nil
+        }
+        call.run_batch(@client_queue, @client_tag, deadline, client_ops)
+
+        # server gets the invocation but sends no metadata back
+        rcv_thread.join
+        expect(recvd_rpc).to_not eq nil
+        server_call = recvd_rpc.call
+        server_ops = {
+          CallOps::SEND_INITIAL_METADATA => md
+        }
+        server_call.run_batch(@server_queue, @server_tag, deadline, server_ops)
+
+        # client receives nothing as expected
+        client_ops = {
+          CallOps::RECV_INITIAL_METADATA => nil
+        }
+        batch_result = call.run_batch(@client_queue, @client_tag, deadline,
+                                      client_ops)
+        replace_symbols = Hash[md.each_pair.collect { |x, y| [x.to_s, y] }]
+        expect(batch_result.metadata).to eq(replace_symbols)
+      end
+    end
+  end
+end
+
+describe 'the http client/server' do
+  before(:example) do
+    server_host = '0.0.0.0:0'
+    @client_queue = GRPC::Core::CompletionQueue.new
+    @server_queue = GRPC::Core::CompletionQueue.new
+    @server = GRPC::Core::Server.new(@server_queue, nil)
+    server_port = @server.add_http2_port(server_host, :this_port_is_insecure)
+    @server.start
+    @ch = Channel.new("0.0.0.0:#{server_port}", nil, :this_channel_is_insecure)
+  end
+
+  after(:example) do
+    @ch.close
+    @server.close(@server_queue, deadline)
+  end
+
+  it_behaves_like 'basic GRPC message delivery is OK' do
+  end
+
+  it_behaves_like 'GRPC metadata delivery works OK' do
+  end
+end
+
+describe 'the secure http client/server' do
+  include_context 'setup: tags'
+
+  def load_test_certs
+    test_root = File.join(File.dirname(__FILE__), 'testdata')
+    files = ['ca.pem', 'server1.key', 'server1.pem']
+    files.map { |f| File.open(File.join(test_root, f)).read }
+  end
+
+  before(:example) do
+    certs = load_test_certs
+    server_host = '0.0.0.0:0'
+    @client_queue = GRPC::Core::CompletionQueue.new
+    @server_queue = GRPC::Core::CompletionQueue.new
+    server_creds = GRPC::Core::ServerCredentials.new(
+      nil, [{ private_key: certs[1], cert_chain: certs[2] }], false)
+    @server = GRPC::Core::Server.new(@server_queue, nil)
+    server_port = @server.add_http2_port(server_host, server_creds)
+    @server.start
+    args = { Channel::SSL_TARGET => 'foo.test.google.fr' }
+    @ch = Channel.new("0.0.0.0:#{server_port}", args,
+                      GRPC::Core::ChannelCredentials.new(certs[0], nil, nil))
+  end
+
+  after(:example) do
+    @server.close(@server_queue, deadline)
+  end
+
+  it_behaves_like 'basic GRPC message delivery is OK' do
+  end
+
+  it_behaves_like 'GRPC metadata delivery works OK' do
+  end
+
+  it 'modifies metadata with CallCredentials' do
+    auth_proc = proc { { 'k1' => 'updated-v1' } }
+    call_creds = GRPC::Core::CallCredentials.new(auth_proc)
+    md = { 'k2' => 'v2' }
+    expected_md = { 'k1' => 'updated-v1', 'k2' => 'v2' }
+    recvd_rpc = nil
+    rcv_thread = Thread.new do
+      recvd_rpc = @server.request_call(@server_queue, @server_tag, deadline)
+    end
+
+    call = new_client_call
+    call.set_credentials! call_creds
+    client_ops = {
+      CallOps::SEND_INITIAL_METADATA => md
+    }
+    batch_result = call.run_batch(@client_queue, @client_tag, deadline,
+                                  client_ops)
+    expect(batch_result.send_metadata).to be true
+
+    # confirm the server can receive the client metadata
+    rcv_thread.join
+    expect(recvd_rpc).to_not eq nil
+    recvd_md = recvd_rpc.metadata
+    replace_symbols = Hash[expected_md.each_pair.collect { |x, y| [x.to_s, y] }]
+    expect(recvd_md).to eq(recvd_md.merge(replace_symbols))
+  end
+end