protobuf 2.2.5-java

data/spec/lib/protobuf/rpc/service_filters_spec.rb

@@ -0,0 +1,451 @@
+require 'spec_helper'
+
+class FilterTest
+  include Protobuf::Rpc::ServiceFilters
+
+  attr_accessor :called
+
+  # Initialize the hash keys as instance vars
+  def initialize(ivar_hash)
+    @called = []
+    ivar_hash.each_pair do |key, value|
+      self.class.class_eval do
+        attr_accessor key
+      end
+      __send__("#{key}=", value)
+    end
+  end
+
+  def endpoint
+    @called << :endpoint
+  end
+
+  def self.clear_filters!
+    @defined_filters = nil
+    @filters = nil
+    @rescue_filters = nil
+  end
+end
+
+describe Protobuf::Rpc::ServiceFilters do
+  let(:params) { {} }
+  subject { FilterTest.new(params) }
+  after(:each) { FilterTest.clear_filters! }
+
+  describe '#before_filter' do
+    let(:params) { { :before_filter_calls => 0 } }
+
+    before(:all) do
+      class FilterTest
+        private
+        def verify_before
+          @called << :verify_before
+          @before_filter_calls += 1
+        end
+
+        def foo
+          @called << :foo
+        end
+      end
+    end
+
+    before do
+      FilterTest.before_filter(:verify_before)
+      FilterTest.before_filter(:verify_before)
+      FilterTest.before_filter(:foo)
+    end
+
+    it 'calls filters in the order they were defined' do
+      subject.__send__(:run_filters, :endpoint)
+      subject.called.should eq [ :verify_before, :foo, :endpoint ]
+      subject.before_filter_calls.should eq 1
+    end
+
+    context 'when filter is configured with "only"' do
+      before(:all) do
+        class FilterTest
+          private
+          def endpoint_with_verify
+            @called << :endpoint_with_verify
+          end
+        end
+      end
+
+      before do
+        FilterTest.clear_filters!
+        FilterTest.before_filter(:verify_before, :only => :endpoint_with_verify)
+      end
+
+      context 'when invoking a method defined in "only" option' do
+        it 'invokes the filter' do
+          subject.__send__(:run_filters, :endpoint_with_verify)
+          subject.called.should eq [ :verify_before, :endpoint_with_verify ]
+        end
+      end
+
+      context 'when invoking a method not defined by "only" option' do
+        it 'does not invoke the filter' do
+          subject.__send__(:run_filters, :endpoint)
+          subject.called.should eq [ :endpoint ]
+        end
+      end
+    end
+
+    context 'when filter is configured with "except"' do
+      before(:all) do
+        class FilterTest
+          private
+          def endpoint_without_verify
+            @called << :endpoint_without_verify
+          end
+        end
+      end
+
+      before do
+        FilterTest.clear_filters!
+        FilterTest.before_filter(:verify_before, :except => :endpoint_without_verify)
+      end
+
+      context 'when invoking a method not defined in "except" option' do
+        it 'invokes the filter' do
+          subject.__send__(:run_filters, :endpoint)
+          subject.called.should eq [ :verify_before, :endpoint ]
+        end
+      end
+
+      context 'when invoking a method defined by "except" option' do
+        it 'does not invoke the filter' do
+          subject.__send__(:run_filters, :endpoint_without_verify)
+          subject.called.should eq [ :endpoint_without_verify ]
+        end
+      end
+    end
+
+    context 'when filter is configured with "if"' do
+      before(:all) do
+        class FilterTest
+          private
+          def check_true; return true; end
+          def check_false; return false; end
+          def verify_before; @called << :verify_before; end
+        end
+      end
+
+      context 'when "if" option is a method that returns true' do
+        before do
+          FilterTest.clear_filters!
+          FilterTest.before_filter(:verify_before, :if => :check_true)
+        end
+
+        it 'invokes the filter' do
+          subject.__send__(:run_filters, :endpoint)
+          subject.called.should eq [ :verify_before, :endpoint ]
+        end
+      end
+
+      context 'when "if" option is a callable that returns true' do
+        before do
+          FilterTest.clear_filters!
+          FilterTest.before_filter(:verify_before, :if => lambda { |service| true })
+        end
+
+        it 'invokes the filter' do
+          subject.__send__(:run_filters, :endpoint)
+          subject.called.should eq [ :verify_before, :endpoint ]
+        end
+      end
+
+      context 'when "if" option is a method that returns false' do
+        before do
+          FilterTest.clear_filters!
+          FilterTest.before_filter(:verify_before, :if => :check_false)
+        end
+
+        it 'skips the filter' do
+          subject.__send__(:run_filters, :endpoint)
+          subject.called.should eq [ :endpoint ]
+        end
+      end
+
+      context 'when "if" option is a callable that returns false' do
+        before do
+          FilterTest.clear_filters!
+          FilterTest.before_filter(:verify_before, :if => lambda { |service| false })
+        end
+
+        it 'skips the filter' do
+          subject.__send__(:run_filters, :endpoint)
+          subject.called.should eq [ :endpoint ]
+        end
+      end
+    end
+
+    context 'when filter is configured with "unless"' do
+      before(:all) do
+        class FilterTest
+          private
+          def check_true; return true; end
+          def check_false; return false; end
+          def verify_before; @called << :verify_before; end
+        end
+      end
+
+      context 'when "unless" option is a method that returns false' do
+        before do
+          FilterTest.clear_filters!
+          FilterTest.before_filter(:verify_before, :unless => :check_false)
+        end
+
+        it 'invokes the filter' do
+          subject.__send__(:run_filters, :endpoint)
+          subject.called.should eq [ :verify_before, :endpoint ]
+        end
+      end
+
+      context 'when "unless" option is a callable that returns true' do
+        before do
+          FilterTest.clear_filters!
+          FilterTest.before_filter(:verify_before, :unless => lambda { |service| false })
+        end
+
+        it 'invokes the filter' do
+          subject.__send__(:run_filters, :endpoint)
+          subject.called.should eq [ :verify_before, :endpoint ]
+        end
+      end
+
+      context 'when "unless" option is a method that returns false' do
+        before do
+          FilterTest.clear_filters!
+          FilterTest.before_filter(:verify_before, :unless => :check_true)
+        end
+
+        it 'skips the filter' do
+          subject.__send__(:run_filters, :endpoint)
+          subject.called.should eq [ :endpoint ]
+        end
+      end
+
+      context 'when "unless" option is a callable that returns false' do
+        before do
+          FilterTest.clear_filters!
+          FilterTest.before_filter(:verify_before, :unless => lambda { |service| true })
+        end
+
+        it 'skips the filter' do
+          subject.__send__(:run_filters, :endpoint)
+          subject.called.should eq [ :endpoint ]
+        end
+      end
+    end
+
+    context 'when filter returns false' do
+      before(:all) do
+        class FilterTest
+          private
+          def short_circuit_filter
+            @called << :short_circuit_filter
+            return false
+          end
+        end
+      end
+
+      before do
+        FilterTest.clear_filters!
+        FilterTest.before_filter(:short_circuit_filter)
+      end
+
+      it 'does not invoke the rpc method' do
+        subject.should_not_receive(:endpoint)
+        subject.__send__(:run_filters, :endpoint)
+        subject.called.should eq [ :short_circuit_filter ]
+      end
+    end
+  end
+
+  describe '#after_filter' do
+    let(:params) { { :after_filter_calls => 0 } }
+
+    before(:all) do
+      class FilterTest
+        private
+        def verify_after
+          @called << :verify_after
+          @after_filter_calls += 1
+        end
+
+        def foo
+          @called << :foo
+        end
+      end
+    end
+
+    before do
+      FilterTest.after_filter(:verify_after)
+      FilterTest.after_filter(:verify_after)
+      FilterTest.after_filter(:foo)
+    end
+
+    it 'calls filters in the order they were defined' do
+      subject.__send__(:run_filters, :endpoint)
+      subject.called.should eq [ :endpoint, :verify_after, :foo ]
+      subject.after_filter_calls.should eq 1
+    end
+  end
+
+  describe '#around_filter' do
+    let(:params) { {} }
+
+    before(:all) do
+      class FilterTest
+        private
+        def outer_around
+          @called << :outer_around_top
+          yield
+          @called << :outer_around_bottom
+        end
+
+        def inner_around
+          @called << :inner_around_top
+          yield
+          @called << :inner_around_bottom
+        end
+      end
+    end
+
+    before do
+      FilterTest.around_filter(:outer_around)
+      FilterTest.around_filter(:inner_around)
+      FilterTest.around_filter(:outer_around)
+      FilterTest.around_filter(:inner_around)
+    end
+
+    it 'calls filters in the order they were defined' do
+      subject.__send__(:run_filters, :endpoint)
+      subject.called.should eq([ :outer_around_top,
+                                 :inner_around_top,
+                                 :endpoint,
+                                 :inner_around_bottom,
+                                 :outer_around_bottom ])
+    end
+
+    context 'when around_filter does not yield' do
+      before do
+        class FilterTest
+          private
+          def inner_around
+            @called << :inner_around
+          end
+        end
+      end
+
+      before do
+        FilterTest.around_filter(:outer_around)
+        FilterTest.around_filter(:inner_around)
+      end
+
+      it 'cancels calling the rest of the filters and the endpoint' do
+        subject.should_not_receive(:endpoint)
+        subject.__send__(:run_filters, :endpoint)
+        subject.called.should eq([ :outer_around_top,
+                                   :inner_around,
+                                   :outer_around_bottom ])
+      end
+
+    end
+  end
+
+  describe '#rescue_from' do
+    before do
+      class CustomError1 < StandardError; end
+      class CustomError2 < StandardError; end
+      class CustomError3 < StandardError; end
+    end
+
+    before do
+      class FilterTest
+        private
+
+        def filter_with_error1
+          @called << :filter_with_error1
+          raise CustomError1, 'Filter 1 failed'
+        end
+
+        def filter_with_error2
+          @called << :filter_with_error2
+          raise CustomError1, 'Filter 2 failed'
+        end
+
+        def filter_with_error3
+          @called << :filter_with_error3
+          raise CustomError3, 'Filter 3 failed'
+        end
+
+        def custom_error_occurred(ex)
+          @ex_class = ex.class
+          @called << :custom_error_occurred
+        end
+      end
+    end
+
+    let(:params) { { :ex_class => nil } }
+
+    context 'when defining multiple errors with a given callback' do
+      before do
+        FilterTest.rescue_from(CustomError1, CustomError2, CustomError3, :with => :custom_error_occurred)
+      end
+      before { FilterTest.before_filter(:filter_with_error3) }
+
+      it 'short-circuits the call stack' do
+        expect {
+          subject.should_not_receive(:endpoint)
+          subject.__send__(:run_filters, :endpoint)
+          subject.called.should eq([ :filter_with_error3, :custom_error_occurred ])
+          subject.ex_class.should eq CustomError3
+        }.to_not raise_error(CustomError3)
+      end
+    end
+
+    context 'when defined with options' do
+      context 'when :with option is not given' do
+        specify do
+          expect { FilterTest.rescue_from(CustomError1) }.to raise_error(ArgumentError, /with/)
+        end
+      end
+
+      context 'when error occurs inside filter' do
+        before { FilterTest.rescue_from(CustomError1, :with => :custom_error_occurred) }
+        before { FilterTest.before_filter(:filter_with_error1) }
+
+        it 'short-circuits the call stack' do
+          expect {
+            subject.should_not_receive(:endpoint)
+            subject.__send__(:run_filters, :endpoint)
+            subject.called.should eq([ :filter_with_error1, :custom_error_occurred ])
+            subject.ex_class.should eq CustomError1
+          }.to_not raise_error(CustomError1)
+        end
+      end
+    end
+
+    context 'when defined with block' do
+      before do
+        FilterTest.rescue_from(CustomError1) do |service, ex|
+          service.ex_class = ex.class
+          service.called << :block_rescue_handler
+        end
+      end
+      before { FilterTest.before_filter(:filter_with_error1) }
+
+      it 'short-circuits the call stack' do
+        expect {
+          subject.should_not_receive(:endpoint)
+          subject.__send__(:run_filters, :endpoint)
+          subject.called.should eq([ :filter_with_error1, :block_rescue_handler ])
+          subject.ex_class.should eq CustomError1
+        }.to_not raise_error(CustomError1)
+      end
+    end
+  end
+
+end

data/spec/lib/protobuf/rpc/service_spec.rb

@@ -0,0 +1,165 @@
+require 'spec_helper'
+require 'spec/support/test/resource_service'
+
+describe Protobuf::Rpc::Service do
+
+  context 'class methods' do
+    subject { Test::ResourceService }
+
+    before :each do
+      reset_service_location Test::ResourceService
+    end
+
+    describe '.host' do
+      its(:host) { should eq described_class::DEFAULT_HOST }
+    end
+
+    describe '.host=' do
+      before { subject.host = 'mynewhost.com' }
+      its(:host) { should eq 'mynewhost.com' }
+    end
+
+    describe '.port' do
+      its(:port) { should eq described_class::DEFAULT_PORT }
+    end
+
+    describe '.port=' do
+      before { subject.port = 12345 }
+      its(:port) { should eq 12345 }
+    end
+
+    describe '.configure' do
+      context 'when providing a host' do
+        before { subject.configure(:host => 'mynewhost.com') }
+        its(:host) { should eq 'mynewhost.com' }
+      end
+
+      context 'when providing a port' do
+        before { subject.configure(:port => 12345) }
+        its(:port) { should eq 12345 }
+      end
+    end
+
+    describe '.located_at' do
+      context 'when given location is empty' do
+        before { subject.located_at(nil) }
+        its(:host) { should eq described_class::DEFAULT_HOST }
+        its(:port) { should eq described_class::DEFAULT_PORT }
+      end
+
+      context 'when given location is invalid' do
+        before { subject.located_at('i like pie') }
+        its(:host) { should eq described_class::DEFAULT_HOST }
+        its(:port) { should eq described_class::DEFAULT_PORT }
+      end
+
+      context 'when given location contains a host and port' do
+        before { subject.located_at('mynewdomain.com:12345') }
+        its(:host) { should eq 'mynewdomain.com' }
+        its(:port) { should eq 12345 }
+      end
+    end
+
+    describe '.client' do
+      it 'initializes a client object for this service' do
+        client = double('client')
+        ::Protobuf::Rpc::Client.should_receive(:new)
+                                .with(hash_including({ :service => subject,
+                                                       :host => subject.host,
+                                                       :port => subject.port }))
+                                .and_return(client)
+        subject.client.should eq client
+      end
+    end
+
+    describe '.rpc' do
+      before { Test::ResourceService.rpc(:update, Test::ResourceFindRequest, Test::Resource) }
+      subject { Test::ResourceService.rpcs[:update] }
+      its(:method) { should eq :update }
+      its(:request_type) { should eq Test::ResourceFindRequest }
+      its(:response_type) { should eq Test::Resource }
+    end
+
+    describe '.rpc_method?' do
+      before { Test::ResourceService.rpc(:delete, Test::Resource, Test::Resource) }
+
+      context 'when given name is a pre-defined rpc method' do
+        it 'returns true' do
+          subject.rpc_method?(:delete).should be_true
+        end
+      end
+
+      context 'when given name is not a pre-defined rpc method' do
+        it 'returns false' do
+          subject.rpc_method?(:zoobaboo).should be_false
+        end
+      end
+    end
+  end
+
+  context 'instance methods' do
+    context 'when invoking a service call' do
+      before(:all) do
+        class ::NewTestService < Protobuf::Rpc::Service
+          rpc :find_with_implied_response, Test::ResourceFindRequest, Test::Resource
+          def find_with_implied_response
+            response.name = 'Implicit response'
+          end
+
+          rpc :find_with_respond_with, Test::ResourceFindRequest, Test::Resource
+          def find_with_respond_with
+            custom = Test::Resource.new(:name => 'Custom response')
+            respond_with(custom)
+          end
+
+          rpc :find_with_rpc_failed, Test::ResourceFindRequest, Test::Resource
+          def find_with_rpc_failed
+            rpc_failed('This is a failed endpoint')
+            response.name = 'Name will still be set'
+          end
+        end
+      end
+
+
+      let(:request) do
+        Test::ResourceFindRequest.new(:name => 'resource')
+      end
+
+      let(:response) do
+        Test::Resource.new
+      end
+
+      context 'when calling the rpc method' do
+        context 'when response is implied' do
+          subject { NewTestService.new(:find_with_implied_response, request.serialize_to_string) }
+
+          before { subject.find_with_implied_response }
+          its(:response) { should be_a(Test::Resource) }
+          specify { subject.response.name.should eq 'Implicit response' }
+        end
+
+        context 'when using respond_with paradigm' do
+          subject { NewTestService.new(:find_with_respond_with, request.serialize_to_string) }
+
+          before { subject.find_with_respond_with }
+          its(:response) { should be_a(Test::Resource) }
+          specify { subject.response.name.should eq 'Custom response' }
+        end
+      end
+
+      context 'when calling rpc_failed in the method' do
+        subject { NewTestService.new(:find_with_rpc_failed, request.serialize_to_string) }
+
+        it 'invokes the rpc_failed callback with the error' do
+          error = nil
+          subject.on_rpc_failed(lambda { |err| error = err })
+          subject.find_with_rpc_failed
+          error.should eq 'This is a failed endpoint'
+          subject.response.name.should eq 'Name will still be set'
+        end
+      end
+    end
+
+  end
+
+end

data/spec/lib/protobuf_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require 'protobuf'
+
+describe ::Protobuf do
+
+  describe '.connector_type' do
+    before { described_class.instance_variable_set(:@_connector_type, nil) }
+
+    it 'defaults to socket' do
+      described_class.connector_type.should eq :socket
+    end
+
+    it 'accepts socket, evented, or zmq' do
+      [:socket, :evented, :zmq].each do |type|
+        described_class.connector_type = type
+        described_class.connector_type.should eq type
+      end
+    end
+
+    it 'does not accept other types' do
+      [:hello, :world].each do |type|
+        expect {
+          described_class.connector_type = type
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe '.gc_pause_server_request?' do
+    before { described_class.instance_variable_set(:@_gc_pause_server_request, nil) }
+
+    it 'defaults to a false value' do
+      described_class.gc_pause_server_request?.should be_false
+    end
+
+    it 'is settable' do
+      described_class.gc_pause_server_request = true
+      described_class.gc_pause_server_request?.should be_true
+    end
+  end
+
+  describe '.print_deprecation_warnings?' do
+    before { described_class.instance_variable_set(:@_print_deprecation_warnings, nil) }
+
+    it 'defaults to a true value' do
+      described_class.print_deprecation_warnings?.should be_true
+    end
+
+    it 'is settable' do
+      described_class.print_deprecation_warnings = false
+      described_class.print_deprecation_warnings?.should be_false
+    end
+
+    context 'when ENV["PB_IGNORE_DEPRECATIONS"] present' do
+      it 'defaults to a false value' do
+        ENV['PB_IGNORE_DEPRECATIONS'] = '1'
+        described_class.print_deprecation_warnings?.should be_false
+      end
+    end
+  end
+
+end