src/ruby/spec/client_server_spec.rb - platform/external/grpc-grpc - Git at Google

 # 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'

 include GRPC::Core

 shared_context 'setup: tags' do
   let(:sent_message) { 'sent message' }
   let(:reply_text) { 'the reply' }

   def deadline
     Time.now + 5
   end

   def server_allows_client_to_proceed(metadata = {})
     recvd_rpc = @server.request_call
     expect(recvd_rpc).to_not eq nil
     server_call = recvd_rpc.call
     ops = { CallOps::SEND_INITIAL_METADATA => metadata }
     server_batch = server_call.run_batch(ops)
     expect(server_batch.send_metadata).to be true
     server_call
   end

   def new_client_call
     @ch.create_call(nil, nil, '/method', nil, deadline)
   end

   def ok_status
     Struct::Status.new(StatusCodes::OK, 'OK')
   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,
       CallOps::SEND_CLOSE_FROM_CLIENT => nil
     }
     client_batch = call.run_batch(client_ops)
     expect(client_batch.send_metadata).to be true
     expect(client_batch.send_message).to be true
     expect(client_batch.send_close).to be true

     # confirm the server can read the inbound message
     server_thread.join
     server_ops = {
       CallOps::RECV_MESSAGE => nil
     }
     server_batch = server_call.run_batch(server_ops)
     expect(server_batch.message).to eq(sent_message)
     server_ops = {
       CallOps::RECV_CLOSE_ON_SERVER => nil,
       CallOps::SEND_STATUS_FROM_SERVER => ok_status
     }
     server_batch = server_call.run_batch(server_ops)
     expect(server_batch.send_close).to be true
     expect(server_batch.send_status).to be true

     # finish the call
     final_client_batch = call.run_batch(
       CallOps::RECV_INITIAL_METADATA => nil,
       CallOps::RECV_STATUS_ON_CLIENT => nil)
     expect(final_client_batch.metadata).to eq({})
     expect(final_client_batch.status.code).to eq(0)
   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,
       CallOps::SEND_CLOSE_FROM_CLIENT => nil
     }
     client_batch = call.run_batch(client_ops)
     expect(client_batch.send_metadata).to be true
     expect(client_batch.send_message).to be true
     expect(client_batch.send_close).to be true

     # confirm the server can read the inbound message
     server_thread.join
     server_ops = {
       CallOps::RECV_MESSAGE => nil
     }
     server_batch = server_call.run_batch(server_ops)
     expect(server_batch.message).to eq(sent_message)
     server_ops = {
       CallOps::RECV_CLOSE_ON_SERVER => nil,
       CallOps::SEND_MESSAGE => reply_text,
       CallOps::SEND_STATUS_FROM_SERVER => ok_status
     }
     server_batch = server_call.run_batch(server_ops)
     expect(server_batch.send_close).to be true
     expect(server_batch.send_message).to be true
     expect(server_batch.send_status).to be true

     # finish the call
     final_client_batch = call.run_batch(
       CallOps::RECV_INITIAL_METADATA => nil,
       CallOps::RECV_MESSAGE => nil,
       CallOps::RECV_STATUS_ON_CLIENT => nil)
     expect(final_client_batch.metadata).to eq({})
     expect(final_client_batch.message).to eq(reply_text)
     expect(final_client_batch.status.code).to eq(0)
   end

   it 'compressed messages can be sent and received' do
     call = new_client_call
     server_call = nil
     long_request_str = '0' * 2000
     long_response_str = '1' * 2000
     md = { 'grpc-internal-encoding-request' => 'gzip' }

     server_thread = Thread.new do
       server_call = server_allows_client_to_proceed(md)
     end

     client_ops = {
       CallOps::SEND_INITIAL_METADATA => md,
       CallOps::SEND_MESSAGE => long_request_str,
       CallOps::SEND_CLOSE_FROM_CLIENT => nil
     }
     client_batch = call.run_batch(client_ops)
     expect(client_batch.send_metadata).to be true
     expect(client_batch.send_message).to be true
     expect(client_batch.send_close).to be true

     # confirm the server can read the inbound message
     server_thread.join
     server_ops = {
       CallOps::RECV_MESSAGE => nil
     }
     server_batch = server_call.run_batch(server_ops)
     expect(server_batch.message).to eq(long_request_str)
     server_ops = {
       CallOps::RECV_CLOSE_ON_SERVER => nil,
       CallOps::SEND_MESSAGE => long_response_str,
       CallOps::SEND_STATUS_FROM_SERVER => ok_status
     }
     server_batch = server_call.run_batch(server_ops)
     expect(server_batch.send_close).to be true
     expect(server_batch.send_message).to be true
     expect(server_batch.send_status).to be true

     client_ops = {
       CallOps::RECV_INITIAL_METADATA => nil,
       CallOps::RECV_MESSAGE => nil,
       CallOps::RECV_STATUS_ON_CLIENT => nil
     }
     final_client_batch = call.run_batch(client_ops)
     expect(final_client_batch.metadata).to eq({})
     expect(final_client_batch.message).to eq long_response_str
     expect(final_client_batch.status.code).to eq(0)
   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,
       CallOps::SEND_CLOSE_FROM_CLIENT => nil
     }
     client_batch = call.run_batch(client_ops)
     expect(client_batch.send_metadata).to be true
     expect(client_batch.send_message).to be true
     expect(client_batch.send_close).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
     }
     server_batch = server_call.run_batch(server_ops)
     expect(server_batch.message).to eq nil
     expect(server_batch.send_status).to be true

     final_client_batch = call.run_batch(
       CallOps::RECV_INITIAL_METADATA => nil,
       CallOps::RECV_STATUS_ON_CLIENT => nil)
     expect(final_client_batch.metadata).to eq({})
     expect(final_client_batch.status.code).to eq(0)
   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
     }
     client_batch = call.run_batch(client_ops)
     expect(client_batch.send_metadata).to be true
     expect(client_batch.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
     }
     server_batch = server_call.run_batch(server_ops)
     expect(server_batch.message).to eq sent_message
     server_ops = {
       CallOps::SEND_MESSAGE => reply_text,
       CallOps::SEND_STATUS_FROM_SERVER => the_status
     }
     server_batch = server_call.run_batch(server_ops)
     expect(server_batch.send_status).to be true
     expect(server_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_INITIAL_METADATA => nil,
       CallOps::RECV_MESSAGE => nil,
       CallOps::RECV_STATUS_ON_CLIENT => nil
     }
     final_client_batch = call.run_batch(client_ops)
     expect(final_client_batch.send_close).to be true
     expect(final_client_batch.message).to eq reply_text
     expect(final_client_batch.status).to eq the_status

     # confirm the server can receive the client close.
     server_ops = {
       CallOps::RECV_CLOSE_ON_SERVER => nil
     }
     final_server_batch = server_call.run_batch(server_ops)
     expect(final_server_batch.send_close).to be true
   end

   def client_cancel_test(cancel_proc, expected_code,
                          expected_details)
     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::RECV_INITIAL_METADATA => nil
     }
     client_batch = call.run_batch(client_ops)
     expect(client_batch.send_metadata).to be true
     expect(client_batch.metadata).to eq({})

     cancel_proc.call(call)

     server_thread.join
     server_ops = {
       CallOps::RECV_CLOSE_ON_SERVER => nil
     }
     server_batch = server_call.run_batch(server_ops)
     expect(server_batch.send_close).to be true

     client_ops = {
       CallOps::RECV_STATUS_ON_CLIENT => {}
     }
     client_batch = call.run_batch(client_ops)

     expect(client_batch.status.code).to be expected_code
     expect(client_batch.status.details).to eq expected_details
   end

   it 'clients can cancel a call on the server' do
     expected_code = StatusCodes::CANCELLED
     expected_details = 'CANCELLED'
     cancel_proc = proc { |call| call.cancel }
     client_cancel_test(cancel_proc, expected_code, expected_details)
   end

   it 'cancel_with_status unknown status' do
     code = StatusCodes::UNKNOWN
     details = 'test unknown reason'
     cancel_proc = proc { |call| call.cancel_with_status(code, details) }
     client_cancel_test(cancel_proc, code, details)
   end

   it 'cancel_with_status unknown status' do
     code = StatusCodes::FAILED_PRECONDITION
     details = 'test failed precondition reason'
     cancel_proc = proc { |call| call.cancel_with_status(code, details) }
     client_cancel_test(cancel_proc, code, details)
   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_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
         end

         call = new_client_call
         client_ops = {
           CallOps::SEND_INITIAL_METADATA => md,
           CallOps::SEND_CLOSE_FROM_CLIENT => nil
         }
         client_batch = call.run_batch(client_ops)
         expect(client_batch.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))

         # finish the call
         final_server_batch = recvd_rpc.call.run_batch(
           CallOps::RECV_CLOSE_ON_SERVER => nil,
           CallOps::SEND_INITIAL_METADATA => nil,
           CallOps::SEND_STATUS_FROM_SERVER => ok_status)
         expect(final_server_batch.send_close).to be(true)
         expect(final_server_batch.send_metadata).to be(true)
         expect(final_server_batch.send_status).to be(true)

         final_client_batch = call.run_batch(
           CallOps::RECV_INITIAL_METADATA => nil,
           CallOps::RECV_STATUS_ON_CLIENT => nil)
         expect(final_client_batch.metadata).to eq({})
         expect(final_client_batch.status.code).to eq(0)
       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
         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_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_ops)
         end
         expect(&blk).to raise_error

         # cancel the call so the server can shut down immediately
         call.cancel
       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
       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,
         CallOps::SEND_CLOSE_FROM_CLIENT => nil
       }
       client_batch = call.run_batch(client_ops)
       expect(client_batch.send_metadata).to be true
       expect(client_batch.send_close).to be true

       # 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 = {
         # receive close and send status to finish the call
         CallOps::RECV_CLOSE_ON_SERVER => nil,
         CallOps::SEND_INITIAL_METADATA => nil,
         CallOps::SEND_STATUS_FROM_SERVER => ok_status
       }
       srv_batch = server_call.run_batch(server_ops)
       expect(srv_batch.send_close).to be true
       expect(srv_batch.send_metadata).to be true
       expect(srv_batch.send_status).to be true

       # client receives nothing as expected
       client_ops = {
         CallOps::RECV_INITIAL_METADATA => nil,
         # receive status to finish the call
         CallOps::RECV_STATUS_ON_CLIENT => nil
       }
       final_client_batch = call.run_batch(client_ops)
       expect(final_client_batch.metadata).to eq({})
       expect(final_client_batch.status.code).to eq(0)
     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
         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,
           CallOps::SEND_CLOSE_FROM_CLIENT => nil
         }
         client_batch = call.run_batch(client_ops)
         expect(client_batch.send_metadata).to be true
         expect(client_batch.send_close).to be true

         # 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::RECV_CLOSE_ON_SERVER => nil,
           CallOps::SEND_INITIAL_METADATA => md,
           CallOps::SEND_STATUS_FROM_SERVER => ok_status
         }
         srv_batch = server_call.run_batch(server_ops)
         expect(srv_batch.send_close).to be true
         expect(srv_batch.send_metadata).to be true
         expect(srv_batch.send_status).to be true

         # client receives nothing as expected
         client_ops = {
           CallOps::RECV_INITIAL_METADATA => nil,
           CallOps::RECV_STATUS_ON_CLIENT => nil
         }
         final_client_batch = call.run_batch(client_ops)
         replace_symbols = Hash[md.each_pair.collect { |x, y| [x.to_s, y] }]
         expect(final_client_batch.metadata).to eq(replace_symbols)
         expect(final_client_batch.status.code).to eq(0)
       end
     end
   end
 end

 describe 'the http client/server' do
   before(:example) do
     server_host = '0.0.0.0:0'
     @server = new_core_server_for_testing(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.shutdown_and_notify(deadline)
     @server.close
   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'
     server_creds = GRPC::Core::ServerCredentials.new(
       nil, [{ private_key: certs[1], cert_chain: certs[2] }], false)
     @server = new_core_server_for_testing(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.shutdown_and_notify(deadline)
     @server.close
   end

   it_behaves_like 'basic GRPC message delivery is OK' do
   end

   it_behaves_like 'GRPC metadata delivery works OK' do
   end

   def credentials_update_test(creds_update_md)
     auth_proc = proc { creds_update_md }
     call_creds = GRPC::Core::CallCredentials.new(auth_proc)

     initial_md_key = 'k2'
     initial_md_val = 'v2'
     initial_md = { initial_md_key => initial_md_val }
     expected_md = creds_update_md.clone
     fail 'bad test param' unless expected_md[initial_md_key].nil?
     expected_md[initial_md_key] = initial_md_val

     recvd_rpc = nil
     rcv_thread = Thread.new do
       recvd_rpc = @server.request_call
     end

     call = new_client_call
     call.set_credentials! call_creds

     client_batch = call.run_batch(
       CallOps::SEND_INITIAL_METADATA => initial_md,
       CallOps::SEND_CLOSE_FROM_CLIENT => nil)
     expect(client_batch.send_metadata).to be true
     expect(client_batch.send_close).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))

     credentials_update_test_finish_call(call, recvd_rpc.call)
   end

   def credentials_update_test_finish_call(client_call, server_call)
     final_server_batch = server_call.run_batch(
       CallOps::RECV_CLOSE_ON_SERVER => nil,
       CallOps::SEND_INITIAL_METADATA => nil,
       CallOps::SEND_STATUS_FROM_SERVER => ok_status)
     expect(final_server_batch.send_close).to be(true)
     expect(final_server_batch.send_metadata).to be(true)
     expect(final_server_batch.send_status).to be(true)

     final_client_batch = client_call.run_batch(
       CallOps::RECV_INITIAL_METADATA => nil,
       CallOps::RECV_STATUS_ON_CLIENT => nil)
     expect(final_client_batch.metadata).to eq({})
     expect(final_client_batch.status.code).to eq(0)
   end

   it 'modifies metadata with CallCredentials' do
     credentials_update_test('k1' => 'updated-v1')
   end

   it 'modifies large metadata with CallCredentials' do
     val_array = %w(
       '00000000000000000000000000000000000000000000000000000000000000',
       '11111111111111111111111111111111111111111111111111111111111111',
     )
     md = {
       k3: val_array,
       k4: '0000000000000000000000000000000000000000000000000000000000',
       keeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeey5: 'v1'
     }
     credentials_update_test(md)
   end
 end
	# 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'

	include GRPC::Core

	shared_context 'setup: tags' do
	let(:sent_message) { 'sent message' }
	let(:reply_text) { 'the reply' }

	def deadline
	Time.now + 5
	end

	def server_allows_client_to_proceed(metadata = {})
	recvd_rpc = @server.request_call
	expect(recvd_rpc).to_not eq nil
	server_call = recvd_rpc.call
	ops = { CallOps::SEND_INITIAL_METADATA => metadata }
	server_batch = server_call.run_batch(ops)
	expect(server_batch.send_metadata).to be true
	server_call
	end

	def new_client_call
	@ch.create_call(nil, nil, '/method', nil, deadline)
	end

	def ok_status
	Struct::Status.new(StatusCodes::OK, 'OK')
	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,
	CallOps::SEND_CLOSE_FROM_CLIENT => nil
	}
	client_batch = call.run_batch(client_ops)
	expect(client_batch.send_metadata).to be true
	expect(client_batch.send_message).to be true
	expect(client_batch.send_close).to be true

	# confirm the server can read the inbound message
	server_thread.join
	server_ops = {
	CallOps::RECV_MESSAGE => nil
	}
	server_batch = server_call.run_batch(server_ops)
	expect(server_batch.message).to eq(sent_message)
	server_ops = {
	CallOps::RECV_CLOSE_ON_SERVER => nil,
	CallOps::SEND_STATUS_FROM_SERVER => ok_status
	}
	server_batch = server_call.run_batch(server_ops)
	expect(server_batch.send_close).to be true
	expect(server_batch.send_status).to be true

	# finish the call
	final_client_batch = call.run_batch(
	CallOps::RECV_INITIAL_METADATA => nil,
	CallOps::RECV_STATUS_ON_CLIENT => nil)
	expect(final_client_batch.metadata).to eq({})
	expect(final_client_batch.status.code).to eq(0)
	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,
	CallOps::SEND_CLOSE_FROM_CLIENT => nil
	}
	client_batch = call.run_batch(client_ops)
	expect(client_batch.send_metadata).to be true
	expect(client_batch.send_message).to be true
	expect(client_batch.send_close).to be true

	# confirm the server can read the inbound message
	server_thread.join
	server_ops = {
	CallOps::RECV_MESSAGE => nil
	}
	server_batch = server_call.run_batch(server_ops)
	expect(server_batch.message).to eq(sent_message)
	server_ops = {
	CallOps::RECV_CLOSE_ON_SERVER => nil,
	CallOps::SEND_MESSAGE => reply_text,
	CallOps::SEND_STATUS_FROM_SERVER => ok_status
	}
	server_batch = server_call.run_batch(server_ops)
	expect(server_batch.send_close).to be true
	expect(server_batch.send_message).to be true
	expect(server_batch.send_status).to be true

	# finish the call
	final_client_batch = call.run_batch(
	CallOps::RECV_INITIAL_METADATA => nil,
	CallOps::RECV_MESSAGE => nil,
	CallOps::RECV_STATUS_ON_CLIENT => nil)
	expect(final_client_batch.metadata).to eq({})
	expect(final_client_batch.message).to eq(reply_text)
	expect(final_client_batch.status.code).to eq(0)
	end

	it 'compressed messages can be sent and received' do
	call = new_client_call
	server_call = nil
	long_request_str = '0' * 2000
	long_response_str = '1' * 2000
	md = { 'grpc-internal-encoding-request' => 'gzip' }

	server_thread = Thread.new do
	server_call = server_allows_client_to_proceed(md)
	end

	client_ops = {
	CallOps::SEND_INITIAL_METADATA => md,
	CallOps::SEND_MESSAGE => long_request_str,
	CallOps::SEND_CLOSE_FROM_CLIENT => nil
	}
	client_batch = call.run_batch(client_ops)
	expect(client_batch.send_metadata).to be true
	expect(client_batch.send_message).to be true
	expect(client_batch.send_close).to be true

	# confirm the server can read the inbound message
	server_thread.join
	server_ops = {
	CallOps::RECV_MESSAGE => nil
	}
	server_batch = server_call.run_batch(server_ops)
	expect(server_batch.message).to eq(long_request_str)
	server_ops = {
	CallOps::RECV_CLOSE_ON_SERVER => nil,
	CallOps::SEND_MESSAGE => long_response_str,
	CallOps::SEND_STATUS_FROM_SERVER => ok_status
	}
	server_batch = server_call.run_batch(server_ops)
	expect(server_batch.send_close).to be true
	expect(server_batch.send_message).to be true
	expect(server_batch.send_status).to be true

	client_ops = {
	CallOps::RECV_INITIAL_METADATA => nil,
	CallOps::RECV_MESSAGE => nil,
	CallOps::RECV_STATUS_ON_CLIENT => nil
	}
	final_client_batch = call.run_batch(client_ops)
	expect(final_client_batch.metadata).to eq({})
	expect(final_client_batch.message).to eq long_response_str
	expect(final_client_batch.status.code).to eq(0)
	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,
	CallOps::SEND_CLOSE_FROM_CLIENT => nil
	}
	client_batch = call.run_batch(client_ops)
	expect(client_batch.send_metadata).to be true
	expect(client_batch.send_message).to be true
	expect(client_batch.send_close).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
	}
	server_batch = server_call.run_batch(server_ops)
	expect(server_batch.message).to eq nil
	expect(server_batch.send_status).to be true

	final_client_batch = call.run_batch(
	CallOps::RECV_INITIAL_METADATA => nil,
	CallOps::RECV_STATUS_ON_CLIENT => nil)
	expect(final_client_batch.metadata).to eq({})
	expect(final_client_batch.status.code).to eq(0)
	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
	}
	client_batch = call.run_batch(client_ops)
	expect(client_batch.send_metadata).to be true
	expect(client_batch.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
	}
	server_batch = server_call.run_batch(server_ops)
	expect(server_batch.message).to eq sent_message
	server_ops = {
	CallOps::SEND_MESSAGE => reply_text,
	CallOps::SEND_STATUS_FROM_SERVER => the_status
	}
	server_batch = server_call.run_batch(server_ops)
	expect(server_batch.send_status).to be true
	expect(server_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_INITIAL_METADATA => nil,
	CallOps::RECV_MESSAGE => nil,
	CallOps::RECV_STATUS_ON_CLIENT => nil
	}
	final_client_batch = call.run_batch(client_ops)
	expect(final_client_batch.send_close).to be true
	expect(final_client_batch.message).to eq reply_text
	expect(final_client_batch.status).to eq the_status

	# confirm the server can receive the client close.
	server_ops = {
	CallOps::RECV_CLOSE_ON_SERVER => nil
	}
	final_server_batch = server_call.run_batch(server_ops)
	expect(final_server_batch.send_close).to be true
	end

	def client_cancel_test(cancel_proc, expected_code,
	expected_details)
	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::RECV_INITIAL_METADATA => nil
	}
	client_batch = call.run_batch(client_ops)
	expect(client_batch.send_metadata).to be true
	expect(client_batch.metadata).to eq({})

	cancel_proc.call(call)

	server_thread.join
	server_ops = {
	CallOps::RECV_CLOSE_ON_SERVER => nil
	}
	server_batch = server_call.run_batch(server_ops)
	expect(server_batch.send_close).to be true

	client_ops = {
	CallOps::RECV_STATUS_ON_CLIENT => {}
	}
	client_batch = call.run_batch(client_ops)

	expect(client_batch.status.code).to be expected_code
	expect(client_batch.status.details).to eq expected_details
	end

	it 'clients can cancel a call on the server' do
	expected_code = StatusCodes::CANCELLED
	expected_details = 'CANCELLED'
	cancel_proc = proc { \|call\| call.cancel }
	client_cancel_test(cancel_proc, expected_code, expected_details)
	end

	it 'cancel_with_status unknown status' do
	code = StatusCodes::UNKNOWN
	details = 'test unknown reason'
	cancel_proc = proc { \|call\| call.cancel_with_status(code, details) }
	client_cancel_test(cancel_proc, code, details)
	end

	it 'cancel_with_status unknown status' do
	code = StatusCodes::FAILED_PRECONDITION
	details = 'test failed precondition reason'
	cancel_proc = proc { \|call\| call.cancel_with_status(code, details) }
	client_cancel_test(cancel_proc, code, details)
	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_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
	end

	call = new_client_call
	client_ops = {
	CallOps::SEND_INITIAL_METADATA => md,
	CallOps::SEND_CLOSE_FROM_CLIENT => nil
	}
	client_batch = call.run_batch(client_ops)
	expect(client_batch.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))

	# finish the call
	final_server_batch = recvd_rpc.call.run_batch(
	CallOps::RECV_CLOSE_ON_SERVER => nil,
	CallOps::SEND_INITIAL_METADATA => nil,
	CallOps::SEND_STATUS_FROM_SERVER => ok_status)
	expect(final_server_batch.send_close).to be(true)
	expect(final_server_batch.send_metadata).to be(true)
	expect(final_server_batch.send_status).to be(true)

	final_client_batch = call.run_batch(
	CallOps::RECV_INITIAL_METADATA => nil,
	CallOps::RECV_STATUS_ON_CLIENT => nil)
	expect(final_client_batch.metadata).to eq({})
	expect(final_client_batch.status.code).to eq(0)
	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
	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_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_ops)
	end
	expect(&blk).to raise_error

	# cancel the call so the server can shut down immediately
	call.cancel
	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
	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,
	CallOps::SEND_CLOSE_FROM_CLIENT => nil
	}
	client_batch = call.run_batch(client_ops)
	expect(client_batch.send_metadata).to be true
	expect(client_batch.send_close).to be true

	# 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 = {
	# receive close and send status to finish the call
	CallOps::RECV_CLOSE_ON_SERVER => nil,
	CallOps::SEND_INITIAL_METADATA => nil,
	CallOps::SEND_STATUS_FROM_SERVER => ok_status
	}
	srv_batch = server_call.run_batch(server_ops)
	expect(srv_batch.send_close).to be true
	expect(srv_batch.send_metadata).to be true
	expect(srv_batch.send_status).to be true

	# client receives nothing as expected
	client_ops = {
	CallOps::RECV_INITIAL_METADATA => nil,
	# receive status to finish the call
	CallOps::RECV_STATUS_ON_CLIENT => nil
	}
	final_client_batch = call.run_batch(client_ops)
	expect(final_client_batch.metadata).to eq({})
	expect(final_client_batch.status.code).to eq(0)
	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
	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,
	CallOps::SEND_CLOSE_FROM_CLIENT => nil
	}
	client_batch = call.run_batch(client_ops)
	expect(client_batch.send_metadata).to be true
	expect(client_batch.send_close).to be true

	# 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::RECV_CLOSE_ON_SERVER => nil,
	CallOps::SEND_INITIAL_METADATA => md,
	CallOps::SEND_STATUS_FROM_SERVER => ok_status
	}
	srv_batch = server_call.run_batch(server_ops)
	expect(srv_batch.send_close).to be true
	expect(srv_batch.send_metadata).to be true
	expect(srv_batch.send_status).to be true

	# client receives nothing as expected
	client_ops = {
	CallOps::RECV_INITIAL_METADATA => nil,
	CallOps::RECV_STATUS_ON_CLIENT => nil
	}
	final_client_batch = call.run_batch(client_ops)
	replace_symbols = Hash[md.each_pair.collect { \|x, y\| [x.to_s, y] }]
	expect(final_client_batch.metadata).to eq(replace_symbols)
	expect(final_client_batch.status.code).to eq(0)
	end
	end
	end
	end

	describe 'the http client/server' do
	before(:example) do
	server_host = '0.0.0.0:0'
	@server = new_core_server_for_testing(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.shutdown_and_notify(deadline)
	@server.close
	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'
	server_creds = GRPC::Core::ServerCredentials.new(
	nil, [{ private_key: certs[1], cert_chain: certs[2] }], false)
	@server = new_core_server_for_testing(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.shutdown_and_notify(deadline)
	@server.close
	end

	it_behaves_like 'basic GRPC message delivery is OK' do
	end

	it_behaves_like 'GRPC metadata delivery works OK' do
	end

	def credentials_update_test(creds_update_md)
	auth_proc = proc { creds_update_md }
	call_creds = GRPC::Core::CallCredentials.new(auth_proc)

	initial_md_key = 'k2'
	initial_md_val = 'v2'
	initial_md = { initial_md_key => initial_md_val }
	expected_md = creds_update_md.clone
	fail 'bad test param' unless expected_md[initial_md_key].nil?
	expected_md[initial_md_key] = initial_md_val

	recvd_rpc = nil
	rcv_thread = Thread.new do
	recvd_rpc = @server.request_call
	end

	call = new_client_call
	call.set_credentials! call_creds

	client_batch = call.run_batch(
	CallOps::SEND_INITIAL_METADATA => initial_md,
	CallOps::SEND_CLOSE_FROM_CLIENT => nil)
	expect(client_batch.send_metadata).to be true
	expect(client_batch.send_close).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))

	credentials_update_test_finish_call(call, recvd_rpc.call)
	end

	def credentials_update_test_finish_call(client_call, server_call)
	final_server_batch = server_call.run_batch(
	CallOps::RECV_CLOSE_ON_SERVER => nil,
	CallOps::SEND_INITIAL_METADATA => nil,
	CallOps::SEND_STATUS_FROM_SERVER => ok_status)
	expect(final_server_batch.send_close).to be(true)
	expect(final_server_batch.send_metadata).to be(true)
	expect(final_server_batch.send_status).to be(true)

	final_client_batch = client_call.run_batch(
	CallOps::RECV_INITIAL_METADATA => nil,
	CallOps::RECV_STATUS_ON_CLIENT => nil)
	expect(final_client_batch.metadata).to eq({})
	expect(final_client_batch.status.code).to eq(0)
	end

	it 'modifies metadata with CallCredentials' do
	credentials_update_test('k1' => 'updated-v1')
	end

	it 'modifies large metadata with CallCredentials' do
	val_array = %w(
	'00000000000000000000000000000000000000000000000000000000000000',
	'11111111111111111111111111111111111111111111111111111111111111',
	)
	md = {
	k3: val_array,
	k4: '0000000000000000000000000000000000000000000000000000000000',
	keeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeey5: 'v1'
	}
	credentials_update_test(md)
	end
	end