grpc 1.66.0.pre5-arm64-darwin → 1.67.0-arm64-darwin

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -16,36 +16,8 @@ require 'spec_helper'
16
16
 
17
17
  include GRPC::Core
18
18
 
19
- shared_context 'setup: tags' do
20
- let(:sent_message) { 'sent message' }
21
- let(:reply_text) { 'the reply' }
22
-
23
- def deadline
24
- Time.now + 5
25
- end
26
-
27
- def server_allows_client_to_proceed(metadata = {})
28
- recvd_rpc = @server.request_call
29
- expect(recvd_rpc).to_not eq nil
30
- server_call = recvd_rpc.call
31
- ops = { CallOps::SEND_INITIAL_METADATA => metadata }
32
- server_batch = server_call.run_batch(ops)
33
- expect(server_batch.send_metadata).to be true
34
- server_call
35
- end
36
-
37
- def new_client_call
38
- @ch.create_call(nil, nil, '/method', nil, deadline)
39
- end
40
-
41
- def ok_status
42
- Struct::Status.new(StatusCodes::OK, 'OK')
43
- end
44
- end
45
-
46
19
  shared_examples 'basic GRPC message delivery is OK' do
47
20
  include GRPC::Core
48
- include_context 'setup: tags'
49
21
 
50
22
  context 'the test channel' do
51
23
  it 'should have a target' do
@@ -53,272 +25,45 @@ shared_examples 'basic GRPC message delivery is OK' do
53
25
  end
54
26
  end
55
27
 
56
- context 'a client call' do
57
- it 'should have a peer' do
58
- expect(new_client_call.peer).to be_a(String)
59
- end
60
- end
61
-
62
- it 'calls have peer info' do
63
- call = new_client_call
64
- expect(call.peer).to be_a(String)
65
- end
66
-
67
- it 'servers receive requests from clients and can respond' do
68
- call = new_client_call
69
- server_call = nil
70
-
71
- server_thread = Thread.new do
72
- server_call = server_allows_client_to_proceed
73
- end
74
-
75
- client_ops = {
76
- CallOps::SEND_INITIAL_METADATA => {},
77
- CallOps::SEND_MESSAGE => sent_message,
78
- CallOps::SEND_CLOSE_FROM_CLIENT => nil
79
- }
80
- client_batch = call.run_batch(client_ops)
81
- expect(client_batch.send_metadata).to be true
82
- expect(client_batch.send_message).to be true
83
- expect(client_batch.send_close).to be true
84
-
85
- # confirm the server can read the inbound message
86
- server_thread.join
87
- server_ops = {
88
- CallOps::RECV_MESSAGE => nil
89
- }
90
- server_batch = server_call.run_batch(server_ops)
91
- expect(server_batch.message).to eq(sent_message)
92
- server_ops = {
93
- CallOps::RECV_CLOSE_ON_SERVER => nil,
94
- CallOps::SEND_STATUS_FROM_SERVER => ok_status
95
- }
96
- server_batch = server_call.run_batch(server_ops)
97
- expect(server_batch.send_close).to be true
98
- expect(server_batch.send_status).to be true
99
-
100
- # finish the call
101
- final_client_batch = call.run_batch(
102
- CallOps::RECV_INITIAL_METADATA => nil,
103
- CallOps::RECV_STATUS_ON_CLIENT => nil)
104
- expect(final_client_batch.metadata).to eq({})
105
- expect(final_client_batch.status.code).to eq(0)
106
- end
107
-
108
- it 'responses written by servers are received by the client' do
109
- call = new_client_call
110
- server_call = nil
111
-
112
- server_thread = Thread.new do
113
- server_call = server_allows_client_to_proceed
114
- end
115
-
116
- client_ops = {
117
- CallOps::SEND_INITIAL_METADATA => {},
118
- CallOps::SEND_MESSAGE => sent_message,
119
- CallOps::SEND_CLOSE_FROM_CLIENT => nil
120
- }
121
- client_batch = call.run_batch(client_ops)
122
- expect(client_batch.send_metadata).to be true
123
- expect(client_batch.send_message).to be true
124
- expect(client_batch.send_close).to be true
125
-
126
- # confirm the server can read the inbound message
127
- server_thread.join
128
- server_ops = {
129
- CallOps::RECV_MESSAGE => nil
130
- }
131
- server_batch = server_call.run_batch(server_ops)
132
- expect(server_batch.message).to eq(sent_message)
133
- server_ops = {
134
- CallOps::RECV_CLOSE_ON_SERVER => nil,
135
- CallOps::SEND_MESSAGE => reply_text,
136
- CallOps::SEND_STATUS_FROM_SERVER => ok_status
137
- }
138
- server_batch = server_call.run_batch(server_ops)
139
- expect(server_batch.send_close).to be true
140
- expect(server_batch.send_message).to be true
141
- expect(server_batch.send_status).to be true
142
-
143
- # finish the call
144
- final_client_batch = call.run_batch(
145
- CallOps::RECV_INITIAL_METADATA => nil,
146
- CallOps::RECV_MESSAGE => nil,
147
- CallOps::RECV_STATUS_ON_CLIENT => nil)
148
- expect(final_client_batch.metadata).to eq({})
149
- expect(final_client_batch.message).to eq(reply_text)
150
- expect(final_client_batch.status.code).to eq(0)
151
- end
152
-
153
- it 'compressed messages can be sent and received' do
154
- call = new_client_call
155
- server_call = nil
156
- long_request_str = '0' * 2000
157
- long_response_str = '1' * 2000
158
- md = { 'grpc-internal-encoding-request' => 'gzip' }
159
-
160
- server_thread = Thread.new do
161
- server_call = server_allows_client_to_proceed(md)
28
+ it 'unary calls work' do
29
+ run_services_on_server(@server, services: [EchoService]) do
30
+ call = @stub.an_rpc(EchoMsg.new, return_op: true)
31
+ expect(call.execute).to be_a(EchoMsg)
162
32
  end
163
-
164
- client_ops = {
165
- CallOps::SEND_INITIAL_METADATA => md,
166
- CallOps::SEND_MESSAGE => long_request_str,
167
- CallOps::SEND_CLOSE_FROM_CLIENT => nil
168
- }
169
- client_batch = call.run_batch(client_ops)
170
- expect(client_batch.send_metadata).to be true
171
- expect(client_batch.send_message).to be true
172
- expect(client_batch.send_close).to be true
173
-
174
- # confirm the server can read the inbound message
175
- server_thread.join
176
- server_ops = {
177
- CallOps::RECV_MESSAGE => nil
178
- }
179
- server_batch = server_call.run_batch(server_ops)
180
- expect(server_batch.message).to eq(long_request_str)
181
- server_ops = {
182
- CallOps::RECV_CLOSE_ON_SERVER => nil,
183
- CallOps::SEND_MESSAGE => long_response_str,
184
- CallOps::SEND_STATUS_FROM_SERVER => ok_status
185
- }
186
- server_batch = server_call.run_batch(server_ops)
187
- expect(server_batch.send_close).to be true
188
- expect(server_batch.send_message).to be true
189
- expect(server_batch.send_status).to be true
190
-
191
- client_ops = {
192
- CallOps::RECV_INITIAL_METADATA => nil,
193
- CallOps::RECV_MESSAGE => nil,
194
- CallOps::RECV_STATUS_ON_CLIENT => nil
195
- }
196
- final_client_batch = call.run_batch(client_ops)
197
- expect(final_client_batch.metadata).to eq({})
198
- expect(final_client_batch.message).to eq long_response_str
199
- expect(final_client_batch.status.code).to eq(0)
200
33
  end
201
34
 
202
- it 'servers can ignore a client write and send a status' do
203
- call = new_client_call
204
- server_call = nil
205
-
206
- server_thread = Thread.new do
207
- server_call = server_allows_client_to_proceed
35
+ it 'unary calls work when enabling compression' do
36
+ run_services_on_server(@server, services: [EchoService]) do
37
+ long_request_str = '0' * 2000
38
+ md = { 'grpc-internal-encoding-request' => 'gzip' }
39
+ call = @stub.an_rpc(EchoMsg.new(msg: long_request_str),
40
+ return_op: true,
41
+ metadata: md)
42
+ response = call.execute
43
+ expect(response).to be_a(EchoMsg)
44
+ expect(response.msg).to eq(long_request_str)
208
45
  end
209
-
210
- client_ops = {
211
- CallOps::SEND_INITIAL_METADATA => {},
212
- CallOps::SEND_MESSAGE => sent_message,
213
- CallOps::SEND_CLOSE_FROM_CLIENT => nil
214
- }
215
- client_batch = call.run_batch(client_ops)
216
- expect(client_batch.send_metadata).to be true
217
- expect(client_batch.send_message).to be true
218
- expect(client_batch.send_close).to be true
219
-
220
- # confirm the server can read the inbound message
221
- the_status = Struct::Status.new(StatusCodes::OK, 'OK')
222
- server_thread.join
223
- server_ops = {
224
- CallOps::SEND_STATUS_FROM_SERVER => the_status
225
- }
226
- server_batch = server_call.run_batch(server_ops)
227
- expect(server_batch.message).to eq nil
228
- expect(server_batch.send_status).to be true
229
-
230
- final_client_batch = call.run_batch(
231
- CallOps::RECV_INITIAL_METADATA => nil,
232
- CallOps::RECV_STATUS_ON_CLIENT => nil)
233
- expect(final_client_batch.metadata).to eq({})
234
- expect(final_client_batch.status.code).to eq(0)
235
- end
236
-
237
- it 'completes calls by sending status to client and server' do
238
- call = new_client_call
239
- server_call = nil
240
-
241
- server_thread = Thread.new do
242
- server_call = server_allows_client_to_proceed
243
- end
244
-
245
- client_ops = {
246
- CallOps::SEND_INITIAL_METADATA => {},
247
- CallOps::SEND_MESSAGE => sent_message
248
- }
249
- client_batch = call.run_batch(client_ops)
250
- expect(client_batch.send_metadata).to be true
251
- expect(client_batch.send_message).to be true
252
-
253
- # confirm the server can read the inbound message and respond
254
- the_status = Struct::Status.new(StatusCodes::OK, 'OK', {})
255
- server_thread.join
256
- server_ops = {
257
- CallOps::RECV_MESSAGE => nil
258
- }
259
- server_batch = server_call.run_batch(server_ops)
260
- expect(server_batch.message).to eq sent_message
261
- server_ops = {
262
- CallOps::SEND_MESSAGE => reply_text,
263
- CallOps::SEND_STATUS_FROM_SERVER => the_status
264
- }
265
- server_batch = server_call.run_batch(server_ops)
266
- expect(server_batch.send_status).to be true
267
- expect(server_batch.send_message).to be true
268
-
269
- # confirm the client can receive the server response and status.
270
- client_ops = {
271
- CallOps::SEND_CLOSE_FROM_CLIENT => nil,
272
- CallOps::RECV_INITIAL_METADATA => nil,
273
- CallOps::RECV_MESSAGE => nil,
274
- CallOps::RECV_STATUS_ON_CLIENT => nil
275
- }
276
- final_client_batch = call.run_batch(client_ops)
277
- expect(final_client_batch.send_close).to be true
278
- expect(final_client_batch.message).to eq reply_text
279
- expect(final_client_batch.status).to eq the_status
280
-
281
- # confirm the server can receive the client close.
282
- server_ops = {
283
- CallOps::RECV_CLOSE_ON_SERVER => nil
284
- }
285
- final_server_batch = server_call.run_batch(server_ops)
286
- expect(final_server_batch.send_close).to be true
287
46
  end
288
47
 
289
48
  def client_cancel_test(cancel_proc, expected_code,
290
49
  expected_details)
291
- call = new_client_call
292
- server_call = nil
293
-
294
- server_thread = Thread.new do
295
- server_call = server_allows_client_to_proceed
50
+ call = @stub.an_rpc(EchoMsg.new, return_op: true)
51
+ run_services_on_server(@server, services: [EchoService]) do
52
+ # start the call, but don't send a message yet
53
+ call.start_call
54
+ # cancel the call
55
+ cancel_proc.call(call)
56
+ # check the client's status
57
+ failed = false
58
+ begin
59
+ call.execute
60
+ rescue GRPC::BadStatus => e
61
+ failed = true
62
+ expect(e.code).to be expected_code
63
+ expect(e.details).to eq expected_details
64
+ end
65
+ expect(failed).to be(true)
296
66
  end
297
-
298
- client_ops = {
299
- CallOps::SEND_INITIAL_METADATA => {},
300
- CallOps::RECV_INITIAL_METADATA => nil
301
- }
302
- client_batch = call.run_batch(client_ops)
303
- expect(client_batch.send_metadata).to be true
304
- expect(client_batch.metadata).to eq({})
305
-
306
- cancel_proc.call(call)
307
-
308
- server_thread.join
309
- server_ops = {
310
- CallOps::RECV_CLOSE_ON_SERVER => nil
311
- }
312
- server_batch = server_call.run_batch(server_ops)
313
- expect(server_batch.send_close).to be true
314
-
315
- client_ops = {
316
- CallOps::RECV_STATUS_ON_CLIENT => {}
317
- }
318
- client_batch = call.run_batch(client_ops)
319
-
320
- expect(client_batch.status.code).to be expected_code
321
- expect(client_batch.status.details).to eq expected_details
322
67
  end
323
68
 
324
69
  it 'clients can cancel a call on the server' do
@@ -344,8 +89,6 @@ shared_examples 'basic GRPC message delivery is OK' do
344
89
  end
345
90
 
346
91
  shared_examples 'GRPC metadata delivery works OK' do
347
- include_context 'setup: tags'
348
-
349
92
  describe 'from client => server' do
350
93
  before(:example) do
351
94
  n = 7 # arbitrary number of metadata
@@ -364,53 +107,31 @@ shared_examples 'GRPC metadata delivery works OK' do
364
107
 
365
108
  it 'raises an exception if a metadata key is invalid' do
366
109
  @bad_keys.each do |md|
367
- call = new_client_call
368
- client_ops = {
369
- CallOps::SEND_INITIAL_METADATA => md
370
- }
371
- blk = proc do
372
- call.run_batch(client_ops)
110
+ # NOTE: no need to run a server in this test b/c the failure
111
+ # happens while validating metadata to send.
112
+ failed = false
113
+ begin
114
+ @stub.an_rpc(EchoMsg.new, metadata: md)
115
+ rescue TypeError => e
116
+ failed = true
117
+ expect(e.message).to eq('grpc_rb_md_ary_fill_hash_cb: bad type for key parameter')
373
118
  end
374
- expect(&blk).to raise_error
119
+ expect(failed).to be(true)
375
120
  end
376
121
  end
377
122
 
378
123
  it 'sends all the metadata pairs when keys and values are valid' do
379
- @valid_metadata.each do |md|
380
- recvd_rpc = nil
381
- rcv_thread = Thread.new do
382
- recvd_rpc = @server.request_call
124
+ service = EchoService.new
125
+ run_services_on_server(@server, services: [service]) do
126
+ @valid_metadata.each_with_index do |md, i|
127
+ expect(@stub.an_rpc(EchoMsg.new, metadata: md)).to be_a(EchoMsg)
128
+ # confirm the server can receive the client metadata
129
+ # finish the call
130
+ expect(service.received_md.length).to eq(i + 1)
131
+ md.each do |k, v|
132
+ expect(service.received_md[i][k.to_s]).to eq(v)
133
+ end
383
134
  end
384
-
385
- call = new_client_call
386
- client_ops = {
387
- CallOps::SEND_INITIAL_METADATA => md,
388
- CallOps::SEND_CLOSE_FROM_CLIENT => nil
389
- }
390
- client_batch = call.run_batch(client_ops)
391
- expect(client_batch.send_metadata).to be true
392
-
393
- # confirm the server can receive the client metadata
394
- rcv_thread.join
395
- expect(recvd_rpc).to_not eq nil
396
- recvd_md = recvd_rpc.metadata
397
- replace_symbols = Hash[md.each_pair.collect { |x, y| [x.to_s, y] }]
398
- expect(recvd_md).to eq(recvd_md.merge(replace_symbols))
399
-
400
- # finish the call
401
- final_server_batch = recvd_rpc.call.run_batch(
402
- CallOps::RECV_CLOSE_ON_SERVER => nil,
403
- CallOps::SEND_INITIAL_METADATA => nil,
404
- CallOps::SEND_STATUS_FROM_SERVER => ok_status)
405
- expect(final_server_batch.send_close).to be(true)
406
- expect(final_server_batch.send_metadata).to be(true)
407
- expect(final_server_batch.send_status).to be(true)
408
-
409
- final_client_batch = call.run_batch(
410
- CallOps::RECV_INITIAL_METADATA => nil,
411
- CallOps::RECV_STATUS_ON_CLIENT => nil)
412
- expect(final_client_batch.metadata).to eq({})
413
- expect(final_client_batch.status.code).to eq(0)
414
135
  end
415
136
  end
416
137
  end
@@ -432,120 +153,61 @@ shared_examples 'GRPC metadata delivery works OK' do
432
153
  end
433
154
 
434
155
  it 'raises an exception if a metadata key is invalid' do
435
- @bad_keys.each do |md|
436
- recvd_rpc = nil
437
- rcv_thread = Thread.new do
438
- recvd_rpc = @server.request_call
439
- end
440
-
441
- call = new_client_call
442
- # client signals that it's done sending metadata to allow server to
443
- # respond
444
- client_ops = {
445
- CallOps::SEND_INITIAL_METADATA => nil
446
- }
447
- call.run_batch(client_ops)
448
-
449
- # server gets the invocation
450
- rcv_thread.join
451
- expect(recvd_rpc).to_not eq nil
452
- server_ops = {
453
- CallOps::SEND_INITIAL_METADATA => md
454
- }
455
- blk = proc do
456
- recvd_rpc.call.run_batch(server_ops)
156
+ service = EchoService.new
157
+ run_services_on_server(@server, services: [service]) do
158
+ @bad_keys.each do |md|
159
+ proceed = Queue.new
160
+ server_exception = nil
161
+ service.on_call_started = proc do |call|
162
+ call.send_initial_metadata(md)
163
+ rescue TypeError => e
164
+ server_exception = e
165
+ ensure
166
+ proceed.push(1)
167
+ end
168
+ client_exception = nil
169
+ client_call = @stub.an_rpc(EchoMsg.new, return_op: true)
170
+ thr = Thread.new do
171
+ client_call.execute
172
+ rescue GRPC::BadStatus => e
173
+ client_exception = e
174
+ end
175
+ proceed.pop
176
+ # TODO(apolcyn): we shouldn't need this cancel here. It's
177
+ # only currently needed b/c the server does not seem to properly
178
+ # terminate the RPC if it fails to send initial metadata. That
179
+ # should be fixed, in which case this cancellation can be removed.
180
+ client_call.cancel
181
+ thr.join
182
+ p client_exception
183
+ expect(client_exception.nil?).to be(false)
184
+ expect(server_exception.nil?).to be(false)
185
+ expect(server_exception.message).to eq(
186
+ 'grpc_rb_md_ary_fill_hash_cb: bad type for key parameter')
457
187
  end
458
- expect(&blk).to raise_error
459
-
460
- # cancel the call so the server can shut down immediately
461
- call.cancel
462
188
  end
463
189
  end
464
190
 
465
191
  it 'sends an empty hash if no metadata is added' do
466
- recvd_rpc = nil
467
- rcv_thread = Thread.new do
468
- recvd_rpc = @server.request_call
192
+ run_services_on_server(@server, services: [EchoService]) do
193
+ call = @stub.an_rpc(EchoMsg.new, return_op: true)
194
+ expect(call.execute).to be_a(EchoMsg)
195
+ expect(call.metadata).to eq({})
469
196
  end
470
-
471
- call = new_client_call
472
- # client signals that it's done sending metadata to allow server to
473
- # respond
474
- client_ops = {
475
- CallOps::SEND_INITIAL_METADATA => nil,
476
- CallOps::SEND_CLOSE_FROM_CLIENT => nil
477
- }
478
- client_batch = call.run_batch(client_ops)
479
- expect(client_batch.send_metadata).to be true
480
- expect(client_batch.send_close).to be true
481
-
482
- # server gets the invocation but sends no metadata back
483
- rcv_thread.join
484
- expect(recvd_rpc).to_not eq nil
485
- server_call = recvd_rpc.call
486
- server_ops = {
487
- # receive close and send status to finish the call
488
- CallOps::RECV_CLOSE_ON_SERVER => nil,
489
- CallOps::SEND_INITIAL_METADATA => nil,
490
- CallOps::SEND_STATUS_FROM_SERVER => ok_status
491
- }
492
- srv_batch = server_call.run_batch(server_ops)
493
- expect(srv_batch.send_close).to be true
494
- expect(srv_batch.send_metadata).to be true
495
- expect(srv_batch.send_status).to be true
496
-
497
- # client receives nothing as expected
498
- client_ops = {
499
- CallOps::RECV_INITIAL_METADATA => nil,
500
- # receive status to finish the call
501
- CallOps::RECV_STATUS_ON_CLIENT => nil
502
- }
503
- final_client_batch = call.run_batch(client_ops)
504
- expect(final_client_batch.metadata).to eq({})
505
- expect(final_client_batch.status.code).to eq(0)
506
197
  end
507
198
 
508
199
  it 'sends all the pairs when keys and values are valid' do
509
- @valid_metadata.each do |md|
510
- recvd_rpc = nil
511
- rcv_thread = Thread.new do
512
- recvd_rpc = @server.request_call
200
+ service = EchoService.new
201
+ run_services_on_server(@server, services: [service]) do
202
+ @valid_metadata.each do |md|
203
+ service.on_call_started = proc do |call|
204
+ call.send_initial_metadata(md)
205
+ end
206
+ call = @stub.an_rpc(EchoMsg.new, return_op: true)
207
+ call.execute
208
+ replace_symbols = Hash[md.each_pair.collect { |x, y| [x.to_s, y] }]
209
+ expect(call.metadata).to eq(replace_symbols)
513
210
  end
514
-
515
- call = new_client_call
516
- # client signals that it's done sending metadata to allow server to
517
- # respond
518
- client_ops = {
519
- CallOps::SEND_INITIAL_METADATA => nil,
520
- CallOps::SEND_CLOSE_FROM_CLIENT => nil
521
- }
522
- client_batch = call.run_batch(client_ops)
523
- expect(client_batch.send_metadata).to be true
524
- expect(client_batch.send_close).to be true
525
-
526
- # server gets the invocation but sends no metadata back
527
- rcv_thread.join
528
- expect(recvd_rpc).to_not eq nil
529
- server_call = recvd_rpc.call
530
- server_ops = {
531
- CallOps::RECV_CLOSE_ON_SERVER => nil,
532
- CallOps::SEND_INITIAL_METADATA => md,
533
- CallOps::SEND_STATUS_FROM_SERVER => ok_status
534
- }
535
- srv_batch = server_call.run_batch(server_ops)
536
- expect(srv_batch.send_close).to be true
537
- expect(srv_batch.send_metadata).to be true
538
- expect(srv_batch.send_status).to be true
539
-
540
- # client receives nothing as expected
541
- client_ops = {
542
- CallOps::RECV_INITIAL_METADATA => nil,
543
- CallOps::RECV_STATUS_ON_CLIENT => nil
544
- }
545
- final_client_batch = call.run_batch(client_ops)
546
- replace_symbols = Hash[md.each_pair.collect { |x, y| [x.to_s, y] }]
547
- expect(final_client_batch.metadata).to eq(replace_symbols)
548
- expect(final_client_batch.status.code).to eq(0)
549
211
  end
550
212
  end
551
213
  end
@@ -554,16 +216,11 @@ end
554
216
  describe 'the http client/server' do
555
217
  before(:example) do
556
218
  server_host = '0.0.0.0:0'
557
- @server = new_core_server_for_testing(nil)
219
+ @server = new_rpc_server_for_testing
558
220
  server_port = @server.add_http2_port(server_host, :this_port_is_insecure)
559
- @server.start
560
221
  @ch = Channel.new("0.0.0.0:#{server_port}", nil, :this_channel_is_insecure)
561
- end
562
-
563
- after(:example) do
564
- @ch.close
565
- @server.shutdown_and_notify(deadline)
566
- @server.close
222
+ @stub = EchoStub.new(
223
+ "0.0.0.0:#{server_port}", nil, channel_override: @ch)
567
224
  end
568
225
 
569
226
  it_behaves_like 'basic GRPC message delivery is OK' do
@@ -574,8 +231,6 @@ describe 'the http client/server' do
574
231
  end
575
232
 
576
233
  describe 'the secure http client/server' do
577
- include_context 'setup: tags'
578
-
579
234
  def load_test_certs
580
235
  test_root = File.join(File.dirname(__FILE__), 'testdata')
581
236
  files = ['ca.pem', 'server1.key', 'server1.pem']
@@ -587,17 +242,14 @@ describe 'the secure http client/server' do
587
242
  server_host = '0.0.0.0:0'
588
243
  server_creds = GRPC::Core::ServerCredentials.new(
589
244
  nil, [{ private_key: certs[1], cert_chain: certs[2] }], false)
590
- @server = new_core_server_for_testing(nil)
245
+ @server = new_rpc_server_for_testing
591
246
  server_port = @server.add_http2_port(server_host, server_creds)
592
- @server.start
593
247
  args = { Channel::SSL_TARGET => 'foo.test.google.fr' }
594
- @ch = Channel.new("0.0.0.0:#{server_port}", args,
595
- GRPC::Core::ChannelCredentials.new(certs[0], nil, nil))
596
- end
597
-
598
- after(:example) do
599
- @server.shutdown_and_notify(deadline)
600
- @server.close
248
+ @ch = Channel.new(
249
+ "0.0.0.0:#{server_port}", args,
250
+ GRPC::Core::ChannelCredentials.new(certs[0], nil, nil))
251
+ @stub = EchoStub.new(
252
+ "0.0.0.0:#{server_port}", nil, channel_override: @ch)
601
253
  end
602
254
 
603
255
  it_behaves_like 'basic GRPC message delivery is OK' do
@@ -606,59 +258,25 @@ describe 'the secure http client/server' do
606
258
  it_behaves_like 'GRPC metadata delivery works OK' do
607
259
  end
608
260
 
609
- def credentials_update_test(creds_update_md)
610
- auth_proc = proc { creds_update_md }
261
+ it 'modifies metadata with CallCredentials' do
262
+ # create call creds
263
+ auth_proc = proc { { 'k1' => 'v1' } }
611
264
  call_creds = GRPC::Core::CallCredentials.new(auth_proc)
612
-
613
- initial_md_key = 'k2'
614
- initial_md_val = 'v2'
615
- initial_md = { initial_md_key => initial_md_val }
616
- expected_md = creds_update_md.clone
617
- fail 'bad test param' unless expected_md[initial_md_key].nil?
618
- expected_md[initial_md_key] = initial_md_val
619
-
620
- recvd_rpc = nil
621
- rcv_thread = Thread.new do
622
- recvd_rpc = @server.request_call
265
+ # create arbitrary custom metadata
266
+ custom_md = { 'k2' => 'v2' }
267
+ # perform an RPC
268
+ echo_service = EchoService.new
269
+ run_services_on_server(@server, services: [echo_service]) do
270
+ expect(@stub.an_rpc(EchoMsg.new,
271
+ credentials: call_creds,
272
+ metadata: custom_md)).to be_a(EchoMsg)
273
+ end
274
+ # call creds metadata should be merged with custom MD
275
+ expect(echo_service.received_md.length).to eq(1)
276
+ expected_md = { 'k1' => 'v1', 'k2' => 'v2' }
277
+ expected_md.each do |k, v|
278
+ expect(echo_service.received_md[0][k]).to eq(v)
623
279
  end
624
-
625
- call = new_client_call
626
- call.set_credentials! call_creds
627
-
628
- client_batch = call.run_batch(
629
- CallOps::SEND_INITIAL_METADATA => initial_md,
630
- CallOps::SEND_CLOSE_FROM_CLIENT => nil)
631
- expect(client_batch.send_metadata).to be true
632
- expect(client_batch.send_close).to be true
633
-
634
- # confirm the server can receive the client metadata
635
- rcv_thread.join
636
- expect(recvd_rpc).to_not eq nil
637
- recvd_md = recvd_rpc.metadata
638
- replace_symbols = Hash[expected_md.each_pair.collect { |x, y| [x.to_s, y] }]
639
- expect(recvd_md).to eq(recvd_md.merge(replace_symbols))
640
-
641
- credentials_update_test_finish_call(call, recvd_rpc.call)
642
- end
643
-
644
- def credentials_update_test_finish_call(client_call, server_call)
645
- final_server_batch = server_call.run_batch(
646
- CallOps::RECV_CLOSE_ON_SERVER => nil,
647
- CallOps::SEND_INITIAL_METADATA => nil,
648
- CallOps::SEND_STATUS_FROM_SERVER => ok_status)
649
- expect(final_server_batch.send_close).to be(true)
650
- expect(final_server_batch.send_metadata).to be(true)
651
- expect(final_server_batch.send_status).to be(true)
652
-
653
- final_client_batch = client_call.run_batch(
654
- CallOps::RECV_INITIAL_METADATA => nil,
655
- CallOps::RECV_STATUS_ON_CLIENT => nil)
656
- expect(final_client_batch.metadata).to eq({})
657
- expect(final_client_batch.status.code).to eq(0)
658
- end
659
-
660
- it 'modifies metadata with CallCredentials' do
661
- credentials_update_test('k1' => 'updated-v1')
662
280
  end
663
281
 
664
282
  it 'modifies large metadata with CallCredentials' do
@@ -666,11 +284,34 @@ describe 'the secure http client/server' do
666
284
  '00000000000000000000000000000000000000000000000000000000000000',
667
285
  '11111111111111111111111111111111111111111111111111111111111111',
668
286
  )
669
- md = {
670
- k3: val_array,
671
- k4: '0000000000000000000000000000000000000000000000000000000000',
672
- keeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeey5: 'v1'
287
+ # create call creds
288
+ auth_proc = proc do
289
+ {
290
+ k2: val_array,
291
+ k3: '0000000000000000000000000000000000000000000000000000000000',
292
+ keeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeey4: 'v4'
293
+ }
294
+ end
295
+ call_creds = GRPC::Core::CallCredentials.new(auth_proc)
296
+ # create arbitrary custom metadata
297
+ custom_md = { k1: 'v1' }
298
+ # perform an RPC
299
+ echo_service = EchoService.new
300
+ run_services_on_server(@server, services: [echo_service]) do
301
+ expect(@stub.an_rpc(EchoMsg.new,
302
+ credentials: call_creds,
303
+ metadata: custom_md)).to be_a(EchoMsg)
304
+ end
305
+ # call creds metadata should be merged with custom MD
306
+ expect(echo_service.received_md.length).to eq(1)
307
+ expected_md = {
308
+ k1: 'v1',
309
+ k2: val_array,
310
+ k3: '0000000000000000000000000000000000000000000000000000000000',
311
+ keeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeey4: 'v4'
673
312
  }
674
- credentials_update_test(md)
313
+ expected_md.each do |k, v|
314
+ expect(echo_service.received_md[0][k.to_s]).to eq(v)
315
+ end
675
316
  end
676
317
  end