grpc 1.60.0.pre1-aarch64-linux

data/src/ruby/spec/pb/health/checker_spec.rb

@@ -0,0 +1,236 @@
+# 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.
+
+require 'spec_helper'
+require 'grpc/health/v1/health_pb'
+require 'grpc/health/checker'
+require 'open3'
+require 'tmpdir'
+
+def can_run_codegen_check
+  system('which grpc_ruby_plugin') && system('which protoc')
+end
+
+describe 'Health protobuf code generation' do
+  context 'the health service file used by grpc/health/checker' do
+    if !can_run_codegen_check
+      skip 'protoc || grpc_ruby_plugin missing, cannot verify health code-gen'
+    else
+      it 'should already be loaded indirectly i.e, used by the other specs' do
+        expect(require('grpc/health/v1/health_services_pb')).to be(false)
+      end
+
+      it 'should have the same content as created by code generation' do
+        root_dir = File.join(File.dirname(__FILE__), '..', '..', '..', '..')
+        pb_dir = File.join(root_dir, 'proto')
+
+        # Get the current content
+        service_path = File.join(root_dir, 'ruby', 'pb', 'grpc',
+                                 'health', 'v1', 'health_services_pb.rb')
+        want = nil
+        File.open(service_path) { |f| want = f.read }
+
+        # Regenerate it
+        plugin, = Open3.capture2('which', 'grpc_ruby_plugin')
+        plugin = plugin.strip
+        got = nil
+        Dir.mktmpdir do |tmp_dir|
+          gen_out = File.join(tmp_dir, 'grpc', 'health', 'v1',
+                              'health_services_pb.rb')
+          pid = spawn(
+            'protoc',
+            '-I.',
+            'grpc/health/v1/health.proto',
+            "--grpc_out=#{tmp_dir}",
+            "--plugin=protoc-gen-grpc=#{plugin}",
+            chdir: pb_dir)
+          Process.wait(pid)
+          File.open(gen_out) { |f| got = f.read }
+        end
+        expect(got).to eq(want)
+      end
+    end
+  end
+end
+
+describe Grpc::Health::Checker do
+  StatusCodes = GRPC::Core::StatusCodes
+  ServingStatus = Grpc::Health::V1::HealthCheckResponse::ServingStatus
+  HCResp = Grpc::Health::V1::HealthCheckResponse
+  HCReq = Grpc::Health::V1::HealthCheckRequest
+  success_tests =
+    [
+      {
+        desc: 'the service is not specified',
+        service: ''
+      }, {
+        desc: 'the service is specified',
+        service: 'fake-service-1'
+      }
+    ]
+
+  context 'initialization' do
+    it 'can be constructed with no args' do
+      checker = Grpc::Health::Checker.new
+      expect(checker).to_not be(nil)
+    end
+  end
+
+  context 'method `add_status` and `check`' do
+    success_tests.each do |t|
+      it "should succeed when #{t[:desc]}" do
+        checker = Grpc::Health::Checker.new
+        checker.add_status(t[:service], ServingStatus::NOT_SERVING)
+        got = checker.check(HCReq.new(service: t[:service]), nil)
+        want = HCResp.new(status: ServingStatus::NOT_SERVING)
+        expect(got).to eq(want)
+      end
+    end
+  end
+
+  context 'method `add_statuses`' do
+    it 'should add status to each service' do
+      checker = Grpc::Health::Checker.new
+      checker.add_statuses(
+        'service1' => ServingStatus::SERVING,
+        'service2' => ServingStatus::NOT_SERVING
+      )
+      service1_health = checker.check(HCReq.new(service: 'service1'), nil)
+      service2_health = checker.check(HCReq.new(service: 'service2'), nil)
+      expect(service1_health).to eq(HCResp.new(status: ServingStatus::SERVING))
+      expect(service2_health).to eq(HCResp.new(status: ServingStatus::NOT_SERVING))
+    end
+  end
+
+  context 'method `set_status_for_services`' do
+    it 'should add given status to all given services' do
+      checker = Grpc::Health::Checker.new
+      checker.set_status_for_services(
+        ServingStatus::SERVING,
+        'service1',
+        'service2'
+      )
+      service1_health = checker.check(HCReq.new(service: 'service1'), nil)
+      service2_health = checker.check(HCReq.new(service: 'service2'), nil)
+      expect(service1_health).to eq(HCResp.new(status: ServingStatus::SERVING))
+      expect(service2_health).to eq(HCResp.new(status: ServingStatus::SERVING))
+    end
+  end
+
+  context 'method `check`' do
+    success_tests.each do |t|
+      it "should fail with NOT_FOUND when #{t[:desc]}" do
+        checker = Grpc::Health::Checker.new
+        blk = proc do
+          checker.check(HCReq.new(service: t[:service]), nil)
+        end
+        expected_msg = /#{StatusCodes::NOT_FOUND}/
+        expect(&blk).to raise_error GRPC::NotFound, expected_msg
+      end
+    end
+  end
+
+  context 'method `clear_status`' do
+    success_tests.each do |t|
+      it "should fail after clearing status when #{t[:desc]}" do
+        checker = Grpc::Health::Checker.new
+        checker.add_status(t[:service], ServingStatus::NOT_SERVING)
+        got = checker.check(HCReq.new(service: t[:service]), nil)
+        want = HCResp.new(status: ServingStatus::NOT_SERVING)
+        expect(got).to eq(want)
+
+        checker.clear_status(t[:service])
+        blk = proc do
+          checker.check(HCReq.new(service: t[:service]), nil)
+        end
+        expected_msg = /#{StatusCodes::NOT_FOUND}/
+        expect(&blk).to raise_error GRPC::NotFound, expected_msg
+      end
+    end
+  end
+
+  context 'method `clear_all`' do
+    it 'should return NOT_FOUND after being invoked' do
+      checker = Grpc::Health::Checker.new
+      success_tests.each do |t|
+        checker.add_status(t[:service], ServingStatus::NOT_SERVING)
+        got = checker.check(HCReq.new(service: t[:service]), nil)
+        want = HCResp.new(status: ServingStatus::NOT_SERVING)
+        expect(got).to eq(want)
+      end
+
+      checker.clear_all
+
+      success_tests.each do |t|
+        blk = proc do
+          checker.check(HCReq.new(service: t[:service]), nil)
+        end
+        expected_msg = /#{StatusCodes::NOT_FOUND}/
+        expect(&blk).to raise_error GRPC::NotFound, expected_msg
+      end
+    end
+  end
+
+  describe 'running on RpcServer' do
+    RpcServer = GRPC::RpcServer
+    CheckerStub = Grpc::Health::Checker.rpc_stub_class
+
+    before(:each) do
+      server_host = '0.0.0.0:0'
+      @client_opts = { channel_override: @ch }
+      server_opts = {
+        poll_period: 1
+      }
+      @srv = new_rpc_server_for_testing(**server_opts)
+      server_port = @srv.add_http2_port(server_host, :this_port_is_insecure)
+      @host = "localhost:#{server_port}"
+      @ch = GRPC::Core::Channel.new(@host, nil, :this_channel_is_insecure)
+    end
+
+    after(:each) do
+      @srv.stop
+    end
+
+    it 'should receive the correct status', server: true do
+      Thread.abort_on_exception = true
+      checker = Grpc::Health::Checker.new
+      @srv.handle(checker)
+      checker.add_status('', ServingStatus::NOT_SERVING)
+      t = Thread.new { @srv.run }
+      @srv.wait_till_running
+
+      stub = CheckerStub.new(@host, :this_channel_is_insecure, **@client_opts)
+      got = stub.check(HCReq.new)
+      want = HCResp.new(status: ServingStatus::NOT_SERVING)
+      expect(got).to eq(want)
+      @srv.stop
+      t.join
+    end
+
+    it 'should fail on unknown services', server: true do
+      checker = Grpc::Health::Checker.new
+      @srv.handle(checker)
+      t = Thread.new { @srv.run }
+      @srv.wait_till_running
+      blk = proc do
+        stub = CheckerStub.new(@host, :this_channel_is_insecure, **@client_opts)
+        stub.check(HCReq.new(service: 'unknown'))
+      end
+      expected_msg = /#{StatusCodes::NOT_FOUND}/
+      expect(&blk).to raise_error GRPC::NotFound, expected_msg
+      @srv.stop
+      t.join
+    end
+  end
+end

data/src/ruby/spec/server_credentials_spec.rb

@@ -0,0 +1,104 @@
+# 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.
+
+require 'spec_helper'
+
+def load_test_certs
+  test_root = File.join(File.dirname(__FILE__), 'testdata')
+  files = ['ca.pem', 'server1.key', 'server1.pem']
+  contents = files.map { |f| File.open(File.join(test_root, f)).read }
+  [contents[0], [{ private_key: contents[1], cert_chain: contents[2] }], false]
+end
+
+describe GRPC::Core::ServerCredentials do
+  Creds = GRPC::Core::ServerCredentials
+  XdsCreds = GRPC::Core::XdsServerCredentials
+
+  describe '#new' do
+    it 'can be constructed from a fake CA PEM, server PEM and a server key' do
+      creds = Creds.new('a', [{ private_key: 'a', cert_chain: 'b' }], false)
+      expect(creds).to_not be_nil
+    end
+
+    it 'can be constructed using the test certificates' do
+      certs = load_test_certs
+      expect { Creds.new(*certs) }.not_to raise_error
+    end
+
+    it 'cannot be constructed without a nil key_cert pair array' do
+      root_cert, _, _ = load_test_certs
+      blk = proc do
+        Creds.new(root_cert, nil, false)
+      end
+      expect(&blk).to raise_error
+    end
+
+    it 'cannot be constructed without any key_cert pairs' do
+      root_cert, _, _ = load_test_certs
+      blk = proc do
+        Creds.new(root_cert, [], false)
+      end
+      expect(&blk).to raise_error
+    end
+
+    it 'cannot be constructed without a server cert chain' do
+      root_cert, server_key, _ = load_test_certs
+      blk = proc do
+        Creds.new(root_cert,
+                  [{ server_key: server_key, cert_chain: nil }],
+                  false)
+      end
+      expect(&blk).to raise_error
+    end
+
+    it 'cannot be constructed without a server key' do
+      root_cert, _, _ = load_test_certs
+      blk = proc do
+        Creds.new(root_cert,
+                  [{ server_key: nil, cert_chain: cert_chain }])
+      end
+      expect(&blk).to raise_error
+    end
+
+    it 'can be constructed without a root_cret' do
+      _, cert_pairs, _ = load_test_certs
+      blk = proc { Creds.new(nil, cert_pairs, false) }
+      expect(&blk).to_not raise_error
+    end
+
+    it 'can be constructed with a fallback credential' do
+      _, cert_pairs, _ = load_test_certs
+      fallback = Creds.new(nil, cert_pairs, false)
+      blk = proc { XdsCreds.new(fallback) }
+      expect(&blk).to_not raise_error
+    end
+
+    it 'cannot be constructed with nil' do
+      blk = proc { XdsCreds.new(nil) }
+      expect(&blk).to raise_error TypeError, /expected grpc_server_credentials/
+    end
+
+    it 'cannot be constructed with a non-C-extension object' do
+      not_a_fallback = 100
+      blk = proc { XdsCreds.new(not_a_fallback) }
+      expect(&blk).to raise_error TypeError, /expected grpc_server_credentials/
+    end
+
+    it 'cannot be constructed with a non-ServerCredentials object' do
+      not_a_fallback = GRPC::Core::ChannelCredentials.new
+      blk = proc { XdsCreds.new(not_a_fallback) }
+      expect(&blk).to raise_error TypeError, /expected grpc_server_credentials/
+    end
+  end
+end

data/src/ruby/spec/server_spec.rb

@@ -0,0 +1,231 @@
+# 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.
+
+require 'spec_helper'
+
+def load_test_certs
+  test_root = File.join(File.dirname(__FILE__), 'testdata')
+  files = ['ca.pem', 'server1.key', 'server1.pem']
+  contents = files.map { |f| File.open(File.join(test_root, f)).read }
+  [contents[0], [{ private_key: contents[1], cert_chain: contents[2] }], false]
+end
+
+Server = GRPC::Core::Server
+
+describe Server do
+  def create_test_cert
+    GRPC::Core::ServerCredentials.new(*load_test_certs)
+  end
+
+  describe '#start' do
+    it 'runs without failing' do
+      blk = proc { new_core_server_for_testing(nil).start }
+      expect(&blk).to_not raise_error
+    end
+
+    it 'fails if the server is closed' do
+      s = new_core_server_for_testing(nil)
+      s.shutdown_and_notify(nil)
+      s.close
+      expect { s.start }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe '#shutdown_and_notify and #destroy' do
+    it 'destroys a server ok' do
+      s = start_a_server
+      blk = proc do
+        s.shutdown_and_notify(nil)
+        s.destroy
+      end
+      expect(&blk).to_not raise_error
+    end
+
+    it 'can be called more than once without error' do
+      s = start_a_server
+      begin
+        blk = proc do
+          s.shutdown_and_notify(nil)
+          s.destroy
+        end
+        expect(&blk).to_not raise_error
+        blk.call
+        expect(&blk).to_not raise_error
+      ensure
+        s.shutdown_and_notify(nil)
+        s.close
+      end
+    end
+  end
+
+  describe '#shutdown_and_notify and #close' do
+    it 'closes a server ok' do
+      s = start_a_server
+      begin
+        blk = proc do
+          s.shutdown_and_notify(nil)
+          s.close
+        end
+        expect(&blk).to_not raise_error
+      ensure
+        s.shutdown_and_notify(nil)
+        s.close
+      end
+    end
+
+    it 'can be called more than once without error' do
+      s = start_a_server
+      blk = proc do
+        s.shutdown_and_notify(nil)
+        s.close
+      end
+      expect(&blk).to_not raise_error
+      blk.call
+      expect(&blk).to_not raise_error
+    end
+  end
+
+  describe '#add_http_port' do
+    describe 'for insecure servers' do
+      it 'runs without failing' do
+        blk = proc do
+          s = new_core_server_for_testing(nil)
+          s.add_http2_port('localhost:0', :this_port_is_insecure)
+          s.shutdown_and_notify(nil)
+          s.close
+        end
+        expect(&blk).to_not raise_error
+      end
+
+      it 'fails if the server is closed' do
+        s = new_core_server_for_testing(nil)
+        s.shutdown_and_notify(nil)
+        s.close
+        blk = proc do
+          s.add_http2_port('localhost:0', :this_port_is_insecure)
+        end
+        expect(&blk).to raise_error(RuntimeError)
+      end
+    end
+
+    describe 'for secure servers' do
+      let(:cert) { create_test_cert }
+      it 'runs without failing' do
+        blk = proc do
+          s = new_core_server_for_testing(nil)
+          s.add_http2_port('localhost:0', cert)
+          s.shutdown_and_notify(nil)
+          s.close
+        end
+        expect(&blk).to_not raise_error
+      end
+
+      it 'fails if the server is closed' do
+        s = new_core_server_for_testing(nil)
+        s.shutdown_and_notify(nil)
+        s.close
+        blk = proc { s.add_http2_port('localhost:0', cert) }
+        expect(&blk).to raise_error(RuntimeError)
+      end
+    end
+
+    describe 'for xds servers' do
+      let(:cert) { create_test_cert }
+      let(:xds) { GRPC::Core::XdsServerCredentials.new(cert) }
+      it 'runs without failing' do
+        blk = proc do
+          s = new_core_server_for_testing(nil)
+          s.add_http2_port('localhost:0', xds)
+          s.shutdown_and_notify(nil)
+          s.close
+        end
+        expect(&blk).to_not raise_error
+      end
+
+      it 'fails if the server is closed' do
+        s = new_core_server_for_testing(nil)
+        s.shutdown_and_notify(nil)
+        s.close
+        blk = proc { s.add_http2_port('localhost:0', xds) }
+        expect(&blk).to raise_error(RuntimeError)
+      end
+    end
+  end
+
+  shared_examples '#new' do
+    it 'takes nil channel args' do
+      expect { new_core_server_for_testing(nil) }.to_not raise_error
+    end
+
+    it 'does not take a hash with bad keys as channel args' do
+      blk = construct_with_args(Object.new => 1)
+      expect(&blk).to raise_error TypeError
+      blk = construct_with_args(1 => 1)
+      expect(&blk).to raise_error TypeError
+    end
+
+    it 'does not take a hash with bad values as channel args' do
+      blk = construct_with_args(symbol: Object.new)
+      expect(&blk).to raise_error TypeError
+      blk = construct_with_args('1' => {})
+      expect(&blk).to raise_error TypeError
+    end
+
+    it 'can take a hash with a symbol key as channel args' do
+      blk = construct_with_args(a_symbol: 1)
+      expect(&blk).to_not raise_error
+    end
+
+    it 'can take a hash with a string key as channel args' do
+      blk = construct_with_args('a_symbol' => 1)
+      expect(&blk).to_not raise_error
+    end
+
+    it 'can take a hash with a string value as channel args' do
+      blk = construct_with_args(a_symbol: '1')
+      expect(&blk).to_not raise_error
+    end
+
+    it 'can take a hash with a symbol value as channel args' do
+      blk = construct_with_args(a_symbol: :another_symbol)
+      expect(&blk).to_not raise_error
+    end
+
+    it 'can take a hash with a numeric value as channel args' do
+      blk = construct_with_args(a_symbol: 1)
+      expect(&blk).to_not raise_error
+    end
+
+    it 'can take a hash with many args as channel args' do
+      args = Hash[127.times.collect { |x| [x.to_s, x] }]
+      blk = construct_with_args(args)
+      expect(&blk).to_not raise_error
+    end
+  end
+
+  describe '#new with an insecure channel' do
+    def construct_with_args(a)
+      proc { new_core_server_for_testing(a) }
+    end
+
+    it_behaves_like '#new'
+  end
+
+  def start_a_server
+    s = new_core_server_for_testing(nil)
+    s.add_http2_port('0.0.0.0:0', :this_port_is_insecure)
+    s.start
+    s
+  end
+end

data/src/ruby/spec/spec_helper.rb

@@ -0,0 +1,61 @@
+# 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.
+
+spec_dir = File.expand_path(File.dirname(__FILE__))
+root_dir = File.expand_path(File.join(spec_dir, '..'))
+lib_dir = File.expand_path(File.join(root_dir, 'lib'))
+
+$LOAD_PATH.unshift(spec_dir)
+$LOAD_PATH.unshift(lib_dir)
+$LOAD_PATH.uniq!
+
+# set up coverage
+require 'simplecov'
+SimpleCov.start do
+  add_filter 'spec'
+  add_filter 'bin'
+  SimpleCov.command_name ENV['COVERAGE_NAME']
+end if ENV['COVERAGE_NAME']
+
+require 'rspec'
+require 'logging'
+require 'rspec/logging_helper'
+require 'grpc'
+
+require_relative 'support/services'
+require_relative 'support/helpers'
+
+# GRPC is the general RPC module
+#
+# Configure its logging for fine-grained log control during test runs
+module GRPC
+  extend Logging.globally
+end
+Logging.logger.root.appenders = Logging.appenders.stdout
+Logging.logger.root.level = :info
+Logging.logger['GRPC'].level = :info
+Logging.logger['GRPC::ActiveCall'].level = :info
+Logging.logger['GRPC::BidiCall'].level = :info
+
+# Configure RSpec to capture log messages for each test. The output from the
+# logs will be stored in the @log_output variable. It is a StringIO instance.
+RSpec.configure do |config|
+  include RSpec::LoggingHelper
+  config.capture_log_messages  # comment this out to see logs during test runs
+  include GRPC::Spec::Helpers
+end
+
+RSpec::Expectations.configuration.warn_about_potential_false_positives = false
+
+Thread.abort_on_exception = true