right_agent 0.13.5 → 0.14.0

data/spec/sender_spec.rb

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2009-2011 RightScale Inc
+# Copyright (c) 2009-2012 RightScale Inc
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -58,7 +58,6 @@ describe RightScale::Sender do
 
   describe "when monitoring broker connectivity" do
     before(:each) do
-      flexmock(EM).should_receive(:next_tick).and_yield.by_default
       @now = Time.at(1000000)
       flexmock(Time).should_receive(:now).and_return(@now).by_default
       @broker = flexmock("Broker", :subscribe => true, :publish => ["broker"], :connected? => true,
@@ -193,7 +192,135 @@ describe RightScale::Sender do
       end
     end
   end
-  
+
+  describe "when validating a target" do
+    before(:each) do
+      @timer = flexmock("timer")
+      flexmock(EM::Timer).should_receive(:new).and_return(@timer)
+      flexmock(Time).should_receive(:now).and_return(Time.at(1000000)).by_default
+      @broker = flexmock("Broker", :subscribe => true, :publish => true).by_default
+      @agent = flexmock("Agent", :identity => "agent", :broker => @broker).by_default
+      @agent.should_receive(:options).and_return({}).by_default
+      RightScale::Sender.new(@agent)
+      @instance = RightScale::Sender.instance
+      @instance.initialize_offline_queue
+    end
+
+    it "should accept nil target" do
+      @instance.__send__(:validate_target, nil, true).should be_true
+    end
+
+    it "should accept named target" do
+      @instance.__send__(:validate_target, "name", true).should be_true
+    end
+
+    describe "and target is a hash" do
+
+      describe "and selector is allowed" do
+
+        it "should accept :all or :any selector" do
+          @instance.__send__(:validate_target, {:selector => :all}, true).should be_true
+          @instance.__send__(:validate_target, {"selector" => "any"}, true).should be_true
+        end
+
+        it "should reject values other than :all or :any" do
+          lambda { @instance.__send__(:validate_target, {:selector => :other}, true) }.
+              should raise_error(ArgumentError, /Invalid target selector/)
+        end
+
+      end
+
+      describe "and selector is not allowed" do
+
+        it "should reject selector" do
+          lambda { @instance.__send__(:validate_target, {:selector => :all}, false) }.
+              should raise_error(ArgumentError, /Invalid target hash/)
+        end
+
+      end
+
+      describe "and tags is specified" do
+
+        it "should accept tags" do
+          @instance.__send__(:validate_target, {:tags => []}, true).should be_true
+          @instance.__send__(:validate_target, {"tags" => ["tag"]}, true).should be_true
+        end
+
+        it "should reject non-array" do
+          lambda { @instance.__send__(:validate_target, {:tags => {}}, true) }.
+              should raise_error(ArgumentError, /Invalid target tags/)
+        end
+
+      end
+
+      describe "and scope is specified" do
+
+        it "should accept account" do
+          @instance.__send__(:validate_target, {:scope => {:account => 1}}, true).should be_true
+          @instance.__send__(:validate_target, {"scope" => {"account" => 1}}, true).should be_true
+        end
+
+        it "should accept shard" do
+          @instance.__send__(:validate_target, {:scope => {:shard => 1}}, true).should be_true
+          @instance.__send__(:validate_target, {"scope" => {"shard" => 1}}, true).should be_true
+        end
+
+        it "should accept account and shard" do
+          @instance.__send__(:validate_target, {"scope" => {:shard => 1, "account" => 1}}, true).should be_true
+        end
+
+        it "should reject keys other than account and shard" do
+          target = {"scope" => {:shard => 1, "account" => 1, :other => 2}}
+          lambda { @instance.__send__(:validate_target, target, true) }.
+              should raise_error(ArgumentError, /Invalid target scope/)
+        end
+
+        it "should reject empty hash" do
+          lambda { @instance.__send__(:validate_target, {:scope => {}}, true) }.
+              should raise_error(ArgumentError, /Invalid target scope/)
+        end
+
+      end
+
+      describe "and multiple are specified" do
+
+        it "should accept scope and tags" do
+          @instance.__send__(:validate_target, {:scope => {:shard => 1}, :tags => []}, true).should be_true
+        end
+
+        it "should accept scope, tags, and selector" do
+          target = {:scope => {:shard => 1}, :tags => ["tag"], :selector => :all}
+          @instance.__send__(:validate_target, target, true).should be_true
+        end
+
+        it "should reject selector if not allowed" do
+          target = {:scope => {:shard => 1}, :tags => ["tag"], :selector => :all}
+          lambda { @instance.__send__(:validate_target, target, false) }.
+              should raise_error(ArgumentError, /Invalid target hash/)
+        end
+
+      end
+
+      it "should reject keys other than selector, scope, and tags" do
+        target = {:scope => {:shard => 1}, :tags => [], :selector => :all, :other => 2}
+        lambda { @instance.__send__(:validate_target, target, true) }.
+            should raise_error(ArgumentError, /Invalid target hash/)
+      end
+
+      it "should reject empty hash" do
+        lambda { @instance.__send__(:validate_target, {}, true) }.
+            should raise_error(ArgumentError, /Invalid target hash/)
+      end
+
+      it "should reject value that is not nil, string, or hash" do
+        lambda { @instance.__send__(:validate_target, [], true) }.
+            should raise_error(ArgumentError, /Invalid target/)
+      end
+
+    end
+
+  end
+
   describe "when making a push request" do
     before(:each) do
       @timer = flexmock("timer")
@@ -209,22 +336,8 @@ describe RightScale::Sender do
 
     it "should validate target" do
       @broker.should_receive(:publish)
-      lambda { @instance.send_push('/foo/bar', nil) }.should be_true
-      lambda { @instance.send_push('/foo/bar', nil, "target") }.should be_true
-      lambda { @instance.send_push('/foo/bar', nil, {}) }.should be_true
-      lambda { @instance.send_push('/foo/bar', nil, :tags => "tags") }.should be_true
-      lambda { @instance.send_push('/foo/bar', nil, "tags" => "tags") }.should be_true
-      lambda { @instance.send_push('/foo/bar', nil, :tags => "tags", :scope => {:shard => 1}) }.should be_true
-      lambda { @instance.send_push('/foo/bar', nil, "scope" => {:shard => 1, "account" => 1}) }.should be_true
-      lambda { @instance.send_push('/foo/bar', nil, :scope => {}) }.should be_true
-      lambda { @instance.send_push('/foo/bar', nil, :selector => :all) }.should be_true
-      lambda { @instance.send_push('/foo/bar', nil, "selector" => "any") }.should be_true
-      lambda { @instance.send_push('/foo/bar', nil, 1) }.should raise_error(ArgumentError)
-      lambda { @instance.send_push('/foo/bar', nil, []) }.should raise_error(ArgumentError)
-      lambda { @instance.send_push('/foo/bar', nil, :bogus => 1) }.should raise_error(ArgumentError)
-      lambda { @instance.send_push('/foo/bar', nil, :scope => 1) }.should raise_error(ArgumentError)
-      lambda { @instance.send_push('/foo/bar', nil, :scope => {:bogus => 1}) }.should raise_error(ArgumentError)
-      lambda { @instance.send_push('/foo/bar', nil, :selector => :bogus) }.should raise_error(ArgumentError)
+      flexmock(@instance).should_receive(:validate_target).with("target", true).once
+      @instance.send_push('/foo/bar', nil, "target").should be_true
     end
 
     it "should create a Push object" do
@@ -283,6 +396,15 @@ describe RightScale::Sender do
       @instance.offline_handler.queue.size.should == 1
     end
 
+    it 'should raise exception if not connected to any brokers and :offline_queueing disabled' do
+      @log.should_receive(:error).with(/Failed to publish request/, RightAMQP::HABrokerClient::NoConnectedBrokers).once
+      @broker.should_receive(:publish).and_raise(RightAMQP::HABrokerClient::NoConnectedBrokers)
+      @agent.should_receive(:options).and_return({:offline_queueing => false})
+      RightScale::Sender.new(@agent)
+      @instance = RightScale::Sender.instance
+      lambda { @instance.send_push('/welcome/aboard', 'iZac') }.should raise_error(RightScale::Sender::TemporarilyOffline)
+    end
+
     it "should store the response handler if given" do
       response_handler = lambda {}
       flexmock(RightScale::AgentIdentity).should_receive(:generate).and_return('abc').once
@@ -313,6 +435,12 @@ describe RightScale::Sender do
       @instance.pending_requests['xyz'].should_not be_nil
       @instance.pending_requests['abc'].should be_nil
     end
+
+    it "should log exceptions and re-raise them" do
+      @log.should_receive(:error).with(/Failed to publish request/, Exception, :trace).once
+      @broker.should_receive(:publish).and_raise(Exception)
+      lambda { @instance.send_push('/welcome/aboard', 'iZac') }.should raise_error(RightScale::Sender::SendFailure)
+    end
   end
 
   describe "when making a send_persistent_push request" do
@@ -380,7 +508,6 @@ describe RightScale::Sender do
     before(:each) do
       @timer = flexmock("timer")
       flexmock(EM::Timer).should_receive(:new).and_return(@timer).by_default
-      flexmock(EM).should_receive(:next_tick).and_yield.by_default
       @broker_id = "broker"
       @broker_ids = [@broker_id]
       @broker = flexmock("Broker", :subscribe => true, :publish => @broker_ids, :connected? => true,
@@ -394,33 +521,15 @@ describe RightScale::Sender do
 
     it "should validate target" do
       @broker.should_receive(:publish)
-      lambda { @instance.send_retryable_request('/foo/bar', nil) }.should be_true
-      lambda { @instance.send_retryable_request('/foo/bar', nil, "target") }.should be_true
-      lambda { @instance.send_retryable_request('/foo/bar', nil, {}) }.should be_true
-      lambda { @instance.send_retryable_request('/foo/bar', nil, :tags => "tags") }.should be_true
-      lambda { @instance.send_retryable_request('/foo/bar', nil, "tags" => "tags") }.should be_true
-      lambda { @instance.send_retryable_request('/foo/bar', nil, :tags => "tags", :scope => {:shard => 1}) }.should be_true
-      lambda { @instance.send_retryable_request('/foo/bar', nil, "scope" => {:shard => 1, "account" => 1}) }.should be_true
-      lambda { @instance.send_retryable_request('/foo/bar', nil, :scope => {}) }.should be_true
-      lambda { @instance.send_retryable_request('/foo/bar', nil, :selector => :all) }.should raise_error(ArgumentError)
-      lambda { @instance.send_retryable_request('/foo/bar', nil, 1) }.should raise_error(ArgumentError)
-      lambda { @instance.send_retryable_request('/foo/bar', nil, []) }.should raise_error(ArgumentError)
-      lambda { @instance.send_retryable_request('/foo/bar', nil, :bogus => 1) }.should raise_error(ArgumentError)
-      lambda { @instance.send_retryable_request('/foo/bar', nil, :scope => 1) }.should raise_error(ArgumentError)
-      lambda { @instance.send_retryable_request('/foo/bar', nil, :scope => {:bogus => 1}) }.should raise_error(ArgumentError)
-      lambda { @instance.send_retryable_request('/foo/bar', nil, :selector => :bogus) }.should raise_error(ArgumentError)
+      flexmock(@instance).should_receive(:validate_target).with("target", false).once
+      @instance.send_retryable_request('/foo/bar', nil, "target") {_}.should be_true
     end
 
     it "should create a Request object" do
       @broker.should_receive(:publish).with(hsh(:name => "request"), on do |request|
         request.class.should == RightScale::Request
       end, hsh(:persistent => false, :mandatory => true)).once
-      @instance.send_retryable_request('/welcome/aboard', 'iZac') {|response|}
-    end
-
-    it "should process request in next tick to preserve pending request data integrity" do
-      flexmock(EM).should_receive(:next_tick).and_yield.once
-      @instance.send_retryable_request('/welcome/aboard', 'iZac') {|response|}
+      @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_|}
     end
 
     it "should set correct attributes on the request message" do
@@ -433,7 +542,7 @@ describe RightScale::Sender do
         request.target.should be_nil
         request.expires_at.should == 1000100
       end, hsh(:persistent => false, :mandatory => true)).once
-      @instance.send_retryable_request('/welcome/aboard', 'iZac') {|response|}
+      @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_|}
     end
 
     it "should disable time-to-live if disabled in configuration" do
@@ -445,14 +554,14 @@ describe RightScale::Sender do
       @broker.should_receive(:publish).with(hsh(:name => "request"), on do |request|
         request.expires_at.should == 0
       end, hsh(:persistent => false, :mandatory => true)).once
-      @instance.send_retryable_request('/welcome/aboard', 'iZac') {|response|}
+      @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_|}
     end
 
     it "should set the correct target if specified" do
       @broker.should_receive(:publish).with(hsh(:name => "request"), on do |request|
         request.target.should == 'my-target'
       end, hsh(:persistent => false, :mandatory => true)).once
-      @instance.send_retryable_request('/welcome/aboard', 'iZac', 'my-target') {|response|}
+      @instance.send_retryable_request('/welcome/aboard', 'iZac', 'my-target') {|_|}
     end
 
     it "should set the correct target selectors if specified" do
@@ -461,12 +570,12 @@ describe RightScale::Sender do
         request.selector.should == :any
         request.scope.should == {:account => 123}
       end, hsh(:persistent => false, :mandatory => true)).once
-      @instance.send_retryable_request('/welcome/aboard', 'iZac', :tags => ['tag'], :scope => {:account => 123})
+      @instance.send_retryable_request('/welcome/aboard', 'iZac', :tags => ['tag'], :scope => {:account => 123}) {|_|}
     end
 
     it "should set up for retrying the request if necessary by default" do
       flexmock(@instance).should_receive(:publish_with_timeout_retry).once
-      @instance.send_retryable_request('/welcome/aboard', 'iZac', 'my-target') {|response|}
+      @instance.send_retryable_request('/welcome/aboard', 'iZac', 'my-target') {|_|}
     end
 
     it "should store the response handler" do
@@ -480,7 +589,7 @@ describe RightScale::Sender do
       flexmock(RightScale::AgentIdentity).should_receive(:generate).and_return('abc').once
       flexmock(Time).should_receive(:now).and_return(Time.at(1000000)).by_default
       @instance.pending_requests.kind(RightScale::Sender::PendingRequests::REQUEST_KINDS).youngest_age.should be_nil
-      @instance.send_retryable_request('/welcome/aboard', 'iZac')
+      @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_|}
       @instance.pending_requests['abc'].receive_time.should == Time.at(1000000)
       flexmock(Time).should_receive(:now).and_return(Time.at(1000100))
       @instance.pending_requests.kind(RightScale::Sender::PendingRequests::REQUEST_KINDS).youngest_age.should == 100
@@ -494,17 +603,40 @@ describe RightScale::Sender do
       @broker.should_receive(:publish).never
       @instance.enable_offline_mode
       @instance.offline_handler.mode.should == :offline
-      @instance.send_retryable_request('/welcome/aboard', 'iZac')
+      @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_|}
       @instance.offline_handler.queue.size.should == 1
     end
 
+    it 'should raise exception if not connected to any brokers and :offline_queueing disabled' do
+      @log.should_receive(:error).with(/Failed to publish request/, RightAMQP::HABrokerClient::NoConnectedBrokers).once
+      @broker.should_receive(:publish).and_raise(RightAMQP::HABrokerClient::NoConnectedBrokers)
+      @agent.should_receive(:options).and_return({:offline_queueing => false})
+      RightScale::Sender.new(@agent)
+      @instance = RightScale::Sender.instance
+      lambda { @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_|} }.should raise_error(RightScale::Sender::TemporarilyOffline)
+    end
+
     it "should dump the pending requests" do
       flexmock(RightScale::AgentIdentity).should_receive(:generate).and_return('abc').once
       flexmock(Time).should_receive(:now).and_return(Time.at(1000000))
-      @instance.send_retryable_request('/welcome/aboard', 'iZac')
+      @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_|}
       @instance.dump_requests.should == ["#{Time.at(1000000).localtime} <abc>"]
     end
 
+    it "should not allow a selector target" do
+      lambda { @instance.send_retryable_request('/welcome/aboard', 'iZac', :selector => :all) }.should raise_error(ArgumentError)
+    end
+
+    it "should raise error if there is no callback block" do
+      lambda { @instance.send_retryable_request('/welcome/aboard', 'iZac') }.should raise_error(ArgumentError)
+    end
+
+    it "should log exceptions and re-raise them" do
+      @log.should_receive(:error).with(/Failed to publish request/, Exception, :trace).once
+      @broker.should_receive(:publish).and_raise(Exception)
+      lambda { @instance.send_retryable_request('/welcome/aboard', 'iZac') {|r|} }.should raise_error(RightScale::Sender::SendFailure)
+    end
+
     describe "with retry" do
       it "should not setup for retry if retry_timeout nil" do
         flexmock(EM).should_receive(:add_timer).never
@@ -512,7 +644,7 @@ describe RightScale::Sender do
         RightScale::Sender.new(@agent)
         @instance = RightScale::Sender.instance
         @broker.should_receive(:publish).once
-        @instance.send_retryable_request('/welcome/aboard', 'iZac') {|response|}
+        @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_|}
       end
 
       it "should not setup for retry if retry_interval nil" do
@@ -521,7 +653,7 @@ describe RightScale::Sender do
         RightScale::Sender.new(@agent)
         @instance = RightScale::Sender.instance
         @broker.should_receive(:publish).once
-        @instance.send_retryable_request('/welcome/aboard', 'iZac') {|response|}
+        @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_|}
       end
 
       it "should not setup for retry if publish failed" do
@@ -530,7 +662,7 @@ describe RightScale::Sender do
         RightScale::Sender.new(@agent)
         @instance = RightScale::Sender.instance
         @broker.should_receive(:publish).and_return([]).once
-        @instance.send_retryable_request('/welcome/aboard', 'iZac') {|response|}
+        @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_|}
       end
 
       it "should setup for retry if retry_timeout and retry_interval not nil and publish successful" do
@@ -539,7 +671,7 @@ describe RightScale::Sender do
         RightScale::Sender.new(@agent)
         @instance = RightScale::Sender.instance
         @broker.should_receive(:publish).and_return(@broker_ids).once
-        @instance.send_retryable_request('/welcome/aboard', 'iZac') {|response|}
+        @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_|}
       end
 
       it "should adjust retry interval by recent request duration" do
@@ -559,12 +691,10 @@ describe RightScale::Sender do
           @instance.send_retryable_request('/welcome/aboard', 'iZac') do |response|
             result = RightScale::OperationResult.from_results(response)
           end
-          header = flexmock("amqp header")
-          header.should_receive(:ack).once
           EM.add_timer(0.15) do
             @instance.pending_requests.empty?.should be_false
             result = RightScale::Result.new(token, nil, {'from' => RightScale::OperationResult.success}, nil)
-            @instance.handle_response(result, header)
+            @instance.handle_response(result)
           end
           EM.add_timer(0.3) do
             EM.stop
@@ -609,7 +739,7 @@ describe RightScale::Sender do
           @broker.should_receive(:publish).with(hsh(:name => "request"), on do |request|
             request.expires_at.should == (expires_at ||= request.expires_at)
           end, hsh(:persistent => false, :mandatory => true)).and_return(@broker_ids).twice
-          @instance.send_retryable_request('/welcome/aboard', 'iZac') {|response|}
+          @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_|}
           EM.add_timer(0.2) { EM.stop }
         end
       end
@@ -675,7 +805,6 @@ describe RightScale::Sender do
     before(:each) do
       @timer = flexmock("timer")
       flexmock(EM::Timer).should_receive(:new).and_return(@timer).by_default
-      flexmock(EM).should_receive(:next_tick).and_yield.by_default
       @broker_id = "broker"
       @broker_ids = [@broker_id]
       @broker = flexmock("Broker", :subscribe => true, :publish => @broker_ids, :connected? => true,
@@ -691,7 +820,7 @@ describe RightScale::Sender do
       @broker.should_receive(:publish).with(hsh(:name => "request"), on do |request|
         request.class.should == RightScale::Request
       end, hsh(:persistent => true, :mandatory => true)).once
-      @instance.send_persistent_request('/welcome/aboard', 'iZac') {|response|}
+      @instance.send_persistent_request('/welcome/aboard', 'iZac') {|_|}
     end
 
     it "should set correct attributes on the request message" do
@@ -704,14 +833,14 @@ describe RightScale::Sender do
         request.target.should be_nil
         request.expires_at.should == 0
       end, hsh(:persistent => true, :mandatory => true)).once
-      @instance.send_persistent_request('/welcome/aboard', 'iZac') {|response|}
+      @instance.send_persistent_request('/welcome/aboard', 'iZac') {|_|}
     end
 
     it "should set the correct target if specified" do
       @broker.should_receive(:publish).with(hsh(:name => "request"), on do |request|
         request.target.should == 'my-target'
       end, hsh(:persistent => true, :mandatory => true)).once
-      @instance.send_persistent_request('/welcome/aboard', 'iZac', 'my-target') {|response|}
+      @instance.send_persistent_request('/welcome/aboard', 'iZac', 'my-target') {|_|}
     end
 
     it "should set the correct target selectors if specified" do
@@ -720,18 +849,25 @@ describe RightScale::Sender do
         request.selector.should == :any
         request.scope.should == {:account => 123}
       end, hsh(:persistent => true, :mandatory => true)).once
-      @instance.send_persistent_request('/welcome/aboard', 'iZac', :tags => ['tag'], :scope => {:account => 123})
+      @instance.send_persistent_request('/welcome/aboard', 'iZac', :tags => ['tag'], :scope => {:account => 123}) {|_|}
     end
 
     it "should not set up for retrying the request" do
       flexmock(@instance).should_receive(:publish_with_timeout_retry).never
-      @instance.send_persistent_request('/welcome/aboard', 'iZac', 'my-target') {|response|}
+      @instance.send_persistent_request('/welcome/aboard', 'iZac', 'my-target') {|_|}
+    end
+
+    it "should not allow a selector target" do
+      lambda { @instance.send_retryable_request('/welcome/aboard', 'iZac', :selector => :all) }.should raise_error(ArgumentError)
+    end
+
+    it "should raise error if there is no callback block" do
+      lambda { @instance.send_persistent_request('/welcome/aboard', 'iZac') }.should raise_error(ArgumentError)
     end
   end
 
   describe "when handling a response" do
     before(:each) do
-      flexmock(EM).should_receive(:next_tick).and_yield.by_default
       flexmock(EM).should_receive(:defer).and_yield.by_default
       @broker = flexmock("Broker", :subscribe => true, :publish => ["broker"], :connected? => true,
                          :identity_parts => ["host", 123, 0, 0]).by_default
@@ -739,92 +875,61 @@ describe RightScale::Sender do
       RightScale::Sender.new(@agent)
       @instance = RightScale::Sender.instance
       flexmock(RightScale::AgentIdentity, :generate => 'token1')
-      @header = flexmock("amqp header")
     end
 
     it "should deliver the response for a Request" do
       @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_|}
       response = RightScale::Result.new('token1', 'to', RightScale::OperationResult.success, 'target1')
-      flexmock(@instance).should_receive(:deliver).with(response, RightScale::Sender::PendingRequest, @header).once
-      @instance.handle_response(response, @header)
+      flexmock(@instance).should_receive(:deliver).with(response, RightScale::Sender::PendingRequest).once
+      @instance.handle_response(response)
     end
 
     it "should deliver the response for a Push" do
       @instance.send_push('/welcome/aboard', 'iZac') {|_|}
       response = RightScale::Result.new('token1', 'to', RightScale::OperationResult.success, 'target1')
-      flexmock(@instance).should_receive(:deliver).with(response, RightScale::Sender::PendingRequest, @header).once
-      @instance.handle_response(response, @header)
+      flexmock(@instance).should_receive(:deliver).with(response, RightScale::Sender::PendingRequest).once
+      @instance.handle_response(response)
     end
 
     it "should not deliver TARGET_NOT_CONNECTED and TTL_EXPIRATION responses for send_retryable_request" do
-      @header.should_receive(:ack).twice
       @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_|}
       flexmock(@instance).should_receive(:deliver).never
       non_delivery = RightScale::OperationResult.non_delivery(RightScale::OperationResult::TARGET_NOT_CONNECTED)
       response = RightScale::Result.new('token1', 'to', non_delivery, 'target1')
-      @instance.handle_response(response, @header)
+      @instance.handle_response(response)
       non_delivery = RightScale::OperationResult.non_delivery(RightScale::OperationResult::TTL_EXPIRATION)
       response = RightScale::Result.new('token1', 'to', non_delivery, 'target1')
-      @instance.handle_response(response, @header)
+      @instance.handle_response(response)
     end
 
     it "should record non-delivery regardless of whether there is a response handler" do
-      @header.should_receive(:ack).once
       @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_|}
       non_delivery = RightScale::OperationResult.non_delivery(RightScale::OperationResult::NO_ROUTE_TO_TARGET)
       response = RightScale::Result.new('token1', 'to', non_delivery, 'target1')
-      @instance.handle_response(response, @header)
+      @instance.handle_response(response)
       @instance.instance_variable_get(:@non_delivery_stats).total.should == 1
     end
 
     it "should log non-delivery if there is no response handler" do
-      @header.should_receive(:ack).once
       @log.should_receive(:info).with(/Non-delivery of/).once
       @instance.send_push('/welcome/aboard', 'iZac')
       non_delivery = RightScale::OperationResult.non_delivery(RightScale::OperationResult::NO_ROUTE_TO_TARGET)
       response = RightScale::Result.new('token1', 'to', non_delivery, 'target1')
-      @instance.handle_response(response, @header)
+      @instance.handle_response(response)
     end
 
     it "should log a debug message if request no longer pending" do
-      @header.should_receive(:ack).once
       @log.should_receive(:debug).with(/No pending request for response/).once
       @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_|}
       @instance.pending_requests['token1'].should_not be_nil
       @instance.pending_requests['token2'].should be_nil
       response = RightScale::Result.new('token2', 'to', RightScale::OperationResult.success, 'target1')
-      @instance.handle_response(response, @header)
-    end
-
-    it "should ack response even if fail while handling it" do
-      @header.should_receive(:ack).once
-      @instance.send_push('/welcome/aboard', 'iZac') {|_|}
-      response = RightScale::Result.new('token1', 'to', RightScale::OperationResult.success, 'target1')
-      flexmock(response).should_receive(:token).and_raise(Exception).once
-      flexmock(@instance).should_receive(:deliver).never
-      lambda { @instance.handle_response(response, @header) }.should raise_error(Exception)
-    end
-
-    it "should not attempt to ack response if fail while handling it and there is no header" do
-      @instance.send_push('/welcome/aboard', 'iZac') {|_|}
-      response = RightScale::Result.new('token1', 'to', RightScale::OperationResult.success, 'target1')
-      exception = Exception.new("test")
-      flexmock(response).should_receive(:token).and_raise(exception).once
-      flexmock(@instance).should_receive(:deliver).never
-      lambda { @instance.handle_response(response, nil) }.should raise_error(Exception, "test")
-    end
-
-    it "should not attempt to ack response if there is no header" do
-      @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_|}
-      response = RightScale::Result.new('token1', 'to', RightScale::OperationResult.success, 'target1')
-      flexmock(@instance).should_receive(:deliver).with(response, RightScale::Sender::PendingRequest, nil).once
       @instance.handle_response(response)
     end
   end
 
   describe "when delivering a response" do
     before(:each) do
-      flexmock(EM).should_receive(:next_tick).and_yield.by_default
       flexmock(EM).should_receive(:defer).and_yield.by_default
       @broker = flexmock("Broker", :subscribe => true, :publish => ["broker"], :connected? => true,
                          :identity_parts => ["host", 123, 0, 0]).by_default
@@ -832,15 +937,13 @@ describe RightScale::Sender do
       RightScale::Sender.new(@agent)
       @instance = RightScale::Sender.instance
       flexmock(RightScale::AgentIdentity, :generate => 'token1')
-      @header = flexmock("amqp header")
-      @header.should_receive(:ack).once.by_default
     end
 
     it "should delete all associated pending Request requests" do
       @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_|}
       @instance.pending_requests['token1'].should_not be_nil
       response = RightScale::Result.new('token1', 'to', RightScale::OperationResult.success, 'target1')
-      @instance.handle_response(response, @header)
+      @instance.handle_response(response)
       @instance.pending_requests['token1'].should be_nil
     end
 
@@ -848,7 +951,7 @@ describe RightScale::Sender do
       @instance.send_push('/welcome/aboard', 'iZac') {|_|}
       @instance.pending_requests['token1'].should_not be_nil
       response = RightScale::Result.new('token1', 'to', RightScale::OperationResult.success, 'target1')
-      @instance.handle_response(response, @header)
+      @instance.handle_response(response)
       @instance.pending_requests['token1'].should_not be_nil
     end
 
@@ -858,7 +961,7 @@ describe RightScale::Sender do
       @instance.pending_requests['token2'] = @instance.pending_requests['token1'].dup
       @instance.pending_requests['token2'].retry_parent = 'token1'
       response = RightScale::Result.new('token2', 'to', RightScale::OperationResult.success, 'target1')
-      @instance.handle_response(response, @header)
+      @instance.handle_response(response)
       @instance.pending_requests['token1'].should be_nil
       @instance.pending_requests['token2'].should be_nil
     end
@@ -867,67 +970,8 @@ describe RightScale::Sender do
       called = 0
       @instance.send_retryable_request('/welcome/aboard', 'iZac') {|response| called += 1}
       response = RightScale::Result.new('token1', 'to', RightScale::OperationResult.success, 'target1')
-      @instance.handle_response(response, @header)
-      called.should == 1
-    end
-
-    it "should defer the response handler call if not single threaded" do
-      @agent.should_receive(:options).and_return({:single_threaded => false})
-      RightScale::Sender.new(@agent)
-      @instance = RightScale::Sender.instance
-      called = 0
-      @instance.send_retryable_request('/welcome/aboard', 'iZac') {|response| called += 1}
-      response = RightScale::Result.new('token1', 'to', RightScale::OperationResult.success, 'target1')
-      flexmock(EM).should_receive(:defer).and_yield.once
-      flexmock(EM).should_receive(:next_tick).never
-      @instance.handle_response(response, @header)
-      called.should == 1
-    end
-
-    it "should not defer the response handler call if single threaded" do
-      @agent.should_receive(:options).and_return({:single_threaded => true})
-      RightScale::Sender.new(@agent)
-      @instance = RightScale::Sender.instance
-      called = 0
-      @instance.send_retryable_request('/welcome/aboard', 'iZac') {|response| called += 1}
-      response = RightScale::Result.new('token1', 'to', RightScale::OperationResult.success, 'target1')
-      flexmock(EM).should_receive(:next_tick).and_yield.once
-      flexmock(EM).should_receive(:defer).never
-      @instance.handle_response(response, @header)
-      called.should == 1
-    end
-
-    it "should log an error if the response handler raises an exception but still delete pending request" do
-      @agent.should_receive(:options).and_return({:single_threaded => true})
-      @log.should_receive(:error).with(/Failed processing response/, Exception, :trace).once
-      @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_| raise Exception}
-      @instance.pending_requests['token1'].should_not be_nil
-      response = RightScale::Result.new('token1', 'to', RightScale::OperationResult.success, 'target1')
-      @instance.handle_response(response, @header)
-      @instance.pending_requests['token1'].should be_nil
-    end
-
-    it "should ack response even if fail while delivering it" do
-      flexmock(EM).should_receive(:defer).and_raise(Exception).once
-      @instance.send_push('/welcome/aboard', 'iZac') {|_|}
-      response = RightScale::Result.new('token1', 'to', RightScale::OperationResult.success, 'target1')
-      lambda { @instance.handle_response(response, @header) }.should raise_error(Exception)
-    end
-
-    it "should not attempt to ack response if fail while delivering it and there is no header" do
-      @header.should_receive(:ack).never
-      exception = Exception.new("test")
-      flexmock(EM).should_receive(:defer).and_raise(exception).once
-      @instance.send_push('/welcome/aboard', 'iZac') {|_|}
-      response = RightScale::Result.new('token1', 'to', RightScale::OperationResult.success, 'target1')
-      lambda { @instance.handle_response(response, nil) }.should raise_error(Exception, "test")
-    end
-
-    it "should not attempt to ack response if there is no header" do
-      @header.should_receive(:ack).never
-      @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_|}
-      response = RightScale::Result.new('token1', 'to', RightScale::OperationResult.success, 'target1')
       @instance.handle_response(response)
+      called.should == 1
     end
   end