beetle 0.1

data/test/beetle/publisher_test.rb

@@ -0,0 +1,407 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+
+module Beetle
+  class PublisherTest < Test::Unit::TestCase
+    def setup
+      client = Client.new
+      @pub = Publisher.new(client)
+    end
+
+    test "acccessing a bunny for a server which doesn't have one should create it and associate it with the server" do
+      @pub.expects(:new_bunny).returns(42)
+      assert_equal 42, @pub.send(:bunny)
+      bunnies = @pub.instance_variable_get("@bunnies")
+      assert_equal(42, bunnies[@pub.server])
+    end
+
+    test "new bunnies should be created using current host and port and they should be started" do
+      m = mock("dummy")
+      expected_bunny_options = {
+        :host => @pub.send(:current_host), :port => @pub.send(:current_port),
+        :logging => false, :user => "guest", :pass => "guest", :vhost => "/"
+      }
+      Bunny.expects(:new).with(expected_bunny_options).returns(m)
+      m.expects(:start)
+      assert_equal m, @pub.send(:new_bunny)
+    end
+
+    test "initially there should be no bunnies" do
+      assert_equal({}, @pub.instance_variable_get("@bunnies"))
+    end
+
+    test "initially there should be no dead servers" do
+      assert_equal({}, @pub.instance_variable_get("@dead_servers"))
+    end
+
+    test "stop! should shut down bunny and clean internal data structures" do
+      b = mock("bunny")
+      b.expects(:stop).raises(Exception.new)
+      @pub.expects(:bunny).returns(b)
+      @pub.send(:stop!)
+      assert_equal({}, @pub.send(:exchanges))
+      assert_equal({}, @pub.send(:queues))
+      assert_nil @pub.instance_variable_get(:@bunnies)[@pub.server]
+    end
+
+  end
+
+  class PublisherPublishingTest < Test::Unit::TestCase
+    def setup
+      @client = Client.new
+      @pub = Publisher.new(@client)
+      @pub.stubs(:bind_queues_for_exchange)
+      @client.register_queue("mama", :exchange => "mama-exchange")
+      @client.register_message("mama", :ttl => 1.hour, :exchange => "mama-exchange")
+      @opts = { :ttl => 1.hour , :key => "mama", :persistent => true}
+      @data = 'XXX'
+    end
+
+    test "failover publishing should try to recycle dead servers before trying to publish the message" do
+      @pub.servers << "localhost:3333"
+      @pub.send(:mark_server_dead)
+      publishing = sequence('publishing')
+      @pub.expects(:recycle_dead_servers).in_sequence(publishing)
+      @pub.expects(:publish_with_failover).with("mama-exchange", "mama", @data, @opts).in_sequence(publishing)
+      @pub.publish("mama", @data)
+    end
+
+    test "redundant publishing should try to recycle dead servers before trying to publish the message" do
+      @pub.servers << "localhost:3333"
+      @pub.send(:mark_server_dead)
+      publishing = sequence('publishing')
+      @pub.expects(:recycle_dead_servers).in_sequence(publishing)
+      @pub.expects(:publish_with_redundancy).with("mama-exchange", "mama", @data, @opts.merge(:redundant => true)).in_sequence(publishing)
+      @pub.publish("mama", @data, :redundant => true)
+    end
+
+    test "publishing should fail over to the next server" do
+      failover = sequence('failover')
+      @pub.expects(:select_next_server).in_sequence(failover)
+      e = mock("exchange")
+      @pub.expects(:exchange).with("mama-exchange").returns(e).in_sequence(failover)
+      e.expects(:publish).raises(Bunny::ConnectionError).in_sequence(failover)
+      @pub.expects(:stop!).in_sequence(failover)
+      @pub.expects(:mark_server_dead).in_sequence(failover)
+      @pub.publish_with_failover("mama-exchange", "mama", @data, @opts)
+    end
+
+    test "redundant publishing should send the message to two servers" do
+      redundant = sequence("redundant")
+      @pub.servers = ["someserver", "someotherserver"]
+      @pub.server = "someserver"
+
+      e = mock("exchange")
+      @pub.expects(:exchange).with("mama-exchange").returns(e).in_sequence(redundant)
+      e.expects(:publish).in_sequence(redundant)
+      @pub.expects(:exchange).with("mama-exchange").returns(e).in_sequence(redundant)
+      e.expects(:publish).in_sequence(redundant)
+
+      assert_equal 2, @pub.publish_with_redundancy("mama-exchange", "mama", @data, @opts)
+    end
+
+    test "redundant publishing should return 1 if the message was published to one server only" do
+      redundant = sequence("redundant")
+      @pub.servers = ["someserver", "someotherserver"]
+      @pub.server = "someserver"
+
+      e = mock("exchange")
+      @pub.expects(:exchange).with("mama-exchange").returns(e).in_sequence(redundant)
+      e.expects(:publish).raises(Bunny::ConnectionError).in_sequence(redundant)
+      @pub.expects(:exchange).with("mama-exchange").returns(e).in_sequence(redundant)
+      e.expects(:publish).in_sequence(redundant)
+
+      assert_equal 1, @pub.publish_with_redundancy("mama-exchange", "mama", @data, @opts)
+    end
+
+    test "redundant publishing should return 0 if the message was published to no server" do
+      redundant = sequence("redundant")
+      @pub.servers = ["someserver", "someotherserver"]
+      @pub.server = "someserver"
+
+      e = mock("exchange")
+      @pub.expects(:exchange).with("mama-exchange").returns(e).in_sequence(redundant)
+      e.expects(:publish).raises(Bunny::ConnectionError).in_sequence(redundant)
+      @pub.expects(:exchange).with("mama-exchange").returns(e).in_sequence(redundant)
+      e.expects(:publish).raises(Bunny::ConnectionError).in_sequence(redundant)
+
+      assert_equal 0, @pub.publish_with_redundancy("mama-exchange", "mama", @data, @opts)
+    end
+
+    test "redundant publishing should fallback to failover publishing if less than one server is available" do
+      @pub.server = ["a server"]
+      @pub.expects(:publish_with_failover).with("mama-exchange", "mama", @data, @opts).returns(1)
+      assert_equal 1, @pub.publish_with_redundancy("mama-exchange", "mama", @data, @opts)
+    end
+
+    test "redundant publishing should publish to two of three servers if one server is dead" do
+      @pub.servers = %w(server1 server2 server3)
+      @pub.server = "server1"
+      redundant = sequence("redundant")
+
+      e = mock("exchange")
+
+      @pub.expects(:exchange).returns(e).in_sequence(redundant)
+      e.expects(:publish).in_sequence(redundant)
+
+      @pub.expects(:exchange).returns(e).in_sequence(redundant)
+      e.expects(:publish).raises(Bunny::ConnectionError).in_sequence(redundant)
+      @pub.expects(:stop!).in_sequence(redundant)
+
+      @pub.expects(:exchange).returns(e).in_sequence(redundant)
+      e.expects(:publish).in_sequence(redundant)
+
+      assert_equal 2, @pub.publish_with_redundancy("mama-exchange", "mama", @data, @opts)
+    end
+
+    test "publishing should use the message ttl passed in the options hash to encode the message body" do
+      opts = {:ttl => 1.day}
+      Message.expects(:publishing_options).with(:ttl => 1.day).returns({})
+      @pub.expects(:select_next_server)
+      e = mock("exchange")
+      @pub.expects(:exchange).returns(e)
+      e.expects(:publish)
+      assert_equal 1, @pub.publish_with_failover("mama-exchange", "mama", @data, opts)
+    end
+
+    test "publishing with redundancy should use the message ttl passed in the options hash to encode the message body" do
+      opts = {:ttl => 1.day}
+      Message.expects(:publishing_options).with(:ttl => 1.day).returns({})
+      @pub.expects(:select_next_server)
+      e = mock("exchange")
+      @pub.expects(:exchange).returns(e)
+      e.expects(:publish)
+      assert_equal 1, @pub.publish_with_redundancy("mama-exchange", "mama", @data, opts)
+    end
+
+    test "publishing should use the message ttl from the message configuration if no ttl is passed in via the options hash" do
+      @pub.expects(:publish_with_failover).with("mama-exchange", "mama", @data, @opts).returns(1)
+      assert_equal 1, @pub.publish("mama", @data)
+    end
+  end
+
+  class PublisherQueueManagementTest < Test::Unit::TestCase
+    def setup
+      @client = Client.new
+      @pub = Publisher.new(@client)
+    end
+
+    test "initially there should be no queues for the current server" do
+      assert_equal({}, @pub.send(:queues))
+      assert !@pub.send(:queues)["some_queue"]
+    end
+
+    test "binding a queue should create it using the config and bind it to the exchange with the name specified" do
+      @client.register_queue("some_queue", :exchange => "some_exchange", :key => "haha.#")
+      @pub.expects(:exchange).with("some_exchange").returns(:the_exchange)
+      q = mock("queue")
+      q.expects(:bind).with(:the_exchange, {:key => "haha.#"})
+      m = mock("Bunny")
+      m.expects(:queue).with("some_queue", :durable => true, :passive => false, :auto_delete => false, :exclusive => false).returns(q)
+      @pub.expects(:bunny).returns(m)
+
+      @pub.send(:queue, "some_queue")
+      assert_equal q, @pub.send(:queues)["some_queue"]
+    end
+
+    test "should bind the defined queues for the used exchanges when publishing" do
+      @client.register_queue('test_queue_1', :exchange => 'test_exchange')
+      @client.register_queue('test_queue_2', :exchange => 'test_exchange')
+      @client.register_queue('test_queue_3', :exchange => 'test_exchange_2')
+      @pub.expects(:bind_queue!).returns(1).times(3)
+      @pub.send(:bind_queues_for_exchange, 'test_exchange')
+      @pub.send(:bind_queues_for_exchange, 'test_exchange_2')
+    end
+
+    test "should not rebind the defined queues for the used exchanges if they already have been bound" do
+      @client.register_queue('test_queue_1', :exchange => 'test_exchange')
+      @client.register_queue('test_queue_2', :exchange => 'test_exchange')
+      @pub.expects(:bind_queue!).twice
+      @pub.send(:bind_queues_for_exchange, 'test_exchange')
+      @pub.send(:bind_queues_for_exchange, 'test_exchange')
+    end
+
+    test "call the queue binding method when publishing" do
+      data = "XXX"
+      opts = {}
+      @client.register_queue("mama", :exchange => "mama-exchange")
+      @client.register_message("mama", :ttl => 1.hour, :exchange => "mama-exchange")
+      e = stub('exchange', 'publish')
+      @pub.expects(:exchange).with('mama-exchange').returns(e)
+      @pub.expects(:bind_queues_for_exchange).with('mama-exchange').returns(true)
+      @pub.publish('mama', data)
+    end
+
+    test "purging a queue should purge the queues on all servers" do
+      @pub.servers = %w(a b)
+      queue = mock("queue")
+      s = sequence("purging")
+      @pub.expects(:set_current_server).with("a").in_sequence(s)
+      @pub.expects(:queue).with("queue").returns(queue).in_sequence(s)
+      queue.expects(:purge).in_sequence(s)
+      @pub.expects(:set_current_server).with("b").in_sequence(s)
+      @pub.expects(:queue).with("queue").returns(queue).in_sequence(s)
+      queue.expects(:purge).in_sequence(s)
+      @pub.purge("queue")
+    end
+  end
+
+  class PublisherExchangeManagementTest < Test::Unit::TestCase
+    def setup
+      @client = Client.new
+      @pub = Publisher.new(@client)
+    end
+
+    test "initially there should be no exchanges for the current server" do
+      assert_equal({}, @pub.send(:exchanges))
+    end
+
+    test "accessing a given exchange should create it using the config. further access should return the created exchange" do
+      m = mock("Bunny")
+      m.expects(:exchange).with("some_exchange", :type => :topic, :durable => true).returns(42)
+      @client.register_exchange("some_exchange", :type => :topic, :durable => true)
+      @pub.expects(:bunny).returns(m)
+      ex  = @pub.send(:exchange, "some_exchange")
+      assert @pub.send(:exchanges).include?("some_exchange")
+      ex2 = @pub.send(:exchange, "some_exchange")
+      assert_equal ex2, ex
+    end
+  end
+
+  class PublisherServerManagementTest < Test::Unit::TestCase
+    def setup
+      @client = Client.new
+      @pub = Publisher.new(@client)
+    end
+
+    test "marking the current server as dead should add it to the dead servers hash and remove it from the active servers list" do
+      @pub.servers = ["localhost:1111", "localhost:2222"]
+      @pub.send(:set_current_server, "localhost:2222")
+      @pub.send(:mark_server_dead)
+      assert_equal ["localhost:1111"], @pub.servers
+      dead = @pub.instance_variable_get "@dead_servers"
+      assert_equal ["localhost:2222"], dead.keys
+      assert_kind_of Time, dead["localhost:2222"]
+    end
+
+    test "recycle_dead_servers should move servers from the dead server hash to the servers list only if the have been markd dead for longer than 10 seconds" do
+      @pub.servers = ["a:1", "b:2"]
+      @pub.send(:set_current_server, "a:1")
+      @pub.send(:mark_server_dead)
+      assert_equal ["b:2"], @pub.servers
+      dead = @pub.instance_variable_get("@dead_servers")
+      dead["a:1"] = 9.seconds.ago
+      @pub.send(:recycle_dead_servers)
+      assert_equal ["a:1"], dead.keys
+      dead["a:1"] = 11.seconds.ago
+      @pub.send(:recycle_dead_servers)
+      assert_equal ["b:2", "a:1"], @pub.servers
+      assert_equal({}, dead)
+    end
+
+    test "select_next_server should cycle through the list of all servers" do
+      @pub.servers = ["a:1", "b:2"]
+      @pub.send(:set_current_server, "a:1")
+      @pub.send(:select_next_server)
+      assert_equal "b:2", @pub.server
+      @pub.send(:select_next_server)
+      assert_equal "a:1", @pub.server
+    end
+
+    test "select_next_server should return 0 if there are no servers to publish to" do
+      @pub.servers = []
+      logger = mock('logger')
+      logger.expects(:error).returns(true)
+      @pub.expects(:logger).returns(logger)
+      assert_equal 0, @pub.send(:select_next_server)
+    end
+
+    test "stop should shut down all bunnies" do
+      @pub.servers = ["localhost:1111", "localhost:2222"]
+      s = sequence("shutdown")
+      bunny = mock("bunny")
+      @pub.expects(:set_current_server).with("localhost:1111").in_sequence(s)
+      @pub.expects(:bunny).returns(bunny).in_sequence(s)
+      bunny.expects(:stop).in_sequence(s)
+      @pub.expects(:set_current_server).with("localhost:2222").in_sequence(s)
+      @pub.expects(:bunny).returns(bunny).in_sequence(s)
+      bunny.expects(:stop).in_sequence(s)
+      @pub.stop
+    end
+  end
+
+
+  class RPCTest < Test::Unit::TestCase
+    def setup
+      @client = Client.new
+      @pub = Publisher.new(@client)
+      @client.register_message(:test, :exchange => :some_exchange)
+    end
+
+    test "rpc should return a timeout status if bunny throws an exception" do
+      bunny = mock("bunny")
+      @pub.expects(:bunny).returns(bunny)
+      bunny.expects(:queue).raises(Bunny::ConnectionError.new)
+      s = sequence("rpc")
+      @pub.expects(:select_next_server).in_sequence(s)
+      @pub.expects(:bind_queues_for_exchange).with("some_exchange").in_sequence(s)
+      @pub.expects(:stop!)
+      assert_equal "TIMEOUT", @pub.rpc("test", "hello").first
+    end
+
+    test "rpc should return a timeout status if the answer doesn't arrive in time" do
+      bunny = mock("bunny")
+      reply_queue = mock("reply_queue")
+      exchange = mock("exchange")
+      @pub.expects(:bunny).returns(bunny)
+      bunny.expects(:queue).returns(reply_queue)
+      reply_queue.stubs(:name).returns("reply_queue")
+      s = sequence("rpc")
+      @pub.expects(:select_next_server).in_sequence(s)
+      @pub.expects(:bind_queues_for_exchange).with("some_exchange").in_sequence(s)
+      @pub.expects(:exchange).with("some_exchange").returns(exchange).in_sequence(s)
+      exchange.expects(:publish).in_sequence(s)
+      reply_queue.expects(:subscribe).with(:message_max => 1, :timeout => 10).in_sequence(s)
+      assert_equal "TIMEOUT", @pub.rpc("test", "hello").first
+    end
+
+    test "rpc should recover dead servers before selecting the next server" do
+      @pub.servers << "localhost:3333"
+      @pub.send(:mark_server_dead)
+      bunny = mock("bunny")
+      reply_queue = mock("reply_queue")
+      exchange = mock("exchange")
+      @pub.expects(:bunny).returns(bunny)
+      bunny.expects(:queue).returns(reply_queue)
+      reply_queue.stubs(:name).returns("reply_queue")
+      s = sequence("rpc")
+      @pub.expects(:recycle_dead_servers).in_sequence(s)
+      @pub.expects(:select_next_server).in_sequence(s)
+      @pub.expects(:bind_queues_for_exchange).with("some_exchange").in_sequence(s)
+      @pub.expects(:exchange).with("some_exchange").returns(exchange).in_sequence(s)
+      exchange.expects(:publish).in_sequence(s)
+      reply_queue.expects(:subscribe).with(:message_max => 1, :timeout => 10).in_sequence(s)
+      assert_equal "TIMEOUT", @pub.rpc("test", "hello").first
+    end
+
+    test "rpc should fetch the result and the status code from the reply message" do
+      bunny = mock("bunny")
+      reply_queue = mock("reply_queue")
+      exchange = mock("exchange")
+      @pub.expects(:bunny).returns(bunny)
+      bunny.expects(:queue).returns(reply_queue)
+      reply_queue.stubs(:name).returns("reply_queue")
+      s = sequence("rpc")
+      @pub.expects(:select_next_server).in_sequence(s)
+      @pub.expects(:bind_queues_for_exchange).with("some_exchange").in_sequence(s)
+      @pub.expects(:exchange).with("some_exchange").returns(exchange).in_sequence(s)
+      exchange.expects(:publish).in_sequence(s)
+      header = mock("header")
+      header.expects(:properties).returns({:headers => {:status => "OK"}})
+      msg = {:payload => 1, :header => header}
+      reply_queue.expects(:subscribe).with(:message_max => 1, :timeout => 10).in_sequence(s).yields(msg)
+      assert_equal ["OK",1], @pub.rpc("test", "hello")
+    end
+
+  end
+end

data/test/beetle/r_c_test.rb

@@ -0,0 +1,9 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+module Beetle
+  class ReturnCodesTest < Test::Unit::TestCase
+    test "inspecting a return code should display the name of the returncode" do
+      assert_equal "Beetle::RC::OK", Beetle::RC::OK.inspect
+    end
+  end
+end

data/test/beetle/subscriber_test.rb

@@ -0,0 +1,263 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+module Beetle
+  class SubscriberTest < Test::Unit::TestCase
+    def setup
+      client = Client.new
+      @sub = client.send(:subscriber)
+    end
+
+    test "initially there should be no amqp connections" do
+      assert_equal({}, @sub.instance_variable_get("@amqp_connections"))
+    end
+
+    test "initially there should be no instances of MQ" do
+      assert_equal({}, @sub.instance_variable_get("@mqs"))
+    end
+
+    test "acccessing an amq_connection for a server which doesn't have one should create it and associate it with the server" do
+      @sub.expects(:new_amqp_connection).returns(42)
+      # TODO: smarter way to test? what triggers the amqp_connection private method call?
+      assert_equal 42, @sub.send(:amqp_connection)
+      connections = @sub.instance_variable_get("@amqp_connections")
+      assert_equal 42, connections[@sub.server]
+    end
+
+    test "new amqp connections should be created using current host and port" do
+      m = mock("dummy")
+      expected_amqp_options = {
+        :host => @sub.send(:current_host), :port => @sub.send(:current_port),
+        :user => "guest", :pass => "guest", :vhost => "/"
+      }
+      AMQP.expects(:connect).with(expected_amqp_options).returns(m)
+      # TODO: smarter way to test? what triggers the amqp_connection private method call?
+      assert_equal m, @sub.send(:new_amqp_connection)
+    end
+
+    test "mq instances should be created for the current server if accessed" do
+      @sub.expects(:amqp_connection).returns(11)
+      mq_mock = mock('mq')
+      mq_mock.expects(:prefetch).with(1).returns(42)
+      MQ.expects(:new).with(11).returns(mq_mock)
+      assert_equal 42, @sub.send(:mq)
+      mqs = @sub.instance_variable_get("@mqs")
+      assert_equal 42, mqs[@sub.server]
+    end
+
+    test "stop! should stop the event loop" do
+      EM.expects(:stop_event_loop)
+      @sub.send(:stop!)
+    end
+
+  end
+
+  class SubscriberQueueManagementTest < Test::Unit::TestCase
+    def setup
+      @client = Client.new
+      @sub = @client.send(:subscriber)
+    end
+
+    test "initially there should be no queues for the current server" do
+      assert_equal({}, @sub.send(:queues))
+      assert !@sub.send(:queues)["some_queue"]
+    end
+
+    test "binding a queue should create it using the config and bind it to the exchange with the name specified" do
+      @client.register_queue("some_queue", "durable" => true, "exchange" => "some_exchange", "key" => "haha.#")
+      @sub.expects(:exchange).with("some_exchange").returns(:the_exchange)
+      q = mock("queue")
+      q.expects(:bind).with(:the_exchange, {:key => "haha.#"})
+      m = mock("MQ")
+      m.expects(:queue).with("some_queue", :durable => true, :passive => false, :auto_delete => false, :exclusive => false).returns(q)
+      @sub.expects(:mq).returns(m)
+
+      @sub.send(:queue, "some_queue")
+      assert_equal q, @sub.send(:queues)["some_queue"]
+    end
+
+    test "binding queues should iterate over all servers" do
+      s = sequence("binding")
+      @client.register_queue(:x)
+      @client.register_queue(:y)
+      @client.register_handler(%w(x y)){}
+      @sub.servers = %w(a b)
+      @sub.expects(:set_current_server).with("a").in_sequence(s)
+      @sub.expects(:queue).with("x").in_sequence(s)
+      @sub.expects(:queue).with("y").in_sequence(s)
+      @sub.expects(:set_current_server).with("b").in_sequence(s)
+      @sub.expects(:queue).with("x").in_sequence(s)
+      @sub.expects(:queue).with("y").in_sequence(s)
+      @sub.send(:bind_queues, %W(x y))
+    end
+
+  end
+
+  class SubscriberExchangeManagementTest < Test::Unit::TestCase
+    def setup
+      @client = Client.new
+      @sub = @client.send(:subscriber)
+    end
+
+    test "initially there should be no exchanges for the current server" do
+      assert_equal({}, @sub.send(:exchanges))
+    end
+
+    test "accessing a given exchange should create it using the config. further access should return the created exchange" do
+      @client.register_exchange("some_exchange", "type" => "topic", "durable" => true)
+      m = mock("AMQP")
+      m.expects(:topic).with("some_exchange", :durable => true).returns(42)
+      @sub.expects(:mq).returns(m)
+      ex = @sub.send(:exchange, "some_exchange")
+      assert @sub.send(:exchanges).include?("some_exchange")
+      ex2 = @sub.send(:exchange, "some_exchange")
+      assert_equal ex2, ex
+    end
+
+    test "should create exchanges for all exchanges passed to create_exchanges, for all servers" do
+      @sub.servers = %w(x y)
+      @client.register_queue(:donald, :exchange => 'duck')
+      @client.register_queue(:mickey)
+      @client.register_queue(:mouse, :exchange => 'mickey')
+
+      exchange_creation = sequence("exchange creation")
+      @sub.expects(:set_current_server).with('x').in_sequence(exchange_creation)
+      @sub.expects(:create_exchange!).with("duck", anything).in_sequence(exchange_creation)
+      @sub.expects(:create_exchange!).with("mickey", anything).in_sequence(exchange_creation)
+      @sub.expects(:set_current_server).with('y', anything).in_sequence(exchange_creation)
+      @sub.expects(:create_exchange!).with("duck", anything).in_sequence(exchange_creation)
+      @sub.expects(:create_exchange!).with("mickey", anything).in_sequence(exchange_creation)
+      @sub.send(:create_exchanges, %w(duck mickey))
+    end
+  end
+
+  class CallBackExecutionTest < Test::Unit::TestCase
+    def setup
+      client = Client.new
+      @queue = "somequeue"
+      client.register_queue(@queue)
+      @sub = client.send(:subscriber)
+      @exception = Exception.new "murks"
+      @handler = Handler.create(lambda{|*args| raise @exception})
+      @callback = @sub.send(:create_subscription_callback, "my myessage", @queue, @handler, :exceptions => 1)
+    end
+
+    test "exceptions raised from message processing should be ignored" do
+      header = header_with_params({})
+      Message.any_instance.expects(:process).raises(Exception.new)
+      assert_nothing_raised { @callback.call(header, 'foo') }
+    end
+
+    test "should call recover on the server when processing the handler returns true on recover?" do
+      header = header_with_params({})
+      result = mock("result")
+      result.expects(:recover?).returns(true)
+      Message.any_instance.expects(:process).returns(result)
+      @sub.expects(:sleep).with(1)
+      mq = mock("MQ")
+      mq.expects(:recover)
+      @sub.expects(:mq).with(@sub.server).returns(mq)
+      @callback.call(header, 'foo')
+    end
+
+    test "should sent a reply with status OK if the message reply_to header is set and processing the handler succeeds" do
+      header = header_with_params(:reply_to => "tmp-queue")
+      result = RC::OK
+      Message.any_instance.expects(:process).returns(result)
+      Message.any_instance.expects(:handler_result).returns("response-data")
+      mq = mock("MQ")
+      @sub.expects(:mq).with(@sub.server).returns(mq)
+      exchange = mock("exchange")
+      exchange.expects(:publish).with("response-data", :headers => {:status => "OK"})
+      MQ::Exchange.expects(:new).with(mq, :direct, "", :key => "tmp-queue").returns(exchange)
+      @callback.call(header, 'foo')
+    end
+
+    test "should sent a reply with status FAILED if the message reply_to header is set and processing the handler fails" do
+      header = header_with_params(:reply_to => "tmp-queue")
+      result = RC::AttemptsLimitReached
+      Message.any_instance.expects(:process).returns(result)
+      Message.any_instance.expects(:handler_result).returns(nil)
+      mq = mock("MQ")
+      @sub.expects(:mq).with(@sub.server).returns(mq)
+      exchange = mock("exchange")
+      exchange.expects(:publish).with("", :headers => {:status => "FAILED"})
+      MQ::Exchange.expects(:new).with(mq, :direct, "", :key => "tmp-queue").returns(exchange)
+      @callback.call(header, 'foo')
+    end
+
+  end
+
+  class SubscriptionTest < Test::Unit::TestCase
+    def setup
+      @client = Client.new
+      @sub = @client.send(:subscriber)
+    end
+
+    test "subscribe should create subscriptions on all queues for all servers" do
+      @sub.servers << "localhost:7777"
+      @client.register_message(:a)
+      @client.register_message(:b)
+      @client.register_queue(:a)
+      @client.register_queue(:b)
+      @client.register_handler(%W(a b)){}
+      @sub.expects(:subscribe).with("a").times(2)
+      @sub.expects(:subscribe).with("b").times(2)
+      @sub.send(:subscribe_queues, %W(a b))
+    end
+
+    test "subscribe should subscribe with a subscription callback created from the registered block" do
+      @client.register_queue(:some_queue, :exchange => "some_exchange", :key => "some_key")
+      server = @sub.server
+      header = header_with_params({})
+      header.expects(:ack)
+      block_called = false
+      proc = lambda do |m|
+        block_called = true
+        assert_equal header, m.header
+        assert_equal "data", m.data
+        assert_equal server, m.server
+      end
+      @sub.register_handler("some_queue", &proc)
+      q = mock("QUEUE")
+      q.expects(:subscribe).with({:ack => true, :key => "#"}).yields(header, 'foo')
+      @sub.expects(:queues).returns({"some_queue" => q})
+      @sub.send(:subscribe, "some_queue")
+      assert block_called
+    end
+
+    test "subscribe should fail if no handler exists for given message" do
+      assert_raises(Error){ @sub.send(:subscribe, "some_queue") }
+    end
+
+    test "listening should use eventmachine. create exchanges. bind queues. install subscribers. and yield." do
+      @client.register_queue(:a)
+      @client.register_message(:a)
+      EM.expects(:run).yields
+      @sub.expects(:create_exchanges).with(["a"])
+      @sub.expects(:bind_queues).with(["a"])
+      @sub.expects(:subscribe_queues).with(["a"])
+      @sub.listen(["a"]) {}
+    end
+  end
+
+  class HandlersTest < Test::Unit::TestCase
+    def setup
+      @client = Client.new
+      @sub = @client.send(:subscriber)
+    end
+
+    test "initially we should have no handlers" do
+      assert_equal({}, @sub.instance_variable_get("@handlers"))
+    end
+
+    test "registering a handler for a queue should store it in the configuration with symbolized option keys" do
+      opts = {"ack" => true}
+      @sub.register_handler("some_queue", opts){ |*args| 42 }
+      opts, block = @sub.instance_variable_get("@handlers")["some_queue"]
+      assert_equal({:ack => true}, opts)
+      assert_equal 42, block.call(1)
+    end
+
+  end
+
+end