rubarb 0.2.0

data/spec/rubarb/id_spec.rb

@@ -0,0 +1,26 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'rubarb/id'
+
+include Rubarb
+
+describe Id do
+
+  before(:each) do
+    @id = Id.new
+  end
+
+  it "starts generator at 00000001" do
+    @id.next.should == "00000001"
+  end
+
+  it "increments counter by 1 when next is called" do
+    @id.next
+    @id.next.should == "00000002"
+  end
+
+  it "resets counter to one if id is 99999999" do
+    @id.instance_eval{ @id = 99999999 }
+    @id.next
+    @id.next.should == "00000001"
+  end
+end

data/spec/rubarb/incoming_connection_spec.rb

@@ -0,0 +1,79 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+require "rubarb/incoming_connection"
+require "rubarb/remote_call"
+require "rubarb/default"
+
+describe Rubarb::IncomingConnection do
+  include Rubarb::RemoteCall
+  include Rubarb::IncomingConnection
+  attr_reader :api
+
+  class TestApi
+    attr_accessor :dodo
+    def amethod(responder, dodo)
+      @dodo = dodo
+    end
+    def ==(rhs)
+    end
+  end
+
+  before(:each) do
+    @api = TestApi.new
+    @insecure_methods = Rubarb::Default::INSECURE_METHODS
+  end
+
+  it "should receive message" do
+    receive_message(marshal_call("00000001", :amethod, "goo"))
+    @api.dodo.should == "goo"
+  end
+
+  it "should receive reply with exception when a non-existent method is called" do
+    should_receive(:reply).with do |id, exception|
+      id.should == "0"
+      exception.message.include?("undefined method").should == true
+    end
+    receive_message(marshal_call("00000001", :not_a_method, "foo"))
+    @api.should_not_receive(:send)
+  end
+
+  def blocks_method_in_receive_message(method)
+    @method = method
+    should_receive(:reply).with do |id, exception|
+      id.should == "0"
+      exception.message.should == "Remote client attempts to call method #{@method}, but was denied."
+    end
+    receive_message(marshal_call("00000001", method, "foo"))
+    @api.should_not_receive(:send)
+  end
+
+  it "blocks :== in receive_message" do
+    blocks_method_in_receive_message(:==)
+  end
+
+  it "blocks any insecure method in receive_message" do
+    Rubarb::Default::INSECURE_METHODS.each do |method|
+      blocks_method_in_receive_message(method)
+    end
+  end
+
+  it "receives message with id, method, and *args" do
+    message = marshal_call("00000001", :amethod, "foo")
+    receive_message(message)
+    @api.dodo.should == "foo"
+  end
+
+  it "replies message with id and args" do
+    message = marshal_call("00000001", :amethod, "foo")
+    receive_message(message)
+    self.should_receive(:send_message).with(marshal_call(["00000001", "result"]))
+    reply("00000001", "result")
+  end
+
+  it "replies message with id 00000002 and args" do
+    message = marshal_call("00000002", :amethod, "foo")
+    receive_message(message)
+    self.should_receive(:send_message).with(marshal_call(["00000002", "result"]))
+    reply("00000002", "result")
+  end
+end

data/spec/rubarb/integration_spec.rb

@@ -0,0 +1,174 @@
+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
+
+  before(:each) do
+    @reactor = start_reactor
+    @server_api = mock("server")
+    @client_api = TestClientApi.new
+
+    @server = Rubarb::Server.new("127.0.0.1", 9441, @server_api)
+    @connection = Rubarb::Connection.new("127.0.0.1", 9441, @client_api)
+  end
+
+  after(:each) do
+    stop_reactor(@reactor)
+  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 "Client to Server communication and response" do
+  class TestReply
+    attr_reader :message
+
+    def initialize(name)
+      @message = "How are you #{name}, my friend?"
+    end
+  end
+
+  class TestServerApi
+    attr_reader :hi_called
+    def hi(responder)
+      responder.reply("how are you?")
+      @hi_called = true
+    end
+
+    def hello(responder, name)
+      responder.reply("how are you #{name}?")
+    end
+
+    def hello_friend(responder, name)
+      responder.reply(TestReply.new(name))
+    end
+
+    attr_reader :conn_id
+    def save_id(responder)
+      @conn_id = responder.conn_id
+      responder.reply(nil)
+    end
+  end
+
+  before(:each) do
+    @reactor = start_reactor
+    @server_api = TestServerApi.new
+    @client_api = mock("client")
+
+    @server = Rubarb::Server.new("127.0.0.1", 9441, @server_api)
+    @connection = Rubarb::Connection.new("127.0.0.1", 9441, @client_api)
+  end
+
+  after(:each) do
+    stop_reactor(@reactor)
+  end
+
+  it "without a callback" do
+    @server.start
+
+    @connection.start do
+      @connection.hi
+    end
+
+    wait_for {@server_api.hi_called}
+  end
+  
+  it "without parameters" do
+    @callback_called = false
+    @server.start
+
+    @connection.start do
+      @connection.hi do |response|
+        response.should == "how are you?"
+        @callback_called = true
+      end
+    end
+
+    wait_for {@callback_called}
+  end
+
+  it "with parameters" do
+    @callback_called = false
+    @server.start
+    @connection.start do
+      @connection.hello("Doug") do |response|
+        @callback_called = true
+        response.should == "how are you Doug?"
+      end
+    end
+    wait_for {@callback_called}
+  end
+
+  it "with complex response" do
+    @callback_called = false
+    @server.start
+    @connection.start do
+      @connection.hello_friend("Doug") do |response|
+        @callback_called = true
+        response.message.should == "How are you Doug, my friend?"
+      end
+    end
+
+    wait_for {@callback_called}
+  end
+
+  it "can get connection id on connection" do
+    @callback_called = false
+    @new_connection_id = nil
+    @server.start do |new_connection|
+      @new_connection_id = new_connection.conn_id
+    end
+
+    @connection.start do
+      @connection.save_id do |response|
+        @callback_called = true
+      end
+    end
+
+    wait_for {@callback_called}
+    @server_api.conn_id.should == @new_connection_id
+  end
+
+  it "should close from server side" do
+    @server_side_client_proxy = nil
+    @server.start do |new_connection|
+      @server_side_client_proxy = new_connection
+    end
+
+    @connection.errback do
+      @client_side_closed = true
+    end
+    @connection.start
+
+    wait_for {!@server_side_client_proxy.nil?}
+    @server_side_client_proxy.stop
+
+    wait_for {@client_side_closed}
+    @client_side_closed.should == true
+    
+  end
+
+end

data/spec/rubarb/outgoing_connection_spec.rb

@@ -0,0 +1,103 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+require "rubarb/outgoing_connection"
+require "rubarb/remote_call"
+
+describe Rubarb::OutgoingConnection do
+  include Rubarb::RemoteCall
+  include Rubarb::OutgoingConnection
+
+  before(:each) do
+    @callback = {}
+    set_id("00000001")
+  end
+
+  def set_id(id)
+    id_generator = mock("id")
+    id_generator.stub!(:next).and_return(id)
+    @msg_id_generator = id_generator
+  end
+
+  it "sets callback" do
+    block = Proc.new { puts "Hello" }
+    self.should_receive(:send_message)
+    remote_call(:amethod, "asdf", &block)
+    @callback["00000001"].should == block
+  end
+
+  it "executes callback block when receive_message is called" do
+    block = Proc.new do |v|
+      @value = v
+    end
+    should_receive(:send_message)
+    remote_call(:amethod, "asdf", &block)
+    receive_message(marshal_call("00000001", "value"))
+    @value.should == "value"
+  end
+
+  it "does not execute callback block when receive_message is called with an exception" do
+    block = Proc.new { puts "Hello" }
+    should_receive(:send_message)
+    remote_call(:amethod, "asdf", &block)
+    should_receive(:call_errbacks)
+    @callback.should_not_receive(:call)
+    receive_message(marshal_call("00000001", Exception.new))
+  end
+
+  it "saves error message when receive_message is called with an exception" do
+    exception = Exception.new("Hello")
+    error = nil
+    @errbacks = [Proc.new { |e| error = e }]
+    block = Proc.new { puts "Hello" }
+
+    should_receive(:send_message)
+    remote_call(:amethod, "asdf", &block)
+    stub!(:call_errbacks).and_return(@errbacks.first.call(exception))
+    @callback.stub!(:call)
+
+    receive_message(marshal_call("00000001", exception))
+
+    error.class.should == Exception
+    error.message.should == (exception.message)
+  end
+
+  it "has a message id argument for marshal_call" do
+    block = Proc.new { puts "Hello" }
+    should_receive(:marshal_call).with("00000001", :amethod, "asdf")
+    self.should_receive(:send_message)
+    remote_call(:amethod, "asdf", &block)
+  end
+
+  it "generates a message id" do
+    set_id("00000002")
+    block = Proc.new { puts "Hello" }
+    should_receive(:marshal_call).with("00000002", :amethod, "asdf")
+    should_receive(:send_message)
+    remote_call(:amethod, "asdf", &block)
+  end
+
+  it "pushes callback block to callback hash with id as key" do
+    @callback = {}
+    set_id("00000001")
+    block = Proc.new { puts "Hello" }
+    stub!(:send_message)
+    remote_call(:amethod, "asdf", &block)
+    @callback["00000001"].should == block
+  end
+
+  it "calls the corresponding block with given id" do
+    block = mock("block")
+    block.should_receive(:call).with("asdf")
+    @callback = { "00000002" => block }
+    receive_message(marshal_call("00000002", "asdf"))
+  end
+
+  it "removes callback from hash after call" do
+    block = mock("block")
+    block.should_receive(:call).with("asdf")
+    @callback = { "00000002" => block }
+    receive_message(marshal_call("00000002", "asdf"))
+    @callback.should have(0).items
+  end
+
+end

data/spec/rubarb/remote_call_spec.rb

@@ -0,0 +1,48 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+require 'rubarb/remote_call'
+describe Rubarb::RemoteCall do
+  include Rubarb::RemoteCall
+
+  it "should marshal a call" do
+    identity_test(:foo, "barr", "none")
+  end
+
+  it "should marshal with no args" do
+    identity_test(:food)
+  end
+
+  it "should work with multiple return values" do
+    serialized = marshal_call(:eat, "potatos", "carrots")
+    recovered_method, arg1, arg2 = unmarshal_call(serialized)
+    recovered_method.should == :eat
+    arg1.should == "potatos"
+    arg2.should == "carrots"
+  end
+
+  class Wine
+    attr_accessor :age, :content
+    def initialize(age, content)
+      @age = age
+      @content = content
+    end
+
+    def ==(other)
+      return false unless self.age == other.age
+      return false unless self.content == other.content
+      return true
+    end
+  end
+  
+  it "should handle complexy objects" do
+    identity_test(:make_grapes, Wine.new(15, 0.15), "grapes")
+  end
+
+  def identity_test(method, *args)
+    serialized = marshal_call(method, *args)
+    recovered_method, *recovered_args = unmarshal_call(serialized)
+    recovered_method.should == method
+    recovered_args.should == args
+  end
+
+end

data/spec/rubarb/responder_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require "rubarb/responder"
+require "rubarb/incoming_connection"
+require "rubarb/server"
+
+include Rubarb
+
+class MockHandler
+  include Listener
+  include IncomingConnection
+end
+
+describe Responder do
+  before(:each) do
+    @responder = Responder.new(MockHandler.new, "00000001")
+  end
+
+  it "sets id on initialize" do
+    @responder.message_id.should == "00000001"
+  end
+
+  it "sets handler on initialize" do
+    @responder.handler.class.should == MockHandler
+  end
+
+  it "calls handler#reply with stored message_id" do
+    @responder.handler.should_receive(:reply).with("00000001", "Hello Doug")
+    @responder.reply("Hello Doug")
+  end
+
+  it "calls handler's conn_id" do
+    @responder.handler.should_receive(:conn_id)
+    @responder.conn_id
+  end
+end