protobuffy 3.6.0 → 4.0.0

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

@@ -1,52 +1,35 @@
 require 'spec_helper'
 require 'protobuf/rpc/service_dispatcher'
 
-describe Protobuf::Rpc::ServiceDispatcher do
+RSpec.describe Protobuf::Rpc::ServiceDispatcher do
   let(:app) { proc { |env| env } }
-  let(:env) {
+  let(:env) do
     Protobuf::Rpc::Env.new(
       'method_name' => method_name,
       'request' => request,
       'rpc_service' => service_class,
-      'service_name' => service_name,
+      'service_name' => service_name
     )
-  }
+  end
   let(:method_name) { :find }
   let(:request) { request_type.new(:name => 'required') }
   let(:request_type) { service_class.rpcs[method_name].request_type }
   let(:response) { response_type.new(:name => 'required') }
   let(:response_type) { service_class.rpcs[method_name].response_type }
-
   let(:rpc_service) { service_class.new(env) }
   let(:service_class) { Test::ResourceService }
   let(:service_name) { service_class.to_s }
 
   subject { described_class.new(app) }
 
-  before { subject.stub(:rpc_service).and_return(rpc_service) }
+  before { allow(subject).to receive(:rpc_service).and_return(rpc_service) }
 
   describe '#call' do
-    before { rpc_service.stub(:response).and_return(response) }
+    before { allow(rpc_service).to receive(:response).and_return(response) }
 
     it "dispatches the request" do
-      stack_env = subject.call(env)
-      stack_env.response.should eq response
-    end
-
-    context "when the given RPC method is not implemented" do
-      let(:method_name) { :find_not_implemented }
-
-      it "raises a method not found exception" do
-        expect { subject.call(env) }.to raise_exception(Protobuf::Rpc::MethodNotFound)
-      end
-    end
-
-    context "when the given RPC method is implemented and a NoMethodError is raised" do
-      before { rpc_service.stub(:callable_rpc_method).and_return(lambda { rpc_service.__send__(:foo) }) }
-
-      it "raises the exeception" do
-        expect { subject.call(env) }.to raise_exception(NoMethodError)
-      end
+      stack_env = subject._call(env)
+      expect(stack_env.response).to eq response
     end
   end
 end

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

@@ -27,7 +27,7 @@ class FilterTest
   end
 end
 
-describe Protobuf::Rpc::ServiceFilters do
+RSpec.describe Protobuf::Rpc::ServiceFilters do
   let(:params) { {} }
   subject { FilterTest.new(params) }
   after(:each) { FilterTest.clear_filters! }
@@ -38,6 +38,7 @@ describe Protobuf::Rpc::ServiceFilters do
     before(:all) do
       class FilterTest
         private
+
         def verify_before
           @called << :verify_before
           @before_filter_calls += 1
@@ -55,19 +56,20 @@ describe Protobuf::Rpc::ServiceFilters do
       FilterTest.before_filter(:foo)
     end
 
-    specify { subject.class.should respond_to(:before_filter) }
-    specify { subject.class.should respond_to(:before_action) }
+    specify { expect(subject.class).to respond_to(:before_filter) }
+    specify { expect(subject.class).to respond_to(:before_action) }
 
     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
+      expect(subject.called).to eq [:verify_before, :foo, :endpoint]
+      expect(subject.before_filter_calls).to 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
@@ -82,14 +84,14 @@ describe Protobuf::Rpc::ServiceFilters do
       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 ]
+          expect(subject.called).to 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 ]
+          expect(subject.called).to eq [:endpoint]
         end
       end
     end
@@ -98,6 +100,7 @@ describe Protobuf::Rpc::ServiceFilters do
       before(:all) do
         class FilterTest
           private
+
           def endpoint_without_verify
             @called << :endpoint_without_verify
           end
@@ -112,14 +115,14 @@ describe Protobuf::Rpc::ServiceFilters do
       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 ]
+          expect(subject.called).to 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 ]
+          expect(subject.called).to eq [:endpoint_without_verify]
         end
       end
     end
@@ -128,9 +131,18 @@ describe Protobuf::Rpc::ServiceFilters 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
+
+          def check_true
+            true
+          end
+
+          def check_false
+            false
+          end
+
+          def verify_before
+            @called << :verify_before
+          end
         end
       end
 
@@ -142,19 +154,19 @@ describe Protobuf::Rpc::ServiceFilters do
 
         it 'invokes the filter' do
           subject.__send__(:run_filters, :endpoint)
-          subject.called.should eq [ :verify_before, :endpoint ]
+          expect(subject.called).to 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 })
+          FilterTest.before_filter(:verify_before, :if => ->(_service) { true })
         end
 
         it 'invokes the filter' do
           subject.__send__(:run_filters, :endpoint)
-          subject.called.should eq [ :verify_before, :endpoint ]
+          expect(subject.called).to eq [:verify_before, :endpoint]
         end
       end
 
@@ -166,19 +178,19 @@ describe Protobuf::Rpc::ServiceFilters do
 
         it 'skips the filter' do
           subject.__send__(:run_filters, :endpoint)
-          subject.called.should eq [ :endpoint ]
+          expect(subject.called).to 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 })
+          FilterTest.before_filter(:verify_before, :if => ->(_service) { false })
         end
 
         it 'skips the filter' do
           subject.__send__(:run_filters, :endpoint)
-          subject.called.should eq [ :endpoint ]
+          expect(subject.called).to eq [:endpoint]
         end
       end
     end
@@ -187,9 +199,18 @@ describe Protobuf::Rpc::ServiceFilters 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
+
+          def check_true
+            true
+          end
+
+          def check_false
+            false
+          end
+
+          def verify_before
+            @called << :verify_before
+          end
         end
       end
 
@@ -201,19 +222,19 @@ describe Protobuf::Rpc::ServiceFilters do
 
         it 'invokes the filter' do
           subject.__send__(:run_filters, :endpoint)
-          subject.called.should eq [ :verify_before, :endpoint ]
+          expect(subject.called).to 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 })
+          FilterTest.before_filter(:verify_before, :unless => ->(_service) { false })
         end
 
         it 'invokes the filter' do
           subject.__send__(:run_filters, :endpoint)
-          subject.called.should eq [ :verify_before, :endpoint ]
+          expect(subject.called).to eq [:verify_before, :endpoint]
         end
       end
 
@@ -225,19 +246,19 @@ describe Protobuf::Rpc::ServiceFilters do
 
         it 'skips the filter' do
           subject.__send__(:run_filters, :endpoint)
-          subject.called.should eq [ :endpoint ]
+          expect(subject.called).to 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 })
+          FilterTest.before_filter(:verify_before, :unless => ->(_service) { true })
         end
 
         it 'skips the filter' do
           subject.__send__(:run_filters, :endpoint)
-          subject.called.should eq [ :endpoint ]
+          expect(subject.called).to eq [:endpoint]
         end
       end
     end
@@ -246,9 +267,10 @@ describe Protobuf::Rpc::ServiceFilters do
       before(:all) do
         class FilterTest
           private
+
           def short_circuit_filter
             @called << :short_circuit_filter
-            return false
+            false
           end
         end
       end
@@ -259,9 +281,9 @@ describe Protobuf::Rpc::ServiceFilters do
       end
 
       it 'does not invoke the rpc method' do
-        subject.should_not_receive(:endpoint)
+        expect(subject).not_to receive(:endpoint)
         subject.__send__(:run_filters, :endpoint)
-        subject.called.should eq [ :short_circuit_filter ]
+        expect(subject.called).to eq [:short_circuit_filter]
       end
     end
   end
@@ -272,6 +294,7 @@ describe Protobuf::Rpc::ServiceFilters do
     before(:all) do
       class FilterTest
         private
+
         def verify_after
           @called << :verify_after
           @after_filter_calls += 1
@@ -289,13 +312,13 @@ describe Protobuf::Rpc::ServiceFilters do
       FilterTest.after_filter(:foo)
     end
 
-    specify { subject.class.should respond_to(:after_filter) }
-    specify { subject.class.should respond_to(:after_action) }
+    specify { expect(subject.class).to respond_to(:after_filter) }
+    specify { expect(subject.class).to respond_to(:after_action) }
 
     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
+      expect(subject.called).to eq [:endpoint, :verify_after, :foo]
+      expect(subject.after_filter_calls).to eq 1
     end
   end
 
@@ -305,6 +328,7 @@ describe Protobuf::Rpc::ServiceFilters do
     before(:all) do
       class FilterTest
         private
+
         def outer_around
           @called << :outer_around_top
           yield
@@ -326,22 +350,27 @@ describe Protobuf::Rpc::ServiceFilters do
       FilterTest.around_filter(:inner_around)
     end
 
-    specify { subject.class.should respond_to(:around_filter) }
-    specify { subject.class.should respond_to(:around_action) }
+    specify { expect(subject.class).to respond_to(:around_filter) }
+    specify { expect(subject.class).to respond_to(:around_action) }
 
     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 ])
+      expect(subject.called).to 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
@@ -354,11 +383,15 @@ describe Protobuf::Rpc::ServiceFilters do
       end
 
       it 'cancels calling the rest of the filters and the endpoint' do
-        subject.should_not_receive(:endpoint)
+        expect(subject).not_to receive(:endpoint)
         subject.__send__(:run_filters, :endpoint)
-        subject.called.should eq([ :outer_around_top,
-                                   :inner_around,
-                                   :outer_around_bottom ])
+        expect(subject.called).to eq(
+          [
+            :outer_around_top,
+            :inner_around,
+            :outer_around_bottom,
+          ]
+        )
       end
 
     end
@@ -377,22 +410,22 @@ describe Protobuf::Rpc::ServiceFilters do
 
         def filter_with_error1
           @called << :filter_with_error1
-          raise CustomError1, 'Filter 1 failed'
+          fail CustomError1, 'Filter 1 failed'
         end
 
         def filter_with_error2
           @called << :filter_with_error2
-          raise CustomError1, 'Filter 2 failed'
+          fail CustomError1, 'Filter 2 failed'
         end
 
         def filter_with_error3
           @called << :filter_with_error3
-          raise CustomError3, 'Filter 3 failed'
+          fail CustomError3, 'Filter 3 failed'
         end
 
         def filter_with_runtime_error
           @called << :filter_with_runtime_error
-          raise RuntimeError, 'Filter with runtime error failed'
+          fail 'Filter with runtime error failed'
         end
 
         def custom_error_occurred(ex)
@@ -411,12 +444,12 @@ describe Protobuf::Rpc::ServiceFilters do
       before { FilterTest.before_filter(:filter_with_error3) }
 
       it 'short-circuits the call stack' do
-        expect {
-          subject.should_not_receive(:endpoint)
+        expect do
+          expect(subject).not_to receive(:endpoint)
           subject.__send__(:run_filters, :endpoint)
-          subject.called.should eq([ :filter_with_error3, :custom_error_occurred ])
-          subject.ex_class.should eq CustomError3
-        }.not_to raise_error
+          expect(subject.called).to eq([:filter_with_error3, :custom_error_occurred])
+          expect(subject.ex_class).to eq CustomError3
+        end.not_to raise_error
       end
     end
 
@@ -432,12 +465,12 @@ describe Protobuf::Rpc::ServiceFilters do
         before { FilterTest.before_filter(:filter_with_error1) }
 
         it 'short-circuits the call stack' do
-          expect {
-            subject.should_not_receive(:endpoint)
+          expect do
+            expect(subject).not_to receive(:endpoint)
             subject.__send__(:run_filters, :endpoint)
-            subject.called.should eq([ :filter_with_error1, :custom_error_occurred ])
-            subject.ex_class.should eq CustomError1
-          }.not_to raise_error
+            expect(subject.called).to eq([:filter_with_error1, :custom_error_occurred])
+            expect(subject.ex_class).to eq CustomError1
+          end.not_to raise_error
         end
       end
     end
@@ -452,12 +485,12 @@ describe Protobuf::Rpc::ServiceFilters do
       before { FilterTest.before_filter(:filter_with_error1) }
 
       it 'short-circuits the call stack' do
-        expect {
-          subject.should_not_receive(:endpoint)
+        expect do
+          expect(subject).not_to receive(:endpoint)
           subject.__send__(:run_filters, :endpoint)
-          subject.called.should eq([ :filter_with_error1, :block_rescue_handler ])
-          subject.ex_class.should eq CustomError1
-        }.not_to raise_error
+          expect(subject.called).to eq([:filter_with_error1, :block_rescue_handler])
+          expect(subject.ex_class).to eq CustomError1
+        end.not_to raise_error
       end
     end
 
@@ -471,12 +504,12 @@ describe Protobuf::Rpc::ServiceFilters do
       before { FilterTest.before_filter(:filter_with_runtime_error) }
 
       it 'rescues with the given callable' do
-        expect {
-          subject.should_not_receive(:endpoint)
+        expect do
+          expect(subject).not_to receive(:endpoint)
           subject.__send__(:run_filters, :endpoint)
-          subject.called.should eq([ :filter_with_runtime_error, :standard_error_rescue_handler ])
-          subject.ex_class.should eq RuntimeError
-        }.not_to raise_error
+          expect(subject.called).to eq([:filter_with_runtime_error, :standard_error_rescue_handler])
+          expect(subject.ex_class).to eq RuntimeError
+        end.not_to raise_error
       end
     end
   end