right_amqp 0.3.3 → 0.5.2

data/spec/ha_client/broker_client_spec.rb

@@ -40,11 +40,15 @@ describe RightAMQP::BrokerClient do
     @serializer.should_receive(:load).with(@message).and_return(@packet).by_default
     @exceptions = flexmock("exceptions")
     @exceptions.should_receive(:track).never.by_default
+    @non_deliveries = flexmock("non-deliveries")
+    @non_deliveries.should_receive(:update).never.by_default
     @connection = flexmock("connection")
     @connection.should_receive(:connection_status).by_default
     flexmock(AMQP).should_receive(:connect).and_return(@connection).by_default
     @channel = flexmock("AMQP connection channel")
     @channel.should_receive(:connection).and_return(@connection).by_default
+    @channel.should_receive(:return_message).and_return(true).by_default
+    flexmock(MQ).should_receive(:new).and_return(@channel).by_default
     @identity = "rs-broker-localhost-5672"
     @address = {:host => "localhost", :port => 5672, :index => 0}
     @options = {}
@@ -62,8 +66,8 @@ describe RightAMQP::BrokerClient do
     it "should create a broker with AMQP connection for specified address" do
       @amqp.should_receive(:connect).with(hsh(:user => "user", :pass => "pass", :vhost => "vhost", :host => "localhost",
                                               :port => 5672, :insist => true, :reconnect_interval => 10)).and_return(@connection).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, {:user => "user",
-                                           :pass => "pass", :vhost => "vhost", :insist => true,
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries,
+                                           {:user => "user", :pass => "pass", :vhost => "vhost", :insist => true,
                                            :reconnect_interval => 10})
       broker.host.should == "localhost"
       broker.port.should == 5672
@@ -77,16 +81,16 @@ describe RightAMQP::BrokerClient do
     end
 
     it "should update state from existing client for given broker" do
-      existing = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      existing = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       existing.__send__(:update_status, :disconnected)
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options, existing)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options, existing)
       broker.summary.should == {:alias => "b0", :identity => @identity, :status => :connecting,
                                 :disconnects => 1, :failures => 0, :retries => 0}
     end
 
     it "should log an info message when it creates an AMQP connection" do
       @logger.should_receive(:info).with(/Connecting to broker/).once
-      RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
     end
 
     it "should log an error and set status to :failed if it fails to create an AMQP connection" do
@@ -95,19 +99,25 @@ describe RightAMQP::BrokerClient do
       @logger.should_receive(:info).once
       @logger.should_receive(:error).with(/Failed connecting/).once
       flexmock(MQ).should_receive(:new).with(@connection).and_raise(Exception)
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.summary.should == {:alias => "b0", :identity => @identity, :status => :failed,
                                 :disconnects => 0, :failures => 1, :retries => 0}
     end
 
     it "should set initialize connection status callback" do
       @connection.should_receive(:connection_status).once
-      RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
     end
 
-    it "should set broker prefetch value if specified" do
+    it "should set broker prefetch value only if specified" do
       @channel.should_receive(:prefetch).with(1).once
-      RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, {:prefetch => 1})
+      RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, {:prefetch => 1})
+    end
+
+    it "should setup for message return" do
+      @channel.should_receive(:return_message).with(Proc).once
+      RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
     end
 
   end # when initializing connection
@@ -115,7 +125,7 @@ describe RightAMQP::BrokerClient do
   context "when subscribing" do
 
     before(:each) do
-      @info = flexmock("info", :ack => true).by_default
+      @header = flexmock("header", :ack => true).by_default
       @serializer.should_receive(:load).with(@message).and_return(@packet).by_default
       @direct = flexmock("direct")
       @fanout = flexmock("fanout")
@@ -131,7 +141,7 @@ describe RightAMQP::BrokerClient do
     it "should subscribe queue to exchange" do
       @queue.should_receive(:bind).and_return(@bind).once
       @bind.should_receive(:subscribe).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.__send__(:update_status, :ready)
       broker.subscribe({:name => "queue"}, {:type => :direct, :name => "exchange"}) {|_, _|}
     end
@@ -139,7 +149,7 @@ describe RightAMQP::BrokerClient do
     it "should subscribe queue to second exchange if specified" do
       @queue.should_receive(:bind).and_return(@bind).twice
       @bind.should_receive(:subscribe).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.__send__(:update_status, :ready)
       options = {:exchange2 => {:type => :fanout, :name => "exchange2", :options => {:durable => true}}}
       broker.subscribe({:name => "queue"}, {:type => :direct, :name => "exchange"}, options) {|_, _|}
@@ -147,27 +157,27 @@ describe RightAMQP::BrokerClient do
 
     it "should subscribe queue to exchange when still connecting" do
       @bind.should_receive(:subscribe).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.subscribe({:name => "queue"}, {:type => :direct, :name => "exchange"}) {|_, _|}
     end
 
     it "should subscribe queue to empty exchange if no exchange specified" do
       @queue.should_receive(:subscribe).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.__send__(:update_status, :ready)
       broker.subscribe({:name => "queue"}) {|b, p| p.should == nil}
     end
 
     it "should store queues for future reference" do
       @bind.should_receive(:subscribe).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
-      broker.subscribe({:name => "queue"}, {:type => :direct, :name => "exchange"})
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      broker.subscribe({:name => "queue"}, {:type => :direct, :name => "exchange"}) {|_, _|}
       broker.queues.should == [@queue]
     end
 
     it "should return true if subscribed successfully" do
-      @bind.should_receive(:subscribe).and_yield(@info, @message).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      @bind.should_receive(:subscribe).and_yield(@header, @message).once
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       result = broker.subscribe({:name => "queue"}, {:type => :direct, :name => "exchange"},
                                  RequestMock => true) {|b, p| p.should == @packet}
       result.should be_true
@@ -175,8 +185,8 @@ describe RightAMQP::BrokerClient do
 
     it "should return true if already subscribed and not try to resubscribe" do
       @queue.should_receive(:name).and_return("queue").once
-      @bind.should_receive(:subscribe).and_yield(@info, @message).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      @bind.should_receive(:subscribe).and_yield(@header, @message).once
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       result = broker.subscribe({:name => "queue"}, {:type => :direct, :name => "exchange"},
                                  RequestMock => true) {|b, p| p.should == @packet}
       result.should be_true
@@ -184,10 +194,9 @@ describe RightAMQP::BrokerClient do
       result.should be_true
     end
 
-    it "should ack received message if requested" do
-      @info.should_receive(:ack).once
-      @bind.should_receive(:subscribe).and_yield(@info, @message).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+    it "should enable message ack by subscribe caller if requested" do
+      @bind.should_receive(:subscribe).with({:ack => true}, Proc).and_yield(@header, @message).once
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.__send__(:update_status, :ready)
       result = broker.subscribe({:name => "queue"}, {:type => :direct, :name => "exchange"},
                                 :ack => true, RequestMock => true) {|b, p| p.should == @packet}
@@ -197,130 +206,188 @@ describe RightAMQP::BrokerClient do
     it "should return false if client not usable" do
       @queue.should_receive(:bind).and_return(@bind).never
       @bind.should_receive(:subscribe).never
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.__send__(:update_status, :disconnected)
-      broker.subscribe({:name => "queue"}).should be_false
+      broker.subscribe({:name => "queue"}) { |_, _| }.should be_false
     end
- 
-    it "should receive message causing it to be unserialized and logged" do
+
+    it "should raise if no block supplied" do
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      lambda { broker.subscribe({:name => "queue"}) }.should raise_error(ArgumentError)
+    end
+
+    it "should receive message" do
       @logger.should_receive(:info).with(/Connecting/).once
       @logger.should_receive(:info).with(/Subscribing/).once
-      @logger.should_receive(:info).with(/RECV/).once
-      @serializer.should_receive(:load).with(@message).and_return(@packet).once
-      @bind.should_receive(:subscribe).and_yield(@info, @message).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      @bind.should_receive(:subscribe).and_yield(@header, @message).once
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      subscribe_options = {RequestMock => nil}
+      flexmock(broker).should_receive(:receive).with("queue", @header, @message, subscribe_options, Proc).once
       broker.__send__(:update_status, :ready)
       broker.subscribe({:name => "queue"}, {:type => :direct, :name => "exchange"},
-                       RequestMock => nil) {|b, p| p.class.should == RequestMock}
+                       subscribe_options) {|b, p| p.class.should == RequestMock}
     end
 
-    it "should receive message and log exception if subscribe block fails" do
+    it "should receive message using fiber pool specified as subscribe option" do
       @logger.should_receive(:info).with(/Connecting/).once
       @logger.should_receive(:info).with(/Subscribing/).once
-      @logger.should_receive(:error).with(/Failed executing block/).once
+      @bind.should_receive(:subscribe).and_yield(@header, @message).once
+      fiber_pool = flexmock("fiber pool")
+      fiber_pool.should_receive(:spawn).and_yield.once
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      subscribe_options = {RequestMock => nil, :fiber_pool => fiber_pool}
+      flexmock(broker).should_receive(:receive).with("queue", @header, @message, subscribe_options, Proc).once
+      broker.__send__(:update_status, :ready)
+      broker.subscribe({:name => "queue"}, {:type => :direct, :name => "exchange"},
+                       subscribe_options) {|b, p| p.class.should == RequestMock}
+    end
+
+    it "should receive message using fiber pool specified as constructor option" do
+      @logger.should_receive(:info).with(/Connecting/).once
+      @logger.should_receive(:info).with(/Subscribing/).once
+      @bind.should_receive(:subscribe).and_yield(@header, @message).once
+      fiber_pool = flexmock("fiber pool")
+      fiber_pool.should_receive(:spawn).and_yield.once
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries,
+                                           @options.merge(:fiber_pool => fiber_pool))
+      subscribe_options = {RequestMock => nil}
+      flexmock(broker).should_receive(:receive).with("queue", @header, @message, subscribe_options, Proc).once
+      broker.__send__(:update_status, :ready)
+      broker.subscribe({:name => "queue"}, {:type => :direct, :name => "exchange"},
+                       subscribe_options) {|b, p| p.class.should == RequestMock}
+    end
+
+    it "should receive message and log exception if subscribe block fails and then ack if option set" do
+      @logger.should_receive(:info).with(/Connecting/).once
+      @logger.should_receive(:info).with(/Subscribing/).once
+      @logger.should_receive(:error).with(/Failed receiving message/).once
       @exceptions.should_receive(:track).once
+      @non_deliveries.should_receive(:update).once
       @serializer.should_receive(:load).with(@message).and_return(@packet).once
-      @bind.should_receive(:subscribe).and_yield(@info, @message).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      @header.should_receive(:ack).once
+      @bind.should_receive(:subscribe).and_yield(@header, @message).once
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.__send__(:update_status, :ready)
       result = broker.subscribe({:name => "queue"}, {:type => :direct, :name => "exchange"},
-                                RequestMock => nil) {|b, p| raise Exception}
+                                :ack => true, RequestMock => nil) {|b, p| raise Exception}
       result.should be_false
     end
 
-    it "should ignore 'nil' message when using ack" do
-      @logger.should_receive(:level).and_return(:debug)
+    it "should log an error if a subscribe fails" do
       @logger.should_receive(:info).with(/Connecting/).once
-      @logger.should_receive(:info).with(/Subscribing/).once
-      @logger.should_receive(:debug).with(/nil message ignored/).once
-      @bind.should_receive(:subscribe).and_yield(@info, "nil").once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      @logger.should_receive(:info).with(/RECV/).never
+      @logger.should_receive(:error).with(/Failed subscribing/).once
+      @exceptions.should_receive(:track).once
+      @bind.should_receive(:subscribe).and_raise(Exception)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.__send__(:update_status, :ready)
+      result = broker.subscribe({:name => "queue"}, {:type => :direct, :name => "exchange"}) {|_, _|}
+      result.should be_false
+    end
+
+  end # when subscribing
+
+  context "when receiving" do
+
+    before(:each) do
+      @header = flexmock("header", :ack => true).by_default
+      @subscribe_options = {}
+    end
+
+    it "should unserialize the message by default" do
+      @logger.should_receive(:info).with(/Connecting/).once
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      flexmock(broker).should_receive(:unserialize).and_return(@packet).once
+      broker.__send__(:receive, "queue", @header, @message, @subscribe_options) {|_, _|}
+    end
+
+    it "should not unserialize the message if so requested" do
+      @logger.should_receive(:info).with(/Connecting/).once
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      flexmock(broker).should_receive(:unserialize).never
+      @subscribe_options = {:no_unserialize => true}
+      broker.__send__(:receive, "queue", @header, @message, @subscribe_options) {|_, _|}
+    end
+
+    it "should make callback to deliver message" do
+      @logger.should_receive(:info).with(/Connecting/).once
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      flexmock(broker).should_receive(:unserialize).and_return(@packet).once
+      called = 0
+      broker.__send__(:receive, "queue", @header, @message, @subscribe_options) { |b, m| called += 1 }
+      called.should == 1
+    end
+
+    it "should not make callback if received message is nil but then ack if option set" do
+      @logger.should_receive(:info).with(/Connecting/).once
+      @header.should_receive(:ack).once
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      flexmock(broker).should_receive(:unserialize).and_return(nil).once
+      @subscribe_options = {:ack => true}
       called = 0
-      broker.subscribe({:name => "queue"}, {:type => :direct, :name => "exchange"}, :ack => true) { |b, m| called += 1 }
+      broker.__send__(:receive, "queue", @header, @message, @subscribe_options) { |b, m| called += 1 }
       called.should == 0
     end
 
-    it "should ignore 'nil' message when not using ack" do
-      @logger.should_receive(:level).and_return(:debug)
+    it "should ignore 'nil' message but then ack if option set" do
       @logger.should_receive(:info).with(/Connecting/).once
-      @logger.should_receive(:info).with(/Subscribing/).once
       @logger.should_receive(:debug).with(/nil message ignored/).once
-      @bind.should_receive(:subscribe).and_yield(@info, "nil").once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
-      broker.__send__(:update_status, :ready)
+      @header.should_receive(:ack).once
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      @subscribe_options = {:ack => true}
       called = 0
-      broker.subscribe({:name => "queue"}, {:type => :direct, :name => "exchange"}) { |b, m| called += 1 }
+      broker.__send__(:receive, "queue", @header, "nil", @subscribe_options) { |b, m| called += 1 }
       called.should == 0
     end
 
-    it "should not unserialize the message if requested" do
+    it "should ignore 'nil' message when ack option not set" do
       @logger.should_receive(:info).with(/Connecting/).once
-      @logger.should_receive(:info).with(/Subscribing/).once
-      @logger.should_receive(:info).with(/^RECV/).never
-      @bind.should_receive(:subscribe).and_yield(@info, @message).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
-      broker.__send__(:update_status, :ready)
-      broker.subscribe({:name => "queue"}, {:type => :direct, :name => "exchange"}, :no_unserialize => true) do |b, m|
-        b.should == "rs-broker-localhost-5672"
-        m.should == @message
-      end
+      @logger.should_receive(:debug).with(/nil message ignored/).once
+      @header.should_receive(:ack).never
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      broker.__send__(:receive, "queue", @header, "nil", @subscribe_options) {|_, _|}
     end
 
     it "should pass header with message if callback requires it" do
       @logger.should_receive(:info).with(/Connecting/).once
-      @logger.should_receive(:info).with(/Subscribing/).once
-      @logger.should_receive(:info).with(/^RECV/).never
-      @bind.should_receive(:subscribe).and_yield(@info, @message).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
-      broker.__send__(:update_status, :ready)
-      broker.subscribe({:name => "queue"}, {:type => :direct, :name => "exchange"}, :no_unserialize => true) do |b, m, h|
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      flexmock(broker).should_receive(:unserialize).never
+      @subscribe_options = {:no_unserialize => true}
+      broker.__send__(:receive, "queue", @header, @message, @subscribe_options) do |b, m, h|
         b.should == "rs-broker-localhost-5672"
         m.should == @message
-        h.should == @info
+        h.should == @header
       end
     end
 
-    it "should log an error if a subscribe fails" do
-      @logger.should_receive(:info).with(/Connecting/).once
-      @logger.should_receive(:info).with(/RECV/).never
-      @logger.should_receive(:error).with(/Failed subscribing/).once
-      @exceptions.should_receive(:track).once
-      @bind.should_receive(:subscribe).and_raise(Exception)
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
-      broker.__send__(:update_status, :ready)
-      result = broker.subscribe({:name => "queue"}, {:type => :direct, :name => "exchange"}) {|b, p|}
-      result.should be_false
-    end
-
-  end # when subscribing
+  end # when receiving
 
-  context "when receiving" do
+  context "when unserializing" do
 
     it "should unserialize the message, log it, and return it" do
       @logger.should_receive(:info).with(/Connecting/).once
       @logger.should_receive(:info).with(/^RECV/).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
-      broker.__send__(:receive, "queue", @message, RequestMock => nil).should == @packet
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      broker.__send__(:unserialize, "queue", @message, RequestMock => nil).should == @packet
     end
 
-    it "should log a warning if the message is not of the right type and return nil" do
-      @logger.should_receive(:warning).with(/Received invalid.*packet type/).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
-      broker.__send__(:receive, "queue", @message).should be_nil
+    it "should log an error if the message is not of the right type and return nil" do
+      @logger.should_receive(:error).with(/Received invalid.*packet type/).once
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      broker.__send__(:unserialize, "queue", @message).should be_nil
     end
 
-    it "should show the category in the warning message if specified" do
-      @logger.should_receive(:warning).with(/Received invalid xxxx packet type/).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
-      broker.__send__(:receive, "queue", @message, ResultMock => nil, :category => "xxxx")
+    it "should show the category in the error message if specified" do
+      @logger.should_receive(:error).with(/Received invalid xxxx packet type/).once
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      broker.__send__(:unserialize, "queue", @message, ResultMock => nil, :category => "xxxx")
     end
 
     it "should display broker alias in the log" do
       @logger.should_receive(:info).with(/Connecting/).once
       @logger.should_receive(:info).with(/^RECV b0 /).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
-      broker.__send__(:receive, "queue", @message, RequestMock => nil)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      broker.__send__(:unserialize, "queue", @message, RequestMock => nil)
     end
 
     it "should filter the packet display for :info level" do
@@ -328,8 +395,8 @@ describe RightAMQP::BrokerClient do
       @logger.should_receive(:info).with(/^RECV.*TO YOU/).once
       @logger.should_receive(:debug).with(/^RECV.*TO YOU/).never
       @packet.should_receive(:to_s).with([:to], :recv_version).and_return("TO YOU").once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
-      broker.__send__(:receive, "queue", @message, RequestMock => [:to])
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      broker.__send__(:unserialize, "queue", @message, RequestMock => [:to])
     end
 
     it "should not filter the packet display for :debug level" do
@@ -338,49 +405,51 @@ describe RightAMQP::BrokerClient do
       @logger.should_receive(:info).with(/^RECV.*ALL/).never
       @logger.should_receive(:info).with(/^RECV.*ALL/).once
       @packet.should_receive(:to_s).with(nil, :recv_version).and_return("ALL").once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
-      broker.__send__(:receive, "queue", @message, RequestMock => [:to])
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      broker.__send__(:unserialize, "queue", @message, RequestMock => [:to])
     end
 
     it "should display additional data in log" do
       @logger.should_receive(:info).with(/Connecting/).once
       @logger.should_receive(:info).with(/^RECV.*More data/).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
-      broker.__send__(:receive, "queue", @message, RequestMock => nil, :log_data => "More data")
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      broker.__send__(:unserialize, "queue", @message, RequestMock => nil, :log_data => "More data")
     end
 
     it "should not log a message if requested not to" do
       @logger.should_receive(:info).with(/Connecting/).once
       @logger.should_receive(:info).with(/^RECV/).never
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
-      broker.__send__(:receive, "queue", @message, RequestMock => nil, :no_log => true)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      broker.__send__(:unserialize, "queue", @message, RequestMock => nil, :no_log => true)
     end
 
     it "should not log a message if requested not to unless debug level" do
       @logger.should_receive(:level).and_return(:debug)
       @logger.should_receive(:info).with(/Connecting/).once
       @logger.should_receive(:info).with(/^RECV/).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
-      broker.__send__(:receive, "queue", @message, RequestMock => nil, :no_log => true)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      broker.__send__(:unserialize, "queue", @message, RequestMock => nil, :no_log => true)
     end
 
     it "should log an error if exception prevents normal logging and should then return nil" do
-      @logger.should_receive(:error).with(/Failed receiving from queue/).once
+      @logger.should_receive(:error).with(/Failed unserializing message from queue/).once
       @serializer.should_receive(:load).with(@message).and_raise(Exception).once
       @exceptions.should_receive(:track).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
-      broker.__send__(:receive, "queue", @message).should be_nil
+      @non_deliveries.should_receive(:update).once
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      broker.__send__(:unserialize, "queue", @message).should be_nil
     end
 
     it "should make callback when there is a receive failure" do
-      @logger.should_receive(:error).with(/Failed receiving from queue/).once
+      @logger.should_receive(:error).with(/Failed unserializing message from queue/).once
       @serializer.should_receive(:load).with(@message).and_raise(Exception).once
       @exceptions.should_receive(:track).once
+      @non_deliveries.should_receive(:update).once
       called = 0
       callback = lambda { |msg, e| called += 1 }
       options = {:exception_on_receive_callback => callback}
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, options)
-      broker.__send__(:receive, "queue", @message).should be_nil
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, options)
+      broker.__send__(:unserialize, "queue", @message).should be_nil
       called.should == 1
     end
 
@@ -388,11 +457,11 @@ describe RightAMQP::BrokerClient do
       @logger.should_receive(:info).with(/Connecting/).once
       @logger.should_receive(:info).with(/^RE-RECV/).once
       @packet.should_receive(:tries).and_return(["try1"]).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
-      broker.__send__(:receive, "queue", @message, RequestMock => nil).should == @packet
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      broker.__send__(:unserialize, "queue", @message, RequestMock => nil).should == @packet
     end
 
-  end # when receiving
+  end # when unserializing
 
   context "when unsubscribing" do
 
@@ -407,22 +476,22 @@ describe RightAMQP::BrokerClient do
 
     it "should unsubscribe a queue by name" do
       @queue.should_receive(:unsubscribe).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
-      broker.subscribe({:name => "queue1"}, {:type => :direct, :name => "exchange"})
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      broker.subscribe({:name => "queue1"}, {:type => :direct, :name => "exchange"}) {|_, _|}
       broker.unsubscribe(["queue1"])
     end
 
     it "should ignore unsubscribe if queue unknown" do
       @queue.should_receive(:unsubscribe).never
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
-      broker.subscribe({:name => "queue1"}, {:type => :direct, :name => "exchange"})
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      broker.subscribe({:name => "queue1"}, {:type => :direct, :name => "exchange"}) {|_, _|}
       broker.unsubscribe(["queue2"])
     end
 
     it "should activate block after unsubscribing if provided" do
       @queue.should_receive(:unsubscribe).and_yield.once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
-      broker.subscribe({:name => "queue1"}, {:type => :direct, :name => "exchange"})
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      broker.subscribe({:name => "queue1"}, {:type => :direct, :name => "exchange"}) {|_, _|}
       called = 0
       broker.unsubscribe(["queue1"]) { called += 1 }
       called.should == 1
@@ -430,8 +499,8 @@ describe RightAMQP::BrokerClient do
 
     it "should ignore the request if client not usable" do
       @queue.should_receive(:unsubscribe).and_yield.never
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
-      broker.subscribe({:name => "queue1"}, {:type => :direct, :name => "exchange"})
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      broker.subscribe({:name => "queue1"}, {:type => :direct, :name => "exchange"}) {|_, _|}
       broker.__send__(:update_status, :disconnected)
       broker.unsubscribe(["queue1"])
     end
@@ -440,8 +509,8 @@ describe RightAMQP::BrokerClient do
       @logger.should_receive(:error).with(/Failed unsubscribing/).once
       @queue.should_receive(:unsubscribe).and_raise(Exception).once
       @exceptions.should_receive(:track).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
-      broker.subscribe({:name => "queue1"}, {:type => :direct, :name => "exchange"})
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      broker.subscribe({:name => "queue1"}, {:type => :direct, :name => "exchange"}) {|_, _|}
       called = 0
       broker.unsubscribe(["queue1"]) { called += 1 }
       called.should == 1
@@ -459,13 +528,13 @@ describe RightAMQP::BrokerClient do
 
     it "should declare exchange and return true" do
       @channel.should_receive(:exchange).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.declare(:exchange, "x", :durable => true).should be_true
     end
 
     it "should delete the exchange or queue from the AMQP cache before declaring" do
       @channel.should_receive(:queue).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       flexmock(broker).should_receive(:delete_amqp_resources).with(:queue, "queue").once
       broker.declare(:queue, "queue", :durable => true).should be_true
     end
@@ -474,13 +543,13 @@ describe RightAMQP::BrokerClient do
       @logger.should_receive(:info).with(/Connecting/).once
       @logger.should_receive(:info).with(/Declaring/).once
       @channel.should_receive(:queue).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.declare(:queue, "q").should be_true
     end
 
     it "should return false if client not usable" do
       @channel.should_receive(:exchange).never
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.__send__(:update_status, :disconnected)
       broker.declare(:exchange, "x", :durable => true).should be_false
 
@@ -492,7 +561,7 @@ describe RightAMQP::BrokerClient do
       @logger.should_receive(:error).with(/Failed declaring/).once
       @exceptions.should_receive(:track).once
       @channel.should_receive(:queue).and_raise(Exception).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.declare(:queue, "q").should be_false
     end
 
@@ -508,7 +577,7 @@ describe RightAMQP::BrokerClient do
     it "should serialize message, publish it, and return true" do
       @channel.should_receive(:direct).with("exchange", :durable => true).and_return(@direct).once
       @direct.should_receive(:publish).with(@message, :persistent => true).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.__send__(:update_status, :ready)
       broker.publish({:type => :direct, :name => "exchange", :options => {:durable => true}},
                      @packet, @message, :persistent => true).should be_true
@@ -517,7 +586,7 @@ describe RightAMQP::BrokerClient do
     it "should delete the exchange or queue from the AMQP cache if :declare specified" do
       @channel.should_receive(:direct).with("exchange", {:declare => true}).and_return(@direct)
       @direct.should_receive(:publish).with(@message, {})
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.__send__(:update_status, :ready)
       exchange = {:type => :direct, :name => "exchange", :options => {:declare => true}}
       flexmock(broker).should_receive(:delete_amqp_resources).with(:direct, "exchange").once
@@ -527,7 +596,7 @@ describe RightAMQP::BrokerClient do
     it "should return false if client not connected" do
       @channel.should_receive(:direct).never
       @direct.should_receive(:publish).with(@message, :persistent => true).never
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.publish({:type => :direct, :name => "exchange", :options => {:durable => true}},
                      @packet, @message, :persistent => true).should be_false
     end
@@ -535,9 +604,10 @@ describe RightAMQP::BrokerClient do
     it "should log an error if the publish fails" do
       @logger.should_receive(:error).with(/Failed publishing/).once
       @exceptions.should_receive(:track).once
+      @non_deliveries.should_receive(:update).once
       @channel.should_receive(:direct).and_raise(Exception)
       @direct.should_receive(:publish).with(@message, {}).never
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.__send__(:update_status, :ready)
       broker.publish({:type => :direct, :name => "exchange"}, @packet, @message).should be_false
     end
@@ -547,7 +617,7 @@ describe RightAMQP::BrokerClient do
       @logger.should_receive(:info).with(/^SEND b0/).once
       @channel.should_receive(:direct).with("exchange", {}).and_return(@direct).once
       @direct.should_receive(:publish).with(@message, {}).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.__send__(:update_status, :ready)
       broker.publish({:type => :direct, :name => "exchange"}, @packet, @message).should be_true
     end
@@ -558,7 +628,7 @@ describe RightAMQP::BrokerClient do
       @logger.should_receive(:info).with(/^SEND b0.*publish options/).once
       @channel.should_receive(:direct).with("exchange", {}).and_return(@direct).once
       @direct.should_receive(:publish).with(@message, {}).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.__send__(:update_status, :ready)
       broker.publish({:type => :direct, :name => "exchange"}, @packet, @message).should be_true
     end
@@ -568,7 +638,7 @@ describe RightAMQP::BrokerClient do
       @logger.should_receive(:info).with(/^SEND/).never
       @channel.should_receive(:direct).with("exchange", {}).and_return(@direct).once
       @direct.should_receive(:publish).with(@message, :no_log => true).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.__send__(:update_status, :ready)
       broker.publish({:type => :direct, :name => "exchange"}, @packet, @message, :no_log => true).should be_true
     end
@@ -579,7 +649,7 @@ describe RightAMQP::BrokerClient do
       @logger.should_receive(:info).with(/^SEND/).once
       @channel.should_receive(:direct).with("exchange", {}).and_return(@direct).once
       @direct.should_receive(:publish).with(@message, :no_log => true).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.__send__(:update_status, :ready)
       broker.publish({:type => :direct, :name => "exchange"}, @packet, @message, :no_log => true).should be_true
     end
@@ -589,7 +659,7 @@ describe RightAMQP::BrokerClient do
       @logger.should_receive(:info).with(/^SEND b0 /).once
       @channel.should_receive(:direct).with("exchange", {}).and_return(@direct).once
       @direct.should_receive(:publish).with(@message, {}).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.__send__(:update_status, :ready)
       broker.publish({:type => :direct, :name => "exchange"}, @packet, @message).should be_true
     end
@@ -601,7 +671,7 @@ describe RightAMQP::BrokerClient do
       @packet.should_receive(:to_s).with([:to], :send_version).and_return("TO YOU").once
       @channel.should_receive(:direct).with("exchange", {}).and_return(@direct).once
       @direct.should_receive(:publish).with(@message, :log_filter => [:to]).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.__send__(:update_status, :ready)
       broker.publish({:type => :direct, :name => "exchange"}, @packet, @message, :log_filter => [:to]).should be_true
     end
@@ -614,7 +684,7 @@ describe RightAMQP::BrokerClient do
       @packet.should_receive(:to_s).with(nil, :send_version).and_return("ALL").once
       @channel.should_receive(:direct).with("exchange", {}).and_return(@direct).once
       @direct.should_receive(:publish).with(@message, :log_filter => [:to]).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.__send__(:update_status, :ready)
       broker.publish({:type => :direct, :name => "exchange"}, @packet, @message, :log_filter => [:to]).should be_true
     end
@@ -624,7 +694,7 @@ describe RightAMQP::BrokerClient do
       @logger.should_receive(:info).with(/^SEND.*More data/).once
       @channel.should_receive(:direct).with("exchange", {}).and_return(@direct).once
       @direct.should_receive(:publish).with(@message, :log_data => "More data").once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.__send__(:update_status, :ready)
       broker.publish({:type => :direct, :name => "exchange"}, @packet, @message, :log_data => "More data").should be_true
     end
@@ -635,7 +705,7 @@ describe RightAMQP::BrokerClient do
       @packet.should_receive(:tries).and_return(["try1"]).once
       @channel.should_receive(:direct).with("exchange", {}).and_return(@direct).once
       @direct.should_receive(:publish).with(@message, {}).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.__send__(:update_status, :ready)
       broker.publish({:type => :direct, :name => "exchange"}, @packet, @message).should be_true
     end
@@ -644,64 +714,56 @@ describe RightAMQP::BrokerClient do
 
   context "when returning" do
 
-    class MQ
-      attr_accessor :connection, :on_return_message
-
-      def initialize(connection)
-        @connection = connection
-      end
-
-      def return_message(&blk)
-        @on_return_message = blk
-      end
-    end
-
     before(:each) do
-      @info = flexmock("info", :reply_text => "NO_CONSUMERS", :exchange => "exchange", :routing_key => "routing_key").by_default
+      @header = flexmock("header", :reply_text => "NO_CONSUMERS", :exchange => "exchange", :routing_key => "routing_key").by_default
     end
 
-    it "should invoke block and log the return" do
+    it "should make callback" do
       @logger.should_receive(:info).with(/Connecting to broker/).once
-      @logger.should_receive(:debug).with(/RETURN b0/).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      @logger.should_receive(:debug).with(/RETURN b0 for exchange because NO_CONSUMERS/).once
       called = 0
-      broker.return_message do |to, reason, message|
+      callback = lambda do |identity, to, reason, message|
         called += 1
+        identity.should == @identity
         to.should == "exchange"
         reason.should == "NO_CONSUMERS"
         message.should == @message
       end
-      broker.instance_variable_get(:@channel).on_return_message.call(@info, @message)
+      @options = {:return_message_callback => callback }
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      broker.__send__(:handle_return, @header, @message).should be_true
       called.should == 1
     end
 
-    it "should invoke block with routing key if exchange is empty" do
-      @logger.should_receive(:debug)
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
-      called = 0
-      broker.return_message do |to, reason, message|
-        called += 1
-        to.should == "routing_key"
-        reason.should == "NO_CONSUMERS"
-        message.should == @message
-      end
-      @info.should_receive(:exchange).and_return("")
-      broker.instance_variable_get(:@channel).on_return_message.call(@info, @message)
-      called.should == 1
+    it "should log the return as info if there is no callback" do
+      @logger.should_receive(:info).with(/Connecting to broker/)
+      @logger.should_receive(:info).with("RETURN b0 for exchange because NO_CONSUMERS").once
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      broker.__send__(:handle_return, @header, @message).should be_true
+    end
+
+    it "should log the return as debug if there is a callback" do
+      @logger.should_receive(:debug).with("RETURN b0 for exchange because NO_CONSUMERS").once
+      @options = {:return_message_callback => lambda { |i, t, r, m| } }
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      broker.__send__(:handle_return, @header, @message).should be_true
+    end
+
+    it "should log the return with routing key if exchange is empty" do
+      @logger.should_receive(:info).with(/Connecting to broker/)
+      @logger.should_receive(:info).with("RETURN b0 for routing_key because NO_CONSUMERS").once
+      @header.should_receive(:exchange).and_return("")
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      broker.__send__(:handle_return, @header, @message).should be_true
     end
 
     it "should log an error if there is a failure while processing the return" do
+      @logger.should_receive(:debug).with("RETURN b0 for exchange because NO_CONSUMERS")
       @logger.should_receive(:error).with(/Failed return/).once
-      @logger.should_receive(:debug)
       @exceptions.should_receive(:track).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
-      called = 0
-      broker.return_message do |to, reason, message|
-        called += 1
-        raise Exception
-      end
-      broker.instance_variable_get(:@channel).on_return_message.call(@info, @message)
-      called.should == 1
+      @options = {:return_message_callback => lambda { |i, t, r, m| raise Exception } }
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      broker.__send__(:handle_return, @header, @message).should be_true
     end
 
   end # when returning
@@ -719,8 +781,8 @@ describe RightAMQP::BrokerClient do
 
     it "should delete the named queue and return true" do
       @queue.should_receive(:delete).once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
-      broker.subscribe({:name => "queue1"}, {:type => :direct, :name => "exchange"})
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      broker.subscribe({:name => "queue1"}, {:type => :direct, :name => "exchange"}) {|_, _|}
       broker.queues.should == [@queue]
       broker.delete("queue1").should be_true
       broker.queues.should == []
@@ -728,8 +790,8 @@ describe RightAMQP::BrokerClient do
 
     it "should return false if the client is not usable" do
       @queue.should_receive(:delete).never
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
-      broker.subscribe({:name => "queue1"}, {:type => :direct, :name => "exchange"})
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      broker.subscribe({:name => "queue1"}, {:type => :direct, :name => "exchange"}) {|_, _|}
       broker.queues.should == [@queue]
       broker.__send__(:update_status, :disconnected)
       broker.delete("queue1").should be_false
@@ -740,8 +802,8 @@ describe RightAMQP::BrokerClient do
       @logger.should_receive(:error).with(/Failed deleting queue/).once
       @exceptions.should_receive(:track).once
       @queue.should_receive(:delete).and_raise(Exception)
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
-      broker.subscribe({:name => "queue1"}, {:type => :direct, :name => "exchange"})
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
+      broker.subscribe({:name => "queue1"}, {:type => :direct, :name => "exchange"}) {|_, _|}
       broker.queues.should == [@queue]
       broker.delete("queue1").should be_false
     end
@@ -755,7 +817,7 @@ describe RightAMQP::BrokerClient do
     end
 
     it "should distinguish whether the client is usable based on whether connecting or connected" do
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.usable?.should be_true
       broker.__send__(:update_status, :ready)
       broker.usable?.should be_true
@@ -767,7 +829,7 @@ describe RightAMQP::BrokerClient do
     end
 
     it "should distinguish whether the client is connected" do
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.connected?.should be_false
       broker.__send__(:update_status, :ready)
       broker.connected?.should be_true
@@ -779,7 +841,7 @@ describe RightAMQP::BrokerClient do
     end
 
     it "should distinguish whether the client has failed" do
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.failed?.should be_false
       broker.__send__(:update_status, :ready)
       broker.failed?.should be_false
@@ -791,7 +853,7 @@ describe RightAMQP::BrokerClient do
     end
  
     it "should give broker summary" do
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.summary.should == {:alias => "b0", :identity => @identity, :status => :connecting,
                                 :disconnects => 0, :failures => 0, :retries => 0}
       broker.__send__(:update_status, :ready)
@@ -804,7 +866,7 @@ describe RightAMQP::BrokerClient do
     end
 
     it "should give broker statistics" do
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.stats.should == {"alias" => "b0", "identity" => "rs-broker-localhost-5672",
                               "status" => "connecting", "disconnects" => nil, "disconnect last" => nil,
                               "failures" => nil, "failure last" => nil, "retries" => nil}
@@ -825,17 +887,17 @@ describe RightAMQP::BrokerClient do
       connected_before = false
       callback = lambda { |b, c| called += 1; b.should == broker; c.should == connected_before }
       options = {:update_status_callback => callback}
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, options)
       broker.__send__(:update_status, :ready)
       broker.last_failed.should be_false
       called.should == 1
       connected_before = true
       broker.__send__(:update_status, :disconnected)
       broker.last_failed.should be_false
-      broker.disconnects.total.should == 1
+      broker.disconnect_stats.total.should == 1
       called.should == 2
       broker.__send__(:update_status, :disconnected)
-      broker.disconnects.total.should == 1
+      broker.disconnect_stats.total.should == 1
       called.should == 2
       @logger.should_receive(:error).with(/Failed to connect to broker b0/).once
       connected_before = false
@@ -854,7 +916,7 @@ describe RightAMQP::BrokerClient do
 
     it "should close broker connection and send status update" do
       @connection.should_receive(:close).and_yield.once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       flexmock(broker).should_receive(:update_status).once
       broker.close
       broker.status.should == :closed
@@ -862,14 +924,14 @@ describe RightAMQP::BrokerClient do
 
     it "should not propagate status update if requested not to" do
       @connection.should_receive(:close).and_yield.once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       flexmock(broker).should_receive(:update_status).never
       broker.close(propagate = false)
     end
 
     it "should set status to :failed if not a normal close" do
       @connection.should_receive(:close).and_yield.once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.close(propagate = false, normal = false)
       broker.status.should == :failed
     end
@@ -878,7 +940,7 @@ describe RightAMQP::BrokerClient do
       @logger.should_receive(:info).with(/Connecting/).once
       @logger.should_receive(:info).with(/Closed connection to broker b0/).once
       @connection.should_receive(:close).and_yield.once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.close
     end
 
@@ -886,13 +948,13 @@ describe RightAMQP::BrokerClient do
       @logger.should_receive(:info).with(/Connecting/).once
       @logger.should_receive(:info).with(/Closed connection to broker b0/).never
       @connection.should_receive(:close).and_yield.once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.close(propagate = true, normal = true, log = false)
     end
 
     it "should close broker connection and execute block if supplied" do
       @connection.should_receive(:close).and_yield.once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       called = 0
       broker.close { called += 1; broker.status.should == :closed }
       called.should == 1
@@ -900,13 +962,13 @@ describe RightAMQP::BrokerClient do
 
     it "should close broker connection when no block supplied" do
       @connection.should_receive(:close).and_yield.once
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.close
     end
 
     it "should not propagate status update if already closed" do
       @connection.should_receive(:close).never
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.__send__(:update_status, :closed)
       flexmock(broker).should_receive(:update_status).never
       broker.close
@@ -915,7 +977,7 @@ describe RightAMQP::BrokerClient do
     it "should change failed status to closed" do
       @logger.should_receive(:error).with(/Failed to connect to broker/).once
       @connection.should_receive(:close).never
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.__send__(:update_status, :failed)
       flexmock(broker).should_receive(:update_status).never
       broker.close
@@ -926,7 +988,7 @@ describe RightAMQP::BrokerClient do
       @logger.should_receive(:error).with(/Failed to close broker b0/).once
       @exceptions.should_receive(:track).once
       @connection.should_receive(:close).and_raise(Exception)
-      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @options)
+      broker = RightAMQP::BrokerClient.new(@identity, @address, @serializer, @exceptions, @non_deliveries, @options)
       broker.close
       broker.status.should == :closed
     end