protobuf-cucumber 3.10.4

data/spec/lib/protobuf/rpc/servers/socket_server_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'protobuf/rpc/servers/socket_runner'
+require 'protobuf/socket'
+require SUPPORT_PATH.join('resource_service')
+
+RSpec.describe Protobuf::Rpc::Socket::Server do
+  before(:each) do
+    load 'protobuf/socket.rb'
+  end
+
+  before(:all) do
+    load 'protobuf/socket.rb'
+    Thread.abort_on_exception = true
+    @options = OpenStruct.new(:host => "127.0.0.1", :port => 9399, :backlog => 100, :threshold => 100)
+    @runner = ::Protobuf::Rpc::SocketRunner.new(@options)
+    @server = @runner.instance_variable_get(:@server)
+    @server_thread = Thread.new(@runner, &:run)
+    Thread.pass until @server.running?
+  end
+
+  after(:all) do
+    @server.stop
+    @server_thread.join
+  end
+
+  it "Runner provides a stop method" do
+    expect(@runner).to respond_to(:stop)
+  end
+
+  it "provides a stop method" do
+    expect(@server).to respond_to(:stop)
+  end
+
+  it "signals the Server is running" do
+    expect(@server).to be_running
+  end
+
+end

data/spec/lib/protobuf/rpc/servers/zmq/server_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'protobuf/rpc/servers/zmq/server'
+
+RSpec.describe Protobuf::Rpc::Zmq::Server do
+  subject { described_class.new(options) }
+
+  let(:options) do
+    {
+      :host => '127.0.0.1',
+      :port => 9399,
+      :worker_port => 9400,
+      :workers_only => true,
+    }
+  end
+
+  before do
+    load 'protobuf/zmq.rb'
+  end
+
+  after do
+    subject.teardown
+  end
+
+  describe '.running?' do
+    it 'returns true if running' do
+      subject.instance_variable_set(:@running, true)
+      expect(subject.running?).to be true
+    end
+
+    it 'returns false if not running' do
+      subject.instance_variable_set(:@running, false)
+      expect(subject.running?).to be false
+    end
+  end
+
+  describe '.stop' do
+    it 'sets running to false' do
+      subject.instance_variable_set(:@workers, [])
+      subject.stop
+      expect(subject.instance_variable_get(:@running)).to be false
+    end
+  end
+end

data/spec/lib/protobuf/rpc/servers/zmq/util_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+class UtilTest
+  include ::Protobuf::Rpc::Zmq::Util
+end
+
+RSpec.describe ::Protobuf::Rpc::Zmq::Util do
+  before(:each) do
+    load 'protobuf/zmq.rb'
+  end
+
+  subject { UtilTest.new }
+  describe '#zmq_error_check' do
+    it 'raises when the error code is less than 0' do
+      expect do
+        subject.zmq_error_check(-1, :test)
+      end.to raise_error(/test/)
+    end
+
+    it 'retrieves the error string from ZeroMQ' do
+      allow(ZMQ::Util).to receive(:error_string).and_return('an error from zmq')
+      expect do
+        subject.zmq_error_check(-1, :test)
+      end.to raise_error(RuntimeError, /an error from zmq/i)
+    end
+
+    it 'does nothing if the error code is > 0' do
+      expect do
+        subject.zmq_error_check(1, :test)
+      end.to_not raise_error
+    end
+
+    it 'does nothing if the error code is == 0' do
+      expect do
+        subject.zmq_error_check(0, :test)
+      end.to_not raise_error
+    end
+  end
+
+  describe '#log_signature' do
+    it 'returns the signature for the log' do
+      expect(subject.log_signature).to include('server', 'UtilTest')
+    end
+  end
+
+  describe '.resolve_ip' do
+    it 'resolves ips' do
+      expect(subject.resolve_ip('127.0.0.1')).to eq('127.0.0.1')
+    end
+
+    it 'resolves non ips' do
+      expect(subject.resolve_ip('localhost')).to eq('127.0.0.1')
+    end
+  end
+end

data/spec/lib/protobuf/rpc/servers/zmq/worker_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+RSpec.describe ::Protobuf::Rpc::Zmq::Worker do
+  before(:each) do
+    load 'protobuf/zmq.rb'
+
+    fake_socket = double
+    expect(fake_socket).to receive(:connect).and_return(0)
+    expect(fake_socket).to receive(:send_string).and_return(0)
+
+    fake_context = double
+    expect(fake_context).to receive(:socket).and_return(fake_socket)
+    expect(::ZMQ::Context).to receive(:new).and_return(fake_context)
+  end
+
+  subject do
+    described_class.new(:host => '127.0.0.1', :port => 9400)
+  end
+
+  describe '#run' do
+    # not tested via unit tests
+  end
+
+  describe '#handle_request' do
+    # not tested via unit tests
+  end
+
+  describe '#initialize_buffers' do
+    # not tested via unit tests
+  end
+
+  describe '#send_data' do
+    # not tested via unit tests
+  end
+end

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