Craig Tiller | 0605995 | 2015-02-18 08:34:56 -0800 | [diff] [blame] | 1 | # Copyright 2015, Google Inc. |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 2 | # All rights reserved. |
| 3 | # |
| 4 | # Redistribution and use in source and binary forms, with or without |
| 5 | # modification, are permitted provided that the following conditions are |
| 6 | # met: |
| 7 | # |
| 8 | # * Redistributions of source code must retain the above copyright |
| 9 | # notice, this list of conditions and the following disclaimer. |
| 10 | # * Redistributions in binary form must reproduce the above |
| 11 | # copyright notice, this list of conditions and the following disclaimer |
| 12 | # in the documentation and/or other materials provided with the |
| 13 | # distribution. |
| 14 | # * Neither the name of Google Inc. nor the names of its |
| 15 | # contributors may be used to endorse or promote products derived from |
| 16 | # this software without specific prior written permission. |
| 17 | # |
| 18 | # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 19 | # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 20 | # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| 21 | # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| 22 | # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 23 | # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| 24 | # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 25 | # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 26 | # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 27 | # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| 28 | # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 29 | |
| 30 | require 'grpc' |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 31 | require 'spec_helper' |
| 32 | |
nnoble | 0c475f0 | 2014-12-05 15:37:39 -0800 | [diff] [blame] | 33 | include GRPC::Core |
| 34 | |
| 35 | def load_test_certs |
| 36 | test_root = File.join(File.dirname(__FILE__), 'testdata') |
| 37 | files = ['ca.pem', 'server1.key', 'server1.pem'] |
| 38 | files.map { |f| File.open(File.join(test_root, f)).read } |
| 39 | end |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 40 | |
| 41 | shared_context 'setup: tags' do |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 42 | let(:sent_message) { 'sent message' } |
| 43 | let(:reply_text) { 'the reply' } |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 44 | before(:example) do |
| 45 | @server_finished_tag = Object.new |
| 46 | @client_finished_tag = Object.new |
Tim Emiola | 75d7f9a | 2015-01-26 16:57:33 -0800 | [diff] [blame] | 47 | @client_metadata_tag = Object.new |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 48 | @server_tag = Object.new |
| 49 | @tag = Object.new |
| 50 | end |
| 51 | |
| 52 | def deadline |
Tim Emiola | 75d7f9a | 2015-01-26 16:57:33 -0800 | [diff] [blame] | 53 | Time.now + 2 |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 54 | end |
| 55 | |
Tim Emiola | 75d7f9a | 2015-01-26 16:57:33 -0800 | [diff] [blame] | 56 | def server_allows_client_to_proceed |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 57 | recvd_rpc = @server.request_call(@server_queue, @server_tag, deadline) |
| 58 | expect(recvd_rpc).to_not eq nil |
| 59 | server_call = recvd_rpc.call |
| 60 | ops = { CallOps::SEND_INITIAL_METADATA => {} } |
| 61 | svr_batch = server_call.run_batch(@server_queue, @server_tag, deadline, ops) |
| 62 | expect(svr_batch.send_metadata).to be true |
Tim Emiola | 75d7f9a | 2015-01-26 16:57:33 -0800 | [diff] [blame] | 63 | server_call |
| 64 | end |
| 65 | |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 66 | def new_client_call |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 67 | @ch.create_call(@client_queue, '/method', 'foo.test.google.fr', deadline) |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 68 | end |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 69 | end |
| 70 | |
| 71 | shared_examples 'basic GRPC message delivery is OK' do |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 72 | include GRPC::Core |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 73 | include_context 'setup: tags' |
| 74 | |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 75 | it 'servers receive requests from clients and can respond' do |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 76 | call = new_client_call |
Craig Tiller | 09600be | 2015-05-13 16:46:55 -0700 | [diff] [blame^] | 77 | server_call = nil |
| 78 | |
| 79 | server_thread = Thread.new do |
| 80 | server_call = server_allows_client_to_proceed |
| 81 | end |
| 82 | |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 83 | client_ops = { |
| 84 | CallOps::SEND_INITIAL_METADATA => {}, |
| 85 | CallOps::SEND_MESSAGE => sent_message |
| 86 | } |
| 87 | batch_result = call.run_batch(@client_queue, @client_tag, deadline, |
| 88 | client_ops) |
| 89 | expect(batch_result.send_metadata).to be true |
| 90 | expect(batch_result.send_message).to be true |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 91 | |
| 92 | # confirm the server can read the inbound message |
Craig Tiller | 09600be | 2015-05-13 16:46:55 -0700 | [diff] [blame^] | 93 | server_thread.join |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 94 | server_ops = { |
| 95 | CallOps::RECV_MESSAGE => nil |
| 96 | } |
| 97 | svr_batch = server_call.run_batch(@server_queue, @server_tag, deadline, |
| 98 | server_ops) |
| 99 | expect(svr_batch.message).to eq(sent_message) |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 100 | end |
| 101 | |
| 102 | it 'responses written by servers are received by the client' do |
| 103 | call = new_client_call |
Craig Tiller | 09600be | 2015-05-13 16:46:55 -0700 | [diff] [blame^] | 104 | server_call = nil |
| 105 | |
| 106 | server_thread = Thread.new do |
| 107 | server_call = server_allows_client_to_proceed |
| 108 | end |
| 109 | |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 110 | client_ops = { |
| 111 | CallOps::SEND_INITIAL_METADATA => {}, |
| 112 | CallOps::SEND_MESSAGE => sent_message |
| 113 | } |
| 114 | batch_result = call.run_batch(@client_queue, @client_tag, deadline, |
| 115 | client_ops) |
| 116 | expect(batch_result.send_metadata).to be true |
| 117 | expect(batch_result.send_message).to be true |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 118 | |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 119 | # confirm the server can read the inbound message |
Craig Tiller | 09600be | 2015-05-13 16:46:55 -0700 | [diff] [blame^] | 120 | server_thread.join |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 121 | server_ops = { |
| 122 | CallOps::RECV_MESSAGE => nil, |
| 123 | CallOps::SEND_MESSAGE => reply_text |
| 124 | } |
| 125 | svr_batch = server_call.run_batch(@server_queue, @server_tag, deadline, |
| 126 | server_ops) |
| 127 | expect(svr_batch.message).to eq(sent_message) |
| 128 | expect(svr_batch.send_message).to be true |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 129 | end |
| 130 | |
| 131 | it 'servers can ignore a client write and send a status' do |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 132 | call = new_client_call |
Craig Tiller | 09600be | 2015-05-13 16:46:55 -0700 | [diff] [blame^] | 133 | server_call = nil |
| 134 | |
| 135 | server_thread = Thread.new do |
| 136 | server_call = server_allows_client_to_proceed |
| 137 | end |
| 138 | |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 139 | client_ops = { |
| 140 | CallOps::SEND_INITIAL_METADATA => {}, |
| 141 | CallOps::SEND_MESSAGE => sent_message |
| 142 | } |
| 143 | batch_result = call.run_batch(@client_queue, @client_tag, deadline, |
| 144 | client_ops) |
| 145 | expect(batch_result.send_metadata).to be true |
| 146 | expect(batch_result.send_message).to be true |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 147 | |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 148 | # confirm the server can read the inbound message |
| 149 | the_status = Struct::Status.new(StatusCodes::OK, 'OK') |
Craig Tiller | 09600be | 2015-05-13 16:46:55 -0700 | [diff] [blame^] | 150 | server_thread.join |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 151 | server_ops = { |
| 152 | CallOps::SEND_STATUS_FROM_SERVER => the_status |
| 153 | } |
| 154 | svr_batch = server_call.run_batch(@server_queue, @server_tag, deadline, |
| 155 | server_ops) |
| 156 | expect(svr_batch.message).to eq nil |
| 157 | expect(svr_batch.send_status).to be true |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 158 | end |
| 159 | |
| 160 | it 'completes calls by sending status to client and server' do |
| 161 | call = new_client_call |
Craig Tiller | 09600be | 2015-05-13 16:46:55 -0700 | [diff] [blame^] | 162 | server_call = nil |
| 163 | |
| 164 | server_thread = Thread.new do |
| 165 | server_call = server_allows_client_to_proceed |
| 166 | end |
| 167 | |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 168 | client_ops = { |
| 169 | CallOps::SEND_INITIAL_METADATA => {}, |
| 170 | CallOps::SEND_MESSAGE => sent_message |
| 171 | } |
| 172 | batch_result = call.run_batch(@client_queue, @client_tag, deadline, |
| 173 | client_ops) |
| 174 | expect(batch_result.send_metadata).to be true |
| 175 | expect(batch_result.send_message).to be true |
| 176 | |
| 177 | # confirm the server can read the inbound message and respond |
| 178 | the_status = Struct::Status.new(StatusCodes::OK, 'OK', {}) |
Craig Tiller | 09600be | 2015-05-13 16:46:55 -0700 | [diff] [blame^] | 179 | server_thread.join |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 180 | server_ops = { |
| 181 | CallOps::RECV_MESSAGE => nil, |
| 182 | CallOps::SEND_MESSAGE => reply_text, |
| 183 | CallOps::SEND_STATUS_FROM_SERVER => the_status |
| 184 | } |
| 185 | svr_batch = server_call.run_batch(@server_queue, @server_tag, deadline, |
| 186 | server_ops) |
| 187 | expect(svr_batch.message).to eq sent_message |
| 188 | expect(svr_batch.send_status).to be true |
| 189 | expect(svr_batch.send_message).to be true |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 190 | |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 191 | # confirm the client can receive the server response and status. |
| 192 | client_ops = { |
| 193 | CallOps::SEND_CLOSE_FROM_CLIENT => nil, |
| 194 | CallOps::RECV_MESSAGE => nil, |
| 195 | CallOps::RECV_STATUS_ON_CLIENT => nil |
| 196 | } |
| 197 | batch_result = call.run_batch(@client_queue, @client_tag, deadline, |
| 198 | client_ops) |
| 199 | expect(batch_result.send_close).to be true |
| 200 | expect(batch_result.message).to eq reply_text |
| 201 | expect(batch_result.status).to eq the_status |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 202 | |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 203 | # confirm the server can receive the client close. |
| 204 | server_ops = { |
| 205 | CallOps::RECV_CLOSE_ON_SERVER => nil |
| 206 | } |
| 207 | svr_batch = server_call.run_batch(@server_queue, @server_tag, deadline, |
| 208 | server_ops) |
| 209 | expect(svr_batch.send_close).to be true |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 210 | end |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 211 | end |
| 212 | |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 213 | shared_examples 'GRPC metadata delivery works OK' do |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 214 | include_context 'setup: tags' |
| 215 | |
| 216 | describe 'from client => server' do |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 217 | before(:example) do |
| 218 | n = 7 # arbitrary number of metadata |
Tim Emiola | 1e09812 | 2015-04-14 09:42:09 -0700 | [diff] [blame] | 219 | diff_keys_fn = proc { |i| [format('k%d', i), format('v%d', i)] } |
Tim Emiola | e2860c5 | 2015-01-16 02:58:41 -0800 | [diff] [blame] | 220 | diff_keys = Hash[n.times.collect { |x| diff_keys_fn.call x }] |
Tim Emiola | 1e09812 | 2015-04-14 09:42:09 -0700 | [diff] [blame] | 221 | null_vals_fn = proc { |i| [format('k%d', i), format('v\0%d', i)] } |
Tim Emiola | e2860c5 | 2015-01-16 02:58:41 -0800 | [diff] [blame] | 222 | null_vals = Hash[n.times.collect { |x| null_vals_fn.call x }] |
Tim Emiola | 1e09812 | 2015-04-14 09:42:09 -0700 | [diff] [blame] | 223 | same_keys_fn = proc { |i| [format('k%d', i), [format('v%d', i)] * n] } |
Tim Emiola | e2860c5 | 2015-01-16 02:58:41 -0800 | [diff] [blame] | 224 | same_keys = Hash[n.times.collect { |x| same_keys_fn.call x }] |
| 225 | symbol_key = { a_key: 'a val' } |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 226 | @valid_metadata = [diff_keys, same_keys, null_vals, symbol_key] |
| 227 | @bad_keys = [] |
| 228 | @bad_keys << { Object.new => 'a value' } |
| 229 | @bad_keys << { 1 => 'a value' } |
| 230 | end |
| 231 | |
| 232 | it 'raises an exception if a metadata key is invalid' do |
| 233 | @bad_keys.each do |md| |
| 234 | call = new_client_call |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 235 | client_ops = { |
| 236 | CallOps::SEND_INITIAL_METADATA => md |
| 237 | } |
| 238 | blk = proc do |
| 239 | call.run_batch(@client_queue, @client_tag, deadline, |
| 240 | client_ops) |
| 241 | end |
| 242 | expect(&blk).to raise_error |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 243 | end |
| 244 | end |
| 245 | |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 246 | it 'sends all the metadata pairs when keys and values are valid' do |
| 247 | @valid_metadata.each do |md| |
Craig Tiller | 09600be | 2015-05-13 16:46:55 -0700 | [diff] [blame^] | 248 | recvd_rpc = nil |
| 249 | rcv_thread = Thread.new do |
| 250 | recvd_rpc = @server.request_call(@server_queue, @server_tag, deadline) |
| 251 | end |
| 252 | |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 253 | call = new_client_call |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 254 | client_ops = { |
| 255 | CallOps::SEND_INITIAL_METADATA => md |
| 256 | } |
| 257 | batch_result = call.run_batch(@client_queue, @client_tag, deadline, |
| 258 | client_ops) |
| 259 | expect(batch_result.send_metadata).to be true |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 260 | |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 261 | # confirm the server can receive the client metadata |
Craig Tiller | 09600be | 2015-05-13 16:46:55 -0700 | [diff] [blame^] | 262 | rcv_thread.join |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 263 | expect(recvd_rpc).to_not eq nil |
| 264 | recvd_md = recvd_rpc.metadata |
Tim Emiola | e2860c5 | 2015-01-16 02:58:41 -0800 | [diff] [blame] | 265 | replace_symbols = Hash[md.each_pair.collect { |x, y| [x.to_s, y] }] |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 266 | expect(recvd_md).to eq(recvd_md.merge(replace_symbols)) |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 267 | end |
| 268 | end |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 269 | end |
| 270 | |
| 271 | describe 'from server => client' do |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 272 | before(:example) do |
| 273 | n = 7 # arbitrary number of metadata |
Tim Emiola | 1e09812 | 2015-04-14 09:42:09 -0700 | [diff] [blame] | 274 | diff_keys_fn = proc { |i| [format('k%d', i), format('v%d', i)] } |
Tim Emiola | e2860c5 | 2015-01-16 02:58:41 -0800 | [diff] [blame] | 275 | diff_keys = Hash[n.times.collect { |x| diff_keys_fn.call x }] |
Tim Emiola | 1e09812 | 2015-04-14 09:42:09 -0700 | [diff] [blame] | 276 | null_vals_fn = proc { |i| [format('k%d', i), format('v\0%d', i)] } |
Tim Emiola | e2860c5 | 2015-01-16 02:58:41 -0800 | [diff] [blame] | 277 | null_vals = Hash[n.times.collect { |x| null_vals_fn.call x }] |
Tim Emiola | 1e09812 | 2015-04-14 09:42:09 -0700 | [diff] [blame] | 278 | same_keys_fn = proc { |i| [format('k%d', i), [format('v%d', i)] * n] } |
Tim Emiola | e2860c5 | 2015-01-16 02:58:41 -0800 | [diff] [blame] | 279 | same_keys = Hash[n.times.collect { |x| same_keys_fn.call x }] |
| 280 | symbol_key = { a_key: 'a val' } |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 281 | @valid_metadata = [diff_keys, same_keys, null_vals, symbol_key] |
| 282 | @bad_keys = [] |
| 283 | @bad_keys << { Object.new => 'a value' } |
| 284 | @bad_keys << { 1 => 'a value' } |
| 285 | end |
| 286 | |
| 287 | it 'raises an exception if a metadata key is invalid' do |
| 288 | @bad_keys.each do |md| |
Craig Tiller | 09600be | 2015-05-13 16:46:55 -0700 | [diff] [blame^] | 289 | recvd_rpc = nil |
| 290 | rcv_thread = Thread.new do |
| 291 | recvd_rpc = @server.request_call(@server_queue, @server_tag, deadline) |
| 292 | end |
| 293 | |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 294 | call = new_client_call |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 295 | # client signals that it's done sending metadata to allow server to |
| 296 | # respond |
| 297 | client_ops = { |
| 298 | CallOps::SEND_INITIAL_METADATA => nil |
| 299 | } |
| 300 | call.run_batch(@client_queue, @client_tag, deadline, client_ops) |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 301 | |
| 302 | # server gets the invocation |
Craig Tiller | 09600be | 2015-05-13 16:46:55 -0700 | [diff] [blame^] | 303 | rcv_thread.join |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 304 | expect(recvd_rpc).to_not eq nil |
| 305 | server_ops = { |
| 306 | CallOps::SEND_INITIAL_METADATA => md |
| 307 | } |
| 308 | blk = proc do |
| 309 | recvd_rpc.call.run_batch(@server_queue, @server_tag, deadline, |
| 310 | server_ops) |
| 311 | end |
| 312 | expect(&blk).to raise_error |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 313 | end |
| 314 | end |
| 315 | |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 316 | it 'sends an empty hash if no metadata is added' do |
Craig Tiller | 09600be | 2015-05-13 16:46:55 -0700 | [diff] [blame^] | 317 | recvd_rpc = nil |
| 318 | rcv_thread = Thread.new do |
| 319 | recvd_rpc = @server.request_call(@server_queue, @server_tag, deadline) |
| 320 | end |
| 321 | |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 322 | call = new_client_call |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 323 | # client signals that it's done sending metadata to allow server to |
| 324 | # respond |
| 325 | client_ops = { |
| 326 | CallOps::SEND_INITIAL_METADATA => nil |
| 327 | } |
| 328 | call.run_batch(@client_queue, @client_tag, deadline, client_ops) |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 329 | |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 330 | # server gets the invocation but sends no metadata back |
Craig Tiller | 09600be | 2015-05-13 16:46:55 -0700 | [diff] [blame^] | 331 | rcv_thread.join |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 332 | expect(recvd_rpc).to_not eq nil |
| 333 | server_call = recvd_rpc.call |
| 334 | server_ops = { |
| 335 | CallOps::SEND_INITIAL_METADATA => nil |
| 336 | } |
| 337 | server_call.run_batch(@server_queue, @server_tag, deadline, server_ops) |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 338 | |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 339 | # client receives nothing as expected |
| 340 | client_ops = { |
| 341 | CallOps::RECV_INITIAL_METADATA => nil |
| 342 | } |
| 343 | batch_result = call.run_batch(@client_queue, @client_tag, deadline, |
| 344 | client_ops) |
| 345 | expect(batch_result.metadata).to eq({}) |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 346 | end |
| 347 | |
Tim Emiola | 5d66df8 | 2015-02-09 12:35:10 -0800 | [diff] [blame] | 348 | it 'sends all the pairs when keys and values are valid' do |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 349 | @valid_metadata.each do |md| |
Craig Tiller | 09600be | 2015-05-13 16:46:55 -0700 | [diff] [blame^] | 350 | recvd_rpc = nil |
| 351 | rcv_thread = Thread.new do |
| 352 | recvd_rpc = @server.request_call(@server_queue, @server_tag, deadline) |
| 353 | end |
| 354 | |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 355 | call = new_client_call |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 356 | # client signals that it's done sending metadata to allow server to |
| 357 | # respond |
| 358 | client_ops = { |
| 359 | CallOps::SEND_INITIAL_METADATA => nil |
| 360 | } |
| 361 | call.run_batch(@client_queue, @client_tag, deadline, client_ops) |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 362 | |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 363 | # server gets the invocation but sends no metadata back |
Craig Tiller | 09600be | 2015-05-13 16:46:55 -0700 | [diff] [blame^] | 364 | rcv_thread.join |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 365 | expect(recvd_rpc).to_not eq nil |
| 366 | server_call = recvd_rpc.call |
| 367 | server_ops = { |
| 368 | CallOps::SEND_INITIAL_METADATA => md |
| 369 | } |
| 370 | server_call.run_batch(@server_queue, @server_tag, deadline, server_ops) |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 371 | |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 372 | # client receives nothing as expected |
| 373 | client_ops = { |
| 374 | CallOps::RECV_INITIAL_METADATA => nil |
| 375 | } |
| 376 | batch_result = call.run_batch(@client_queue, @client_tag, deadline, |
| 377 | client_ops) |
Tim Emiola | e2860c5 | 2015-01-16 02:58:41 -0800 | [diff] [blame] | 378 | replace_symbols = Hash[md.each_pair.collect { |x, y| [x.to_s, y] }] |
Tim Emiola | 05e934f | 2015-03-28 15:19:34 -0700 | [diff] [blame] | 379 | expect(batch_result.metadata).to eq(replace_symbols) |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 380 | end |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 381 | end |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 382 | end |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 383 | end |
| 384 | |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 385 | describe 'the http client/server' do |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 386 | before(:example) do |
Tim Emiola | 75d7f9a | 2015-01-26 16:57:33 -0800 | [diff] [blame] | 387 | server_host = '0.0.0.0:0' |
nnoble | 0c475f0 | 2014-12-05 15:37:39 -0800 | [diff] [blame] | 388 | @client_queue = GRPC::Core::CompletionQueue.new |
| 389 | @server_queue = GRPC::Core::CompletionQueue.new |
| 390 | @server = GRPC::Core::Server.new(@server_queue, nil) |
Tim Emiola | 0343b10 | 2015-01-26 17:06:51 -0800 | [diff] [blame] | 391 | server_port = @server.add_http2_port(server_host) |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 392 | @server.start |
Tim Emiola | 75d7f9a | 2015-01-26 16:57:33 -0800 | [diff] [blame] | 393 | @ch = Channel.new("0.0.0.0:#{server_port}", nil) |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 394 | end |
| 395 | |
| 396 | after(:example) do |
Tim Emiola | 75d7f9a | 2015-01-26 16:57:33 -0800 | [diff] [blame] | 397 | @ch.close |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 398 | @server.close |
| 399 | end |
| 400 | |
nnoble | 0c475f0 | 2014-12-05 15:37:39 -0800 | [diff] [blame] | 401 | it_behaves_like 'basic GRPC message delivery is OK' do |
| 402 | end |
| 403 | |
| 404 | it_behaves_like 'GRPC metadata delivery works OK' do |
| 405 | end |
nnoble | 0c475f0 | 2014-12-05 15:37:39 -0800 | [diff] [blame] | 406 | end |
| 407 | |
| 408 | describe 'the secure http client/server' do |
nnoble | 0c475f0 | 2014-12-05 15:37:39 -0800 | [diff] [blame] | 409 | before(:example) do |
| 410 | certs = load_test_certs |
Tim Emiola | 0ce8edc | 2015-03-05 15:17:30 -0800 | [diff] [blame] | 411 | server_host = '0.0.0.0:0' |
nnoble | 0c475f0 | 2014-12-05 15:37:39 -0800 | [diff] [blame] | 412 | @client_queue = GRPC::Core::CompletionQueue.new |
| 413 | @server_queue = GRPC::Core::CompletionQueue.new |
| 414 | server_creds = GRPC::Core::ServerCredentials.new(nil, certs[1], certs[2]) |
Tim Emiola | 0ce8edc | 2015-03-05 15:17:30 -0800 | [diff] [blame] | 415 | @server = GRPC::Core::Server.new(@server_queue, nil) |
| 416 | server_port = @server.add_http2_port(server_host, server_creds) |
nnoble | 0c475f0 | 2014-12-05 15:37:39 -0800 | [diff] [blame] | 417 | @server.start |
Julien Boeuf | 597a4f2 | 2015-02-23 15:57:14 -0800 | [diff] [blame] | 418 | args = { Channel::SSL_TARGET => 'foo.test.google.fr' } |
Tim Emiola | 2b90e30 | 2015-01-26 17:37:15 -0800 | [diff] [blame] | 419 | @ch = Channel.new("0.0.0.0:#{server_port}", args, |
nnoble | 0c475f0 | 2014-12-05 15:37:39 -0800 | [diff] [blame] | 420 | GRPC::Core::Credentials.new(certs[0], nil, nil)) |
| 421 | end |
| 422 | |
| 423 | after(:example) do |
| 424 | @server.close |
| 425 | end |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 426 | |
Tim Emiola | 0ce8edc | 2015-03-05 15:17:30 -0800 | [diff] [blame] | 427 | it_behaves_like 'basic GRPC message delivery is OK' do |
| 428 | end |
nnoble | 097ef9b | 2014-12-01 17:06:10 -0800 | [diff] [blame] | 429 | |
Tim Emiola | 0ce8edc | 2015-03-05 15:17:30 -0800 | [diff] [blame] | 430 | it_behaves_like 'GRPC metadata delivery works OK' do |
| 431 | end |
Craig Tiller | 190d360 | 2015-02-18 09:23:38 -0800 | [diff] [blame] | 432 | end |