grpc 1.58.3-aarch64-linux

data/src/ruby/spec/google_rpc_status_utils_spec.rb

@@ -0,0 +1,282 @@
+# Copyright 2017 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_relative '../lib/grpc/google_rpc_status_utils'
+require_relative '../pb/src/proto/grpc/testing/messages_pb'
+require_relative '../pb/src/proto/grpc/testing/messages_pb'
+require 'google/protobuf/well_known_types'
+
+include GRPC::Core
+include GRPC::Spec::Helpers
+
+describe 'conversion from a status struct to a google protobuf status' do
+  it 'fails if the input is not a status struct' do
+    begin
+      GRPC::GoogleRpcStatusUtils.extract_google_rpc_status('string')
+    rescue => e
+      exception = e
+    end
+    expect(exception.is_a?(ArgumentError)).to be true
+    expect(exception.message.include?('bad type')).to be true
+  end
+
+  it 'returns nil if the header key is missing' do
+    status = Struct::Status.new(1, 'details', key: 'val')
+    expect(status.metadata.nil?).to be false
+    expect(GRPC::GoogleRpcStatusUtils.extract_google_rpc_status(
+             status)).to be(nil)
+  end
+
+  it 'fails with some error if the header key fails to deserialize' do
+    status = Struct::Status.new(1, 'details',
+                                'grpc-status-details-bin' => 'string_val')
+    expect do
+      GRPC::GoogleRpcStatusUtils.extract_google_rpc_status(status)
+    end.to raise_error(StandardError)
+  end
+
+  it 'silently ignores erroneous mismatch between messages in '\
+    'status struct and protobuf status' do
+    proto = Google::Rpc::Status.new(code: 1, message: 'proto message')
+    encoded_proto = Google::Rpc::Status.encode(proto)
+    status = Struct::Status.new(1, 'struct message',
+                                'grpc-status-details-bin' => encoded_proto)
+    rpc_status = GRPC::GoogleRpcStatusUtils.extract_google_rpc_status(status)
+    expect(rpc_status).to eq(proto)
+  end
+
+  it 'silently ignores erroneous mismatch between codes in status struct '\
+    'and protobuf status' do
+    proto = Google::Rpc::Status.new(code: 1, message: 'matching message')
+    encoded_proto = Google::Rpc::Status.encode(proto)
+    status = Struct::Status.new(2, 'matching message',
+                                'grpc-status-details-bin' => encoded_proto)
+    rpc_status = GRPC::GoogleRpcStatusUtils.extract_google_rpc_status(status)
+    expect(rpc_status).to eq(proto)
+  end
+
+  it 'can successfully convert a status struct into a google protobuf status '\
+    'when there are no rpcstatus details' do
+    proto = Google::Rpc::Status.new(code: 1, message: 'matching message')
+    encoded_proto = Google::Rpc::Status.encode(proto)
+    status = Struct::Status.new(1, 'matching message',
+                                'grpc-status-details-bin' => encoded_proto)
+    out = GRPC::GoogleRpcStatusUtils.extract_google_rpc_status(status)
+    expect(out.code).to eq(1)
+    expect(out.message).to eq('matching message')
+    expect(out.details).to eq([])
+  end
+
+  it 'can successfully convert a status struct into a google protobuf '\
+    'status when there are multiple rpcstatus details' do
+    simple_request_any = Google::Protobuf::Any.new
+    simple_request = Grpc::Testing::SimpleRequest.new(
+      payload: Grpc::Testing::Payload.new(body: 'request'))
+    simple_request_any.pack(simple_request)
+    simple_response_any = Google::Protobuf::Any.new
+    simple_response = Grpc::Testing::SimpleResponse.new(
+      payload: Grpc::Testing::Payload.new(body: 'response'))
+    simple_response_any.pack(simple_response)
+    payload_any = Google::Protobuf::Any.new
+    payload = Grpc::Testing::Payload.new(body: 'payload')
+    payload_any.pack(payload)
+    proto = Google::Rpc::Status.new(code: 1,
+                                    message: 'matching message',
+                                    details: [
+                                      simple_request_any,
+                                      simple_response_any,
+                                      payload_any
+                                    ])
+    encoded_proto = Google::Rpc::Status.encode(proto)
+    status = Struct::Status.new(1, 'matching message',
+                                'grpc-status-details-bin' => encoded_proto)
+    out = GRPC::GoogleRpcStatusUtils.extract_google_rpc_status(status)
+    expect(out.code).to eq(1)
+    expect(out.message).to eq('matching message')
+    expect(out.details[0].unpack(
+             Grpc::Testing::SimpleRequest)).to eq(simple_request)
+    expect(out.details[1].unpack(
+             Grpc::Testing::SimpleResponse)).to eq(simple_response)
+    expect(out.details[2].unpack(
+             Grpc::Testing::Payload)).to eq(payload)
+  end
+end
+
+# A test service that fills in the "reserved" grpc-status-details-bin trailer,
+# for client-side testing of GoogleRpcStatus protobuf extraction from trailers.
+class GoogleRpcStatusTestService
+  include GRPC::GenericService
+  rpc :an_rpc, EchoMsg, EchoMsg
+
+  def initialize(encoded_rpc_status)
+    @encoded_rpc_status = encoded_rpc_status
+  end
+
+  def an_rpc(_, _)
+    # TODO: create a server-side utility API for sending a google rpc status.
+    # Applications are not expected to set the grpc-status-details-bin
+    # ("grpc"-fixed and reserved for library use) manually.
+    # Doing so here is only for testing of the client-side api for extracting
+    # a google rpc status, which is useful
+    # when the interacting with a server that does fill in this trailer.
+    fail GRPC::Unknown.new('test message',
+                           'grpc-status-details-bin' => @encoded_rpc_status)
+  end
+end
+
+GoogleRpcStatusTestStub = GoogleRpcStatusTestService.rpc_stub_class
+
+describe 'receving a google rpc status from a remote endpoint' do
+  def start_server(encoded_rpc_status)
+    @srv = new_rpc_server_for_testing(pool_size: 1)
+    @server_port = @srv.add_http2_port('localhost:0',
+                                       :this_port_is_insecure)
+    @srv.handle(GoogleRpcStatusTestService.new(encoded_rpc_status))
+    @server_thd = Thread.new { @srv.run }
+    @srv.wait_till_running
+  end
+
+  def stop_server
+    expect(@srv.stopped?).to be(false)
+    @srv.stop
+    @server_thd.join
+    expect(@srv.stopped?).to be(true)
+  end
+
+  before(:each) do
+    simple_request_any = Google::Protobuf::Any.new
+    simple_request = Grpc::Testing::SimpleRequest.new(
+      payload: Grpc::Testing::Payload.new(body: 'request'))
+    simple_request_any.pack(simple_request)
+    simple_response_any = Google::Protobuf::Any.new
+    simple_response = Grpc::Testing::SimpleResponse.new(
+      payload: Grpc::Testing::Payload.new(body: 'response'))
+    simple_response_any.pack(simple_response)
+    payload_any = Google::Protobuf::Any.new
+    payload = Grpc::Testing::Payload.new(body: 'payload')
+    payload_any.pack(payload)
+    @expected_proto = Google::Rpc::Status.new(
+      code: StatusCodes::UNKNOWN,
+      message: 'test message',
+      details: [simple_request_any, simple_response_any, payload_any])
+    start_server(Google::Rpc::Status.encode(@expected_proto))
+  end
+
+  after(:each) do
+    stop_server
+  end
+
+  it 'should receive be able to extract a google rpc status from the '\
+    'status struct taken from a BadStatus exception' do
+    stub = GoogleRpcStatusTestStub.new("localhost:#{@server_port}",
+                                       :this_channel_is_insecure)
+    begin
+      stub.an_rpc(EchoMsg.new)
+    rescue GRPC::BadStatus => e
+      rpc_status = GRPC::GoogleRpcStatusUtils.extract_google_rpc_status(
+        e.to_status)
+    end
+    expect(rpc_status).to eq(@expected_proto)
+  end
+
+  it 'should receive be able to extract a google rpc status from the '\
+    'status struct taken from the op view of a call' do
+    stub = GoogleRpcStatusTestStub.new("localhost:#{@server_port}",
+                                       :this_channel_is_insecure)
+    op = stub.an_rpc(EchoMsg.new, return_op: true)
+    begin
+      op.execute
+    rescue GRPC::BadStatus => e
+      status_from_exception = e.to_status
+    end
+    rpc_status = GRPC::GoogleRpcStatusUtils.extract_google_rpc_status(
+      op.status)
+    expect(rpc_status).to eq(@expected_proto)
+    # "to_status" on the bad status should give the same result
+    # as "status" on the "op view".
+    expect(GRPC::GoogleRpcStatusUtils.extract_google_rpc_status(
+             status_from_exception)).to eq(rpc_status)
+  end
+end
+
+# A test service that fails without explicitly setting the
+# grpc-status-details-bin trailer. Tests assumptions about value
+# of grpc-status-details-bin on the client side when the trailer wasn't
+# set explicitly.
+class NoStatusDetailsBinTestService
+  include GRPC::GenericService
+  rpc :an_rpc, EchoMsg, EchoMsg
+
+  def an_rpc(_, _)
+    fail GRPC::Unknown
+  end
+end
+
+NoStatusDetailsBinTestServiceStub = NoStatusDetailsBinTestService.rpc_stub_class
+
+describe 'when the endpoint doesnt send grpc-status-details-bin' do
+  def start_server
+    @srv = new_rpc_server_for_testing(pool_size: 1)
+    @server_port = @srv.add_http2_port('localhost:0',
+                                       :this_port_is_insecure)
+    @srv.handle(NoStatusDetailsBinTestService)
+    @server_thd = Thread.new { @srv.run }
+    @srv.wait_till_running
+  end
+
+  def stop_server
+    expect(@srv.stopped?).to be(false)
+    @srv.stop
+    @server_thd.join
+    expect(@srv.stopped?).to be(true)
+  end
+
+  before(:each) do
+    start_server
+  end
+
+  after(:each) do
+    stop_server
+  end
+
+  it 'should receive nil when we extract try to extract a google '\
+    'rpc status from a BadStatus exception that didnt have it' do
+    stub = NoStatusDetailsBinTestServiceStub.new("localhost:#{@server_port}",
+                                                 :this_channel_is_insecure)
+    begin
+      stub.an_rpc(EchoMsg.new)
+    rescue GRPC::Unknown => e
+      rpc_status = GRPC::GoogleRpcStatusUtils.extract_google_rpc_status(
+        e.to_status)
+    end
+    expect(rpc_status).to be(nil)
+  end
+
+  it 'should receive nil when we extract try to extract a google '\
+    'rpc status from an op views status object that didnt have it' do
+    stub = NoStatusDetailsBinTestServiceStub.new("localhost:#{@server_port}",
+                                                 :this_channel_is_insecure)
+    op = stub.an_rpc(EchoMsg.new, return_op: true)
+    begin
+      op.execute
+    rescue GRPC::Unknown => e
+      status_from_exception = e.to_status
+    end
+    expect(GRPC::GoogleRpcStatusUtils.extract_google_rpc_status(
+             status_from_exception)).to be(nil)
+    expect(GRPC::GoogleRpcStatusUtils.extract_google_rpc_status(
+             op.status)).to be nil
+  end
+end

data/src/ruby/spec/pb/codegen/grpc/testing/package_options.proto

@@ -0,0 +1,28 @@
+// Copyright 2018 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.
+
+syntax = "proto3";
+
+package grpc.testing;
+
+// For sanity checking package definitions
+option ruby_package = "Grpc.Testing.Package.Options";
+
+message TestRequest { }
+
+message TestResponse { }
+
+service TestService {
+  rpc GetTest(TestRequest) returns (TestResponse) { }
+}

data/src/ruby/spec/pb/codegen/grpc/testing/package_options_import.proto

@@ -0,0 +1,22 @@
+// Copyright 2019 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.
+
+syntax = "proto3";
+
+package grpc.testing;
+
+// For sanity checking package definitions
+option ruby_package = "A::Other";
+
+message Thing { }

data/src/ruby/spec/pb/codegen/grpc/testing/package_options_import2.proto

@@ -0,0 +1,23 @@
+// Copyright 2020 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.
+
+syntax = "proto3";
+
+package grpc.foo;
+
+option ruby_package = "B::Other";
+
+message Foo {
+  message Bar { }
+}

data/src/ruby/spec/pb/codegen/grpc/testing/package_options_ruby_style.proto

@@ -0,0 +1,41 @@
+// Copyright 2019 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.
+
+syntax = "proto3";
+
+package grpc.testing;
+
+import "grpc/testing/package_options_import.proto";
+import "grpc/testing/package_options_import2.proto";
+
+// For sanity checking package definitions
+option ruby_package = "RPC::Test::New::Package::Options";
+
+message AnotherTestRequest { }
+
+message AnotherTestResponse { }
+
+message Foo { }
+
+message Bar {
+  message Baz { }
+}
+
+service AnotherTestService {
+  rpc GetTest(AnotherTestRequest) returns (AnotherTestResponse) { }
+  rpc OtherTest(Thing) returns (Thing) { }
+  rpc PackageTest(grpc.testing.Thing) returns (grpc.foo.Foo.Bar) { }
+  rpc FooTest(Foo) returns (Foo) { }
+  rpc NestedMessageTest(Foo) returns (Bar.Baz) { }
+}

data/src/ruby/spec/pb/codegen/grpc/testing/same_package_service_name.proto

@@ -0,0 +1,27 @@
+// Copyright 2020 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.
+
+syntax = "proto3";
+
+package same_name;
+
+service SameName {
+  rpc Health(Request) returns (Status);
+}
+
+message Status {
+  string msg = 1;
+}
+
+message Request {}

data/src/ruby/spec/pb/codegen/grpc/testing/same_ruby_package_service_name.proto

@@ -0,0 +1,29 @@
+// Copyright 2020 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.
+
+syntax = "proto3";
+
+package other_name;
+
+option ruby_package = "SameName2";
+
+service SameName2 {
+  rpc Health(Request) returns (Status);
+}
+
+message Status {
+  string msg = 1;
+}
+
+message Request {}

data/src/ruby/spec/pb/codegen/package_option_spec.rb

@@ -0,0 +1,98 @@
+# Copyright 2018 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 'open3'
+require 'tmpdir'
+
+describe 'Code Generation Options' do
+  it 'should generate and respect package options' do
+    with_protos(%w[grpc/testing/package_options.proto]) do
+      expect { Grpc::Testing::Package::Options::TestService::Service }.to raise_error(NameError)
+      expect(require('grpc/testing/package_options_services_pb')).to be_truthy
+      expect { Grpc::Testing::Package::Options::TestService::Service }.to_not raise_error
+      expect { Grpc::Testing::TestService::Service }.to raise_error(NameError)
+    end
+  end
+
+  it 'should generate and respect Ruby style package options' do
+    with_protos(['grpc/testing/package_options_ruby_style.proto',
+                 'grpc/testing/package_options_import.proto',
+                 'grpc/testing/package_options_import2.proto']) do
+      expect { RPC::Test::New::Package::Options::AnotherTestService::Service }.to raise_error(NameError)
+      expect(require('grpc/testing/package_options_ruby_style_services_pb')).to be_truthy
+      expect { RPC::Test::New::Package::Options::AnotherTestService::Service }.to_not raise_error
+      expect { Grpc::Testing::AnotherTestService::Service }.to raise_error(NameError)
+
+      services = RPC::Test::New::Package::Options::AnotherTestService::Service.rpc_descs
+      expect(services[:GetTest].input).to eq(RPC::Test::New::Package::Options::AnotherTestRequest)
+      expect(services[:GetTest].output).to eq(RPC::Test::New::Package::Options::AnotherTestResponse)
+      expect(services[:OtherTest].input).to eq(A::Other::Thing)
+      expect(services[:OtherTest].output).to eq(A::Other::Thing)
+      expect(services[:PackageTest].input).to eq(A::Other::Thing)
+      expect(services[:PackageTest].output).to eq(B::Other::Foo::Bar)
+      expect(services[:FooTest].input).to eq(RPC::Test::New::Package::Options::Foo)
+      expect(services[:FooTest].output).to eq(RPC::Test::New::Package::Options::Foo)
+      expect(services[:NestedMessageTest].input).to eq(RPC::Test::New::Package::Options::Foo)
+      expect(services[:NestedMessageTest].output).to eq(RPC::Test::New::Package::Options::Bar::Baz)
+    end
+  end
+
+  it 'should generate when package and service has same name' do
+    with_protos(['grpc/testing/same_package_service_name.proto']) do
+      expect { SameName::SameName::Service }.to raise_error(NameError)
+      expect(require('grpc/testing/same_package_service_name_services_pb')).to be_truthy
+      expect { SameName::SameName::Service }.to_not raise_error
+      expect { SameName::Request }.to_not raise_error
+      expect { SameName::Status }.to_not raise_error
+    end
+  end
+
+  it 'should generate when ruby_package and service has same name' do
+    with_protos(['grpc/testing/same_ruby_package_service_name.proto']) do
+      expect { SameName2::SameName2::Service }.to raise_error(NameError)
+      expect(require('grpc/testing/same_ruby_package_service_name_services_pb')).to be_truthy
+      expect { SameName2::SameName2::Service }.to_not raise_error
+      expect { SameName2::Request }.to_not raise_error
+      expect { SameName2::Status }.to_not raise_error
+    end
+  end
+end
+
+def with_protos(file_paths)
+  pb_dir = File.dirname(__FILE__)
+  bins_dir = File.join('..', '..', '..', '..', '..', 'cmake', 'build')
+  plugin = File.join(bins_dir, 'grpc_ruby_plugin')
+  protoc = File.join(bins_dir, 'third_party', 'protobuf', 'protoc')
+
+  # Generate the service from the proto
+  Dir.mktmpdir(nil, File.dirname(__FILE__)) do |tmp_dir|
+    gen_file = system(protoc,
+                      '-I.',
+                      *file_paths,
+                      "--grpc_out=#{tmp_dir}", # generate the service
+                      "--ruby_out=#{tmp_dir}", # generate the definitions
+                      "--plugin=protoc-gen-grpc=#{plugin}",
+                      chdir: pb_dir,
+                      out: File::NULL)
+
+    expect(gen_file).to be_truthy
+    begin
+      $LOAD_PATH.push(tmp_dir)
+      yield
+    ensure
+      $LOAD_PATH.delete(tmp_dir)
+    end
+  end
+end

data/src/ruby/spec/pb/duplicate/codegen_spec.rb

@@ -0,0 +1,57 @@
+# Copyright 2016 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 'open3'
+require 'tmpdir'
+
+def can_run_codegen_check
+  system('which grpc_ruby_plugin') && system('which protoc')
+end
+
+describe 'Ping protobuf code generation' do
+  if !can_run_codegen_check
+    skip 'protoc || grpc_ruby_plugin missing, cannot verify ping code-gen'
+  else
+    it 'should have the same content as created by code generation' do
+      root_dir = File.join(File.dirname(__FILE__), '..', '..', '..', '..', '..')
+
+      # Get the current content
+      service_path = File.join(root_dir, 'src', 'ruby', 'pb', 'grpc',
+                               'testing', 'duplicate',
+                               'echo_duplicate_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, 'src', 'proto', 'grpc', 'testing',
+                            'duplicate', 'echo_duplicate_services_pb.rb')
+        pid = spawn(
+          'protoc',
+          '-I.',
+          'src/proto/grpc/testing/duplicate/echo_duplicate.proto',
+          "--grpc_out=#{tmp_dir}",
+          "--plugin=protoc-gen-grpc=#{plugin}",
+          chdir: root_dir)
+        Process.wait(pid)
+        File.open(gen_out) { |f| got = f.read }
+      end
+      expect(got).to eq(want)
+    end
+  end
+end