protobuf 2.7.12 → 2.8.0.beta1

data/spec/lib/protobuf/enum_spec.rb

@@ -6,7 +6,7 @@ describe Protobuf::Enum do
 
   before(:all) do
     Test::EnumTestType.define(:MINUS_ONE, -1)
-    Test::EnumTestType.define(name, tag)
+    Test::EnumTestType.define(:THREE, 3)
   end
 
   describe '.define' do

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

@@ -6,7 +6,7 @@ describe Protobuf::Rpc::Client do
     load 'protobuf/evented.rb'
   end
 
-  context "when using fiber based calls" do
+  context "when using fiber based calls", :skip => true do
     it "waits for response" do
       EventMachine.fiber_run do
         StubServer.new(:delay => 1) do |server|

data/spec/lib/protobuf/rpc/connectors/zmq_spec.rb

@@ -2,6 +2,16 @@ require 'spec_helper'
 require 'protobuf/zmq'
 
 describe ::Protobuf::Rpc::Connectors::Zmq do
+  subject { described_class.new(options) }
+
+  let(:options) {{
+    :service => "Test::Service",
+    :method => "find",
+    :timeout => 3,
+    :host => "127.0.0.1",
+    :port => "9400"
+  }}
+
   let(:socket_mock) do
     sm = mock(::ZMQ::Socket)
     sm.stub(:connect).and_return(0)
@@ -14,9 +24,41 @@ describe ::Protobuf::Rpc::Connectors::Zmq do
     zc
   end
 
-  before(:each) do
+  before do
     ::ZMQ::Context.stub(:new).and_return(zmq_context_mock)
   end
 
+  describe "#lookup_server_uri" do
+    let(:service_directory) { double('ServiceDirectory', :running? => running? ) }
+    let(:listing) { double('Listing', :address => '127.0.0.2', :port => 9399) }
+    let(:running?) { true }
+
+    before do
+      subject.stub(:service_directory) { service_directory }
+    end
+
+    context "when the service directory is running" do
+      it "searches the service directory" do
+        service_directory.should_receive(:lookup).and_return(listing)
+        subject.send(:lookup_server_uri).should eq "tcp://127.0.0.2:9399"
+      end
+
+      it "defaults to the options" do
+        service_directory.should_receive(:lookup) { nil }
+        subject.send(:lookup_server_uri).should eq "tcp://127.0.0.1:9400"
+      end
+    end
+
+    context "when the service directory is not running" do
+      let(:running?) { false }
+
+      it "does not search the directory" do
+        service_directory.should_not_receive(:lookup)
+        subject.send(:lookup_server_uri).should eq "tcp://127.0.0.1:9400"
+      end
+    end
+
+  end
+
   pending
 end

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

@@ -12,7 +12,8 @@ describe Protobuf::Rpc::Evented::Server do
 
   it "Runner provides a stop method" do
     runner_class = described_class.to_s.gsub(/Evented::Server/, "EventedRunner").constantize
-    runner_class.respond_to?(:stop).should be_true
+    runner = runner_class.new({})
+    runner.respond_to?(:stop).should be_true
   end
 
 end

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

@@ -12,23 +12,24 @@ describe Protobuf::Rpc::Socket::Server do
   before(:all) do
     load 'protobuf/socket.rb'
     Thread.abort_on_exception = true
-    server = OpenStruct.new(:server => "127.0.0.1", :port => 9399, :backlog => 100, :threshold => 100)
-    @server_thread = Thread.new(server) { |s| Protobuf::Rpc::SocketRunner.run(s) }
-    Thread.pass until Protobuf::Rpc::Socket::Server.running?
+    @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) { |runner| runner.run }
+    Thread.pass until @server.running?
   end
 
   after(:all) do
-    Protobuf::Rpc::SocketRunner.stop
+    @server.stop
     @server_thread.join
   end
 
   it "Runner provides a stop method" do
-    runner_class = described_class.to_s.gsub(/Evented::Server/, "EventedRunner").constantize
-    runner_class.respond_to?(:stop).should be_true
+    @runner.should respond_to(:stop)
   end
 
   it "provides a stop method" do
-    described_class.respond_to?(:stop).should be_true
+    @server.should respond_to(:stop)
   end
 
   it "provides a Runner class" do
@@ -37,7 +38,7 @@ describe Protobuf::Rpc::Socket::Server do
   end
 
   it "signals the Server is running" do
-    described_class.running?.should be_true
+    @server.should be_running
   end
 
 end

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

@@ -2,40 +2,45 @@ require 'spec_helper'
 require 'protobuf/rpc/servers/zmq/server'
 
 describe Protobuf::Rpc::Zmq::Server do
-  before(:each) do 
+  subject { described_class.new(options) }
+
+  let(:options) {{
+    :host => '127.0.0.1',
+    :port => 9399,
+    :worker_port => 9400,
+    :workers_only => true
+  }}
+
+  before do
     load 'protobuf/zmq.rb'
   end
 
+  after do
+    subject.teardown
+  end
+
   describe '.running?' do
     it 'returns true if running' do
-      described_class.instance_variable_set(:@running, true)
-      described_class.running?.should be_true
+      subject.instance_variable_set(:@running, true)
+      subject.running?.should be_true
     end
 
     it 'returns false if not running' do
-      described_class.instance_variable_set(:@running, false)
-      described_class.running?.should be_false
+      subject.instance_variable_set(:@running, false)
+      subject.running?.should be_false
     end
   end
 
   describe '.stop' do
-    # keep threads instance variable from retaining any thread mocks we've
-    # created (breaks tests down the line, otherwise)
-    after(:each) do
-      described_class.instance_variable_set(:@threads, [])
-    end
-
-    it 'lets all threads stop' do
-      thread_mock = double(Thread)
-      thread_mock.should_receive(:join).and_return(thread_mock)
-      described_class.instance_variable_set(:@threads, [thread_mock])
-      described_class.stop
+    it 'signals shutdown' do
+      subject.should_receive(:signal_shutdown)
+      subject.stop
     end
 
     it 'sets running to false' do
-      described_class.instance_variable_set(:@threads, [])
-      described_class.stop
-      described_class.instance_variable_get(:@running).should be_false
+      subject.instance_variable_set(:@workers, [])
+      subject.stop
+      subject.instance_variable_get(:@running).should be_false
     end
   end
 end

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

@@ -13,26 +13,26 @@ describe ::Protobuf::Rpc::Zmq::Util do
   describe '#zmq_error_check' do
     it 'raises when the error code is less than 0' do
       expect {
-        subject.zmq_error_check(-1)
-      }.to raise_error
+        subject.zmq_error_check(-1, :test)
+      }.to raise_error(/test/)
     end
 
     it 'retrieves the error string from ZeroMQ' do
       ZMQ::Util.stub(:error_string).and_return('an error from zmq')
       expect {
-        subject.zmq_error_check(-1)
+        subject.zmq_error_check(-1, :test)
       }.to raise_error(RuntimeError, /an error from zmq/i)
     end
 
     it 'does nothing if the error code is > 0' do
       expect {
-        subject.zmq_error_check(1)
+        subject.zmq_error_check(1, :test)
       }.to_not raise_error
     end
 
     it 'does nothing if the error code is == 0' do
       expect {
-        subject.zmq_error_check(0)
+        subject.zmq_error_check(0, :test)
       }.to_not raise_error
     end
   end

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

@@ -0,0 +1,183 @@
+require 'spec_helper'
+
+require 'protobuf/rpc/service_directory'
+
+describe ::Protobuf::Rpc::ServiceDirectory do
+  let(:instance) { ::Protobuf::Rpc::ServiceDirectory.instance }
+
+  def listings
+    instance.instance_variable_get(:@listings)
+  end
+
+  def duration
+    start = Time.now.to_f
+    yield
+    Time.now.to_f - start
+  end
+
+  after do
+    instance.stop
+  end
+
+  it "is a singleton" do
+    instance.should be_a_kind_of(Singleton)
+  end
+
+  describe "#lookup" do
+    let(:server) { double('server', :uuid => '123',
+                          :services => ['Known::Service'],
+                          :address => "0.0.0.0",
+                          :port => 9999,
+                          :ttl => 15) }
+    let(:listing) { ::Protobuf::Rpc::ServiceDirectory::Listing.new(server) }
+
+    it "returns a listing for the given service" do
+      instance.add_listing_for(server)
+      instance.lookup("Known::Service").should eq listing
+    end
+
+    it "returns random listings" do
+      instance.add_listing_for double(:uuid => 1, :ttl => 5, :services => ["Test"])
+      instance.add_listing_for double(:uuid => 2, :ttl => 5, :services => ["Test"])
+
+      uuids = 100.times.map { instance.lookup("Test").uuid }
+      uuids.count(1).should be_within(25).of(50)
+      uuids.count(2).should be_within(25).of(50)
+    end
+
+    it "does not return expired listings" do
+      instance.instance_variable_set(:@listings, {
+        '1' => double(:current? => false, :services => ["Test"]),
+      })
+
+      instance.lookup("Test").should be_nil
+    end
+  end
+
+  describe "#remove_expired_listings" do
+    before do
+      instance.instance_variable_set(:@listings, {
+        '1' => double(:expired? => true),
+        '2' => double(:expired? => true),
+        '3' => double(:expired? => false),
+      })
+    end
+
+    it "removes expired listings" do
+      expect {
+        instance.remove_expired_listings
+      }.to change(listings, :size).from(3).to(1)
+      listings.keys.should eq ['3']
+    end
+  end
+
+  describe "#start" do
+    it "creates a thread" do
+      Thread.should_receive(:new)
+      instance.start
+    end
+
+    it "initializes the socket" do
+      instance.should_receive :init_socket
+      instance.start
+    end
+
+    it "calls #run" do
+      instance.should_receive(:run)
+      instance.start
+      sleep 0.01
+    end
+
+    it "changes the running state" do
+      expect {
+        instance.start
+      }.to change(instance, :running?).from(false).to(true)
+    end
+  end
+
+  describe "#wait_for" do
+    it "returns a listing for the given service" do
+      server = double(:uuid => 1, :ttl => 5, :services => ["Test"])
+      instance.add_listing_for server
+      instance.lookup("Test").should eq server
+    end
+
+    it "depends on #lookup" do
+      instance.stub(:lookup).with("Hayoob!") { "yup" }
+      instance.wait_for("Hayoob!").should eq "yup"
+    end
+
+    it "waits for the service to appear" do
+      server = double(:uuid => 1, :ttl => 5, :services => ["Test"])
+
+      t = Thread.new do
+        sleep 0.5
+        instance.add_listing_for server
+      end
+
+      duration { instance.wait_for("Test") }.should be_within(0.01).of(0.5)
+      t.join
+    end
+
+    it "returns nil if the service doesn't appear withint the timeout period" do
+      server = double(:uuid => 1, :ttl => 5, :services => ["Test"])
+
+      t = Thread.new do
+        sleep 0.5
+        instance.add_listing_for server
+      end
+
+      instance.wait_for("Test", 0.1).should be_nil
+      t.join
+    end
+  end
+
+  describe "a running service directory" do
+    let(:socket) { UDPSocket.new }
+
+    def thread
+      instance.instance_variable_get(:@thread)
+    end
+
+    before do
+      described_class.start do |config|
+        config.address = "127.0.0.1"
+        config.port = 33333
+      end
+
+      socket.connect described_class.address, described_class.port
+    end
+
+    context "receiving a heartbeat" do
+      let(:server) { ::Protobuf::Rpc::DynamicDiscovery::Server.new(:uuid => 'heartbeat', :address => '127.0.0.1') }
+      let(:beacon) { ::Protobuf::Rpc::DynamicDiscovery::Beacon.new(
+        :server => server,
+        :beacon_type => ::Protobuf::Rpc::DynamicDiscovery::BeaconType::HEARTBEAT
+      )}
+      let(:payload) { beacon.serialize_to_string }
+
+      it "adds a listing" do
+        instance.should_receive(:add_listing_for).with(server)
+        instance.should_receive(:remove_expired_listings)
+        socket.send(payload, 0)
+        sleep 0.01
+      end
+    end
+
+    context "receiving a flatline" do
+      let(:server) { ::Protobuf::Rpc::DynamicDiscovery::Server.new(:uuid => 'flatline', :address => '127.0.0.1') }
+      let(:beacon) { ::Protobuf::Rpc::DynamicDiscovery::Beacon.new(
+        :server => server,
+        :beacon_type => ::Protobuf::Rpc::DynamicDiscovery::BeaconType::FLATLINE
+      )}
+      let(:payload) { beacon.serialize_to_string }
+
+      it "removes a listing" do
+        instance.should_receive(:remove_listing_for).with(server)
+        instance.should_receive(:remove_expired_listings)
+        socket.send(payload, 0)
+        sleep 0.01
+      end
+    end
+  end
+end

data/spec/support/server.rb

@@ -53,8 +53,10 @@ class StubServer
 
   def start
     case
-    when @options.server == Protobuf::Rpc::Evented::Server then start_em_server
-    when @options.server == Protobuf::Rpc::Zmq::Server then start_zmq_server
+    when @options.server == Protobuf::Rpc::Evented::Server
+      start_em_server
+    when @options.server == Protobuf::Rpc::Zmq::Server
+      start_zmq_server
     else
       start_socket_server
     end
@@ -67,18 +69,25 @@ class StubServer
   end
 
   def start_em_server
-    @server_handle = EventMachine.start_server(@options.host, @options.port, StubProtobufServerFactory.build(@options.delay))
+    @server_handle = EventMachine.start_server(
+      @options.host,
+      @options.port,
+      StubProtobufServerFactory.build(@options.delay)
+    )
   end
 
   def start_socket_server
-    @sock_server = Thread.new(@options) { |opt| Protobuf::Rpc::SocketRunner.run(opt) }
-    @sock_server.abort_on_exception = true # Set for testing purposes
-    Thread.pass until Protobuf::Rpc::Socket::Server.running?
+    @sock_runner = ::Protobuf::Rpc::SocketRunner.new(opt)
+    @sock_thread = Thread.new(@sock_runner) { |runner| runner.run }
+    @sock_thread.abort_on_exception = true # Set for testing purposes
+    Thread.pass until @sock_runner.running?
   end
 
   def start_zmq_server
-    @zmq_server = Thread.new(@options) { |opt| Protobuf::Rpc::ZmqRunner.run(opt) }
-    Thread.pass until Protobuf::Rpc::Zmq::Server.running?
+    @zmq_runnger = ::Protobuf::Rpc::ZmqRunner.new(opt)
+    @zmq_thread = Thread.new(@zmq_runner) { |runner| runner.run }
+    @zmq_thread.abort_on_exception = true # Set for testing purposes
+    Thread.pass until @zmq_runner.running?
   end
 
   def stop
@@ -86,11 +95,11 @@ class StubServer
     when @options.server == Protobuf::Rpc::Evented::Server then
       EventMachine.stop_server(@server_handle) if @server_handle
     when @options.server == Protobuf::Rpc::Zmq::Server then
-      Protobuf::Rpc::ZmqRunner.stop
-      @zmq_server.join if @zmq_server
+      @zmq_runner.try :stop
+      @zmq_thread.join if @zmq_thread
     else
-      Protobuf::Rpc::SocketRunner.stop
-      @sock_server.join if @sock_server
+      @sock_runner.stop
+      @sock_thread.join if @sock_thread
     end
 
     @running = false