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 256
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 649
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 476
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 490
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 386
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 270
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 373
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 335
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 581
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 463
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 261
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 328
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 266
def large_unary
  perform_large_unary
end
oauth2_auth_token() click to toggle source
# File src/ruby/pb/test/client.rb, line 343
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 354
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 447
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 430
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 312
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 524
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 454
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 502
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 513
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 660
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 683
def send_probe_for_compressed_request_support(&send_probe)
  bad_status_occured = false

  begin
    send_probe.call
  rescue GRPC::BadStatus => e
    if e.code == GRPC::Core::StatusCodes::INVALID_ARGUMENT
      bad_status_occured = 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_occured
  end
end