wearefair-grpc 1.3.1.pre.a

data/src/ruby/spec/generic/service_spec.rb

@@ -0,0 +1,276 @@
+# Copyright 2015, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+require 'grpc'
+require 'grpc/generic/rpc_desc'
+require 'grpc/generic/service'
+
+# A test message that encodes/decodes using marshal/marshal.
+class GoodMsg
+  def self.marshal(_o)
+    ''
+  end
+
+  def self.unmarshal(_o)
+    GoodMsg.new
+  end
+end
+
+# A test message that encodes/decodes using encode/decode.
+class EncodeDecodeMsg
+  def self.encode(_o)
+    ''
+  end
+
+  def self.decode(_o)
+    GoodMsg.new
+  end
+end
+
+GenericService = GRPC::GenericService
+Dsl = GenericService::Dsl
+
+describe Dsl do
+  it 'can be included in new classes' do
+    blk = proc { Class.new { include Dsl } }
+    expect(&blk).to_not raise_error
+  end
+end
+
+describe GenericService do
+  context '#underscore' do
+    it 'should convert CamelCase to underscore separated' do
+      expect(GenericService.underscore('AnRPC')).to eq('an_rpc')
+      expect(GenericService.underscore('AMethod')).to eq('a_method')
+      expect(GenericService.underscore('PrintHTML')).to eq('print_html')
+      expect(GenericService.underscore('SeeHTMLBooks')).to eq('see_html_books')
+    end
+  end
+
+  describe 'including it' do
+    it 'adds a class method, rpc' do
+      c = Class.new do
+        include GenericService
+      end
+      expect(c.methods).to include(:rpc)
+    end
+
+    it 'adds rpc descs using the added class method, #rpc' do
+      c = Class.new do
+        include GenericService
+        rpc :AnRpc, GoodMsg, GoodMsg
+      end
+
+      expect(c.rpc_descs).to include(:AnRpc)
+      expect(c.rpc_descs[:AnRpc]).to be_a(GRPC::RpcDesc)
+    end
+
+    it 'give subclasses access to #rpc_descs' do
+      base = Class.new do
+        include GenericService
+        rpc :AnRpc, GoodMsg, GoodMsg
+      end
+      c = Class.new(base) do
+      end
+      expect(c.rpc_descs).to include(:AnRpc)
+      expect(c.rpc_descs[:AnRpc]).to be_a(GRPC::RpcDesc)
+    end
+
+    it 'adds a default service name' do
+      c = Class.new do
+        include GenericService
+      end
+      expect(c.service_name).to eq('GenericService')
+    end
+
+    it 'adds a default service name to subclasses' do
+      base = Class.new do
+        include GenericService
+      end
+      c = Class.new(base) do
+      end
+      expect(c.service_name).to eq('GenericService')
+    end
+
+    it 'adds the specified service name' do
+      c = Class.new do
+        include GenericService
+        self.service_name = 'test.service.TestService'
+      end
+      expect(c.service_name).to eq('test.service.TestService')
+    end
+
+    it 'adds the specified service name to subclasses' do
+      base = Class.new do
+        include GenericService
+        self.service_name = 'test.service.TestService'
+      end
+      c = Class.new(base) do
+      end
+      expect(c.service_name).to eq('test.service.TestService')
+    end
+  end
+
+  describe '#include' do
+    it 'raises if #rpc is missing an arg' do
+      blk = proc do
+        Class.new do
+          include GenericService
+          rpc :AnRpc, GoodMsg
+        end
+      end
+      expect(&blk).to raise_error ArgumentError
+
+      blk = proc do
+        Class.new do
+          include GenericService
+          rpc :AnRpc
+        end
+      end
+      expect(&blk).to raise_error ArgumentError
+    end
+
+    describe 'when #rpc args are incorrect' do
+      it 'raises if an arg does not have the marshal or unmarshal methods' do
+        blk = proc do
+          Class.new do
+            include GenericService
+            rpc :AnRpc, GoodMsg, Object
+          end
+        end
+        expect(&blk).to raise_error ArgumentError
+      end
+
+      it 'raises if a type arg only has the marshal method' do
+        # a bad message type with only a marshal method
+        class OnlyMarshal
+          def marshal(o)
+            o
+          end
+        end
+
+        blk = proc do
+          Class.new do
+            include GenericService
+            rpc :AnRpc, OnlyMarshal, GoodMsg
+          end
+        end
+        expect(&blk).to raise_error ArgumentError
+      end
+
+      it 'raises if a type arg only has the unmarshal method' do
+        # a bad message type with only an unmarshal method
+        class OnlyUnmarshal
+          def self.ummarshal(o)
+            o
+          end
+        end
+        blk = proc do
+          Class.new do
+            include GenericService
+            rpc :AnRpc, GoodMsg, OnlyUnmarshal
+          end
+        end
+        expect(&blk).to raise_error ArgumentError
+      end
+    end
+
+    it 'is ok for services that expect the default {un,}marshal methods' do
+      blk = proc do
+        Class.new do
+          include GenericService
+          rpc :AnRpc, GoodMsg, GoodMsg
+        end
+      end
+      expect(&blk).not_to raise_error
+    end
+
+    it 'is ok for services that override the default {un,}marshal methods' do
+      blk = proc do
+        Class.new do
+          include GenericService
+          self.marshal_class_method = :encode
+          self.unmarshal_class_method = :decode
+          rpc :AnRpc, EncodeDecodeMsg, EncodeDecodeMsg
+        end
+      end
+      expect(&blk).not_to raise_error
+    end
+  end
+
+  describe '#rpc_stub_class' do
+    it 'generates a client class that defines any of the rpc methods' do
+      s = Class.new do
+        include GenericService
+        rpc :AnRpc, GoodMsg, GoodMsg
+        rpc :AServerStreamer, GoodMsg, stream(GoodMsg)
+        rpc :AClientStreamer, stream(GoodMsg), GoodMsg
+        rpc :ABidiStreamer, stream(GoodMsg), stream(GoodMsg)
+      end
+      client_class = s.rpc_stub_class
+      expect(client_class.instance_methods).to include(:an_rpc)
+      expect(client_class.instance_methods).to include(:a_server_streamer)
+      expect(client_class.instance_methods).to include(:a_client_streamer)
+      expect(client_class.instance_methods).to include(:a_bidi_streamer)
+    end
+
+    describe 'the generated instances' do
+      it 'can be instanciated with just a hostname and credentials' do
+        s = Class.new do
+          include GenericService
+          rpc :AnRpc, GoodMsg, GoodMsg
+          rpc :AServerStreamer, GoodMsg, stream(GoodMsg)
+          rpc :AClientStreamer, stream(GoodMsg), GoodMsg
+          rpc :ABidiStreamer, stream(GoodMsg), stream(GoodMsg)
+        end
+        client_class = s.rpc_stub_class
+        blk = proc do
+          client_class.new('fakehostname', :this_channel_is_insecure)
+        end
+        expect(&blk).not_to raise_error
+      end
+
+      it 'has the methods defined in the service' do
+        s = Class.new do
+          include GenericService
+          rpc :AnRpc, GoodMsg, GoodMsg
+          rpc :AServerStreamer, GoodMsg, stream(GoodMsg)
+          rpc :AClientStreamer, stream(GoodMsg), GoodMsg
+          rpc :ABidiStreamer, stream(GoodMsg), stream(GoodMsg)
+        end
+        client_class = s.rpc_stub_class
+        o = client_class.new('fakehostname', :this_channel_is_insecure)
+        expect(o.methods).to include(:an_rpc)
+        expect(o.methods).to include(:a_bidi_streamer)
+        expect(o.methods).to include(:a_client_streamer)
+        expect(o.methods).to include(:a_bidi_streamer)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# Copyright 2016, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+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

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

@@ -0,0 +1,222 @@
+# Copyright 2015, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+require 'grpc'
+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 `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 = RpcServer.new(**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