rubarb 0.2.0 → 0.2.11

data/spec/rubarb/incoming_connection_spec.rb

@@ -76,4 +76,10 @@ describe Rubarb::IncomingConnection do
     self.should_receive(:send_message).with(marshal_call(["00000002", "result"]))
     reply("00000002", "result")
   end
+
+  it "should handle empty message" do
+    self.should_not_receive(:send_message)
+    receive_message(marshal_call(""))
+  end
+
 end

data/spec/rubarb/integration_spec.rb

@@ -3,16 +3,48 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 require 'rubarb/server'
 require 'rubarb/connection'
 
-describe "Server to Client communication and response" do
+class TestClientApi
+  def name(responder)
+    responder.reply("Doug")
+  end
+end
+
+
+describe "With Keep alives enables" do
+
+  before(:each) do
+    @server_api = mock("server")
+    @client_api = TestClientApi.new
 
-  class TestClientApi
-    def name(responder)
-      responder.reply("Doug")
+    @server = Rubarb::Server.new("127.0.0.1", 9441, @server_api, Rubarb::Default::INSECURE_METHODS, 0.1)
+    @connection = Rubarb::Connection.new("127.0.0.1", 9441, @client_api, Rubarb::Default::INSECURE_METHODS, 0.1)
+  end
+
+  after(:each) do
+    sync_stop(@server)
+  end
+
+  it "should communicate with the client" do
+    @callback_called = false
+
+    @server.start do |new_client|
+      new_client.name do|result|
+        result.should == "Doug"
+        @callback_called = true
+      end
     end
+
+    @connection.start
+
+    wait_for {@callback_called}
+
   end
 
+end
+
+describe "Server to Client communication and response" do
+
   before(:each) do
-    @reactor = start_reactor
     @server_api = mock("server")
     @client_api = TestClientApi.new
 
@@ -21,7 +53,7 @@ describe "Server to Client communication and response" do
   end
 
   after(:each) do
-    stop_reactor(@reactor)
+    sync_stop(@server)
   end
 
   it "should communicate with the client" do
@@ -74,7 +106,6 @@ describe "Client to Server communication and response" do
   end
 
   before(:each) do
-    @reactor = start_reactor
     @server_api = TestServerApi.new
     @client_api = mock("client")
 
@@ -83,7 +114,7 @@ describe "Client to Server communication and response" do
   end
 
   after(:each) do
-    stop_reactor(@reactor)
+    sync_stop(@server)
   end
 
   it "without a callback" do
@@ -171,4 +202,32 @@ describe "Client to Server communication and response" do
     
   end
 
+  it "should close one of the connections" do
+    @server_side_client_proxy = nil
+    @client_side_closed = 0
+    @server.start do |new_connection|
+      @server_side_client_proxy = new_connection
+    end
+
+    @connection.errback do
+      @client_side_closed += 1
+    end    
+    @connection.start
+
+    wait_for {!@server_side_client_proxy.nil?}
+    EM::next_tick {@server.connections[1].close_connection}
+
+    wait_for {@client_side_closed >= 1}
+    @client_side_closed.should == 1
+
+    @server_api.stub!(:foo) do |responder|
+      responder.reply("bar")
+    end
+    @connection.foo do |result|
+      @foobar = result
+    end
+    sleep(3)
+    @foobar.should_not == "bar"
+  end
+
 end

data/spec/rubarb/outgoing_connection_spec.rb

@@ -100,4 +100,8 @@ describe Rubarb::OutgoingConnection do
     @callback.should have(0).items
   end
 
+  it "should handle empty message" do
+    proc {receive_message(marshal_call(""))}.should_not raise_error
+  end
+
 end

data/spec/rubarb/server_failure_spec.rb

@@ -7,8 +7,8 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe "Server Failures" do
 
-  CONNECTION_ERROR      = "Connection Failure"
-  NO_METHOD_ERROR       = "received unexpected message :not_a_method"
+  CONNECTION_ERROR = "Connection Failure"
+  NO_METHOD_ERROR = "received unexpected message :not_a_method"
   INSECURE_METHOD_ERROR = "Remote client attempts to call method class, but was denied."
 
   before(:all) do
@@ -16,11 +16,16 @@ describe "Server Failures" do
   end
 
   before(:each) do
+    @port += 1
     @server = Rubarb::Server.new("127.0.0.1", @port, mock("server"))
     @connection1 = Rubarb::Connection.new("127.0.0.1", @port, mock("client"))
     @connection2 = Rubarb::Connection.new("127.0.0.1", @port, mock("client"))
   end
 
+  after(:each) do
+    sync_stop(@server)
+  end
+
   def wait_for_connections(n, ttl, &block)
     if ttl <= 0
       fail("TTL expired")
@@ -35,104 +40,50 @@ describe "Server Failures" do
     end
   end
 
+
   def check_messages(size, actual, expected)
     actual.should have(size).items
     (0...size).each { |i| actual[i].include?(expected[i]).should be_true }
   end
 
   def run_server_failure(blocks)
-    server_block   = blocks[:server]
-    client_block   = blocks[:client]
+    server_block = blocks[:server]
+    client_block = blocks[:client]
     server_errback = blocks[:server_errback]
     client_errback = blocks[:client_errback]
     connected = false
     errbacked = false
-    thread = start_reactor
     EM.schedule do
-      @server.errback      { |e| server_errback.call(e) if server_errback; errbacked = true }
-      @server.start        { |connection| server_block.call(connection) if server_block }
+      @server.errback { |e| server_errback.call(e) if server_errback; errbacked = true }
+      @server.start { |connection| server_block.call(connection) if server_block }
       @connection1.errback { |e| client_errback.call(e) if client_errback; errbacked = true }
-      @connection1.start   { client_block.call(@connection1) if client_block; connected = true }
+      @connection1.start { client_block.call(@connection1) if client_block; connected = true }
     end
-    wait_for{connected}
-    wait_for{errbacked}
-    stop_reactor(thread)
-  end
-
-  it "should handle the loss of a client" do
-    EM.run do
-      @cons = 0
-      @server.start do |client|
-        @cons += 1
-        if (@cons == 2)
-          @connection1.stop
-        end
-        client.errback do
-          @cons -= 1
-          if @cons == 1
-            EM.stop
-          end
-        end
-      end
-  
-      @connection1.start
-      @connection2.start
-  
-      wait_for_connections(2, 10) do
-        @connection1.stop
-        wait_for_connections(1, 10) do
-          @cons.should == 1
-          EM.stop
-        end
-      end
-    end
-  end
-  
-  it "should call errorback when port is already in use" do
-    errback_called = false
-    err_message = ""
-
-    thread = start_reactor
-    EM.run do
-      blocked_server = Rubarb::Server.new("127.0.0.1", @port, mock("server"))
-
-      blocked_server.errback do |e|
-        errback_called = true
-        err_message = e.message
-      end
-
-      @server.start
-      blocked_server.start
-    end
-
-    wait_for{errback_called}
-    stop_reactor(thread)
-
-    errback_called.should be_true
-    err_message.include?("acceptor").should be_true
+    wait_for { connected }
+    wait_for { errbacked }
   end
 
   it "handles no method call on server side" do
     err_messages = []
-    expected_messages = [NO_METHOD_ERROR, CONNECTION_ERROR]
+    expected_messages = [NO_METHOD_ERROR]
     client_errback_block = Proc.new { |e| err_messages << e.message }
     client_block = Proc.new { |connection| connection.not_a_method }
     run_server_failure({:client => client_block, :client_errback => client_errback_block})
-    check_messages(2, err_messages, expected_messages)
+    check_messages(1, err_messages, expected_messages)
   end
 
   it "handles no method call on client side" do
     err_messages = []
-    expected_messages = [NO_METHOD_ERROR, CONNECTION_ERROR, CONNECTION_ERROR]
+    expected_messages = [NO_METHOD_ERROR]
     server_errback_block = Proc.new { |e| err_messages << e.message }
     server_block = Proc.new { |connection| connection.not_a_method }
     run_server_failure({:server => server_block, :server_errback => server_errback_block})
-    check_messages(3, err_messages, expected_messages)
+    check_messages(1, err_messages, expected_messages)
   end
 
   it "handles insecure method call on server side" do
     err_messages = []
-    expected_messages = [INSECURE_METHOD_ERROR, CONNECTION_ERROR, CONNECTION_ERROR]
+    expected_messages = [INSECURE_METHOD_ERROR]
 
     client_block = Proc.new do |connection|
       connection.instance_eval("undef class")
@@ -140,15 +91,15 @@ describe "Server Failures" do
         result.should be_a(InsecureMethodCallError)
       end
     end
-  
+
     client_errback_block = Proc.new { |e| err_messages << e.message }
     run_server_failure({:server => client_block, :server_errback => client_errback_block})
-    check_messages(3, err_messages, expected_messages)
+    check_messages(1, err_messages, expected_messages)
   end
-  
+
   it "handles insecure method call on client side" do
     err_messages = []
-    expected_messages = [INSECURE_METHOD_ERROR, CONNECTION_ERROR, CONNECTION_ERROR]
+    expected_messages = [INSECURE_METHOD_ERROR]
 
     server_block = Proc.new do |connection|
       connection.instance_eval("undef class")
@@ -159,53 +110,9 @@ describe "Server Failures" do
 
     server_errback_block = Proc.new { |e| err_messages << e.message }
     run_server_failure({:server => server_block, :server_errback => server_errback_block})
-    check_messages(3, err_messages, expected_messages)
-  end
-
-  it "removes unbinded connection from connections ivar" do
-    thread = start_reactor
-    connected = false
-    EM.schedule do
-      @server.start
-      @connection1.start {connected = true}
-    end
-    wait_for{connected}
-    @server.connections.size.times { @server.connections.first.unbind }
-    @server.connections.should have(0).items
-    stop_reactor(thread)
-  end
-  
-  it "removes one unbinded connection from connections ivar of size two" do
-    thread = start_reactor
-    connected = false
-    @server.start
-    @connection1.start
-    @connection2.start {connected = true}
-    wait_for{connected}
-    2.times { @server.connections.first.unbind }
-    @server.connections.should have(2).items
-    stop_reactor(thread)
+    check_messages(1, err_messages, expected_messages)
   end
 
-  it "does not error out after calling stop twice consecutively" do
-    EventMachine.should_receive(:stop_server).once
-    thread = start_reactor
-    connected = false
-    @server.start
-    @connection1.start {connected = true}
-    wait_for{connected}
-    stopped = []
-    @server.stop do |result|
-      stopped << result
-    end
-    @server.stop do |result|
-      stopped << result
-    end
-    wait_for{stopped.size == 2}
-    stopped.should == [true, false]
-    stop_reactor(thread)
-  end
-  
   it "executes all errback blocks when exception is thrown on client side" do
     @errback1 = false
     @errback2 = false
@@ -228,8 +135,8 @@ describe "Server Failures" do
 
     @errback1.should be_true
     @errback2.should be_true
-    @errback3.should be_true
-    @errback4.should be_true
+    @errback3.should be_false
+    @errback4.should be_false
   end
 
   it "executes all errback blocks when exception is thrown on server side" do
@@ -252,10 +159,105 @@ describe "Server Failures" do
     run_server_failure({:server => server_block,
                         :client => client_block})
 
-    @errback1.should be_true
-    @errback2.should be_true
+    @errback1.should be_false
+    @errback2.should be_false
     @errback3.should be_true
     @errback4.should be_true
   end
 
+  it "removes unbinded connection from connections ivar" do
+    connected = false
+    EM.schedule do
+      @server.start
+      @connection1.start { connected = true }
+    end
+    wait_for { connected }
+    @server.connections.size.times { @server.connections.first.unbind }
+    @server.connections.should have(0).items
+  end
+
+  it "removes one unbinded connection from connections ivar of size two" do
+    connected = false
+    @server.start
+    @connection1.start
+    @connection2.start { connected = true }
+    wait_for { connected }
+    2.times { @server.connections.first.unbind }
+    @server.connections.should have(2).items
+  end
+
+  it "does not error out after calling stop twice consecutively" do
+    connected = false
+    @server.start
+    @connection1.start { connected = true }
+    wait_for { connected }
+    stopped = []
+    @server.stop do |result|
+      stopped << result
+    end
+    @server.stop do |result|
+      stopped << result
+    end
+    wait_for { stopped.size == 2 }
+    stopped.should == [true, false]
+  end
+
+
+  it "should handle the loss of a client" do
+    pending "messes with Reactor running for all other tests"
+    EM.run do
+      @cons = 0
+      @server.start do |client|
+        @cons += 1
+        if (@cons == 2)
+          @connection1.stop
+        end
+        client.errback do
+          @cons -= 1
+          if @cons == 1
+            EM.stop
+          end
+        end
+      end
+
+      @connection1.start
+      @connection2.start
+
+      wait_for_connections(2, 10) do
+        @connection1.stop
+        wait_for_connections(1, 10) do
+          @cons.should == 1
+          EM.stop
+        end
+      end
+    end
+  end
+
+  it "should call errorback when port is already in use" do
+    pending "hangs on occasion"
+    errback_called = false
+    err_message = ""
+
+    thread = start_reactor
+    EM.run do
+      blocked_server = Rubarb::Server.new("127.0.0.1", @port, mock("server"))
+
+      blocked_server.errback do |e|
+        errback_called = true
+        err_message = e.message
+      end
+
+      @server.start
+      blocked_server.start
+    end
+
+    wait_for { errback_called }
+    stop_reactor(thread)
+
+    errback_called.should be_true
+    err_message.include?("acceptor").should be_true
+    @server.stop
+    blocked_server.stop
+  end
+
 end