grpc 1.30.2-x86-linux

data/src/ruby/spec/call_credentials_spec.rb

@@ -0,0 +1,42 @@
+# 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'
+
+describe GRPC::Core::CallCredentials do
+  CallCredentials = GRPC::Core::CallCredentials
+
+  let(:auth_proc) { proc { { 'plugin_key' => 'plugin_value' } } }
+
+  describe '#new' do
+    it 'can successfully create a CallCredentials from a proc' do
+      expect { CallCredentials.new(auth_proc) }.not_to raise_error
+    end
+  end
+
+  describe '#compose' do
+    it 'can compose with another CallCredentials' do
+      creds1 = CallCredentials.new(auth_proc)
+      creds2 = CallCredentials.new(auth_proc)
+      expect { creds1.compose creds2 }.not_to raise_error
+    end
+
+    it 'can compose with multiple CallCredentials' do
+      creds1 = CallCredentials.new(auth_proc)
+      creds2 = CallCredentials.new(auth_proc)
+      creds3 = CallCredentials.new(auth_proc)
+      expect { creds1.compose(creds2, creds3) }.not_to raise_error
+    end
+  end
+end

data/src/ruby/spec/call_spec.rb

@@ -0,0 +1,180 @@
+# 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'
+
+include GRPC::Core::StatusCodes
+
+describe GRPC::Core::WriteFlags do
+  it 'should define the known write flag values' do
+    m = GRPC::Core::WriteFlags
+    expect(m.const_get(:BUFFER_HINT)).to_not be_nil
+    expect(m.const_get(:NO_COMPRESS)).to_not be_nil
+  end
+end
+
+describe GRPC::Core::RpcErrors do
+  before(:each) do
+    @known_types = {
+      OK: 0,
+      ERROR: 1,
+      NOT_ON_SERVER: 2,
+      NOT_ON_CLIENT: 3,
+      ALREADY_ACCEPTED: 4,
+      ALREADY_INVOKED: 5,
+      NOT_INVOKED: 6,
+      ALREADY_FINISHED: 7,
+      TOO_MANY_OPERATIONS: 8,
+      INVALID_FLAGS: 9,
+      ErrorMessages: {
+        0 => 'ok',
+        1 => 'unknown error',
+        2 => 'not available on a server',
+        3 => 'not available on a client',
+        4 => 'call is already accepted',
+        5 => 'call is already invoked',
+        6 => 'call is not yet invoked',
+        7 => 'call is already finished',
+        8 => 'outstanding read or write present',
+        9 => 'a bad flag was given'
+      }
+    }
+  end
+
+  it 'should have symbols for all the known error codes' do
+    m = GRPC::Core::RpcErrors
+    syms_and_codes = m.constants.collect { |c| [c, m.const_get(c)] }
+    expect(Hash[syms_and_codes]).to eq(@known_types)
+  end
+end
+
+describe GRPC::Core::CallOps do
+  before(:each) do
+    @known_types = {
+      SEND_INITIAL_METADATA: 0,
+      SEND_MESSAGE: 1,
+      SEND_CLOSE_FROM_CLIENT: 2,
+      SEND_STATUS_FROM_SERVER: 3,
+      RECV_INITIAL_METADATA: 4,
+      RECV_MESSAGE: 5,
+      RECV_STATUS_ON_CLIENT: 6,
+      RECV_CLOSE_ON_SERVER: 7
+    }
+  end
+
+  it 'should have symbols for all the known operation types' do
+    m = GRPC::Core::CallOps
+    syms_and_codes = m.constants.collect { |c| [c, m.const_get(c)] }
+    expect(Hash[syms_and_codes]).to eq(@known_types)
+  end
+end
+
+describe GRPC::Core::Call do
+  let(:test_tag)  { Object.new }
+  let(:fake_host) { 'localhost:10101' }
+
+  before(:each) do
+    @ch = GRPC::Core::Channel.new(fake_host, nil, :this_channel_is_insecure)
+  end
+
+  describe '#status' do
+    it 'can save the status and read it back' do
+      call = make_test_call
+      sts = Struct::Status.new(OK, 'OK')
+      expect { call.status = sts }.not_to raise_error
+      expect(call.status).to eq(sts)
+    end
+
+    it 'must be set to a status' do
+      call = make_test_call
+      bad_sts = Object.new
+      expect { call.status = bad_sts }.to raise_error(TypeError)
+    end
+
+    it 'can be set to nil' do
+      call = make_test_call
+      expect { call.status = nil }.not_to raise_error
+    end
+  end
+
+  describe '#metadata' do
+    it 'can save the metadata hash and read it back' do
+      call = make_test_call
+      md = { 'k1' => 'v1',  'k2' => 'v2' }
+      expect { call.metadata = md }.not_to raise_error
+      expect(call.metadata).to be(md)
+    end
+
+    it 'must be set with a hash' do
+      call = make_test_call
+      bad_md = Object.new
+      expect { call.metadata = bad_md }.to raise_error(TypeError)
+    end
+
+    it 'can be set to nil' do
+      call = make_test_call
+      expect { call.metadata = nil }.not_to raise_error
+    end
+  end
+
+  describe '#set_credentials!' do
+    it 'can set a valid CallCredentials object' do
+      call = make_test_call
+      auth_proc = proc { { 'plugin_key' => 'plugin_value' } }
+      creds = GRPC::Core::CallCredentials.new auth_proc
+      expect { call.set_credentials! creds }.not_to raise_error
+    end
+  end
+
+  describe '#cancel' do
+    it 'completes ok' do
+      call = make_test_call
+      expect { call.cancel }.not_to raise_error
+    end
+
+    it 'completes ok when the call is closed' do
+      call = make_test_call
+      call.close
+      expect { call.cancel }.not_to raise_error
+    end
+  end
+
+  describe '#cancel_with_status' do
+    it 'completes ok' do
+      call = make_test_call
+      expect do
+        call.cancel_with_status(0, 'test status')
+      end.not_to raise_error
+      expect do
+        call.cancel_with_status(0, nil)
+      end.to raise_error(TypeError)
+    end
+
+    it 'completes ok when the call is closed' do
+      call = make_test_call
+      call.close
+      expect do
+        call.cancel_with_status(0, 'test status')
+      end.not_to raise_error
+    end
+  end
+
+  def make_test_call
+    @ch.create_call(nil, nil, 'dummy_method', nil, deadline)
+  end
+
+  def deadline
+    Time.now + 2  # in 2 seconds; arbitrary
+  end
+end

data/src/ruby/spec/channel_connection_spec.rb

@@ -0,0 +1,126 @@
+# 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 'timeout'
+
+include Timeout
+include GRPC::Core
+include GRPC::Spec::Helpers
+
+def start_server(port = 0)
+  @srv = new_rpc_server_for_testing(pool_size: 1)
+  server_port = @srv.add_http2_port("localhost:#{port}", :this_port_is_insecure)
+  @srv.handle(EchoService)
+  @server_thd = Thread.new { @srv.run }
+  @srv.wait_till_running
+  server_port
+end
+
+def stop_server
+  expect(@srv.stopped?).to be(false)
+  @srv.stop
+  @server_thd.join
+  expect(@srv.stopped?).to be(true)
+end
+
+describe 'channel connection behavior' do
+  it 'the client channel handles temporary loss of a transport' do
+    port = start_server
+    stub = EchoStub.new("localhost:#{port}", :this_channel_is_insecure)
+    req = EchoMsg.new
+    expect(stub.an_rpc(req)).to be_a(EchoMsg)
+    stop_server
+    sleep 1
+    # TODO(apolcyn) grabbing the same port might fail, is this stable enough?
+    start_server(port)
+    expect(stub.an_rpc(req)).to be_a(EchoMsg)
+    stop_server
+  end
+
+  it 'observably connects and reconnects to transient server' \
+    ' when using the channel state API' do
+    port = start_server
+    ch = GRPC::Core::Channel.new("localhost:#{port}", {},
+                                 :this_channel_is_insecure)
+
+    expect(ch.connectivity_state).to be(GRPC::Core::ConnectivityStates::IDLE)
+
+    state = ch.connectivity_state(true)
+
+    count = 0
+    while count < 20 && state != GRPC::Core::ConnectivityStates::READY
+      ch.watch_connectivity_state(state, Time.now + 60)
+      state = ch.connectivity_state(true)
+      count += 1
+    end
+
+    expect(state).to be(GRPC::Core::ConnectivityStates::READY)
+
+    stop_server
+
+    state = ch.connectivity_state
+
+    count = 0
+    while count < 20 && state == GRPC::Core::ConnectivityStates::READY
+      ch.watch_connectivity_state(state, Time.now + 60)
+      state = ch.connectivity_state
+      count += 1
+    end
+
+    expect(state).to_not be(GRPC::Core::ConnectivityStates::READY)
+
+    start_server(port)
+
+    state = ch.connectivity_state(true)
+
+    count = 0
+    while count < 20 && state != GRPC::Core::ConnectivityStates::READY
+      ch.watch_connectivity_state(state, Time.now + 60)
+      state = ch.connectivity_state(true)
+      count += 1
+    end
+
+    expect(state).to be(GRPC::Core::ConnectivityStates::READY)
+
+    stop_server
+  end
+
+  it 'concurrent watches on the same channel' do
+    timeout(180) do
+      port = start_server
+      ch = GRPC::Core::Channel.new("localhost:#{port}", {},
+                                   :this_channel_is_insecure)
+      stop_server
+
+      thds = []
+      50.times do
+        thds << Thread.new do
+          while ch.connectivity_state(true) != ConnectivityStates::READY
+            ch.watch_connectivity_state(
+              ConnectivityStates::READY, Time.now + 60)
+            break
+          end
+        end
+      end
+
+      sleep 0.01
+
+      start_server(port)
+
+      thds.each(&:join)
+
+      stop_server
+    end
+  end
+end

data/src/ruby/spec/channel_credentials_spec.rb

@@ -0,0 +1,82 @@
+# 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'
+
+describe GRPC::Core::ChannelCredentials do
+  ChannelCredentials = GRPC::Core::ChannelCredentials
+  CallCredentials = GRPC::Core::CallCredentials
+
+  def load_test_certs
+    test_root = File.join(File.dirname(__FILE__), 'testdata')
+    files = ['ca.pem', 'server1.key', 'server1.pem']
+    files.map { |f| File.open(File.join(test_root, f)).read }
+  end
+
+  describe '#new' do
+    it 'can be constructed with fake inputs' do
+      blk = proc  { ChannelCredentials.new('root_certs', 'key', 'cert') }
+      expect(&blk).not_to raise_error
+    end
+
+    it 'it can be constructed using specific test certificates' do
+      certs = load_test_certs
+      expect { ChannelCredentials.new(*certs) }.not_to raise_error
+    end
+
+    it 'can be constructed with server roots certs only' do
+      root_cert, _, _ = load_test_certs
+      expect { ChannelCredentials.new(root_cert) }.not_to raise_error
+    end
+
+    it 'can be constructed with a nil server roots' do
+      _, client_key, client_chain = load_test_certs
+      blk = proc { ChannelCredentials.new(nil, client_key, client_chain) }
+      expect(&blk).not_to raise_error
+    end
+
+    it 'can be constructed with no params' do
+      blk = proc { ChannelCredentials.new(nil) }
+      expect(&blk).not_to raise_error
+    end
+  end
+
+  describe '#compose' do
+    it 'can compose with a CallCredentials' do
+      certs = load_test_certs
+      channel_creds = ChannelCredentials.new(*certs)
+      auth_proc = proc { { 'plugin_key' => 'plugin_value' } }
+      call_creds = CallCredentials.new auth_proc
+      expect { channel_creds.compose call_creds }.not_to raise_error
+    end
+
+    it 'can compose with multiple CallCredentials' do
+      certs = load_test_certs
+      channel_creds = ChannelCredentials.new(*certs)
+      auth_proc = proc { { 'plugin_key' => 'plugin_value' } }
+      call_creds1 = CallCredentials.new auth_proc
+      call_creds2 = CallCredentials.new auth_proc
+      expect do
+        channel_creds.compose(call_creds1, call_creds2)
+      end.not_to raise_error
+    end
+
+    it 'cannot compose with ChannelCredentials' do
+      certs = load_test_certs
+      channel_creds1 = ChannelCredentials.new(*certs)
+      channel_creds2 = ChannelCredentials.new(*certs)
+      expect { channel_creds1.compose channel_creds2 }.to raise_error(TypeError)
+    end
+  end
+end

data/src/ruby/spec/channel_spec.rb

@@ -0,0 +1,234 @@
+# 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 'English'
+
+def load_test_certs
+  test_root = File.join(File.dirname(__FILE__), 'testdata')
+  files = ['ca.pem', 'server1.key', 'server1.pem']
+  files.map { |f| File.open(File.join(test_root, f)).read }
+end
+
+describe GRPC::Core::Channel do
+  let(:fake_host) { 'localhost:0' }
+
+  def create_test_cert
+    GRPC::Core::ChannelCredentials.new(load_test_certs[0])
+  end
+
+  def fork_with_propagated_error_message
+    pipe_read, pipe_write = IO.pipe
+    pid = fork do
+      pipe_read.close
+      begin
+        yield
+      rescue => exc
+        pipe_write.syswrite(exc.message)
+      end
+      pipe_write.close
+    end
+    pipe_write.close
+
+    exc_message = pipe_read.read
+    Process.wait(pid)
+
+    unless $CHILD_STATUS.success?
+      raise "forked process failed with #{$CHILD_STATUS}"
+    end
+    raise exc_message unless exc_message.empty?
+  end
+
+  shared_examples '#new' do
+    it 'take a host name without channel args' do
+      blk = proc do
+        GRPC::Core::Channel.new('dummy_host', nil, :this_channel_is_insecure)
+      end
+      expect(&blk).not_to 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
+
+    it 'raises if grpc was initialized in another process' do
+      blk = construct_with_args({})
+      expect(&blk).not_to raise_error
+      expect do
+        fork_with_propagated_error_message(&blk)
+      end.to raise_error(RuntimeError, 'grpc cannot be used before and after forking')
+    end
+  end
+
+  describe '#new for secure channels' do
+    def construct_with_args(a)
+      proc { GRPC::Core::Channel.new('dummy_host', a, create_test_cert) }
+    end
+
+    it_behaves_like '#new'
+  end
+
+  describe '#new for insecure channels' do
+    it_behaves_like '#new'
+
+    def construct_with_args(a)
+      proc do
+        GRPC::Core::Channel.new('dummy_host', a, :this_channel_is_insecure)
+      end
+    end
+  end
+
+  describe '#create_call' do
+    it 'creates a call OK' do
+      ch = GRPC::Core::Channel.new(fake_host, nil, :this_channel_is_insecure)
+
+      deadline = Time.now + 5
+
+      blk = proc do
+        ch.create_call(nil, nil, 'dummy_method', nil, deadline)
+      end
+      expect(&blk).to_not raise_error
+    end
+
+    it 'raises an error if called on a closed channel' do
+      ch = GRPC::Core::Channel.new(fake_host, nil, :this_channel_is_insecure)
+      ch.close
+
+      deadline = Time.now + 5
+      blk = proc do
+        ch.create_call(nil, nil, 'dummy_method', nil, deadline)
+      end
+      expect(&blk).to raise_error(RuntimeError)
+    end
+
+    it 'raises if grpc was initialized in another process' do
+      ch = GRPC::Core::Channel.new(fake_host, nil, :this_channel_is_insecure)
+
+      deadline = Time.now + 5
+
+      blk = proc do
+        fork_with_propagated_error_message do
+          ch.create_call(nil, nil, 'dummy_method', nil, deadline)
+        end
+      end
+      expect(&blk).to raise_error(RuntimeError, 'grpc cannot be used before and after forking')
+    end
+  end
+
+  describe '#destroy' do
+    it 'destroys a channel ok' do
+      ch = GRPC::Core::Channel.new(fake_host, nil, :this_channel_is_insecure)
+      blk = proc { ch.destroy }
+      expect(&blk).to_not raise_error
+    end
+
+    it 'can be called more than once without error' do
+      ch = GRPC::Core::Channel.new(fake_host, nil, :this_channel_is_insecure)
+      blk = proc { ch.destroy }
+      blk.call
+      expect(&blk).to_not raise_error
+    end
+  end
+
+  describe '#connectivity_state' do
+    it 'returns an enum' do
+      ch = GRPC::Core::Channel.new(fake_host, nil, :this_channel_is_insecure)
+      valid_states = [
+        GRPC::Core::ConnectivityStates::IDLE,
+        GRPC::Core::ConnectivityStates::CONNECTING,
+        GRPC::Core::ConnectivityStates::READY,
+        GRPC::Core::ConnectivityStates::TRANSIENT_FAILURE,
+        GRPC::Core::ConnectivityStates::FATAL_FAILURE
+      ]
+
+      expect(valid_states).to include(ch.connectivity_state)
+    end
+
+    it 'returns an enum when trying to connect' do
+      ch = GRPC::Core::Channel.new(fake_host, nil, :this_channel_is_insecure)
+      ch.connectivity_state(true)
+      valid_states = [
+        GRPC::Core::ConnectivityStates::IDLE,
+        GRPC::Core::ConnectivityStates::CONNECTING,
+        GRPC::Core::ConnectivityStates::READY,
+        GRPC::Core::ConnectivityStates::TRANSIENT_FAILURE,
+        GRPC::Core::ConnectivityStates::FATAL_FAILURE
+      ]
+
+      expect(valid_states).to include(ch.connectivity_state)
+    end
+  end
+
+  describe '::SSL_TARGET' do
+    it 'is a symbol' do
+      expect(GRPC::Core::Channel::SSL_TARGET).to be_a(Symbol)
+    end
+  end
+
+  describe '#close' do
+    it 'closes a channel ok' do
+      ch = GRPC::Core::Channel.new(fake_host, nil, :this_channel_is_insecure)
+      blk = proc { ch.close }
+      expect(&blk).to_not raise_error
+    end
+
+    it 'can be called more than once without error' do
+      ch = GRPC::Core::Channel.new(fake_host, nil, :this_channel_is_insecure)
+      blk = proc { ch.close }
+      blk.call
+      expect(&blk).to_not raise_error
+    end
+  end
+end