prepor-protobuf 3.5.0

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

@@ -0,0 +1,293 @@
+require 'spec_helper'
+
+require 'protobuf/rpc/service_directory'
+
+RSpec.describe ::Protobuf::Rpc::ServiceDirectory do
+  subject { described_class.instance }
+
+  let(:echo_server) do
+    ::Protobuf::Rpc::DynamicDiscovery::Server.new(
+      :uuid => 'echo',
+      :address => '127.0.0.1',
+      :port => '1111',
+      :ttl => 10,
+      :services => %w(EchoService),
+    )
+  end
+
+  let(:hello_server) do
+    ::Protobuf::Rpc::DynamicDiscovery::Server.new(
+      :uuid => "hello",
+      :address => '127.0.0.1',
+      :port => "1112",
+      :ttl => 10,
+      :services => %w(HelloService),
+    )
+  end
+
+  let(:hello_server_with_short_ttl) do
+    ::Protobuf::Rpc::DynamicDiscovery::Server.new(
+      :uuid => "hello_server_with_short_ttl",
+      :address => '127.0.0.1',
+      :port => '1113',
+      :ttl => 1,
+      :services => %w(HelloService),
+    )
+  end
+
+  let(:combo_server) do
+    ::Protobuf::Rpc::DynamicDiscovery::Server.new(
+      :uuid => "combo",
+      :address => '127.0.0.1',
+      :port => '1114',
+      :ttl => 10,
+      :services => %w(HelloService EchoService),
+    )
+  end
+
+  before(:all) do
+    @address = "127.0.0.1"
+    @port = 33333
+    @socket = UDPSocket.new
+    EchoService = Class.new
+
+    described_class.address = @address
+    described_class.port = @port
+  end
+
+  def expect_event_trigger(event)
+    expect(::ActiveSupport::Notifications).to receive(:instrument)
+      .with(event, hash_including(:listing => an_instance_of(::Protobuf::Rpc::ServiceDirectory::Listing))).once
+  end
+
+  def send_beacon(type, server)
+    type = type.to_s.upcase
+    beacon = ::Protobuf::Rpc::DynamicDiscovery::Beacon.new(
+      :server => server,
+      :beacon_type => ::Protobuf::Rpc::DynamicDiscovery::BeaconType.fetch(type),
+    )
+
+    @socket.send(beacon.encode, 0, @address, @port)
+    sleep 0.01 # give the service directory time to process the beacon
+  end
+
+  it "should be a singleton" do
+    expect(subject).to be_a_kind_of(Singleton)
+  end
+
+  it "should be configured to listen to address 127.0.0.1" do
+    expect(described_class.address).to eq '127.0.0.1'
+  end
+
+  it "should be configured to listen to port 33333" do
+    expect(described_class.port).to eq 33333
+  end
+
+  it "should defer .start to the instance#start" do
+    expect(described_class.instance).to receive(:start)
+    described_class.start
+  end
+
+  it "should yeild itself to blocks passed to .start" do
+    allow(described_class.instance).to receive(:start)
+    expect { |b| described_class.start(&b) }.to yield_with_args(described_class)
+  end
+
+  it "should defer .stop to the instance#stop" do
+    expect(described_class.instance).to receive(:stop)
+    described_class.stop
+  end
+
+  context "stopped" do
+    before { subject.stop }
+
+    describe "#lookup" do
+      it "should return nil" do
+        send_beacon(:heartbeat, echo_server)
+        expect(subject.lookup("EchoService")).to be_nil
+      end
+    end
+
+    describe "#restart" do
+      it "should start the service" do
+        subject.restart
+        expect(subject).to be_running
+      end
+    end
+
+    describe "#running" do
+      it "should be false" do
+        expect(subject).to_not be_running
+      end
+    end
+
+    describe "#stop" do
+      it "has no effect" do
+        subject.stop
+      end
+    end
+  end
+
+  context "started" do
+    before { subject.start }
+    after { subject.stop }
+
+    specify { expect(subject).to be_running }
+
+    it "should trigger added events" do
+      expect_event_trigger("directory.listing.added")
+      send_beacon(:heartbeat, echo_server)
+    end
+
+    it "should trigger updated events" do
+      send_beacon(:heartbeat, echo_server)
+      expect_event_trigger("directory.listing.updated")
+      send_beacon(:heartbeat, echo_server)
+    end
+
+    it "should trigger removed events" do
+      send_beacon(:heartbeat, echo_server)
+      expect_event_trigger("directory.listing.removed")
+      send_beacon(:flatline, echo_server)
+    end
+
+    describe "#all_listings_for" do
+      context "when listings are present" do
+        it "returns all listings for a given service" do
+          send_beacon(:heartbeat, hello_server)
+          send_beacon(:heartbeat, combo_server)
+
+          expect(subject.all_listings_for("HelloService").size).to eq(2)
+        end
+      end
+
+      context "when no listings are present" do
+        it "returns and empty array" do
+          expect(subject.all_listings_for("HelloService").size).to eq(0)
+        end
+      end
+    end
+
+    describe "#each_listing" do
+      it "should yield to a block for each listing" do
+        send_beacon(:heartbeat, hello_server)
+        send_beacon(:heartbeat, echo_server)
+        send_beacon(:heartbeat, combo_server)
+
+        expect do |block|
+          subject.each_listing(&block)
+        end.to yield_control.exactly(3).times
+      end
+    end
+
+    describe "#lookup" do
+      it "should provide listings by service" do
+        send_beacon(:heartbeat, hello_server)
+        expect(subject.lookup("HelloService").to_hash).to eq hello_server.to_hash
+      end
+
+      it "should return random listings" do
+        send_beacon(:heartbeat, hello_server)
+        send_beacon(:heartbeat, combo_server)
+
+        uuids = 100.times.map { subject.lookup("HelloService").uuid }
+        expect(uuids.count("hello")).to be_within(25).of(50)
+        expect(uuids.count("combo")).to be_within(25).of(50)
+      end
+
+      it "should not return expired listings" do
+        send_beacon(:heartbeat, hello_server_with_short_ttl)
+        sleep 5
+        expect(subject.lookup("HelloService")).to be_nil
+      end
+
+      it "should not return flatlined servers" do
+        send_beacon(:heartbeat, echo_server)
+        send_beacon(:heartbeat, combo_server)
+        send_beacon(:flatline, echo_server)
+
+        uuids = 100.times.map { subject.lookup("EchoService").uuid }
+        expect(uuids.count("combo")).to eq 100
+      end
+
+      it "should return up-to-date listings" do
+        send_beacon(:heartbeat, echo_server)
+        echo_server.port = "7777"
+        send_beacon(:heartbeat, echo_server)
+
+        expect(subject.lookup("EchoService").port).to eq "7777"
+      end
+
+      context 'when given service identifier is a class name' do
+        it 'returns the listing corresponding to the class name' do
+          send_beacon(:heartbeat, echo_server)
+          expect(subject.lookup(EchoService).uuid).to eq echo_server.uuid
+        end
+      end
+    end
+
+    describe "#restart" do
+      it "should clear all listings" do
+        send_beacon(:heartbeat, echo_server)
+        send_beacon(:heartbeat, combo_server)
+        subject.restart
+        expect(subject.lookup("EchoService")).to be_nil
+      end
+    end
+
+    describe "#running" do
+      it "should be true" do
+        expect(subject).to be_running
+      end
+    end
+
+    describe "#stop" do
+      it "should clear all listings" do
+        send_beacon(:heartbeat, echo_server)
+        send_beacon(:heartbeat, combo_server)
+        subject.stop
+        expect(subject.lookup("EchoService")).to be_nil
+      end
+
+      it "should stop the server" do
+        subject.stop
+        expect(subject).to_not be_running
+      end
+    end
+  end
+
+  if ENV.key?("BENCH")
+    context "performance" do
+      let(:servers) do
+        100.times.map do |x|
+          ::Protobuf::Rpc::DynamicDiscovery::Server.new(
+            :uuid => "performance_server#{x + 1}",
+            :address => '127.0.0.1',
+            :port => (5555 + x).to_s,
+            :ttl => rand(1..5),
+            :services => 10.times.map { |y| "PerformanceService#{y}" },
+          )
+        end
+      end
+
+      before do
+        require 'benchmark'
+        subject.start
+        servers.each { |server| send_beacon(:heartbeat, server) }
+      end
+
+      after do
+        subject.stop
+      end
+
+      it "should perform lookups in constant time" do
+        print "\n\n"
+        Benchmark.bm(17) do |x|
+          x.report("  1_000 lookups:") {   1_000.times { subject.lookup("PerformanceService#{rand(0..9)}") } }
+          x.report(" 10_000 lookups:") {  10_000.times { subject.lookup("PerformanceService#{rand(0..9)}") } }
+          x.report("100_000 lookups:") { 100_000.times { subject.lookup("PerformanceService#{rand(0..9)}") } }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require 'spec_helper'
+require 'protobuf/rpc/service_dispatcher'
+
+RSpec.describe Protobuf::Rpc::ServiceDispatcher do
+  let(:app) { proc { |env| env } }
+  let(:env) do
+    Protobuf::Rpc::Env.new(
+      'method_name' => method_name,
+      'request' => request,
+      'rpc_service' => service_class,
+      '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 { allow(subject).to receive(:rpc_service).and_return(rpc_service) }
+
+  describe '#call' do
+    before { allow(rpc_service).to receive(:response).and_return(response) }
+
+    it "dispatches the request" do
+      stack_env = subject.call(env)
+      expect(stack_env.response).to 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 { allow(rpc_service).to receive(:callable_rpc_method).and_return(-> { rpc_service.__send__(:foo) }) }
+
+      it "raises the exeception" do
+        expect { subject.call(env) }.to raise_exception(NoMethodError)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,517 @@
+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
+
+RSpec.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
+
+    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)
+      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
+        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)
+          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)
+          expect(subject.called).to 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)
+          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)
+          expect(subject.called).to eq [:endpoint_without_verify]
+        end
+      end
+    end
+
+    context 'when filter is configured with "if"' do
+      before(:all) do
+        class FilterTest
+          private
+
+          def check_true
+            true
+          end
+
+          def check_false
+            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)
+          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 => ->(_service) { true })
+        end
+
+        it 'invokes the filter' do
+          subject.__send__(:run_filters, :endpoint)
+          expect(subject.called).to 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)
+          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 => ->(_service) { false })
+        end
+
+        it 'skips the filter' do
+          subject.__send__(:run_filters, :endpoint)
+          expect(subject.called).to eq [:endpoint]
+        end
+      end
+    end
+
+    context 'when filter is configured with "unless"' do
+      before(:all) do
+        class FilterTest
+          private
+
+          def check_true
+            true
+          end
+
+          def check_false
+            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)
+          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 => ->(_service) { false })
+        end
+
+        it 'invokes the filter' do
+          subject.__send__(:run_filters, :endpoint)
+          expect(subject.called).to 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)
+          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 => ->(_service) { true })
+        end
+
+        it 'skips the filter' do
+          subject.__send__(:run_filters, :endpoint)
+          expect(subject.called).to 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
+            false
+          end
+        end
+      end
+
+      before do
+        FilterTest.clear_filters!
+        FilterTest.before_filter(:short_circuit_filter)
+      end
+
+      it 'does not invoke the rpc method' do
+        expect(subject).not_to receive(:endpoint)
+        subject.__send__(:run_filters, :endpoint)
+        expect(subject.called).to 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
+
+    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)
+      expect(subject.called).to eq [:endpoint, :verify_after, :foo]
+      expect(subject.after_filter_calls).to 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
+
+    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)
+      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
+        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
+        expect(subject).not_to receive(:endpoint)
+        subject.__send__(:run_filters, :endpoint)
+        expect(subject.called).to 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
+          fail CustomError1, 'Filter 1 failed'
+        end
+
+        def filter_with_error2
+          @called << :filter_with_error2
+          fail CustomError1, 'Filter 2 failed'
+        end
+
+        def filter_with_error3
+          @called << :filter_with_error3
+          fail CustomError3, 'Filter 3 failed'
+        end
+
+        def filter_with_runtime_error
+          @called << :filter_with_runtime_error
+          fail 'Filter with runtime error 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 do
+          expect(subject).not_to receive(:endpoint)
+          subject.__send__(:run_filters, :endpoint)
+          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
+
+    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 do
+            expect(subject).not_to receive(:endpoint)
+            subject.__send__(:run_filters, :endpoint)
+            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
+
+    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 do
+          expect(subject).not_to receive(:endpoint)
+          subject.__send__(:run_filters, :endpoint)
+          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
+
+    context 'when thrown exception inherits from a mapped exception' do
+      before do
+        FilterTest.rescue_from(StandardError) do |service, ex|
+          service.ex_class = ex.class
+          service.called << :standard_error_rescue_handler
+        end
+      end
+      before { FilterTest.before_filter(:filter_with_runtime_error) }
+
+      it 'rescues with the given callable' do
+        expect do
+          expect(subject).not_to receive(:endpoint)
+          subject.__send__(:run_filters, :endpoint)
+          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
+
+end