class NamedTests
defines methods corresponding to each interop test case.
Public Class Methods
new(stub, args)
click to toggle source
# File src/ruby/pb/test/client.rb, line 259 def initialize(stub, args) @stub = stub @args = args end
Public Instance Methods
all()
click to toggle source
# File src/ruby/pb/test/client.rb, line 652 def all all_methods = NamedTests.instance_methods(false).map(&:to_s) all_methods.each do |m| next if m == 'all' || m.start_with?('assert') p "TESTCASE: #{m}" method(m).call end end
cancel_after_begin()
click to toggle source
# File src/ruby/pb/test/client.rb, line 479 def cancel_after_begin msg_sizes = [27_182, 8, 1828, 45_904] reqs = msg_sizes.map do |x| req = Payload.new(body: nulls(x)) StreamingInputCallRequest.new(payload: req) end op = @stub.streaming_input_call(reqs, return_op: true) op.cancel op.execute fail 'Should have raised GRPC:Cancelled' rescue GRPC::Cancelled assert("#{__callee__}: call operation should be CANCELLED") { op.cancelled? } end
cancel_after_first_response()
click to toggle source
# File src/ruby/pb/test/client.rb, line 493 def cancel_after_first_response msg_sizes = [[27_182, 31_415], [8, 9], [1828, 2653], [45_904, 58_979]] ppp = PingPongPlayer.new(msg_sizes) op = @stub.full_duplex_call(ppp.each_item, return_op: true) ppp.canceller_op = op # causes ppp to cancel after the 1st message op.execute.each { |r| ppp.queue.push(r) } fail 'Should have raised GRPC:Cancelled' rescue GRPC::Cancelled assert("#{__callee__}: call operation should be CANCELLED") { op.cancelled? } op.wait end
client_compressed_streaming()
click to toggle source
# File src/ruby/pb/test/client.rb, line 389 def client_compressed_streaming # first request used also by the probe first_request = StreamingInputCallRequest.new( payload: Payload.new(type: :COMPRESSABLE, body: nulls(27_182)), expect_compressed: BoolValue.new(value: true) ) # send a probe to see if CompressedResponse is supported on the server send_probe_for_compressed_request_support do request_uncompressed_args = { COMPRESSION_REQUEST_ALGORITHM => 'identity' } @stub.streaming_input_call([first_request], metadata: request_uncompressed_args) end second_request = StreamingInputCallRequest.new( payload: Payload.new(type: :COMPRESSABLE, body: nulls(45_904)), expect_compressed: BoolValue.new(value: false) ) # Create the requests messages and the corresponding write flags # for each message requests = WriteFlagSettingStreamingInputEnumerable.new([ { request: first_request, write_flag: 0 }, { request: second_request, write_flag: GRPC::Core::WriteFlags::NO_COMPRESS } ]) # Create the call_op, pass it to the requests enumerable, and # run the call call_op = @stub.streaming_input_call(requests, return_op: true) requests.call_op = call_op resp = call_op.execute wanted_aggregate_size = 73_086 assert("#{__callee__}: aggregate payload size is incorrect") do wanted_aggregate_size == resp.aggregated_payload_size end end
client_compressed_unary()
click to toggle source
# File src/ruby/pb/test/client.rb, line 273 def client_compressed_unary # first request used also for the probe req_size, wanted_response_size = 271_828, 314_159 expect_compressed = BoolValue.new(value: true) payload = Payload.new(type: :COMPRESSABLE, body: nulls(req_size)) req = SimpleRequest.new(response_type: :COMPRESSABLE, response_size: wanted_response_size, payload: payload, expect_compressed: expect_compressed) # send a probe to see if CompressedResponse is supported on the server send_probe_for_compressed_request_support do request_uncompressed_args = { COMPRESSION_REQUEST_ALGORITHM => 'identity' } @stub.unary_call(req, metadata: request_uncompressed_args) end # make a call with a compressed message resp = @stub.unary_call(req) assert('Expected second unary call with compression to work') do resp.payload.body.length == wanted_response_size end # make a call with an uncompressed message stub_options = { COMPRESSION_REQUEST_ALGORITHM => 'identity' } req = SimpleRequest.new( response_type: :COMPRESSABLE, response_size: wanted_response_size, payload: payload, expect_compressed: BoolValue.new(value: false) ) resp = @stub.unary_call(req, metadata: stub_options) assert('Expected second unary call with compression to work') do resp.payload.body.length == wanted_response_size end end
client_streaming()
click to toggle source
# File src/ruby/pb/test/client.rb, line 376 def client_streaming msg_sizes = [27_182, 8, 1828, 45_904] wanted_aggregate_size = 74_922 reqs = msg_sizes.map do |x| req = Payload.new(body: nulls(x)) StreamingInputCallRequest.new(payload: req) end resp = @stub.streaming_input_call(reqs) assert("#{__callee__}: aggregate payload size is incorrect") do wanted_aggregate_size == resp.aggregated_payload_size end end
compute_engine_creds()
click to toggle source
# File src/ruby/pb/test/client.rb, line 338 def compute_engine_creds resp = perform_large_unary(fill_username: true, fill_oauth_scope: true) assert("#{__callee__}: bad username") do @args.default_service_account == resp.username end end
custom_metadata()
click to toggle source
# File src/ruby/pb/test/client.rb, line 584 def custom_metadata # Function wide constants req_size, wanted_response_size = 271_828, 314_159 initial_metadata_key = "x-grpc-test-echo-initial" initial_metadata_value = "test_initial_metadata_value" trailing_metadata_key = "x-grpc-test-echo-trailing-bin" trailing_metadata_value = "\x0a\x0b\x0a\x0b\x0a\x0b" metadata = { initial_metadata_key => initial_metadata_value, trailing_metadata_key => trailing_metadata_value } # Testing with UnaryCall payload = Payload.new(type: :COMPRESSABLE, body: nulls(req_size)) req = SimpleRequest.new(response_type: :COMPRESSABLE, response_size: wanted_response_size, payload: payload) op = @stub.unary_call(req, metadata: metadata, return_op: true) op.execute if not op.metadata.has_key?(initial_metadata_key) fail AssertionError, "Expected initial metadata. None received" elsif op.metadata[initial_metadata_key] != metadata[initial_metadata_key] fail AssertionError, "Expected initial metadata: #{metadata[initial_metadata_key]}. "\ "Received: #{op.metadata[initial_metadata_key]}" end if not op.trailing_metadata.has_key?(trailing_metadata_key) fail AssertionError, "Expected trailing metadata. None received" elsif op.trailing_metadata[trailing_metadata_key] != metadata[trailing_metadata_key] fail AssertionError, "Expected trailing metadata: #{metadata[trailing_metadata_key]}. "\ "Received: #{op.trailing_metadata[trailing_metadata_key]}" end # Testing with FullDuplex req_cls, p_cls = StreamingOutputCallRequest, ResponseParameters duplex_req = req_cls.new(payload: Payload.new(body: nulls(req_size)), response_type: :COMPRESSABLE, response_parameters: [p_cls.new(size: wanted_response_size)]) duplex_op = @stub.full_duplex_call([duplex_req], metadata: metadata, return_op: true) resp = duplex_op.execute resp.each { |r| } # ensures that the server sends trailing data duplex_op.wait if not duplex_op.metadata.has_key?(initial_metadata_key) fail AssertionError, "Expected initial metadata. None received" elsif duplex_op.metadata[initial_metadata_key] != metadata[initial_metadata_key] fail AssertionError, "Expected initial metadata: #{metadata[initial_metadata_key]}. "\ "Received: #{duplex_op.metadata[initial_metadata_key]}" end if not duplex_op.trailing_metadata[trailing_metadata_key] fail AssertionError, "Expected trailing metadata. None received" elsif duplex_op.trailing_metadata[trailing_metadata_key] != metadata[trailing_metadata_key] fail AssertionError, "Expected trailing metadata: #{metadata[trailing_metadata_key]}. "\ "Received: #{duplex_op.trailing_metadata[trailing_metadata_key]}" end end
empty_stream()
click to toggle source
# File src/ruby/pb/test/client.rb, line 466 def empty_stream ppp = PingPongPlayer.new([]) resps = @stub.full_duplex_call(ppp.each_item) count = 0 resps.each do |r| ppp.queue.push(r) count += 1 end assert("#{__callee__}: too many responses expected 0") do count == 0 end end
empty_unary()
click to toggle source
# File src/ruby/pb/test/client.rb, line 264 def empty_unary resp = @stub.empty_call(Empty.new) assert('empty_unary: invalid response') { resp.is_a?(Empty) } end
jwt_token_creds()
click to toggle source
# File src/ruby/pb/test/client.rb, line 331 def jwt_token_creds json_key = File.read(ENV[AUTH_ENV]) wanted_email = MultiJson.load(json_key)['client_email'] resp = perform_large_unary(fill_username: true) assert("#{__callee__}: bad username") { wanted_email == resp.username } end
large_unary()
click to toggle source
# File src/ruby/pb/test/client.rb, line 269 def large_unary perform_large_unary end
oauth2_auth_token()
click to toggle source
# File src/ruby/pb/test/client.rb, line 346 def oauth2_auth_token resp = perform_large_unary(fill_username: true, fill_oauth_scope: true) json_key = File.read(ENV[AUTH_ENV]) wanted_email = MultiJson.load(json_key)['client_email'] assert("#{__callee__}: bad username") { wanted_email == resp.username } assert("#{__callee__}: bad oauth scope") do @args.oauth_scope.include?(resp.oauth_scope) end end
per_rpc_creds()
click to toggle source
# File src/ruby/pb/test/client.rb, line 357 def per_rpc_creds auth_creds = Google::Auth.get_application_default(@args.oauth_scope) update_metadata = proc do |md| kw = auth_creds.updater_proc.call({}) end call_creds = GRPC::Core::CallCredentials.new(update_metadata) resp = perform_large_unary(fill_username: true, fill_oauth_scope: true, credentials: call_creds) json_key = File.read(ENV[AUTH_ENV]) wanted_email = MultiJson.load(json_key)['client_email'] assert("#{__callee__}: bad username") { wanted_email == resp.username } assert("#{__callee__}: bad oauth scope") do @args.oauth_scope.include?(resp.oauth_scope) end end
ping_pong()
click to toggle source
# File src/ruby/pb/test/client.rb, line 450 def ping_pong msg_sizes = [[27_182, 31_415], [8, 9], [1828, 2653], [45_904, 58_979]] ppp = PingPongPlayer.new(msg_sizes) resps = @stub.full_duplex_call(ppp.each_item) resps.each { |r| ppp.queue.push(r) } end
server_streaming()
click to toggle source
# File src/ruby/pb/test/client.rb, line 433 def server_streaming msg_sizes = [31_415, 9, 2653, 58_979] response_spec = msg_sizes.map { |s| ResponseParameters.new(size: s) } req = StreamingOutputCallRequest.new(response_type: :COMPRESSABLE, response_parameters: response_spec) resps = @stub.streaming_output_call(req) resps.each_with_index do |r, i| assert("#{__callee__}: too many responses") { i < msg_sizes.length } assert("#{__callee__}: payload body #{i} has the wrong length") do msg_sizes[i] == r.payload.body.length end assert("#{__callee__}: payload type is wrong") do :COMPRESSABLE == r.payload.type end end end
service_account_creds()
click to toggle source
# File src/ruby/pb/test/client.rb, line 315 def service_account_creds # ignore this test if the oauth options are not set if @args.oauth_scope.nil? p 'NOT RUN: service_account_creds; no service_account settings' return end json_key = File.read(ENV[AUTH_ENV]) wanted_email = MultiJson.load(json_key)['client_email'] resp = perform_large_unary(fill_username: true, fill_oauth_scope: true) assert("#{__callee__}: bad username") { wanted_email == resp.username } assert("#{__callee__}: bad oauth scope") do @args.oauth_scope.include?(resp.oauth_scope) end end
status_code_and_message()
click to toggle source
# File src/ruby/pb/test/client.rb, line 527 def status_code_and_message # Function wide constants. message = "test status method" code = GRPC::Core::StatusCodes::UNKNOWN # Testing with UnaryCall. payload = Payload.new(type: :COMPRESSABLE, body: nulls(1)) echo_status = EchoStatus.new(code: code, message: message) req = SimpleRequest.new(response_type: :COMPRESSABLE, response_size: 1, payload: payload, response_status: echo_status) seen_correct_exception = false begin resp = @stub.unary_call(req) rescue GRPC::Unknown => e if e.details != message fail AssertionError, "Expected message #{message}. Received: #{e.details}" end seen_correct_exception = true rescue Exception => e fail AssertionError, "Expected BadStatus. Received: #{e.inspect}" end if not seen_correct_exception fail AssertionError, "Did not see expected status from UnaryCall" end # testing with FullDuplex req_cls, p_cls = StreamingOutputCallRequest, ResponseParameters duplex_req = req_cls.new(payload: Payload.new(body: nulls(1)), response_type: :COMPRESSABLE, response_parameters: [p_cls.new(size: 1)], response_status: echo_status) seen_correct_exception = false begin resp = @stub.full_duplex_call([duplex_req]) resp.each { |r| } rescue GRPC::Unknown => e if e.details != message fail AssertionError, "Expected message #{message}. Received: #{e.details}" end seen_correct_exception = true rescue Exception => e fail AssertionError, "Expected BadStatus. Received: #{e.inspect}" end if not seen_correct_exception fail AssertionError, "Did not see expected status from FullDuplexCall" end end
timeout_on_sleeping_server()
click to toggle source
# File src/ruby/pb/test/client.rb, line 457 def timeout_on_sleeping_server enum = BlockingEnumerator.new(27_182, 2) deadline = GRPC::Core::TimeConsts::from_relative_time(1) resps = @stub.full_duplex_call(enum.each_item, deadline: deadline) resps.each { } # wait to receive each request (or timeout) fail 'Should have raised GRPC::DeadlineExceeded' rescue GRPC::DeadlineExceeded end
unimplemented_method()
click to toggle source
# File src/ruby/pb/test/client.rb, line 505 def unimplemented_method begin resp = @stub.unimplemented_call(Empty.new) rescue GRPC::Unimplemented => e return rescue Exception => e fail AssertionError, "Expected BadStatus. Received: #{e.inspect}" end fail AssertionError, "GRPC::Unimplemented should have been raised. Was not." end
unimplemented_service()
click to toggle source
# File src/ruby/pb/test/client.rb, line 516 def unimplemented_service begin resp = @stub.unimplemented_call(Empty.new) rescue GRPC::Unimplemented => e return rescue Exception => e fail AssertionError, "Expected BadStatus. Received: #{e.inspect}" end fail AssertionError, "GRPC::Unimplemented should have been raised. Was not." end
Private Instance Methods
perform_large_unary(fill_username: false, fill_oauth_scope: false, **kw)
click to toggle source
# File src/ruby/pb/test/client.rb, line 663 def perform_large_unary(fill_username: false, fill_oauth_scope: false, **kw) req_size, wanted_response_size = 271_828, 314_159 payload = Payload.new(type: :COMPRESSABLE, body: nulls(req_size)) req = SimpleRequest.new(response_type: :COMPRESSABLE, response_size: wanted_response_size, payload: payload) req.fill_username = fill_username req.fill_oauth_scope = fill_oauth_scope resp = @stub.unary_call(req, **kw) assert('payload type is wrong') do :COMPRESSABLE == resp.payload.type end assert('payload body has the wrong length') do wanted_response_size == resp.payload.body.length end assert('payload body is invalid') do nulls(wanted_response_size) == resp.payload.body end resp end
send_probe_for_compressed_request_support(&send_probe)
click to toggle source
Send probing message for compressed request on the server, to see if it's implemented.
# File src/ruby/pb/test/client.rb, line 686 def send_probe_for_compressed_request_support(&send_probe) bad_status_occurred = false begin send_probe.call rescue GRPC::BadStatus => e if e.code == GRPC::Core::StatusCodes::INVALID_ARGUMENT bad_status_occurred = true else fail AssertionError, "Bad status received but code is #{e.code}" end rescue Exception => e fail AssertionError, "Expected BadStatus. Received: #{e.inspect}" end assert('CompressedRequest probe failed') do bad_status_occurred end end