rubarb 0.2.0

data/spec/rubarb/server_failure_spec.rb

@@ -0,0 +1,261 @@
+require 'rubarb/server'
+require 'rubarb/connection'
+require 'rubarb/insecure_method_call_error'
+require 'socket'
+
+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"
+  INSECURE_METHOD_ERROR = "Remote client attempts to call method class, but was denied."
+
+  before(:all) do
+    @port = 9441
+  end
+
+  before(:each) do
+    @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
+
+  def wait_for_connections(n, ttl, &block)
+    if ttl <= 0
+      fail("TTL expired")
+    end
+
+    if @cons != n
+      EventMachine.add_periodic_timer(0.1) do
+        wait_for_connections(n, ttl-1, &block)
+      end
+    else
+      yield
+    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_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 }
+      @connection1.errback { |e| client_errback.call(e) if client_errback; errbacked = 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
+  end
+
+  it "handles no method call on server side" do
+    err_messages = []
+    expected_messages = [NO_METHOD_ERROR, CONNECTION_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)
+  end
+
+  it "handles no method call on client side" do
+    err_messages = []
+    expected_messages = [NO_METHOD_ERROR, CONNECTION_ERROR, CONNECTION_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)
+  end
+
+  it "handles insecure method call on server side" do
+    err_messages = []
+    expected_messages = [INSECURE_METHOD_ERROR, CONNECTION_ERROR, CONNECTION_ERROR]
+
+    client_block = Proc.new do |connection|
+      connection.instance_eval("undef class")
+      connection.class do |result|
+        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)
+  end
+  
+  it "handles insecure method call on client side" do
+    err_messages = []
+    expected_messages = [INSECURE_METHOD_ERROR, CONNECTION_ERROR, CONNECTION_ERROR]
+
+    server_block = Proc.new do |connection|
+      connection.instance_eval("undef class")
+      connection.class do |result|
+        result.should be_a(InsecureMethodCallError)
+      end
+    end
+
+    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)
+  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
+    @errback3 = false
+    @errback4 = false
+
+    server_block = Proc.new do |connection|
+      connection.errback { |e| @errback1 = true }
+      connection.errback { |e| @errback2 = true }
+      connection.not_a_method
+    end
+
+    client_block = Proc.new do |connection|
+      connection.errback { |e| @errback3 = true }
+      connection.errback { |e| @errback4 = true }
+    end
+
+    run_server_failure({:server => server_block,
+                        :client => client_block})
+
+    @errback1.should be_true
+    @errback2.should be_true
+    @errback3.should be_true
+    @errback4.should be_true
+  end
+
+  it "executes all errback blocks when exception is thrown on server side" do
+    @errback1 = false
+    @errback2 = false
+    @errback3 = false
+    @errback4 = false
+
+    server_block = Proc.new do |connection|
+      connection.errback { |e| @errback1 = true }
+      connection.errback { |e| @errback2 = true }
+    end
+
+    client_block = Proc.new do |connection|
+      connection.errback { |e| @errback3 = true }
+      connection.errback { |e| @errback4 = true }
+      connection.not_a_method
+    end
+
+    run_server_failure({:server => server_block,
+                        :client => client_block})
+
+    @errback1.should be_true
+    @errback2.should be_true
+    @errback3.should be_true
+    @errback4.should be_true
+  end
+
+end

data/spec/rubarb/server_spec.rb

@@ -0,0 +1,201 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'rubarb/server'
+require "rubarb/remote_call"
+require 'rubarb/connection'
+require 'rubarb/default'
+
+include Rubarb
+
+describe Listener do
+  include RemoteCall
+
+  before(:each) do
+    extend(Listener)
+    @sent_data = ""
+    self.stub!(:send_data) do |data|
+      @sent_data = data
+    end
+    post_init
+  end
+
+  def set_id(id)
+    id_generator = mock("id")
+    id_generator.stub!(:next).and_return(id)
+    @conn_id_generator = id_generator
+  end
+
+  it "should generate and send connection ID" do
+    set_id("00000001")
+    receive_data("4")
+    @sent_data.should == "00000001"
+  end
+
+  it "should receive another connection" do
+    stub!(:send_message) do |message|
+      @sent_message = message
+    end
+    receive_data("5")
+    receive_data("00000005")
+    @sent_message.should == "00000005"
+    @conn_id.should == "00000005"
+  end
+
+  class OtherProtocol
+
+    attr_reader :buffer, :connection
+
+    def handle_connection(buffer, connection)
+      @buffer = buffer
+      @connection = connection
+    end
+
+  end
+
+  it "should handle other protocols" do
+    @external_protocol = OtherProtocol.new
+    receive_data("1")
+
+    @external_protocol.buffer.should == "1"
+    @external_protocol.connection.should_not be_nil
+  end
+end
+
+describe Rubarb::Server do
+
+  before(:each) do
+    @reactor_thread = nil
+  end
+
+  after(:each) do
+    stop_reactor(@reactor_thread) if @reactor_thread
+  end
+
+  it "has an instance of Rubarb::Id" do
+    server = Server.new("host", "port", "api")
+    server.conn_id_generator.class.should == Rubarb::Id
+  end
+
+  it "has an instance of Rubarb::Id for message ids" do
+    server = Server.new("host", "port", "api")
+    server.msg_id_generator.class.should == Rubarb::Id
+  end
+
+  it "has an instance of insecure_methods" do
+    server = Server.new("host", "port", "api")
+    server.insecure_methods.class.should == Array
+  end
+
+  it "has default insecure_methods" do
+    server = Server.new("host", "port", "api")
+    server.insecure_methods.should == Rubarb::Default::INSECURE_METHODS
+  end
+
+  it "accepts custom insecure methods on initilization" do
+    server = Server.new("host", "port", "api", [:==, :===, :=~])
+    server.insecure_methods.should == [:==, :===, :=~]
+  end
+
+  def connect
+    @reactor_thread = start_reactor
+    connected = false
+    @server = Rubarb::Server.new("127.0.0.1", 9441, mock("server"))
+    @connection = Rubarb::Connection.new("127.0.0.1", 9441, mock("client"))
+    EM.schedule do
+      @server.start { |client| @client = client }
+      @connection.start { connected = true }
+    end
+    wait_for { connected }
+  end
+
+  it "sets instance of Rubarb::Id to each connection for connection ids" do
+    connect
+    generator_class = @server.connections.first.conn_id_generator.class
+    generator_class.should == Rubarb::Id
+  end
+
+  it "sets instance of Rubarb::Id to each connection for message ids" do
+    connect
+    generator_class = @server.connections.first.msg_id_generator.class
+    generator_class.should == Rubarb::Id
+  end
+
+  it "sets instance of insecure_methods on each connection" do
+    connect
+    insecure_methods = @server.connections.first.insecure_methods
+    insecure_methods.should == Rubarb::Default::INSECURE_METHODS
+  end
+
+  it "makes sure @conn_id_generator#next is called in handle_incoming" do
+    extend(Listener)
+    id_generator = mock("id")
+    id_generator.stub!(:next).and_return("00000001")
+    @conn_id_generator = id_generator
+    should_receive(:send_data).with("00000001")
+    stub!(:switch_protocol)
+    handle_incoming
+    @conn_id.should == "00000001"
+  end
+
+  it "makes two overlapping calls" do
+    @reactor_thread = start_reactor
+    connected = false
+
+    @server = Rubarb::Server.new("127.0.0.1", 9441, TestApi.new)
+    @connection = Rubarb::Connection.new("127.0.0.1", 9441, mock("client"))
+    EM.run do
+      @server.start
+      @connection.start do
+        @connection.get_one do |counter|
+          counter.should == 1
+        end
+        @connection.get_two do |counter|
+          counter.should == 2
+        end
+        connected = true
+      end
+    end
+    wait_for { connected }
+  end
+
+  it "catches exceptions that occur during a remote call to client" do
+    connect
+    error = nil
+    @client.remote_connection.errbacks << proc { |e| error = e }
+    @client.remote_connection.should_receive(:remote_call).and_raise("Blah")
+
+    @client.foo
+    wait_for { error != nil }
+
+    error.to_s.should == "Blah"
+    EM.reactor_running?.should == true
+  end
+
+  it "should catch exceptions in starting server" do
+    EventMachine.stub!(:start_server).and_raise("EMReactor Exception")
+
+    @reactor_thread = start_reactor
+    done = false
+
+    @server = Rubarb::Server.new("127.0.0.1", 9441, TestApi.new)
+    @server.errback do |error|
+      error.message.should == "EMReactor Exception"
+      done = true
+    end
+
+    @server.start
+
+    wait_for { done }
+    done.should == true
+
+  end
+end
+
+class TestApi
+  def get_one(responder)
+    EM.add_timer(0.5) { responder.reply(1) }
+  end
+
+  def get_two(responder)
+    responder.reply(2)
+  end
+end