grpc-flamingo 1.11.0 → 1.15.0

data/src/ruby/bin/apis/tech/pubsub/proto/pubsub.rb

@@ -1,159 +0,0 @@
-# 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.
-
-# Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: tech/pubsub/proto/pubsub.proto
-
-require 'google/protobuf'
-
-require 'google/protobuf/empty'
-Google::Protobuf::DescriptorPool.generated_pool.build do
-  add_message "tech.pubsub.Topic" do
-    optional :name, :string, 1
-  end
-  add_message "tech.pubsub.PubsubMessage" do
-    optional :data, :string, 1
-    optional :message_id, :string, 3
-  end
-  add_message "tech.pubsub.GetTopicRequest" do
-    optional :topic, :string, 1
-  end
-  add_message "tech.pubsub.PublishRequest" do
-    optional :topic, :string, 1
-    optional :message, :message, 2, "tech.pubsub.PubsubMessage"
-  end
-  add_message "tech.pubsub.PublishBatchRequest" do
-    optional :topic, :string, 1
-    repeated :messages, :message, 2, "tech.pubsub.PubsubMessage"
-  end
-  add_message "tech.pubsub.PublishBatchResponse" do
-    repeated :message_ids, :string, 1
-  end
-  add_message "tech.pubsub.ListTopicsRequest" do
-    optional :query, :string, 1
-    optional :max_results, :int32, 2
-    optional :page_token, :string, 3
-  end
-  add_message "tech.pubsub.ListTopicsResponse" do
-    repeated :topic, :message, 1, "tech.pubsub.Topic"
-    optional :next_page_token, :string, 2
-  end
-  add_message "tech.pubsub.DeleteTopicRequest" do
-    optional :topic, :string, 1
-  end
-  add_message "tech.pubsub.Subscription" do
-    optional :name, :string, 1
-    optional :topic, :string, 2
-    optional :query, :string, 3
-    optional :truncation_policy, :message, 4, "tech.pubsub.Subscription.TruncationPolicy"
-    optional :push_config, :message, 5, "tech.pubsub.PushConfig"
-    optional :ack_deadline_seconds, :int32, 6
-    optional :garbage_collect_seconds, :int64, 7
-  end
-  add_message "tech.pubsub.Subscription.TruncationPolicy" do
-    optional :max_bytes, :int64, 1
-    optional :max_age_seconds, :int64, 2
-  end
-  add_message "tech.pubsub.PushConfig" do
-    optional :push_endpoint, :string, 1
-  end
-  add_message "tech.pubsub.PubsubEvent" do
-    optional :subscription, :string, 1
-    optional :message, :message, 2, "tech.pubsub.PubsubMessage"
-    optional :truncated, :bool, 3
-    optional :deleted, :bool, 4
-  end
-  add_message "tech.pubsub.GetSubscriptionRequest" do
-    optional :subscription, :string, 1
-  end
-  add_message "tech.pubsub.ListSubscriptionsRequest" do
-    optional :query, :string, 1
-    optional :max_results, :int32, 3
-    optional :page_token, :string, 4
-  end
-  add_message "tech.pubsub.ListSubscriptionsResponse" do
-    repeated :subscription, :message, 1, "tech.pubsub.Subscription"
-    optional :next_page_token, :string, 2
-  end
-  add_message "tech.pubsub.TruncateSubscriptionRequest" do
-    optional :subscription, :string, 1
-  end
-  add_message "tech.pubsub.DeleteSubscriptionRequest" do
-    optional :subscription, :string, 1
-  end
-  add_message "tech.pubsub.ModifyPushConfigRequest" do
-    optional :subscription, :string, 1
-    optional :push_config, :message, 2, "tech.pubsub.PushConfig"
-  end
-  add_message "tech.pubsub.PullRequest" do
-    optional :subscription, :string, 1
-    optional :return_immediately, :bool, 2
-  end
-  add_message "tech.pubsub.PullResponse" do
-    optional :ack_id, :string, 1
-    optional :pubsub_event, :message, 2, "tech.pubsub.PubsubEvent"
-  end
-  add_message "tech.pubsub.PullBatchRequest" do
-    optional :subscription, :string, 1
-    optional :return_immediately, :bool, 2
-    optional :max_events, :int32, 3
-  end
-  add_message "tech.pubsub.PullBatchResponse" do
-    repeated :pull_responses, :message, 2, "tech.pubsub.PullResponse"
-  end
-  add_message "tech.pubsub.ModifyAckDeadlineRequest" do
-    optional :subscription, :string, 1
-    optional :ack_id, :string, 2
-    optional :ack_deadline_seconds, :int32, 3
-  end
-  add_message "tech.pubsub.AcknowledgeRequest" do
-    optional :subscription, :string, 1
-    repeated :ack_id, :string, 2
-  end
-  add_message "tech.pubsub.NackRequest" do
-    optional :subscription, :string, 1
-    repeated :ack_id, :string, 2
-  end
-end
-
-module Tech
-  module Pubsub
-    Topic = Google::Protobuf::DescriptorPool.generated_pool.lookup("tech.pubsub.Topic").msgclass
-    PubsubMessage = Google::Protobuf::DescriptorPool.generated_pool.lookup("tech.pubsub.PubsubMessage").msgclass
-    GetTopicRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("tech.pubsub.GetTopicRequest").msgclass
-    PublishRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("tech.pubsub.PublishRequest").msgclass
-    PublishBatchRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("tech.pubsub.PublishBatchRequest").msgclass
-    PublishBatchResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("tech.pubsub.PublishBatchResponse").msgclass
-    ListTopicsRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("tech.pubsub.ListTopicsRequest").msgclass
-    ListTopicsResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("tech.pubsub.ListTopicsResponse").msgclass
-    DeleteTopicRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("tech.pubsub.DeleteTopicRequest").msgclass
-    Subscription = Google::Protobuf::DescriptorPool.generated_pool.lookup("tech.pubsub.Subscription").msgclass
-    Subscription::TruncationPolicy = Google::Protobuf::DescriptorPool.generated_pool.lookup("tech.pubsub.Subscription.TruncationPolicy").msgclass
-    PushConfig = Google::Protobuf::DescriptorPool.generated_pool.lookup("tech.pubsub.PushConfig").msgclass
-    PubsubEvent = Google::Protobuf::DescriptorPool.generated_pool.lookup("tech.pubsub.PubsubEvent").msgclass
-    GetSubscriptionRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("tech.pubsub.GetSubscriptionRequest").msgclass
-    ListSubscriptionsRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("tech.pubsub.ListSubscriptionsRequest").msgclass
-    ListSubscriptionsResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("tech.pubsub.ListSubscriptionsResponse").msgclass
-    TruncateSubscriptionRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("tech.pubsub.TruncateSubscriptionRequest").msgclass
-    DeleteSubscriptionRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("tech.pubsub.DeleteSubscriptionRequest").msgclass
-    ModifyPushConfigRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("tech.pubsub.ModifyPushConfigRequest").msgclass
-    PullRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("tech.pubsub.PullRequest").msgclass
-    PullResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("tech.pubsub.PullResponse").msgclass
-    PullBatchRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("tech.pubsub.PullBatchRequest").msgclass
-    PullBatchResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("tech.pubsub.PullBatchResponse").msgclass
-    ModifyAckDeadlineRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("tech.pubsub.ModifyAckDeadlineRequest").msgclass
-    AcknowledgeRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("tech.pubsub.AcknowledgeRequest").msgclass
-    NackRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("tech.pubsub.NackRequest").msgclass
-  end
-end

data/src/ruby/bin/apis/tech/pubsub/proto/pubsub_services.rb

@@ -1,88 +0,0 @@
-# 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.
-
-# Generated by the protocol buffer compiler.  DO NOT EDIT!
-# Source: tech/pubsub/proto/pubsub.proto for package 'tech.pubsub'
-
-require 'grpc'
-require 'google/protobuf/empty'
-require 'tech/pubsub/proto/pubsub'
-
-module Tech
-  module Pubsub
-    module PublisherService
-
-      # TODO: add proto service documentation here
-      class Service
-
-        include GRPC::GenericService
-
-        self.marshal_class_method = :encode
-        self.unmarshal_class_method = :decode
-        self.service_name = 'tech.pubsub.PublisherService'
-
-        rpc :CreateTopic, Topic, Topic
-        rpc :Publish, PublishRequest, Google::Protobuf::Empty
-        rpc :PublishBatch, PublishBatchRequest, PublishBatchResponse
-        rpc :GetTopic, GetTopicRequest, Topic
-        rpc :ListTopics, ListTopicsRequest, ListTopicsResponse
-        rpc :DeleteTopic, DeleteTopicRequest, Google::Protobuf::Empty
-      end
-
-      Stub = Service.rpc_stub_class
-    end
-    module SubscriberService
-
-      # TODO: add proto service documentation here
-      class Service
-
-        include GRPC::GenericService
-
-        self.marshal_class_method = :encode
-        self.unmarshal_class_method = :decode
-        self.service_name = 'tech.pubsub.SubscriberService'
-
-        rpc :CreateSubscription, Subscription, Subscription
-        rpc :GetSubscription, GetSubscriptionRequest, Subscription
-        rpc :ListSubscriptions, ListSubscriptionsRequest, ListSubscriptionsResponse
-        rpc :DeleteSubscription, DeleteSubscriptionRequest, Google::Protobuf::Empty
-        rpc :TruncateSubscription, TruncateSubscriptionRequest, Google::Protobuf::Empty
-        rpc :ModifyPushConfig, ModifyPushConfigRequest, Google::Protobuf::Empty
-        rpc :Pull, PullRequest, PullResponse
-        rpc :PullBatch, PullBatchRequest, PullBatchResponse
-        rpc :ModifyAckDeadline, ModifyAckDeadlineRequest, Google::Protobuf::Empty
-        rpc :Acknowledge, AcknowledgeRequest, Google::Protobuf::Empty
-        rpc :Nack, NackRequest, Google::Protobuf::Empty
-      end
-
-      Stub = Service.rpc_stub_class
-    end
-    module PushEndpointService
-
-      # TODO: add proto service documentation here
-      class Service
-
-        include GRPC::GenericService
-
-        self.marshal_class_method = :encode
-        self.unmarshal_class_method = :decode
-        self.service_name = 'tech.pubsub.PushEndpointService'
-
-        rpc :HandlePubsubEvent, PubsubEvent, Google::Protobuf::Empty
-      end
-
-      Stub = Service.rpc_stub_class
-    end
-  end
-end

data/src/ruby/pb/test/client.rb

@@ -1,764 +0,0 @@
-#!/usr/bin/env ruby
-
-# 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.
-
-# client is a testing tool that accesses a gRPC interop testing server and runs
-# a test on it.
-#
-# Helps validate interoperation b/w different gRPC implementations.
-#
-# Usage: $ path/to/client.rb --server_host=<hostname> \
-#                            --server_port=<port> \
-#                            --test_case=<testcase_name>
-
-# These lines are required for the generated files to load grpc
-this_dir = File.expand_path(File.dirname(__FILE__))
-lib_dir = File.join(File.dirname(File.dirname(this_dir)), 'lib')
-pb_dir = File.dirname(this_dir)
-$LOAD_PATH.unshift(lib_dir) unless $LOAD_PATH.include?(lib_dir)
-$LOAD_PATH.unshift(pb_dir) unless $LOAD_PATH.include?(pb_dir)
-
-require 'optparse'
-require 'logger'
-
-require_relative '../../lib/grpc'
-require 'googleauth'
-require 'google/protobuf'
-
-require_relative '../src/proto/grpc/testing/empty_pb'
-require_relative '../src/proto/grpc/testing/messages_pb'
-require_relative '../src/proto/grpc/testing/test_services_pb'
-
-AUTH_ENV = Google::Auth::CredentialsLoader::ENV_VAR
-
-# RubyLogger defines a logger for gRPC based on the standard ruby logger.
-module RubyLogger
-  def logger
-    LOGGER
-  end
-
-  LOGGER = Logger.new(STDOUT)
-  LOGGER.level = Logger::INFO
-end
-
-# GRPC is the general RPC module
-module GRPC
-  # Inject the noop #logger if no module-level logger method has been injected.
-  extend RubyLogger
-end
-
-# AssertionError is use to indicate interop test failures.
-class AssertionError < RuntimeError; end
-
-# Fails with AssertionError if the block does evaluate to true
-def assert(msg = 'unknown cause')
-  fail 'No assertion block provided' unless block_given?
-  fail AssertionError, msg unless yield
-end
-
-# loads the certificates used to access the test server securely.
-def load_test_certs
-  this_dir = File.expand_path(File.dirname(__FILE__))
-  data_dir = File.join(File.dirname(File.dirname(this_dir)), 'spec/testdata')
-  files = ['ca.pem', 'server1.key', 'server1.pem']
-  files.map { |f| File.open(File.join(data_dir, f)).read }
-end
-
-# creates SSL Credentials from the test certificates.
-def test_creds
-  certs = load_test_certs
-  GRPC::Core::ChannelCredentials.new(certs[0])
-end
-
-# creates SSL Credentials from the production certificates.
-def prod_creds
-  GRPC::Core::ChannelCredentials.new()
-end
-
-# creates the SSL Credentials.
-def ssl_creds(use_test_ca)
-  return test_creds if use_test_ca
-  prod_creds
-end
-
-# creates a test stub that accesses host:port securely.
-def create_stub(opts)
-  address = "#{opts.host}:#{opts.port}"
-
-  # Provide channel args that request compression by default
-  # for compression interop tests
-  if ['client_compressed_unary',
-      'client_compressed_streaming'].include?(opts.test_case)
-    compression_options =
-      GRPC::Core::CompressionOptions.new(default_algorithm: :gzip)
-    compression_channel_args = compression_options.to_channel_arg_hash
-  else
-    compression_channel_args = {}
-  end
-
-  if opts.secure
-    creds = ssl_creds(opts.use_test_ca)
-    stub_opts = {
-      channel_args: {
-        GRPC::Core::Channel::SSL_TARGET => opts.host_override
-      }
-    }
-
-    # Add service account creds if specified
-    wants_creds = %w(all compute_engine_creds service_account_creds)
-    if wants_creds.include?(opts.test_case)
-      unless opts.oauth_scope.nil?
-        auth_creds = Google::Auth.get_application_default(opts.oauth_scope)
-        call_creds = GRPC::Core::CallCredentials.new(auth_creds.updater_proc)
-        creds = creds.compose call_creds
-      end
-    end
-
-    if opts.test_case == 'oauth2_auth_token'
-      auth_creds = Google::Auth.get_application_default(opts.oauth_scope)
-      kw = auth_creds.updater_proc.call({})  # gives as an auth token
-
-      # use a metadata update proc that just adds the auth token.
-      call_creds = GRPC::Core::CallCredentials.new(proc { |md| md.merge(kw) })
-      creds = creds.compose call_creds
-    end
-
-    if opts.test_case == 'jwt_token_creds'  # don't use a scope
-      auth_creds = Google::Auth.get_application_default
-      call_creds = GRPC::Core::CallCredentials.new(auth_creds.updater_proc)
-      creds = creds.compose call_creds
-    end
-
-    GRPC.logger.info("... connecting securely to #{address}")
-    stub_opts[:channel_args].merge!(compression_channel_args)
-    if opts.test_case == "unimplemented_service"
-      Grpc::Testing::UnimplementedService::Stub.new(address, creds, **stub_opts)
-    else
-      Grpc::Testing::TestService::Stub.new(address, creds, **stub_opts)
-    end
-  else
-    GRPC.logger.info("... connecting insecurely to #{address}")
-    if opts.test_case == "unimplemented_service"
-      Grpc::Testing::UnimplementedService::Stub.new(
-        address,
-        :this_channel_is_insecure,
-        channel_args: compression_channel_args
-      )
-    else
-      Grpc::Testing::TestService::Stub.new(
-        address,
-        :this_channel_is_insecure,
-        channel_args: compression_channel_args
-      )
-    end
-  end
-end
-
-# produces a string of null chars (\0) of length l.
-def nulls(l)
-  fail 'requires #{l} to be +ve' if l < 0
-  [].pack('x' * l).force_encoding('ascii-8bit')
-end
-
-# a PingPongPlayer implements the ping pong bidi test.
-class PingPongPlayer
-  include Grpc::Testing
-  include Grpc::Testing::PayloadType
-  attr_accessor :queue
-  attr_accessor :canceller_op
-
-  # reqs is the enumerator over the requests
-  def initialize(msg_sizes)
-    @queue = Queue.new
-    @msg_sizes = msg_sizes
-    @canceller_op = nil  # used to cancel after the first response
-  end
-
-  def each_item
-    return enum_for(:each_item) unless block_given?
-    req_cls, p_cls = StreamingOutputCallRequest, ResponseParameters  # short
-    count = 0
-    @msg_sizes.each do |m|
-      req_size, resp_size = m
-      req = req_cls.new(payload: Payload.new(body: nulls(req_size)),
-                        response_type: :COMPRESSABLE,
-                        response_parameters: [p_cls.new(size: resp_size)])
-      yield req
-      resp = @queue.pop
-      assert('payload type is wrong') { :COMPRESSABLE == resp.payload.type }
-      assert("payload body #{count} has the wrong length") do
-        resp_size == resp.payload.body.length
-      end
-      p "OK: ping_pong #{count}"
-      count += 1
-      unless @canceller_op.nil?
-        canceller_op.cancel
-        break
-      end
-    end
-  end
-end
-
-class BlockingEnumerator
-  include Grpc::Testing
-  include Grpc::Testing::PayloadType
-
-  def initialize(req_size, sleep_time)
-    @req_size = req_size
-    @sleep_time = sleep_time
-  end
-
-  def each_item
-    return enum_for(:each_item) unless block_given?
-    req_cls = StreamingOutputCallRequest
-    req = req_cls.new(payload: Payload.new(body: nulls(@req_size)))
-    yield req
-    # Sleep until after the deadline should have passed
-    sleep(@sleep_time)
-  end
-end
-
-# Intended to be used to wrap a call_op, and to adjust
-# the write flag of the call_op in between messages yielded to it.
-class WriteFlagSettingStreamingInputEnumerable
-  attr_accessor :call_op
-
-  def initialize(requests_and_write_flags)
-    @requests_and_write_flags = requests_and_write_flags
-  end
-
-  def each
-    @requests_and_write_flags.each do |request_and_flag|
-      @call_op.write_flag = request_and_flag[:write_flag]
-      yield request_and_flag[:request]
-    end
-  end
-end
-
-# defines methods corresponding to each interop test case.
-class NamedTests
-  include Grpc::Testing
-  include Grpc::Testing::PayloadType
-  include GRPC::Core::MetadataKeys
-
-  def initialize(stub, args)
-    @stub = stub
-    @args = args
-  end
-
-  def empty_unary
-    resp = @stub.empty_call(Empty.new)
-    assert('empty_unary: invalid response') { resp.is_a?(Empty) }
-  end
-
-  def large_unary
-    perform_large_unary
-  end
-
-  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
-
-  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
-
-  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
-
-  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
-
-  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
-
-  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
-
-  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
-
-  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
-
-  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
-
-  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
-
-  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
-
-  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
-
-  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
-
-  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
-
-  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
-
-  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
-
-  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
-
-
-  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
-
-  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
-
-  private
-
-  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 probing message for compressed request on the server, to see
-  # if it's implemented.
-  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
-
-end
-
-# Args is used to hold the command line info.
-Args = Struct.new(:default_service_account, :host, :host_override,
-                  :oauth_scope, :port, :secure, :test_case,
-                  :use_test_ca)
-
-# validates the command line options, returning them as a Hash.
-def parse_args
-  args = Args.new
-  args.host_override = 'foo.test.google.fr'
-  OptionParser.new do |opts|
-    opts.on('--oauth_scope scope',
-            'Scope for OAuth tokens') { |v| args['oauth_scope'] = v }
-    opts.on('--server_host SERVER_HOST', 'server hostname') do |v|
-      args['host'] = v
-    end
-    opts.on('--default_service_account email_address',
-            'email address of the default service account') do |v|
-      args['default_service_account'] = v
-    end
-    opts.on('--server_host_override HOST_OVERRIDE',
-            'override host via a HTTP header') do |v|
-      args['host_override'] = v
-    end
-    opts.on('--server_port SERVER_PORT', 'server port') { |v| args['port'] = v }
-    # instance_methods(false) gives only the methods defined in that class
-    test_cases = NamedTests.instance_methods(false).map(&:to_s)
-    test_case_list = test_cases.join(',')
-    opts.on('--test_case CODE', test_cases, {}, 'select a test_case',
-            "  (#{test_case_list})") { |v| args['test_case'] = v }
-    opts.on('--use_tls USE_TLS', ['false', 'true'],
-            'require a secure connection?') do |v|
-      args['secure'] = v == 'true'
-p    end
-    opts.on('--use_test_ca USE_TEST_CA', ['false', 'true'],
-            'if secure, use the test certificate?') do |v|
-      args['use_test_ca'] = v == 'true'
-    end
-  end.parse!
-  _check_args(args)
-end
-
-def _check_args(args)
-  %w(host port test_case).each do |a|
-    if args[a].nil?
-      fail(OptionParser::MissingArgument, "please specify --#{a}")
-    end
-  end
-  args
-end
-
-def main
-  opts = parse_args
-  stub = create_stub(opts)
-  NamedTests.new(stub, opts).method(opts['test_case']).call
-  p "OK: #{opts['test_case']}"
-end
-
-if __FILE__ == $0
-  main
-end