right_agent 1.0.1 → 2.0.7

data/spec/{idempotent_request_spec.rb → retryable_request_spec.rb}

@@ -22,7 +22,7 @@
 
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
-describe RightScale::IdempotentRequest do
+describe RightScale::RetryableRequest do
 
   module RightScale
     class SenderMock
@@ -47,37 +47,37 @@ describe RightScale::IdempotentRequest do
 
     context 'when :targets => nil' do
       it 'should send target-less requests' do
-        request = RightScale::IdempotentRequest.new('type', 'payload')
-        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+        request = RightScale::RetryableRequest.new('type', 'payload')
+        flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', nil, Proc).
             and_yield(RightScale::OperationResult.non_delivery('test')).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_RETRY_DELAY, Proc).once
         request.run
       end
     end
 
     context 'when one target is specified' do
       it 'should send a targeted request' do
-        request = RightScale::IdempotentRequest.new('type', 'payload', :targets => [1])
-        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', 1, Proc).
+        request = RightScale::RetryableRequest.new('type', 'payload', :targets => ["rs-agent-1-1"])
+        flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', {:agent_id => "rs-agent-1-1"}, Proc).
             and_yield(RightScale::OperationResult.non_delivery('test')).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_RETRY_DELAY, Proc).once
         request.run
       end
     end
 
     context 'when many targets are specified' do
       it 'should choose a random target' do
-        request = RightScale::IdempotentRequest.new('type', 'payload', :targets => [1, 2, 3])
-        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).and_return do |type, payload, tgt, block|
+        request = RightScale::RetryableRequest.new('type', 'payload', :targets => ["rs-agent-1-1", "rs-agent-2-2", "rs-agent-3-3"])
+        flexmock(RightScale::Sender.instance).should_receive(:send_request).and_return do |type, payload, target, block|
           type.should == 'type'
           payload.should == 'payload'
-          [1, 2, 3].should include(tgt)
+          ["rs-agent-1-1", "rs-agent-2-2", "rs-agent-3-3"].should include(target[:agent_id])
           block.call(RightScale::OperationResult.non_delivery('test'))
         end
-        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_RETRY_DELAY, Proc).once
         request.run
       end
     end
@@ -88,44 +88,44 @@ describe RightScale::IdempotentRequest do
 
     context 'when not specified' do
       it 'should fail if receives error response' do
-        request = RightScale::IdempotentRequest.new('type', 'payload')
-        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+        request = RightScale::RetryableRequest.new('type', 'payload')
+        flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', nil, Proc).
             and_yield(RightScale::OperationResult.error('test')).once
         flexmock(request).should_receive(:fail).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
         request.run
       end
     end
     
     context 'when specified as true' do
       it 'should retry if receives error response' do
-        request = RightScale::IdempotentRequest.new('type', 'payload', :retry_on_error => true)
-        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+        request = RightScale::RetryableRequest.new('type', 'payload', :retry_on_error => true)
+        flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', nil, Proc).
             and_yield(RightScale::OperationResult.error('test')).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_RETRY_DELAY, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
         request.run
       end
 
       it 'should ignore duplicate responses' do
-        request = RightScale::IdempotentRequest.new('type', 'payload', :retry_on_error => true)
-        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).and_return do |t, p, tgt, b|
+        request = RightScale::RetryableRequest.new('type', 'payload', :retry_on_error => true)
+        flexmock(RightScale::Sender.instance).should_receive(:send_request).and_return do |t, p, tgt, b|
           5.times { b.call(RightScale::OperationResult.success('test')) }
         end
         flexmock(request).should_receive(:fail).never
         flexmock(request).should_receive(:succeed).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).never
-        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_RETRY_DELAY, Proc).never
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
         request.run
       end
 
       it 'should never retry after cancel response' do
-        request = RightScale::IdempotentRequest.new('type', 'payload', :retry_on_error => true)
+        request = RightScale::RetryableRequest.new('type', 'payload', :retry_on_error => true)
         flexmock(RightScale::Log).should_receive(:info).with("Request type canceled (enough already)").once
-        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+        flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', nil, Proc).
             and_yield(RightScale::OperationResult.cancel('enough already')).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).never
-        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_RETRY_DELAY, Proc).never
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
         request.run
       end
     end
@@ -136,57 +136,57 @@ describe RightScale::IdempotentRequest do
 
     context 'when using default settings' do
       it 'should retry non-delivery responses' do
-        request = RightScale::IdempotentRequest.new('type', 'payload')
+        request = RightScale::RetryableRequest.new('type', 'payload')
         flexmock(RightScale::Log).should_receive(:info).with(/Retrying in 5 seconds/).once
         flexmock(RightScale::Log).should_receive(:info).with("Request non-delivery (test) for type").once
-        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+        flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', nil, Proc).
             and_yield(RightScale::OperationResult.non_delivery('test')).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_RETRY_DELAY, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
         request.run
       end
 
       it 'should retry retry responses' do
-        request = RightScale::IdempotentRequest.new('type', 'payload')
+        request = RightScale::RetryableRequest.new('type', 'payload')
         flexmock(RightScale::Log).should_receive(:info).with(/Retrying in 5 seconds/).once
         flexmock(RightScale::Log).should_receive(:info).with("Request type failed (test) and should be retried").once
-        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+        flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', nil, Proc).
             and_yield(RightScale::OperationResult.retry('test')).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_RETRY_DELAY, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
         request.run
       end
 
       it 'should log default retry reason if none given' do
-        request = RightScale::IdempotentRequest.new('type', 'payload')
+        request = RightScale::RetryableRequest.new('type', 'payload')
         flexmock(RightScale::Log).should_receive(:info).with(/Retrying in 5 seconds/).once
         flexmock(RightScale::Log).should_receive(:info).with("Request type failed (RightScale not ready) and should be retried").once
-        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+        flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', nil, Proc).
             and_yield(RightScale::OperationResult.retry).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_RETRY_DELAY, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
         request.run
       end
 
       it 'should ignore responses that arrive post-cancel' do
-        request = RightScale::IdempotentRequest.new('type', 'payload')
-        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+        request = RightScale::RetryableRequest.new('type', 'payload')
+        flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', nil, Proc).
             and_yield(RightScale::OperationResult.success('test')).once
         flexmock(request).should_receive(:fail).once
         flexmock(request).should_receive(:succeed).never
-        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).never
-        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_RETRY_DELAY, Proc).never
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
         request.cancel('test')
         request.run
       end
 
       it 'should never retry after cancel response' do
-        request = RightScale::IdempotentRequest.new('type', 'payload')
+        request = RightScale::RetryableRequest.new('type', 'payload')
         flexmock(RightScale::Log).should_receive(:info).with("Request type canceled (enough already)").once
-        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+        flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', nil, Proc).
             and_yield(RightScale::OperationResult.cancel('enough already')).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).never
-        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_RETRY_DELAY, Proc).never
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
         request.run
       end
     end
@@ -194,22 +194,22 @@ describe RightScale::IdempotentRequest do
     context 'when a :retry_delay is specified' do
       it 'should control the initial retry delay' do
         retry_delay = 10
-        request = RightScale::IdempotentRequest.new('type', 'payload', :retry_delay => retry_delay)
-        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+        request = RightScale::RetryableRequest.new('type', 'payload', :retry_delay => retry_delay)
+        flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', nil, Proc).
             and_yield(RightScale::OperationResult.retry('test')).once
         flexmock(EM).should_receive(:add_timer).with(retry_delay, Proc).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
         flexmock(EM).should_receive(:next_tick).never
         request.run
       end
 
       it 'should treat -1 as meaning no delay' do
         retry_delay = -1
-        request = RightScale::IdempotentRequest.new('type', 'payload', :retry_delay => retry_delay)
-        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+        request = RightScale::RetryableRequest.new('type', 'payload', :retry_delay => retry_delay)
+        flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', nil, Proc).
             and_yield(RightScale::OperationResult.retry('test')).once
         flexmock(EM).should_receive(:add_timer).with(retry_delay, Proc).never
-        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
         flexmock(EM).should_receive(:next_tick).once
         request.run
       end
@@ -219,14 +219,14 @@ describe RightScale::IdempotentRequest do
       it 'should limit the number of retries using the :retry_delay value' do
         retry_delay = 10
         retry_delay_count = 1
-        backoff_factor = RightScale::IdempotentRequest::RETRY_BACKOFF_FACTOR
-        request = RightScale::IdempotentRequest.new('type', 'payload', :retry_delay => retry_delay,
+        backoff_factor = RightScale::RetryableRequest::RETRY_BACKOFF_FACTOR
+        request = RightScale::RetryableRequest.new('type', 'payload', :retry_delay => retry_delay,
                                                     :retry_delay_count => retry_delay_count)
-        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+        flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', nil, Proc).
             and_yield(RightScale::OperationResult.retry('test')).twice
         flexmock(EM).should_receive(:add_timer).with(retry_delay, Proc).and_yield.once
         flexmock(EM).should_receive(:add_timer).with(retry_delay * backoff_factor, Proc).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
         flexmock(EM).should_receive(:next_tick).never
         request.run
       end
@@ -235,16 +235,16 @@ describe RightScale::IdempotentRequest do
         retry_delay = 10
         retry_delay_count = 2
         max_retry_delay = 30
-        backoff_factor = RightScale::IdempotentRequest::RETRY_BACKOFF_FACTOR
-        request = RightScale::IdempotentRequest.new('type', 'payload', :retry_delay => retry_delay,
+        backoff_factor = RightScale::RetryableRequest::RETRY_BACKOFF_FACTOR
+        request = RightScale::RetryableRequest.new('type', 'payload', :retry_delay => retry_delay,
                                                     :retry_delay_count => retry_delay_count,
                                                     :max_retry_delay => max_retry_delay)
-        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+        flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', nil, Proc).
             and_yield(RightScale::OperationResult.retry('test')).times(4)
         flexmock(EM).should_receive(:add_timer).with(retry_delay, Proc).and_yield.twice
         flexmock(EM).should_receive(:add_timer).with(retry_delay * backoff_factor, Proc).and_yield.once
         flexmock(EM).should_receive(:add_timer).with(max_retry_delay, Proc).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
         flexmock(EM).should_receive(:next_tick).never
         request.run
         request.instance_variable_get(:@retry_delay_count).should == retry_delay_count / 2
@@ -256,16 +256,16 @@ describe RightScale::IdempotentRequest do
         retry_delay = 10
         retry_delay_count = 1
         max_retry_delay = 30
-        backoff_factor = RightScale::IdempotentRequest::RETRY_BACKOFF_FACTOR
-        request = RightScale::IdempotentRequest.new('type', 'payload', :retry_delay => retry_delay,
+        backoff_factor = RightScale::RetryableRequest::RETRY_BACKOFF_FACTOR
+        request = RightScale::RetryableRequest.new('type', 'payload', :retry_delay => retry_delay,
                                                     :retry_delay_count => retry_delay_count,
                                                     :max_retry_delay => max_retry_delay)
-        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+        flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', nil, Proc).
             and_yield(RightScale::OperationResult.retry('test')).times(3)
         flexmock(EM).should_receive(:add_timer).with(retry_delay, Proc).and_yield.once
         flexmock(EM).should_receive(:add_timer).with(retry_delay * backoff_factor, Proc).and_yield.once
         flexmock(EM).should_receive(:add_timer).with(max_retry_delay, Proc).once
-        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_TIMEOUT, Proc).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::RetryableRequest::DEFAULT_TIMEOUT, Proc).once
         flexmock(EM).should_receive(:next_tick).never
         request.run
       end
@@ -276,8 +276,8 @@ describe RightScale::IdempotentRequest do
   context ':timeout option' do
     context 'when disable timeout' do
       it 'should not timeout' do
-        request = RightScale::IdempotentRequest.new('type', 'payload', :timeout => -1)
-        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).once
+        request = RightScale::RetryableRequest.new('type', 'payload', :timeout => -1)
+        flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', nil, Proc).once
         flexmock(EM).should_receive(:add_timer).never
         request.run
       end
@@ -286,17 +286,17 @@ describe RightScale::IdempotentRequest do
     context 'when a timeout is specified' do
       it 'should time the response' do
         timeout = 10
-        request = RightScale::IdempotentRequest.new('type', 'payload', :timeout => timeout)
-        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).once
+        request = RightScale::RetryableRequest.new('type', 'payload', :timeout => timeout)
+        flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', nil, Proc).once
         flexmock(EM).should_receive(:add_timer).with(timeout, Proc).once
         request.run
       end
 
       it 'should log a message when timeout' do
         timeout = 10
-        request = RightScale::IdempotentRequest.new('type', 'payload', :timeout => timeout)
+        request = RightScale::RetryableRequest.new('type', 'payload', :timeout => timeout)
         flexmock(RightScale::Log).should_receive(:info).with("Request type timed out after 10 seconds").once
-        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).once
+        flexmock(RightScale::Sender.instance).should_receive(:send_request).with('type', 'payload', nil, Proc).once
         flexmock(EM).should_receive(:add_timer).with(timeout, Proc).and_yield.once
         request.run
       end

data/spec/sender_spec.rb

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2009-2012 RightScale Inc
+# Copyright (c) 2009-2013 RightScale Inc
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -26,1237 +26,1020 @@ describe RightScale::Sender do
 
   include FlexMock::ArgumentTypes
 
-  before(:each) do
-    @log = flexmock(RightScale::Log)
-    @log.should_receive(:error).by_default.and_return { |m| raise RightScale::Log.format(*m) }
-    @log.should_receive(:warning).by_default.and_return { |m| raise RightScale::Log.format(*m) }
-    @timer = flexmock("timer", :cancel => true).by_default
-  end
-
-  describe "when fetching the instance" do
+  context "access instance" do
     before do
       RightScale::Sender.class_eval do
-        if class_variable_defined?(:@@instance)
-          remove_class_variable(:@@instance) 
-        end
+        remove_class_variable(:@@instance) if class_variable_defined?(:@@instance)
       end
     end
-    
-    it "should return nil when the instance is undefined" do
+
+    it "returns nil when the instance is undefined" do
       RightScale::Sender.instance.should == nil
     end
-    
-    it "should return the instance if defined" do
-      instance = flexmock
-      RightScale::Sender.class_eval do
-        @@instance = "instance"
-      end
-      
+
+    it "returns the instance if defined" do
+      RightScale::Sender.class_eval { @@instance = "instance" }
       RightScale::Sender.instance.should_not == nil
     end
   end
 
-  describe "when monitoring broker connectivity" do
-    before(:each) do
-      @now = Time.at(1000000)
-      flexmock(Time).should_receive(:now).and_return(@now).by_default
-      @broker = flexmock("Broker", :subscribe => true, :publish => ["broker"], :connected? => true,
-                         :identity_parts => ["host", 123, 0, 0]).by_default
-      @agent = flexmock("Agent", :identity => "agent", :broker => @broker, :options => {:ping_interval => 0}).by_default
-    end
-
-    it "should start inactivity timer at initialization time" do
-      @agent.should_receive(:options).and_return(:ping_interval => 1000)
-      flexmock(EM::Timer).should_receive(:new).with(1000, Proc).and_return(@timer).once
-      RightScale::Sender.new(@agent)
-    end
-
-    it "should not start inactivity timer at initialization time if ping disabled" do
-      flexmock(EM::Timer).should_receive(:new).never
-      RightScale::Sender.new(@agent)
-    end
-
-    it "should restart inactivity timer only if sufficient time has elapsed since last restart" do
-      @agent.should_receive(:options).and_return(:ping_interval => 1000)
-      flexmock(EM::Timer).should_receive(:new).with(1000, Proc).and_return(@timer).once
-      instance = RightScale::Sender.new(@agent)
-      flexmock(Time).should_receive(:now).and_return(@now + 61)
-      flexmock(instance.connectivity_checker).should_receive(:restart_inactivity_timer).once
-      instance.message_received
-      instance.message_received
-    end
-
-    it "should check connectivity if the inactivity timer times out" do
-      @agent.should_receive(:options).and_return(:ping_interval => 1000)
-      flexmock(EM::Timer).should_receive(:new).and_return(@timer).once.by_default
-      RightScale::Sender.new(@agent)
-      instance = RightScale::Sender.instance
-      flexmock(Time).should_receive(:now).and_return(@now + 61)
-      flexmock(EM::Timer).should_receive(:new).and_return(@timer).and_yield.once
-      flexmock(instance.connectivity_checker).should_receive(:check).once
-      instance.message_received
-    end
-
-    it "should check connectivity by sending mapper ping" do
-      @agent.should_receive(:options).and_return(:ping_interval => 1000)
-      flexmock(EM::Timer).should_receive(:new).and_return(@timer).twice
-      RightScale::Sender.new(@agent)
-      instance = RightScale::Sender.instance
-      broker_id = "rs-broker-1-1"
-      flexmock(instance).should_receive(:publish).with(on do |request|
-        request.type.should == "/mapper/ping";
-        request.from.should == "agent"
-      end, [broker_id]).and_return([broker_id]).once
-      instance.connectivity_checker.check(broker_id)
-      instance.pending_requests.size.should == 1
-    end
-
-    it "should not check connectivity if terminating" do
-      @agent.should_receive(:options).and_return(:ping_interval => 1000)
-      flexmock(EM::Timer).should_receive(:new).and_return(@timer).once
-      RightScale::Sender.new(@agent)
-      instance = RightScale::Sender.instance
-      flexmock(instance).should_receive(:publish).never
-      instance.terminate
-      instance.connectivity_checker.check
-    end
-
-    it "should not check connectivity if not connected to broker" do
-      @agent.should_receive(:options).and_return(:ping_interval => 1000)
-      flexmock(EM::Timer).should_receive(:new).and_return(@timer).once
-      RightScale::Sender.new(@agent)
-      broker_id = "rs-broker-1-1"
-      @broker.should_receive(:connected?).with(broker_id).and_return(false)
-      instance = RightScale::Sender.instance
-      flexmock(instance).should_receive(:publish).never
-      instance.connectivity_checker.check(broker_id)
-    end
-
-    it "should ignore ping timeout if never successfully publish ping" do
-      @agent.should_receive(:options).and_return(:ping_interval => 1000)
-      old_ping_timeout = RightScale::Sender::ConnectivityChecker::PING_TIMEOUT
-      begin
-        RightScale::Sender::ConnectivityChecker.const_set(:PING_TIMEOUT, 0.5)
-        EM.run do
-          EM.add_timer(1) { EM.stop }
-          RightScale::Sender.new(@agent)
-          @instance = RightScale::Sender.instance
-          flexmock(@instance).should_receive(:publish).and_return([]).once
-          @instance.connectivity_checker.check(id = nil)
-        end
-      ensure
-        RightScale::Sender::ConnectivityChecker.const_set(:PING_TIMEOUT, old_ping_timeout)
-        @instance.connectivity_checker.instance_variable_get(:@ping_timer).should be_nil
-        @instance.connectivity_checker.instance_variable_get(:@ping_id).should be_nil
-      end
-    end
-
-    it "should ignore messages received if ping disabled" do
-      @agent.should_receive(:options).and_return(:ping_interval => 0)
-      flexmock(EM::Timer).should_receive(:new).never
-      RightScale::Sender.new(@agent)
-      RightScale::Sender.instance.message_received
-    end
-
-    it "should log an exception if the connectivity check fails" do
-      @log.should_receive(:error).with(/Failed connectivity check/, Exception, :trace).once
-      @agent.should_receive(:options).and_return(:ping_interval => 1000)
-      flexmock(EM::Timer).should_receive(:new).and_return(@timer).once.by_default
+  context "use instance" do
+    # Create new sender with specified mode and options
+    # Also create mock agent and client for it with basic support for both modes
+    def create_sender(mode, options = {})
+      @broker_id = "rs-broker-1-1"
+      @broker_ids = [@broker_id]
+      @client = flexmock("client", :push => true, :request => true, :all => @broker_ids, :publish => @broker_ids).by_default
+      @agent_id = "rs-agent-1-1"
+      @agent = flexmock("agent", :identity => @agent_id, :client => @client, :mode => mode, :request_queue => "request",
+                        :options => options).by_default
       RightScale::Sender.new(@agent)
-      instance = RightScale::Sender.instance
-      flexmock(Time).should_receive(:now).and_return(@now + 61)
-      flexmock(EM::Timer).should_receive(:new).and_return(@timer).and_yield.once
-      flexmock(instance.connectivity_checker).should_receive(:check).and_raise(Exception)
-      instance.message_received
+      RightScale::Sender.instance
     end
 
-    it "should attempt to reconnect if mapper ping times out" do
-      @log.should_receive(:error).with(/Mapper ping via broker/).once
-      @agent.should_receive(:options).and_return(:ping_interval => 1000)
-      broker_id = "rs-broker-localhost-5672"
-      @broker.should_receive(:identity_parts).with(broker_id).and_return(["localhost", 5672, 0, 0]).once
-      @agent.should_receive(:connect).with("localhost", 5672, 0, 0, true).once
-      old_ping_timeout = RightScale::Sender::ConnectivityChecker::PING_TIMEOUT
-      old_max_ping_timeouts = RightScale::Sender::ConnectivityChecker::MAX_PING_TIMEOUTS
-      begin
-        RightScale::Sender::ConnectivityChecker.const_set(:PING_TIMEOUT, 0.5)
-        RightScale::Sender::ConnectivityChecker.const_set(:MAX_PING_TIMEOUTS, 1)
-        EM.run do
-          EM.add_timer(1) { EM.stop }
-          RightScale::Sender.new(@agent)
-          instance = RightScale::Sender.instance
-          flexmock(instance).should_receive(:publish).with(RightScale::Request, nil).and_return([broker_id])
-          instance.connectivity_checker.check
-        end
-      ensure
-        RightScale::Sender::ConnectivityChecker.const_set(:PING_TIMEOUT, old_ping_timeout)
-        RightScale::Sender::ConnectivityChecker.const_set(:MAX_PING_TIMEOUTS, old_max_ping_timeouts)
-      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
+      @log = flexmock(RightScale::Log)
+      @log.should_receive(:error).by_default.and_return { |m| raise RightScale::Log.format(*m) }
+      @log.should_receive(:warning).by_default.and_return { |m| raise RightScale::Log.format(*m) }
+      @sender = create_sender(:http)
+      @token = "token"
+      @type = "/foo/bar"
+      @action = "bar"
+      @payload = {:pay => "load"}
+      @target = "target"
+      @callback = lambda { |_| }
+    end
+
+    context :initialize do
+      it "creates connectivity checker if mode is amqp" do
+        @sender = create_sender(:amqp)
+        @sender.connectivity_checker.should be_a(RightScale::ConnectivityChecker)
+      end
     end
 
-    describe "and target is a hash" do
-
-      describe "and selector is allowed" do
+    context "offline handling" 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
+      context :initialize_offline_queue do
+        it "initializes offline handler" do
+          @sender = create_sender(:amqp, :offline_queueing => true)
+          flexmock(@sender.offline_handler).should_receive(:init).once
+          @sender.initialize_offline_queue
         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/)
+        it "does nothing if offline queueing is disabled" do
+          flexmock(@sender.offline_handler).should_receive(:init).never
+          @sender.initialize_offline_queue
         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/)
+      context :start_offline_queue do
+        it "starts offline handler" do
+          @sender = create_sender(:amqp, :offline_queueing => true)
+          flexmock(@sender.offline_handler).should_receive(:start).once
+          @sender.start_offline_queue
         end
 
+        it "does nothing if offline queueing is disabled" do
+          flexmock(@sender.offline_handler).should_receive(:start).never
+          @sender.start_offline_queue
+        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
+      context :enable_offline_mode do
+       it "enables offline handler" do
+          @sender = create_sender(:amqp, :offline_queueing => true)
+          flexmock(@sender.offline_handler).should_receive(:enable).once
+          @sender.enable_offline_mode
         end
 
-        it "should reject non-array" do
-          lambda { @instance.__send__(:validate_target, {:tags => {}}, true) }.
-              should raise_error(ArgumentError, /Invalid target tags/)
+        it "does nothing if offline queueing is disabled" do
+          flexmock(@sender.offline_handler).should_receive(:enable).never
+          @sender.enable_offline_mode
         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
+      context :disable_offline_mode do
+        it "initializes offline handler" do
+          @sender = create_sender(:amqp, :offline_queueing => true)
+          flexmock(@sender.offline_handler).should_receive(:disable).once
+          @sender.disable_offline_mode
         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
+        it "does nothing if offline queueing is disabled" do
+          flexmock(@sender.offline_handler).should_receive(:disable).never
+          @sender.disable_offline_mode
         end
+      end
+    end
 
-        it "should accept account and shard" do
-          @instance.__send__(:validate_target, {"scope" => {:shard => 1, "account" => 1}}, true).should be_true
-        end
+    context :send_push do
+      it "creates Push object" do
+        flexmock(RightSupport::Data::UUID, :generate => "random token")
+        flexmock(@sender).should_receive(:http_send).with(:send_push, nil, on { |a| a.class == RightScale::Push &&
+            a.type == @type && a.from == @agent_id && a.target.nil? && a.persistent == true && a.confirm.nil? &&
+            a.token == "random token" && a.expires_at == 0 }, Time, nil).once
+        @sender.send_push(@type).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 "stores payload" do
+        flexmock(@sender).should_receive(:http_send).with(:send_push, nil, on { |a| a.payload == @payload }, Time, nil).once
+        @sender.send_push(@type, @payload).should be_true
+      end
 
-        it "should reject empty hash" do
-          lambda { @instance.__send__(:validate_target, {:scope => {}}, true) }.
-              should raise_error(ArgumentError, /Invalid target scope/)
-        end
+      it "sets specific target using string" do
+        flexmock(@sender).should_receive(:http_send).with(:send_push, @target, on { |a| a.target == @target &&
+            a.selector == :any }, Time, nil).once
+        @sender.send_push(@type, nil, @target).should be_true
+      end
 
+      it "sets specific target using :agent_id" do
+        target = {:agent_id => @agent_id}
+        flexmock(@sender).should_receive(:http_send).with(:send_push, target, on { |a| a.target == @agent_id }, Time, nil).once
+        @sender.send_push(@type, nil, target).should be_true
       end
 
-      describe "and multiple are specified" do
+      it "sets target tags" do
+        tags = ["a:b=c"]
+        target = {:tags => tags}
+        flexmock(@sender).should_receive(:http_send).with(:send_push, target, on { |a| a.tags == tags &&
+            a.selector == :any }, Time, nil).once
+        @sender.send_push(@type, nil, target).should be_true
+      end
 
-        it "should accept scope and tags" do
-          @instance.__send__(:validate_target, {:scope => {:shard => 1}, :tags => []}, true).should be_true
-        end
+      it "sets target scope" do
+        scope = {:shard => 1, :account => 123}
+        target = {:scope => scope}
+        flexmock(@sender).should_receive(:http_send).with(:send_push, target, on { |a| a.scope == scope &&
+            a.selector == :any }, Time, nil).once
+        @sender.send_push(@type, nil, target).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 "sets target selector" do
+        tags = ["a:b=c"]
+        target = {:tags => tags, :selector => :all}
+        flexmock(@sender).should_receive(:http_send).with(:send_push, target, on { |a| a.selector == :all }, Time, nil).once
+        @sender.send_push(@type, nil, target).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
+      it "sets token" do
+        flexmock(@sender).should_receive(:http_send).with(:send_push, @target, on { |a| a.token == "token2" }, Time, nil).once
+        @sender.send_push(@type, nil, @target, "token2").should be_true
+      end
 
+      it "sets applies callback for returning response" do
+        flexmock(@sender).should_receive(:http_send).with(:send_push, nil, on { |a| a.confirm == true }, Time, Proc).once
+        @sender.send_push(@type) { |_| }.should be_true
       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/)
+    context :send_request do
+      it "creates Request object" do
+        flexmock(RightSupport::Data::UUID, :generate => "random token")
+        flexmock(@sender).should_receive(:http_send).with(:send_request, nil, on { |a| a.class == RightScale::Request &&
+            a.type == @type && a.from == @agent_id && a.target.nil? && a.persistent.nil? && a.selector == :any &&
+            a.token == "random token" && a.expires_at == 0 }, Time, Proc).once
+        @sender.send_request(@type) { |_| }.should be_true
       end
 
-      it "should reject empty hash" do
-        lambda { @instance.__send__(:validate_target, {}, true) }.
-            should raise_error(ArgumentError, /Invalid target hash/)
+      it "stores payload" do
+        flexmock(@sender).should_receive(:http_send).with(:send_request, nil, on { |a| a.payload == @payload }, Time, Proc)
+        @sender.send_request(@type, @payload) { |_| }.should be_true
       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/)
+      it "sets specific target using string" do
+        flexmock(@sender).should_receive(:http_send).with(:send_request, @agent_id, on { |a| a.target == @agent_id &&
+            a.selector == :any }, Time, Proc).once
+        @sender.send_request(@type, nil, @agent_id) { |_| }.should be_true
       end
 
-    end
+      it "sets specific target using :agent_id" do
+        target = {:agent_id => @agent_id}
+        flexmock(@sender).should_receive(:http_send).with(:send_request, target, on { |a| a.target == @agent_id }, Time, Proc).once
+        @sender.send_request(@type, nil, target) { |_| }.should be_true
+      end
 
-  end
+      it "sets target tags" do
+        tags = ["a:b=c"]
+        target = {:tags => tags}
+        flexmock(@sender).should_receive(:http_send).with(:send_request, target, on { |a| a.tags == tags &&
+            a.selector == :any }, Time, Proc).once
+        @sender.send_request(@type, nil, target) { |_| }.should be_true
+      end
 
-  describe "when making a push request" 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 "sets target scope" do
+        scope = {:shard => 1, :account => 123}
+        target = {:scope => scope}
+        flexmock(@sender).should_receive(:http_send).with(:send_request, target, on { |a| a.scope == scope &&
+            a.selector == :any }, Time, Proc).once
+        @sender.send_request(@type, nil, target) { |_| }.should be_true
+      end
 
-    it "should validate target" do
-      @broker.should_receive(:publish)
-      flexmock(@instance).should_receive(:validate_target).with("target", true).once
-      @instance.send_push('/foo/bar', nil, "target").should be_true
-    end
+      it "sets token" do
+        flexmock(@sender).should_receive(:http_send).with(:send_request, @target, on { |a| a.token == "token2" }, Time, Proc).once
+        @sender.send_request(@type, nil, @target, "token2") { |_| }.should be_true
+      end
 
-    it "should create a Push object" do
-      @broker.should_receive(:publish).with(hsh(:name => "request"), on do |push|
-        push.class.should == RightScale::Push
-      end, hsh(:persistent => false, :mandatory => true)).once
-      @instance.send_push('/welcome/aboard', 'iZac')
-    end
+      it "sets expiration time if TTL enabled" do
+        @sender = create_sender(:http, :time_to_live => 60)
+        flexmock(@sender).should_receive(:http_send).with(:send_request, nil, on { |a| a.expires_at != 0 }, Time, Proc).once
+        @sender.send_request(@type) { |_| }.should be_true
+      end
 
-    it "should set the correct target if specified" do
-      @broker.should_receive(:publish).with(hsh(:name => "request"), on do |push|
-        push.target.should == 'my-target'
-      end, hsh(:persistent => false, :mandatory => true)).once
-      @instance.send_push('/welcome/aboard', 'iZac', 'my-target')
-    end
+      it "does not allow fanout" do
+        lambda { @sender.send_request(@type, nil, :selector => :all) }.should raise_error(ArgumentError)
+      end
 
-    it "should set the correct target selectors for fanout if specified" do
-      @broker.should_receive(:publish).with(hsh(:name => "request"), on do |push|
-        push.tags.should == ['tag']
-        push.selector.should == :all
-        push.scope.should == {:account => 123}
-      end, hsh(:persistent => false, :mandatory => true)).once
-      @instance.send_push('/welcome/aboard', 'iZac', :tags => ['tag'], :selector => :all, :scope => {:account => 123})
+      it "requires callback block" do
+        lambda { @sender.send_request(@type) }.should raise_error(ArgumentError)
+      end
     end
 
-    it "should default the target selector to any" do
-      @broker.should_receive(:publish).with(hsh(:name => "request"), on do |push|
-        push.tags.should == ['tag']
-        push.scope.should == {:account => 123}
-      end, hsh(:persistent => false, :mandatory => true)).once
-      @instance.send_push('/welcome/aboard', 'iZac', :tags => ['tag'], :scope => {:account => 123})
-    end
+    context :build_and_send_packet do
+      [:http, :amqp].each do |mode|
 
-    it "should set correct attributes on the push message" do
-      @broker.should_receive(:publish).with(hsh(:name => "request"), on do |push|
-        push.type.should == '/welcome/aboard'
-        push.token.should_not be_nil
-        push.persistent.should be_false
-        push.from.should == 'agent'
-        push.target.should be_nil
-        push.confirm.should be_nil
-        push.expires_at.should == 0
-      end, hsh(:persistent => false, :mandatory => true)).once
-      @instance.send_push('/welcome/aboard', 'iZac')
-    end
+        context "when #{mode}" do
+          before(:each) do
+            @sender = create_sender(mode)
+          end
 
-    it 'should queue the push if in offline mode and :offline_queueing enabled' do
-      @agent.should_receive(:options).and_return({:offline_queueing => true})
-      RightScale::Sender.new(@agent)
-      @instance = RightScale::Sender.instance
-      @instance.initialize_offline_queue
-      @broker.should_receive(:publish).never
-      @instance.enable_offline_mode
-      @instance.offline_handler.mode.should == :offline
-      @instance.send_push('/welcome/aboard', 'iZac')
-      @instance.offline_handler.queue.size.should == 1
-    end
+          it "builds packet" do
+            packet = flexmock("packet", :type => @type, :token => @token, :selector => :any)
+            flexmock(@sender).should_receive(:build_packet).with(:send_push, @type, @payload, @target, @token, nil).and_return(packet).once
+            flexmock(@sender).should_receive("#{mode}_send".to_sym)
+            @sender.build_and_send_packet(:send_push, @type, @payload, @target, @token, callback = nil).should be_true
+          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 "sends packet" do
+            flexmock(@sender).should_receive("#{mode}_send".to_sym).with(:send_push, @target,
+                on { |a| a.class == RightScale::Push }, Time, nil).once
+            @sender.build_and_send_packet(:send_push, @type, @payload, @target, @token, callback = nil).should be_true
+          end
 
-    it "should store the response handler if given" do
-      response_handler = lambda {}
-      flexmock(RightScale::AgentIdentity).should_receive(:generate).and_return('abc').once
-      @broker.should_receive(:publish).with(hsh(:name => "request"), on do |push|
-        push.confirm.should == true
-      end, hsh(:persistent => false, :mandatory => true)).once
-      @instance.send_push('/welcome/aboard', 'iZac', &response_handler)
-      @instance.pending_requests['abc'].response_handler.should == response_handler
+          it "ignores nil packet result when queueing" do
+            flexmock(@sender).should_receive(:build_packet).with(:send_push, @type, @payload, @target, @token, nil).and_return(nil).once
+            flexmock(@sender).should_receive("#{mode}_send".to_sym).never
+            @sender.build_and_send_packet(:send_push, @type, @payload, @target, @token, callback = nil).should be_true
+          end
+        end
+      end
     end
 
-    it "should store the request receive time if there is a response handler" do
-      response_handler = lambda {}
-      flexmock(RightScale::AgentIdentity).should_receive(:generate).and_return('abc').once
-      @instance.pending_requests.kind(RightScale::Sender::PendingRequests::PUSH_KINDS).youngest_age.should be_nil
-      @instance.send_push('/welcome/aboard', 'iZac', &response_handler)
-      @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::PUSH_KINDS).youngest_age.should == 100
-    end
+    context :build_packet do
+      [:send_push, :send_request].each do |kind|
 
-    it "should eventually remove push from pending requests if no response received" do
-      response_handler = lambda {}
-      flexmock(RightScale::AgentIdentity).should_receive(:generate).and_return('abc', 'xyz').twice
-      @instance.send_push('/welcome/aboard', 'iZac', &response_handler)
-      @instance.pending_requests['abc'].should_not be_nil
-      flexmock(Time).should_receive(:now).and_return(Time.at(1000121))
-      @instance.send_push('/welcome/aboard', 'iZac', &response_handler)
-      @instance.pending_requests['xyz'].should_not be_nil
-      @instance.pending_requests['abc'].should be_nil
-    end
+        context "when #{kind}" do
+          it "validates target" do
+            flexmock(@sender).should_receive(:validate_target).with(@target, kind == :send_push).once
+            @sender.build_packet(kind, @type, nil, @target, @token).should_not 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
+          it "submits request to offline handler and returns nil if queueing" do
+            flexmock(@sender).should_receive(:queueing?).and_return(true).once
+            @sender.build_packet(kind, @type, nil, @target, @token).should be_nil
+          end
 
-  describe "when making a send_persistent_push request" do
-    before(:each) do
-      @timer = flexmock("timer")
-      flexmock(EM::Timer).should_receive(:new).and_return(@timer)
-      @broker = flexmock("Broker", :subscribe => true, :publish => true).by_default
-      @agent = flexmock("Agent", :identity => "agent", :broker => @broker, :options => {}).by_default
-      RightScale::Sender.new(@agent)
-      @instance = RightScale::Sender.instance
-      @instance.initialize_offline_queue
-    end
+          it "generates a request token if none provided" do
+            flexmock(RightSupport::Data::UUID, :generate => "random token")
+            packet = @sender.build_packet(kind, @type, nil, @target, token = nil)
+            packet.token.should == "random token"
+          end
 
-    it "should create a Push object" do
-      @broker.should_receive(:publish).with(hsh(:name => "request"), on do |push|
-        push.class.should == RightScale::Push
-      end, hsh(:persistent => true, :mandatory => true)).once
-      @instance.send_persistent_push('/welcome/aboard', 'iZac')
-    end
+          it "sets payload" do
+            packet = @sender.build_packet(kind, @type, @payload, @target, @token)
+            packet.payload.should == @payload
+          end
 
-    it "should set correct attributes on the push message" do
-      @broker.should_receive(:publish).with(hsh(:name => "request"), on do |push|
-        push.type.should == '/welcome/aboard'
-        push.token.should_not be_nil
-        push.persistent.should be_true
-        push.from.should == 'agent'
-        push.target.should be_nil
-        push.confirm.should be_nil
-        push.expires_at.should == 0
-      end, hsh(:persistent => true, :mandatory => true)).once
-      @instance.send_persistent_push('/welcome/aboard', 'iZac')
-    end
+          it "sets the packet from this agent" do
+            packet = @sender.build_packet(kind, @type, nil, @target, @token)
+            packet.from.should == @agent_id
+          end
 
-    it "should default the target selector to any" do
-      @broker.should_receive(:publish).with(hsh(:name => "request"), on do |push|
-        push.tags.should == ['tag']
-        push.scope.should == {:account => 123}
-      end, hsh(:persistent => true, :mandatory => true)).once
-      @instance.send_persistent_push('/welcome/aboard', 'iZac', :tags => ['tag'], :scope => {:account => 123})
-    end
+          it "sets target if target is not a hash" do
+            packet = @sender.build_packet(kind, @type, nil, @target, @token)
+            packet.target.should == @target
+          end
 
-    it "should store the response handler if given" do
-      response_handler = lambda {}
-      flexmock(RightScale::AgentIdentity).should_receive(:generate).and_return('abc').once
-      @broker.should_receive(:publish).with(hsh(:name => "request"), on do |push|
-        push.confirm.should == true
-      end, hsh(:persistent => true, :mandatory => true)).once
-      @instance.send_persistent_push('/welcome/aboard', 'iZac', &response_handler)
-      @instance.pending_requests['abc'].response_handler.should == response_handler
-    end
+          context "when target is a hash" do
+            it "sets agent ID" do
+              target = {:agent_id => @agent_id}
+              packet = @sender.build_packet(kind, @type, nil, target, @token)
+              packet.target.should == @agent_id
+            end
+
+            it "sets tags" do
+              tags = ["a:b=c"]
+              target = {:tags => tags}
+              packet = @sender.build_packet(kind, @type, nil, target, @token)
+              packet.tags.should == tags
+              packet.scope.should be_nil
+            end
+
+            it "sets scope" do
+              scope = {:shard => 1, :account => 123}
+              target = {:scope => scope}
+              packet = @sender.build_packet(kind, @type, nil, target, @token)
+              packet.tags.should == []
+            end
+          end
 
-    it "should store the request receive time if there is a response handler" do
-      response_handler = lambda {}
-      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::PUSH_KINDS).youngest_age.should be_nil
-      @instance.send_persistent_push('/welcome/aboard', 'iZac', &response_handler)
-      @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::PUSH_KINDS).youngest_age.should == 100
+          if kind == :send_push
+            it "defaults selector to :any" do
+              packet = @sender.build_packet(kind, @type, nil, @target, @token)
+              packet.selector.should == :any
+            end
+
+            it "sets selector" do
+              target = {:selector => :all}
+              packet = @sender.build_packet(kind, @type, nil, target, @token)
+              packet.selector.should == :all
+            end
+
+            it "sets persistent flag" do
+              packet = @sender.build_packet(kind, @type, nil, @target, @token)
+              packet.persistent.should be_true
+            end
+
+            it "enables confirm if callback provided" do
+              packet = @sender.build_packet(kind, @type, nil, @target, @token, @callback)
+              packet.confirm.should be_true
+            end
+
+            it "does not enable confirm if not callback provided" do
+              packet = @sender.build_packet(kind, @type, nil, @target, @token)
+              packet.confirm.should be_false
+            end
+
+            it "does not set expiration time" do
+              packet = @sender.build_packet(kind, @type, nil, @target, @token)
+              packet.expires_at.should == 0
+            end
+          else
+            it "always sets selector to :any" do
+              packet = @sender.build_packet(kind, @type, nil, @target, @token)
+              packet.selector.should == :any
+            end
+
+            it "sets expiration time to specified TTL" do
+              @sender = create_sender(:http, :time_to_live => 99)
+              now = Time.now
+              flexmock(Time).should_receive(:now).and_return(now)
+              packet = @sender.build_packet(kind, @type, nil, @target, @token)
+              packet.expires_at.should == (now + 99).to_i
+            end
+          end
+        end
+      end
     end
-  end
 
-  describe "when making a send_retryable_request request" do
-    before(:each) do
-      @timer = flexmock("timer")
-      flexmock(EM::Timer).should_receive(:new).and_return(@timer).by_default
-      @broker_id = "rs-broker-host-123"
-      @broker_ids = [@broker_id]
-      @broker = flexmock("Broker", :subscribe => true, :publish => @broker_ids, :connected? => true,
-                         :all => @broker_ids, :identity_parts => ["host", 123, 0, 0]).by_default
-      @agent = flexmock("Agent", :identity => "agent", :broker => @broker).by_default
-      @agent.should_receive(:options).and_return({:ping_interval => 0, :time_to_live => 100}).by_default
-      RightScale::Sender.new(@agent)
-      @instance = RightScale::Sender.instance
-      @instance.initialize_offline_queue
-    end
+    context :handle_response do
+      before(:each) do
+        flexmock(RightSupport::Data::UUID, :generate => @token)
+        @received_at = Time.now
+        flexmock(Time).should_receive(:now).and_return(@received_at)
+        @callback = lambda { |_| }
+        @pending_request = RightScale::PendingRequest.new(:send_request, @received_at, @callback)
+        @sender.pending_requests[@token] = @pending_request
+      end
 
-    it "should validate target" do
-      @broker.should_receive(:publish).and_return(@broker_ids).once
-      flexmock(@instance).should_receive(:validate_target).with("target", false).once
-      @instance.send_retryable_request('/foo/bar', nil, "target") {_}.should be_true
-    end
+      [:send_push, :send_request].each do |kind|
+        it "delivers the response for a #{kind}" do
+          @pending_request = RightScale::PendingRequest.new(kind, @received_at, @callback)
+          @sender.pending_requests[@token] = @pending_request
+          response = RightScale::Result.new(@token, "to", RightScale::OperationResult.success, @target)
+          flexmock(@sender).should_receive(:deliver_response).with(response, @pending_request).once
+          @sender.handle_response(response).should be_true
+        end
+      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)).and_return(@broker_ids).once
-      @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_|}
-    end
+      it "logs a debug message if request no longer pending" do
+        @sender.pending_requests.delete(@token)
+        @log.should_receive(:debug).with(/No pending request for response/).once
+        response = RightScale::Result.new(@token, "to", RightScale::OperationResult.success, @target)
+        @sender.handle_response(response)
+      end
 
-    it "should set correct attributes on the request message" do
-      flexmock(Time).should_receive(:now).and_return(Time.at(1000000))
-      @broker.should_receive(:publish).with(hsh(:name => "request"), on do |request|
-        request.type.should == '/welcome/aboard'
-        request.token.should_not be_nil
-        request.persistent.should be_false
-        request.from.should == 'agent'
-        request.target.should be_nil
-        request.expires_at.should == 1000100
-      end, hsh(:persistent => false, :mandatory => true)).and_return(@broker_ids).once
-      @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_|}
-    end
+      it "ignores responses that are not a Result" do
+        flexmock(@sender).should_receive(:deliver_response).never
+        @sender.handle_response("response").should be_true
+      end
 
-    it "should disable time-to-live if disabled in configuration" do
-      @agent.should_receive(:options).and_return({:ping_interval => 0, :time_to_live => 0})
-      RightScale::Sender.new(@agent)
-      @instance = RightScale::Sender.instance
-      @instance.initialize_offline_queue
-      flexmock(Time).should_receive(:now).and_return(Time.at(1000000))
-      @broker.should_receive(:publish).with(hsh(:name => "request"), on do |request|
-        request.expires_at.should == 0
-      end, hsh(:persistent => false, :mandatory => true)).and_return(@broker_ids).once
-      @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_|}
-    end
+      context "when non-delivery" do
+        before(:each) do
+          @reason = RightScale::OperationResult::TARGET_NOT_CONNECTED
+          non_delivery = RightScale::OperationResult.non_delivery(@reason)
+          @response = RightScale::Result.new(@token, "to", non_delivery, @target)
+        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)).and_return(@broker_ids).once
-      @instance.send_retryable_request('/welcome/aboard', 'iZac', 'my-target') {|_|}
-    end
+        it "records non-delivery regardless of whether there is a pending request" do
+          @sender.pending_requests.delete(@token)
+          non_delivery = RightScale::OperationResult.non_delivery(RightScale::OperationResult::NO_ROUTE_TO_TARGET)
+          response = RightScale::Result.new(@token, "to", non_delivery, @target)
+          @sender.handle_response(response).should be_true
+          @sender.instance_variable_get(:@non_delivery_stats).total.should == 1
+        end
 
-    it "should set the correct target selectors if specified" do
-      @broker.should_receive(:publish).with(hsh(:name => "request"), on do |request|
-        request.tags.should == ['tag']
-        request.selector.should == :any
-        request.scope.should == {:account => 123}
-      end, hsh(:persistent => false, :mandatory => true)).and_return(@broker_ids).once
-      @instance.send_retryable_request('/welcome/aboard', 'iZac', :tags => ['tag'], :scope => {:account => 123}) {|_|}
-    end
+        it "logs non-delivery if there is no pending request" do
+          @sender.pending_requests.delete(@token)
+          @log.should_receive(:info).with(/Non-delivery of/).once
+          non_delivery = RightScale::OperationResult.non_delivery(RightScale::OperationResult::NO_ROUTE_TO_TARGET)
+          response = RightScale::Result.new(@token, "to", non_delivery, @target)
+          @sender.handle_response(response).should be_true
+        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') {|_|}
-    end
+        context "for a Request" do
+
+          context "with target not connected" do
+            it "logs non-delivery but does not deliver it" do
+              @log.should_receive(:info).with(/Non-delivery of/).once
+              flexmock(@sender).should_receive(:deliver_response).never
+              @sender.handle_response(@response).should be_true
+            end
+
+            it "records non-delivery reason in pending request if for parent request" do
+              @log.should_receive(:info).with(/Non-delivery of/).once
+              flexmock(@sender).should_receive(:deliver_response).never
+              parent_token = "parent token"
+              parent_pending_request = RightScale::PendingRequest.new(:send_request, @received_at, @callback)
+              @sender.pending_requests[parent_token] = parent_pending_request
+              @pending_request.retry_parent_token = parent_token
+              @sender.handle_response(@response).should be_true
+              parent_pending_request.non_delivery.should == @reason
+            end
+
+            it "updates non-delivery reason if for retry request" do
+              flexmock(@sender).should_receive(:deliver_response).never
+              @sender.handle_response(@response).should be_true
+              @pending_request.non_delivery.should == @reason
+            end
+          end
 
-    it "should store the response handler" do
-      response_handler = lambda {}
-      flexmock(RightScale::AgentIdentity).should_receive(:generate).and_return('abc').once
-      @instance.send_retryable_request('/welcome/aboard', 'iZac', &response_handler)
-      @instance.pending_requests['abc'].response_handler.should == response_handler
-    end
+          context "with retry timeout and previous non-delivery" do
+            it "delivers response using stored non-delivery reason" do
+              @reason = RightScale::OperationResult::RETRY_TIMEOUT
+              @response.results = RightScale::OperationResult.non_delivery(@reason)
+              @pending_request.non_delivery = "other reason"
+              flexmock(@sender).should_receive(:deliver_response).with(on { |a| a.results.content == "other reason"},
+                  @pending_request).once
+              @sender.handle_response(@response).should be_true
+            end
+          end
 
-    it "should store the request receive time" 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.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
+          context "otherwise" do
+            it "delivers non-delivery response as is" do
+              @response.results = RightScale::OperationResult.non_delivery("other")
+              flexmock(@sender).should_receive(:deliver_response).with(on { |a| a.results.content == "other"},
+                  RightScale::PendingRequest).once
+              @sender.handle_response(@response).should be_true
+            end
+          end
+        end
+      end
     end
 
-    it 'should queue the request if in offline mode and :offline_queueing enabled' do
-      @agent.should_receive(:options).and_return({:offline_queueing => true})
-      RightScale::Sender.new(@agent)
-      @instance = RightScale::Sender.instance
-      @instance.initialize_offline_queue
-      @broker.should_receive(:publish).never
-      @instance.enable_offline_mode
-      @instance.offline_handler.mode.should == :offline
-      @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_|}
-      @instance.offline_handler.queue.size.should == 1
-    end
+    context :terminate do
+      it "terminates offline handler" do
+        flexmock(@sender.offline_handler).should_receive(:terminate).once
+        @sender.terminate
+      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 "terminates connectivity checker if configured" do
+        @sender = create_sender(:amqp, :offline_queueing => true)
+        flexmock(@sender.connectivity_checker).should_receive(:terminate).once
+        @sender.terminate
+      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.dump_requests.should == ["#{Time.at(1000000).localtime} <abc>"]
+      it "returns number of pending requests and age of youngest request" do
+        receive_time = Time.now - 10
+        @sender.pending_requests[@token] = RightScale::PendingRequest.new(:send_request, receive_time, @callback)
+        @sender.terminate.should == [1, 10]
+      end
     end
 
-    it "should not allow a selector target" do
-      lambda { @instance.send_retryable_request('/welcome/aboard', 'iZac', :selector => :all) }.should raise_error(ArgumentError)
-    end
+    context :dump_requests do
+      it "returns array of unfinished non-push requests" do
+        time1 = Time.now
+        @sender.pending_requests["token1"] = RightScale::PendingRequest.new(:send_push, time1, @callback)
+        time2 = time1 + 10
+        @sender.pending_requests["token2"] = RightScale::PendingRequest.new(:send_request, time2, @callback)
+        @sender.dump_requests.should == ["#{time2.localtime} <token2>"]
+      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 "returns requests in descending time order" do
+        time1 = Time.now
+        @sender.pending_requests["token1"] = RightScale::PendingRequest.new(:send_request, time1, @callback)
+        time2 = time1 + 10
+        @sender.pending_requests["token2"] = RightScale::PendingRequest.new(:send_request, time2, @callback)
+        @sender.dump_requests.should == ["#{time2.localtime} <token2>", "#{time1.localtime} <token1>"]
+      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)
+      it "limits the number returned to 50" do
+        pending_request = RightScale::PendingRequest.new(:send_request, Time.now, @callback)
+        55.times.each { |i| @sender.pending_requests["token#{i}"] = pending_request }
+        result = @sender.dump_requests
+        result.size.should == 51
+        result.last.should == "..."
+      end
     end
 
-    describe "with retry" do
-      it "should not setup for retry if retry_timeout nil" do
-        flexmock(EM).should_receive(:add_timer).never
-        @agent.should_receive(:options).and_return({:retry_timeout => nil})
-        RightScale::Sender.new(@agent)
-        @instance = RightScale::Sender.instance
-        @broker.should_receive(:publish).and_return(@broker_ids).once
-        @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_|}
+    context :validate_target do
+      it "should accept nil target" do
+        @sender.send(:validate_target, nil, true).should be_true
       end
 
-      it "should not setup for retry if retry_interval nil" do
-        flexmock(EM).should_receive(:add_timer).never
-        @agent.should_receive(:options).and_return({:retry_interval => nil})
-        RightScale::Sender.new(@agent)
-        @instance = RightScale::Sender.instance
-        @broker.should_receive(:publish).and_return(@broker_ids).once
-        @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_|}
+      it "should accept named target" do
+        @sender.send(:validate_target, "name", true).should be_true
       end
 
-      it "should not setup for retry if publish failed" do
-        flexmock(EM).should_receive(:add_timer).never
-        @agent.should_receive(:options).and_return({:retry_timeout => 60, :retry_interval => 60})
-        RightScale::Sender.new(@agent)
-        @instance = RightScale::Sender.instance
-        @broker.should_receive(:publish).and_raise(Exception).once
-        @log.should_receive(:error).with(/Failed to publish request/, Exception, :trace).once
-        lambda do
-          @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_|}
-        end.should raise_error(RightScale::Sender::SendFailure)
-      end
+      context "when target is a hash" do
 
-      it "should setup for retry if retry_timeout and retry_interval not nil and publish successful" do
-        flexmock(EM).should_receive(:add_timer).with(60, any).once
-        @agent.should_receive(:options).and_return({:retry_timeout => 60, :retry_interval => 60})
-        RightScale::Sender.new(@agent)
-        @instance = RightScale::Sender.instance
-        @broker.should_receive(:publish).and_return(@broker_ids).once
-        @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_|}
-      end
+        context "and agent ID is specified" do
+          it "should not allow other keys" do
+            @sender.send(:validate_target, {:agent_id => @agent_id}, true).should be_true
+            lambda { @sender.send(:validate_target, {:agent_id => @agent_id, :tags => ["a:b=c"]}, true) }.should \
+              raise_error(ArgumentError, /Invalid target/)
+          end
+        end
 
-      it "should succeed after retrying once" do
-        EM.run do
-          token = 'abc'
-          result = RightScale::OperationResult.non_delivery(RightScale::OperationResult::RETRY_TIMEOUT)
-          flexmock(RightScale::AgentIdentity).should_receive(:generate).and_return(token).twice
-          @agent.should_receive(:options).and_return({:retry_timeout => 0.3, :retry_interval => 0.1})
-          RightScale::Sender.new(@agent)
-          @instance = RightScale::Sender.instance
-          flexmock(@instance.connectivity_checker).should_receive(:check).once
-          @broker.should_receive(:publish).and_return(@broker_ids).twice
-          @instance.send_retryable_request('/welcome/aboard', 'iZac') do |response|
-            result = RightScale::OperationResult.from_results(response)
+        context "and selector is allowed" do
+          it "should accept :all or :any selector" do
+            @sender.send(:validate_target, {:selector => :all}, true).should be_true
+            @sender.send(:validate_target, {"selector" => "any"}, true).should be_true
           end
-          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)
+
+          it "should reject values other than :all or :any" do
+            lambda { @sender.send(:validate_target, {:selector => :other}, true) }.
+                should raise_error(ArgumentError, /Invalid target selector/)
           end
-          EM.add_timer(0.3) do
-            EM.stop
-            result.success?.should be_true
-            @instance.pending_requests.empty?.should be_true
+        end
+
+        context "and selector is not allowed" do
+          it "should reject selector" do
+            lambda { @sender.send(:validate_target, {:selector => :all}, false) }.
+                should raise_error(ArgumentError, /Invalid target hash/)
           end
         end
-      end
 
-      it "should respond with retry if publish fails with no brokers when retrying" do
-        EM.run do
-          token = 'abc'
-          result = RightScale::OperationResult.non_delivery(RightScale::OperationResult::RETRY_TIMEOUT)
-          flexmock(RightScale::AgentIdentity).should_receive(:generate).and_return(token).twice
-          @agent.should_receive(:options).and_return({:retry_timeout => 0.3, :retry_interval => 0.1})
-          RightScale::Sender.new(@agent)
-          @instance = RightScale::Sender.instance
-          flexmock(@instance.connectivity_checker).should_receive(:check).never
-          @broker.should_receive(:publish).and_return(@broker_ids).ordered.once
-          @broker.should_receive(:publish).and_raise(RightAMQP::HABrokerClient::NoConnectedBrokers).ordered.once
-          @log.should_receive(:error).with(/Failed to publish request/, RightAMQP::HABrokerClient::NoConnectedBrokers).once
-          @log.should_receive(:error).with(/Failed retry for.*temporarily offline/).once
-          @instance.send_retryable_request('/welcome/aboard', 'iZac') do |response|
-            result = RightScale::OperationResult.from_results(response)
-            result.retry?.should be_true
-            result.content.should == "lost connectivity"
+        context "and tags is specified" do
+          it "should accept tags" do
+            @sender.send(:validate_target, {:tags => []}, true).should be_true
+            @sender.send(:validate_target, {"tags" => ["tag"]}, true).should be_true
           end
-          EM.add_timer(0.15) do
-            EM.stop
-            result.retry?.should be_true
-            @instance.pending_requests.empty?.should be_true
+
+          it "should reject non-array" do
+            lambda { @sender.send(:validate_target, {:tags => {}}, true) }.
+                should raise_error(ArgumentError, /Invalid target tags/)
           end
         end
-      end
 
-      it "should respond with non-delivery if publish fails in unknown way when retrying" do
-        EM.run do
-          token = 'abc'
-          result = RightScale::OperationResult.non_delivery(RightScale::OperationResult::RETRY_TIMEOUT)
-          flexmock(RightScale::AgentIdentity).should_receive(:generate).and_return(token).twice
-          @agent.should_receive(:options).and_return({:retry_timeout => 0.3, :retry_interval => 0.1})
-          RightScale::Sender.new(@agent)
-          @instance = RightScale::Sender.instance
-          flexmock(@instance.connectivity_checker).should_receive(:check).never
-          @broker.should_receive(:publish).and_return(@broker_ids).ordered.once
-          @broker.should_receive(:publish).and_raise(Exception.new).ordered.once
-          @log.should_receive(:error).with(/Failed to publish request/, Exception, :trace).once
-          @log.should_receive(:error).with(/Failed retry for.*send failure/).once
-          @instance.send_retryable_request('/welcome/aboard', 'iZac') do |response|
-            result = RightScale::OperationResult.from_results(response)
-            result.non_delivery?.should be_true
-            result.content.should == "retry failed"
+        context "and scope is specified" do
+          it "should accept account" do
+            @sender.send(:validate_target, {:scope => {:account => 1}}, true).should be_true
+            @sender.send(:validate_target, {"scope" => {"account" => 1}}, true).should be_true
           end
-          EM.add_timer(0.15) do
-            EM.stop
-            result.non_delivery?.should be_true
-            @instance.pending_requests.empty?.should be_true
+
+          it "should accept shard" do
+            @sender.send(:validate_target, {:scope => {:shard => 1}}, true).should be_true
+            @sender.send(:validate_target, {"scope" => {"shard" => 1}}, true).should be_true
           end
-        end
-      end
 
-      it "should not respond if retry mechanism fails in unknown way" do
-        EM.run do
-          token = 'abc'
-          result = nil
-          flexmock(RightScale::AgentIdentity).should_receive(:generate).and_return(token).twice
-          @agent.should_receive(:options).and_return({:retry_timeout => 0.3, :retry_interval => 0.1})
-          RightScale::Sender.new(@agent)
-          @instance = RightScale::Sender.instance
-          flexmock(@instance.connectivity_checker).should_receive(:check).and_raise(Exception).once
-          @broker.should_receive(:publish).and_return(@broker_ids).twice
-          @log.should_receive(:error).with(/Failed retry for.*without responding/, Exception, :trace).once
-          @instance.send_retryable_request('/welcome/aboard', 'iZac') {_}
-          EM.add_timer(0.15) do
-            EM.stop
-            result.should be_nil
-            @instance.pending_requests.empty?.should be_false
+          it "should accept account and shard" do
+            @sender.send(:validate_target, {"scope" => {:shard => 1, "account" => 1}}, true).should be_true
           end
-        end
-      end
 
-      it "should timeout after retrying twice" do
-        pending 'Too difficult to get timing right for Windows' if RightScale::Platform.windows?
-        EM.run do
-          result = RightScale::OperationResult.success
-          @log.should_receive(:warning).once
-          @agent.should_receive(:options).and_return({:retry_timeout => 0.6, :retry_interval => 0.1})
-          RightScale::Sender.new(@agent)
-          @instance = RightScale::Sender.instance
-          flexmock(@instance.connectivity_checker).should_receive(:check).once
-          @broker.should_receive(:publish).and_return(@broker_ids).times(3)
-          @instance.send_retryable_request('/welcome/aboard', 'iZac') do |response|
-            result = RightScale::OperationResult.from_results(response)
+          it "should reject keys other than account and shard" do
+            target = {"scope" => {:shard => 1, "account" => 1, :other => 2}}
+            lambda { @sender.send(:validate_target, target, true) }.
+                should raise_error(ArgumentError, /Invalid target scope/)
           end
-          @instance.pending_requests.empty?.should be_false
-          EM.add_timer(1) do
-            EM.stop
-            result.non_delivery?.should be_true
-            result.content.should == RightScale::OperationResult::RETRY_TIMEOUT
-            @instance.pending_requests.empty?.should be_true
+
+          it "should reject empty hash" do
+            lambda { @sender.send(:validate_target, {:scope => {}}, true) }.
+                should raise_error(ArgumentError, /Invalid target scope/)
           end
         end
-      end
 
-      it "should return non-delivery after timeout if any attempt failed due to non-delivery" do
-        pending 'Too difficult to get timing right for Windows' if RightScale::Platform.windows?
-        EM.run do
-          result = RightScale::OperationResult.success
-          @log.should_receive(:warning).once
-          @agent.should_receive(:options).and_return({:retry_timeout => 0.6, :retry_interval => 0.1})
-          RightScale::Sender.new(@agent)
-          @instance = RightScale::Sender.instance
-          flexmock(@instance.connectivity_checker).should_receive(:check).once
-          @broker.should_receive(:publish).and_return(@broker_ids).times(3)
-          @instance.send_retryable_request('/welcome/aboard', 'iZac') do |response|
-            result = RightScale::OperationResult.from_results(response)
+        context "and multiple are specified" do
+          it "should accept scope and tags" do
+            @sender.send(:validate_target, {:scope => {:shard => 1}, :tags => []}, true).should be_true
           end
-          @instance.pending_requests.empty?.should be_false
-          token = @instance.pending_requests.keys.last
-          non_delivery = RightScale::OperationResult.non_delivery(RightScale::OperationResult::TARGET_NOT_CONNECTED)
-          @instance.handle_response(RightScale::Result.new(token, 'iZac', non_delivery, "from"))
-          EM.add_timer(1) do
-            EM.stop
-            result.non_delivery?.should be_true
-            result.content.should == non_delivery.content
-            @instance.pending_requests.empty?.should be_true
+
+          it "should accept scope, tags, and selector" do
+            target = {:scope => {:shard => 1}, :tags => ["tag"], :selector => :all}
+            @sender.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 { @sender.send(:validate_target, target, false) }.
+                should raise_error(ArgumentError, /Invalid target hash/)
           end
         end
-      end
 
-      it "should retry with same request expires_at value" do
-        EM.run do
-          token = 'abc'
-          expires_at = nil
-          flexmock(RightScale::AgentIdentity).should_receive(:generate).and_return(token).twice
-          @agent.should_receive(:options).and_return({:retry_timeout => 0.5, :retry_interval => 0.1})
-          RightScale::Sender.new(@agent)
-          @instance = RightScale::Sender.instance
-          flexmock(@instance.connectivity_checker).should_receive(:check).once
-          @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') {|_|}
-          EM.add_timer(0.2) { EM.stop }
+        it "should reject keys other than selector, scope, and tags" do
+          target = {:scope => {:shard => 1}, :tags => [], :selector => :all, :other => 2}
+          lambda { @sender.send(:validate_target, target, true) }.
+              should raise_error(ArgumentError, /Invalid target hash/)
+        end
+
+        it "should reject empty hash" do
+          lambda { @sender.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 { @sender.send(:validate_target, [], true) }.
+              should raise_error(ArgumentError, /Invalid target/)
         end
       end
+    end
+
+    context :http do
 
-      describe "and checking connection status" do
+      context :http_send do
         before(:each) do
-          @broker_id = "rs-broker-host-123"
-          @broker_ids = [@broker_id]
+          @received_at = Time.now
+          flexmock(Time).should_receive(:now).and_return(@received_at)
+          flexmock(RightSupport::Data::UUID).should_receive(:generate).and_return(@token).by_default
+          @packet = @sender.build_packet(:send_request, @type, @payload, @target, @token, @callback)
+          @response = nil
+          @callback = lambda { |response| @response = response }
         end
 
-        it "should not check connection if check already in progress" do
-          flexmock(EM::Timer).should_receive(:new).and_return(@timer).never
-          @instance.connectivity_checker.ping_timer = true
-          flexmock(@instance).should_receive(:publish).never
-          @instance.connectivity_checker.check(@broker_ids)
+        it "sends request using configured client" do
+          @packet = @sender.build_packet(:send_push, @type, @payload, @target, @token, @callback)
+          @client.should_receive(:push).with(@type, @payload, @target, @token).and_return(nil).once
+          @sender.send(:http_send, :send_push, @target, @packet, @received_at, @callback).should be_true
         end
 
-        it "should publish ping to mapper" do
-          flexmock(EM::Timer).should_receive(:new).and_return(@timer).once
-          flexmock(@instance).should_receive(:publish).with(on { |request| request.type.should == "/mapper/ping" },
-                                                            @broker_ids).and_return(@broker_ids).once
-          @instance.connectivity_checker.check(@broker_id)
-          @instance.pending_requests.size.should == 1
+        it "responds with success result containing response" do
+          @client.should_receive(:request).with(@type, @payload, @target, @token).and_return("result").once
+          @sender.send(:http_send, :send_request, @target, @packet, @received_at, @callback).should be_true
+          @response.token.should == @token
+          @response.results.success?.should be_true
+          @response.results.content.should == "result"
+          @response.from.should == @target
+          @response.received_at.should == @received_at.to_f
         end
 
-        it "should not make any connection changes if receive ping response" do
-          flexmock(RightScale::AgentIdentity).should_receive(:generate).and_return('abc').once
-          @timer.should_receive(:cancel).once
-          flexmock(EM::Timer).should_receive(:new).and_return(@timer).once
-          flexmock(@instance).should_receive(:publish).and_return(@broker_ids).once
-          @instance.connectivity_checker.check(@broker_id)
-          @instance.connectivity_checker.ping_timer.should == @timer
-          @instance.pending_requests.size.should == 1
-          @instance.pending_requests['abc'].response_handler.call(nil)
-          @instance.connectivity_checker.ping_timer.should == nil
+        it "responds with success result when response is nil" do
+          @client.should_receive(:request).with(@type, @payload, @target, @token).and_return(nil).once
+          @sender.send(:http_send, :send_request, @target, @packet, @received_at, @callback).should be_true
+          @response.token.should == @token
+          @response.results.success?.should be_true
+          @response.results.content.should be_nil
+          @response.from.should == @target
+          @response.received_at.should == @received_at.to_f
         end
 
-        it "should try to reconnect if ping times out repeatedly" do
-          @log.should_receive(:warning).with(/timed out after 30 seconds/).twice
-          @log.should_receive(:error).with(/reached maximum of 3 timeouts/).once
-          flexmock(EM::Timer).should_receive(:new).and_yield.times(3)
-          flexmock(@agent).should_receive(:connect).once
-          @instance.connectivity_checker.check(@broker_id)
-          @instance.connectivity_checker.check(@broker_id)
-          @instance.connectivity_checker.check(@broker_id)
-          @instance.connectivity_checker.ping_timer.should == nil
+        it "responds asynchronously if requested" do
+          @sender = create_sender(:http, :async_response => true)
+          flexmock(EM).should_receive(:next_tick).and_yield.once
+          @client.should_receive(:request).with(@type, @payload, @target, @token).and_return(nil).once
+          @sender.send(:http_send, :send_request, @target, @packet, @received_at, @callback).should be_true
+          @response.token.should == @token
+          @response.results.success?.should be_true
+          @response.results.content.should be_nil
+          @response.from.should == @target
+          @response.received_at.should == @received_at.to_f
         end
 
-        it "should log error if attempt to reconnect fails" do
-          @log.should_receive(:warning).with(/timed out after 30 seconds/).twice
-          @log.should_receive(:error).with(/Failed to reconnect/, Exception, :trace).once
-          flexmock(@agent).should_receive(:connect).and_raise(Exception)
-          flexmock(EM::Timer).should_receive(:new).and_yield.times(3)
-          @instance.connectivity_checker.check(@broker_id)
-          @instance.connectivity_checker.check(@broker_id)
-          @instance.connectivity_checker.check(@broker_id)
+        context "when fails" do
+          context "with connectivity error" do
+            it "queues request if queueing and does not respond" do
+              @sender = create_sender(:http, :offline_queueing => true)
+              @sender.initialize_offline_queue
+              @sender.enable_offline_mode
+              @client.should_receive(:request).and_raise(RightScale::Exceptions::ConnectivityFailure, "disconnected").once
+              flexmock(@sender.offline_handler).should_receive(:queue_request).with(:send_request, @type,
+                  @payload, @target, @callback).once
+              flexmock(@sender).should_receive(:handle_response).never
+              @sender.send(:http_send, :send_request, @target, @packet, @received_at, @callback).should be_true
+            end
+
+            it "responds with retry result if not queueing" do
+              @client.should_receive(:request).and_raise(RightScale::Exceptions::ConnectivityFailure, "Server not responding").once
+              @sender.send(:http_send, :send_request, @target, @packet, @received_at, @callback).should be_true
+              @response.results.retry?.should be_true
+              @response.results.content.should == "Server not responding"
+            end
+          end
+
+          it "responds with retry result if retryable error" do
+            @client.should_receive(:request).and_raise(RightScale::Exceptions::RetryableError, "try again").once
+            @sender.send(:http_send, :send_request, @target, @packet, @received_at, @callback).should be_true
+            @response.results.retry?.should be_true
+            @response.results.content.should == "try again"
+          end
+
+          it "responds with error result if internal error" do
+            @client.should_receive(:request).and_raise(RightScale::Exceptions::InternalServerError.new("unprocessable", "Router")).once
+            @sender.send(:http_send, :send_request, @target, @packet, @received_at, @callback).should be_true
+            @response.results.error?.should be_true
+            @response.results.content.should == "Router internal error"
+          end
+
+          it "does not respond to request if terminating" do
+            @client.should_receive(:request).and_raise(RightScale::Exceptions::Terminating, "going down").once
+            flexmock(@sender).should_receive(:handle_response).never
+            @sender.send(:http_send, :send_request, @target, @packet, @received_at, @callback).should be_true
+          end
+
+          it "responds with error result if HTTP error" do
+            @client.should_receive(:request).and_raise(RestExceptionMock.new(400, "bad data")).once
+            @sender.send(:http_send, :send_request, @target, @packet, @received_at, @callback).should be_true
+            @response.results.error?.should be_true
+            @response.results.content.should == "400 Bad Request: bad data"
+          end
+
+          it "responds with error result if unexpected error" do
+            @log.should_receive(:error).with(/Failed to send/, StandardError, :trace).once
+            @client.should_receive(:request).and_raise(StandardError, "unexpected").once
+            @sender.send(:http_send, :send_request, @target, @packet, @received_at, @callback).should be_true
+            @response.results.error?.should be_true
+            @response.results.content.should == "Agent agent internal error"
+          end
         end
       end
     end
-  end
 
-  describe "when making a send_persistent_request" do
-    before(:each) do
-      @timer = flexmock("timer")
-      flexmock(EM::Timer).should_receive(:new).and_return(@timer).by_default
-      @broker_id = "rs-broker-host-123"
-      @broker_ids = [@broker_id]
-      @broker = flexmock("Broker", :subscribe => true, :publish => @broker_ids, :connected? => true,
-                         :identity_parts => ["host", 123, 0, 0]).by_default
-      @agent = flexmock("Agent", :identity => "agent", :broker => @broker,
-                        :options => {:ping_interval => 0, :time_to_live => 100}).by_default
-      RightScale::Sender.new(@agent)
-      @instance = RightScale::Sender.instance
-      @instance.initialize_offline_queue
-    end
+    context :amqp do
+      before(:each) do
+        @sender = create_sender(:amqp)
+        flexmock(RightSupport::Data::UUID).should_receive(:generate).and_return(@token).by_default
+        @packet = @sender.build_packet(:send_push, @type, @payload, @target, @token, nil)
+        @received_at = Time.now
+        flexmock(Time).should_receive(:now).and_return(@received_at)
+        @response = nil
+        @callback = lambda { |response| @response = response }
+      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 => true, :mandatory => true)).once
-      @instance.send_persistent_request('/welcome/aboard', 'iZac') {|_|}
-    end
+      context :amqp_send do
+        it "stores pending request for use in responding if callback specified" do
+          @packet = @sender.build_packet(:send_push, @type, @payload, @target, @token, @callback)
+          flexmock(@sender).should_receive(:amqp_send_once)
+          @sender.send(:amqp_send, :send_push, @target, @packet, @received_at, @callback).should be_true
+          @sender.pending_requests[@token].should_not be_nil
+        end
 
-    it "should set correct attributes on the request message" do
-      flexmock(Time).should_receive(:now).and_return(Time.at(1000000))
-      @broker.should_receive(:publish).with(hsh(:name => "request"), on do |request|
-        request.type.should == '/welcome/aboard'
-        request.token.should_not be_nil
-        request.persistent.should be_true
-        request.from.should == 'agent'
-        request.target.should be_nil
-        request.expires_at.should == 0
-      end, hsh(:persistent => true, :mandatory => true)).once
-      @instance.send_persistent_request('/welcome/aboard', 'iZac') {|_|}
-    end
+        it "does not store pending request if callback not specified" do
+          flexmock(@sender).should_receive(:amqp_send_once)
+          @sender.send(:amqp_send, :send_push, @target, @packet, @received_at, nil).should be_true
+          @sender.pending_requests[@token].should be_nil
+        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') {|_|}
-    end
+        it "publishes without retry capability if send_push" do
+          flexmock(@sender).should_receive(:amqp_send_once).with(@packet).once
+          @sender.send(:amqp_send, :send_push, @target, @packet, @received_at, nil).should be_true
+        end
 
-    it "should set the correct target selectors if specified" do
-      @broker.should_receive(:publish).with(hsh(:name => "request"), on do |request|
-        request.tags.should == ['tag']
-        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}) {|_|}
-    end
+        it "publishes with retry capability if send_request" do
+          @packet = @sender.build_packet(:send_request, @type, @payload, @target, @token, @callback)
+          flexmock(@sender).should_receive(:amqp_send_retry).with(@packet, @token).once
+          @sender.send(:amqp_send, :send_request, @target, @packet, @received_at, @callback).should be_true
+        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') {|_|}
-    end
+        context "when fails" do
+
+          context "with offline error" do
+            it "submits request to offline handler if queuing" do
+              @sender = create_sender(:amqp, :offline_queueing => true)
+              @sender.initialize_offline_queue
+              @sender.enable_offline_mode
+              flexmock(@sender).should_receive(:amqp_send_once).and_raise(RightScale::Sender::TemporarilyOffline).once
+              @sender.send(:amqp_send, :send_push, @target, @packet, @received_at, nil).should be_true
+              @sender.offline_handler.queue.size.should == 1
+              @sender.pending_requests[@token].should be_nil
+            end
+
+            it "responds with retry result if not queueing" do
+              flexmock(@sender).should_receive(:amqp_send_once).and_raise(RightScale::Sender::TemporarilyOffline).once
+              @sender.send(:amqp_send, :send_push, @target, @packet, @received_at, @callback).should be_true
+              @sender.offline_handler.queue.size.should == 0
+              @sender.pending_requests[@token].should_not be_nil # because send_push does not get deleted when deliver
+              @response.results.retry?.should be_true
+              @response.results.content.should == "lost RightNet connectivity"
+            end
+          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 "responds with non-delivery result if send failure" do
+            flexmock(@sender).should_receive(:amqp_send_once).and_raise(RightScale::Sender::SendFailure).once
+            @sender.send(:amqp_send, :send_push, @target, @packet, @received_at, @callback).should be_true
+            @sender.pending_requests[@token].should_not be_nil # because send_push does not get deleted when deliver
+            @response.results.non_delivery?.should be_true
+            @response.results.content.should == "send failed unexpectedly"
+          end
+        end
+      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
+      context :amqp_send_once do
+        it "publishes request to request queue" do
+          @client.should_receive(:publish).with(hsh(:name => "request"), @packet, hsh(:persistent => true,
+              :mandatory => true, :broker_ids => nil)).and_return(@broker_ids).once
+          @sender.send(:amqp_send_once, @packet, @broker_ids).should == @broker_ids
+        end
 
-  describe "when handling a response" do
-    before(:each) do
-      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
-      @agent = flexmock("Agent", :identity => "agent", :broker => @broker, :options => {:ping_interval => 0}).by_default
-      RightScale::Sender.new(@agent)
-      @instance = RightScale::Sender.instance
-      flexmock(RightScale::AgentIdentity, :generate => 'token1')
-    end
+        context "when fails" do
+          it "raises TemporarilyOffline if no connected brokers" do
+            @log.should_receive(:error).with(/Failed to publish/, RightAMQP::HABrokerClient::NoConnectedBrokers).once
+            @client.should_receive(:publish).and_raise(RightAMQP::HABrokerClient::NoConnectedBrokers).once
+            lambda { @sender.send(:amqp_send_once, @packet) }.should raise_error(RightScale::Sender::TemporarilyOffline)
+          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).once
-      @instance.handle_response(response)
-    end
+          it "raises SendFailure if unexpected exception" do
+            @log.should_receive(:error).with(/Failed to publish/, StandardError, :trace).once
+            @client.should_receive(:publish).and_raise(StandardError, "unexpected").once
+            lambda { @sender.send(:amqp_send_once, @packet) }.should raise_error(RightScale::Sender::SendFailure)
+          end
+        end
+      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).once
-      @instance.handle_response(response)
-    end
+      context :amqp_send_retry do
+        before(:each) do
+          flexmock(RightSupport::Data::UUID).should_receive(:generate).and_return("retry token")
+          @packet = @sender.build_packet(:send_request, @type, @payload, @target, @token, @callback)
+        end
 
-    it "should not deliver TARGET_NOT_CONNECTED response for send_retryable_request" do
-      @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)
-    end
+        it "publishes request to request queue" do
+          @client.should_receive(:publish).with(hsh(:name => "request"), @packet, hsh(:persistent => nil,
+              :mandatory => true, :broker_ids => nil)).and_return(@broker_ids).once
+          @sender.send(:amqp_send_retry, @packet, @token).should be_true
+        end
 
-    it "should record non-delivery regardless of whether there is a response handler" do
-      @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)
-      @instance.instance_variable_get(:@non_delivery_stats).total.should == 1
-    end
+        it "does not rescue if publish fails" do
+          @log.should_receive(:error).with(/Failed to publish request/, RightAMQP::HABrokerClient::NoConnectedBrokers).once
+          @client.should_receive(:publish).and_raise(RightAMQP::HABrokerClient::NoConnectedBrokers).once
+          lambda { @sender.send(:amqp_send_retry, @packet, @token) }.should raise_error(RightScale::Sender::TemporarilyOffline)
+        end
 
-    it "should log non-delivery if there is no response handler" do
-      @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)
-    end
+        it "does not retry if retry timeout not set" do
+          @sender = create_sender(:amqp, :retry_interval => 10)
+          @client.should_receive(:publish).once
+          flexmock(EM).should_receive(:add_timer).never
+          @sender.send(:amqp_send_retry, @packet, @token).should be_true
+        end
 
-    it "should log a debug message if request no longer pending" do
-      @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)
-    end
-  end
+        it "does not retry if retry interval not set" do
+          @sender = create_sender(:amqp, :retry_timeout => 60)
+          @client.should_receive(:publish).once
+          flexmock(EM).should_receive(:add_timer).never
+          @sender.send(:amqp_send_retry, @packet, @token).should be_true
+        end
 
-  describe "when delivering a response" do
-    before(:each) do
-      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
-      @agent = flexmock("Agent", :identity => "agent", :broker => @broker, :options => {:ping_interval => 0}).by_default
-      RightScale::Sender.new(@agent)
-      @instance = RightScale::Sender.instance
-      flexmock(RightScale::AgentIdentity, :generate => 'token1')
-    end
+        context "when retry enabled" do
+          it "uses timer to wait for a response" do
+            @sender = create_sender(:amqp, :retry_timeout => 0.3, :retry_interval => 0.1)
+            @client.should_receive(:publish).once
+            flexmock(EM).should_receive(:add_timer).once
+            @sender.send(:amqp_send_retry, @packet, @token).should be_true
+          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)
-      @instance.pending_requests['token1'].should be_nil
-    end
+          it "stops retrying if response was received" do
+            @sender = create_sender(:amqp, :retry_timeout => 0.3, :retry_interval => 0.1)
+            @client.should_receive(:publish).once
+            flexmock(EM).should_receive(:add_timer).and_yield.once
+            @sender.send(:amqp_send_retry, @packet, @token).should be_true
+            @sender.pending_requests[@token].should be_nil
+          end
 
-    it "should not delete any pending Push requests" 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)
-      @instance.pending_requests['token1'].should_not be_nil
-    end
+          it "keeps retrying if has not exceeded retry timeout" do
+            EM.run do
+              @sender = create_sender(:amqp, :retry_timeout => 0.3, :retry_interval => 0.1)
+              @client.should_receive(:publish).and_return(@broker_ids).twice
+              flexmock(@sender.connectivity_checker).should_receive(:check).once
+              @sender.send(:amqp_send, :send_request, @target, @packet, @received_at, @callback).should be_true
+
+              EM.add_timer(0.15) do
+                @sender.pending_requests.empty?.should be_false
+                result = RightScale::Result.new(@token, nil, RightScale::OperationResult.success, nil)
+                @sender.handle_response(result)
+              end
+
+              EM.add_timer(0.3) do
+                EM.stop
+                @response.results.success?.should be_true
+                @sender.pending_requests.empty?.should be_true
+              end
+            end
+          end
 
-    it "should delete any associated retry requests" do
-      @instance.send_retryable_request('/welcome/aboard', 'iZac') {|_|}
-      @instance.pending_requests['token1'].should_not be_nil
-      @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)
-      @instance.pending_requests['token1'].should be_nil
-      @instance.pending_requests['token2'].should be_nil
-    end
+          it "stops retrying and responds with non-delivery result if exceeds retry timeout" do
+            EM.run do
+              @sender = create_sender(:amqp, :retry_timeout => 0.1, :retry_interval => 0.1)
+              @client.should_receive(:publish).and_return(@broker_ids).once
+              @log.should_receive(:warning).once
+              flexmock(@sender.connectivity_checker).should_receive(:check).once
+              @sender.send(:amqp_send, :send_request, @target, @packet, @received_at, @callback).should be_true
+
+              EM.add_timer(0.3) do
+                EM.stop
+                @response.results.non_delivery?.should be_true
+                @response.results.content.should == RightScale::OperationResult::RETRY_TIMEOUT
+                @sender.pending_requests.empty?.should be_true
+              end
+            end
+          end
 
-    it "should call the response handler" 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)
-      called.should == 1
-    end
-  end
+          it "stops retrying if temporarily offline" do
+            @sender = create_sender(:amqp, :retry_timeout => 0.3, :retry_interval => 0.1)
+            @client.should_receive(:publish).and_return(@broker_ids).once.ordered
+            @client.should_receive(:publish).and_raise(RightAMQP::HABrokerClient::NoConnectedBrokers).once.ordered
+            flexmock(EM).should_receive(:add_timer).and_yield.once
+            @log.should_receive(:error).with(/Failed to publish request/, RightAMQP::HABrokerClient::NoConnectedBrokers).once
+            @log.should_receive(:error).with(/Failed retry.*temporarily offline/).once
+            @sender.send(:amqp_send, :send_request, @target, @packet, @received_at, @callback).should be_true
+            @sender.pending_requests[@token].should_not be_nil
+            @sender.pending_requests["retry token"].should_not be_nil
+          end
 
-  describe "when use offline queueing" do
-    before(:each) do
-      @broker = flexmock("Broker", :subscribe => true, :publish => ["broker"], :connected? => true,
-                         :identity_parts => ["host", 123, 0, 0]).by_default
-      @agent = flexmock("Agent", :identity => "agent", :broker => @broker, :options => {:offline_queueing => true}).by_default
-      RightScale::Sender.new(@agent)
-      @instance = RightScale::Sender.instance
-      @instance.initialize_offline_queue
-    end
+          it "stops retrying if there is a send failure" do
+            @sender = create_sender(:amqp, :retry_timeout => 0.3, :retry_interval => 0.1)
+            @client.should_receive(:publish).and_return(@broker_ids).once.ordered
+            @client.should_receive(:publish).and_raise(StandardError, "failed").once.ordered
+            flexmock(EM).should_receive(:add_timer).and_yield.once
+            @log.should_receive(:error).with(/Failed to publish request/, StandardError, :trace).once
+            @log.should_receive(:error).with(/Failed retry.*send failure/).once
+            @sender.send(:amqp_send, :send_request, @target, @packet, @received_at, @callback).should be_true
+            @sender.pending_requests[@token].should_not be_nil
+            @sender.pending_requests["retry token"].should_not be_nil
+          end
 
-    it 'should queue requests prior to offline handler initialization and then flush once started' do
-      old_flush_delay = RightScale::Sender::OfflineHandler::MAX_QUEUE_FLUSH_DELAY
-      RightScale::Sender.new(@agent)
-      @instance = RightScale::Sender.instance
-      begin
-        RightScale::Sender::OfflineHandler.const_set(:MAX_QUEUE_FLUSH_DELAY, 0.1)
-        EM.run do
-          @instance.send_push('/dummy', 'payload')
-          @instance.offline_handler.offline?.should be_true
-          @instance.offline_handler.state.should == :created
-          @instance.offline_handler.instance_variable_get(:@queue).size.should == 1
-          @instance.initialize_offline_queue
-          @broker.should_receive(:publish).once.and_return { EM.stop }
-          @instance.start_offline_queue
-          EM.add_timer(1) { EM.stop }
+          it "stops retrying if there is an unexpected exception" do
+            # This will actually call amqp_send_retry 3 times recursively because add_timer always yields immediately
+            @sender = create_sender(:amqp, :retry_timeout => 0.3, :retry_interval => 0.1)
+            @client.should_receive(:publish).and_return(@broker_ids)
+            @log.should_receive(:error).with(/Failed retry.*without responding/, StandardError, :trace).twice
+            flexmock(EM).should_receive(:add_timer).and_yield
+            flexmock(@sender.connectivity_checker).should_receive(:check).and_raise(StandardError).once
+            @sender.send(:amqp_send, :send_request, @target, @packet, @received_at, @callback).should be_true
+            @sender.pending_requests[@token].should_not be_nil
+            @sender.pending_requests["retry token"].should_not be_nil
+          end
         end
-      ensure
-        RightScale::Sender::OfflineHandler.const_set(:MAX_QUEUE_FLUSH_DELAY, old_flush_delay)
       end
     end
 
-    it 'should not queue requests prior to offline handler startup if not offline' do
-      old_flush_delay = RightScale::Sender::OfflineHandler::MAX_QUEUE_FLUSH_DELAY
-      RightScale::Sender.new(@agent)
-      @instance = RightScale::Sender.instance
-      begin
-        RightScale::Sender::OfflineHandler.const_set(:MAX_QUEUE_FLUSH_DELAY, 0.1)
-        EM.run do
-          @instance.send_push('/dummy', 'payload')
-          @instance.offline_handler.offline?.should be_true
-          @instance.offline_handler.state.should == :created
-          @instance.offline_handler.instance_variable_get(:@queue).size.should == 1
-          @instance.initialize_offline_queue
-          @broker.should_receive(:publish).with(Hash, on {|arg| arg.type == "/dummy2"}, Hash).once
-          @instance.send_push('/dummy2', 'payload')
-          @instance.offline_handler.offline?.should be_false
-          @instance.offline_handler.mode.should == :initializing
-          @instance.offline_handler.state.should == :initializing
-          @instance.offline_handler.instance_variable_get(:@queue).size.should == 1
-          @instance.offline_handler.instance_variable_get(:@queue).first[:type].should == "/dummy"
-          @broker.should_receive(:publish).with(Hash, on {|arg| arg.type == "/dummy"}, Hash).once
-          @instance.start_offline_queue
-          EM.add_timer(1) do
-            @instance.offline_handler.mode.should == :online
-            @instance.offline_handler.state.should == :running
-            @instance.offline_handler.instance_variable_get(:@queue).size.should == 0
-            EM.stop
-          end
-        end
-      ensure
-        RightScale::Sender::OfflineHandler.const_set(:MAX_QUEUE_FLUSH_DELAY, old_flush_delay)
+    context :deliver_response do
+      before(:each) do
+        @received_at = Time.now
+        flexmock(Time).should_receive(:now).and_return(@received_at)
+        @response = nil
+        @callback = lambda { |response| @response = response }
       end
-    end
 
-    it 'should queue requests at front if received after offline handler initialization but before startup' do
-      old_flush_delay = RightScale::Sender::OfflineHandler::MAX_QUEUE_FLUSH_DELAY
-      RightScale::Sender.new(@agent)
-      @instance = RightScale::Sender.instance
-      begin
-        RightScale::Sender::OfflineHandler.const_set(:MAX_QUEUE_FLUSH_DELAY, 0.1)
-        EM.run do
-          @instance.send_push('/dummy', 'payload')
-          @instance.offline_handler.offline?.should be_true
-          @instance.offline_handler.state.should == :created
-          @instance.offline_handler.instance_variable_get(:@queue).size.should == 1
-          @instance.initialize_offline_queue
-          @instance.offline_handler.offline?.should be_false
-          @instance.offline_handler.mode.should == :initializing
-          @instance.offline_handler.state.should == :initializing
-          @instance.enable_offline_mode
-          @instance.send_push('/dummy2', 'payload')
-          @instance.offline_handler.offline?.should be_true
-          @instance.offline_handler.mode.should == :offline
-          @instance.offline_handler.state.should == :initializing
-          @instance.offline_handler.instance_variable_get(:@queue).size.should == 2
-          @instance.offline_handler.instance_variable_get(:@queue).first[:type].should == "/dummy2"
-          @instance.start_offline_queue
-          @instance.offline_handler.mode.should == :offline
-          @instance.offline_handler.state.should == :running
-          @broker.should_receive(:publish).with(Hash, on {|arg| arg.type == "/dummy2"}, Hash).once
-          @broker.should_receive(:publish).with(Hash, on {|arg| arg.type == "/dummy"}, Hash).once
-          @instance.disable_offline_mode
-          @instance.offline_handler.state.should == :flushing
-          EM.add_timer(1) do
-            @instance.offline_handler.mode.should == :online
-            @instance.offline_handler.state.should == :running
-            @instance.offline_handler.instance_variable_get(:@queue).size.should == 0
-            EM.stop
-          end
-        end
-      ensure
-        RightScale::Sender::OfflineHandler.const_set(:MAX_QUEUE_FLUSH_DELAY, old_flush_delay)
+      it "calls the response handler" do
+        pending_request = RightScale::PendingRequest.new(:send_request, @received_at, @callback)
+        @sender.pending_requests[@token] = pending_request
+        response = RightScale::Result.new(@token, "to", RightScale::OperationResult.success, @target)
+        @sender.send(:deliver_response, response, pending_request).should be_true
+        @response.should == response
       end
-    end
 
-    it 'should vote for restart after the maximum number of queued requests is reached' do
-      @instance.offline_handler.instance_variable_get(:@restart_vote_count).should == 0
-      EM.run do
-        @instance.enable_offline_mode
-        @instance.offline_handler.queue = ('*' * (RightScale::Sender::OfflineHandler::MAX_QUEUED_REQUESTS - 1)).split(//)
-        @instance.send_push('/dummy', 'payload')
-        EM.next_tick { EM.stop }
+      it "deletes associated pending request if is it a Request" do
+        pending_request = RightScale::PendingRequest.new(:send_request, @received_at, @callback)
+        @sender.pending_requests[@token] = pending_request
+        response = RightScale::Result.new(@token, "to", RightScale::OperationResult.success, @target)
+        @sender.send(:deliver_response, response, pending_request).should be_true
+        @sender.pending_requests[@token].should be_nil
       end
-      @instance.offline_handler.queue.size.should == RightScale::Sender::OfflineHandler::MAX_QUEUED_REQUESTS
-      @instance.offline_handler.instance_variable_get(:@restart_vote_count).should == 1
-    end
 
-    it 'should vote for restart after the threshold delay is reached' do
-      old_vote_delay = RightScale::Sender::OfflineHandler::RESTART_VOTE_DELAY
-      begin
-        RightScale::Sender::OfflineHandler.const_set(:RESTART_VOTE_DELAY, 0.1)
-        @instance.offline_handler.instance_variable_get(:@restart_vote_count).should == 0
-        EM.run do
-          @instance.enable_offline_mode
-          @instance.send_push('/dummy', 'payload')
-          EM.add_timer(0.5) { EM.stop }
-        end
-        @instance.offline_handler.instance_variable_get(:@restart_vote_count).should == 1
-      ensure
-        RightScale::Sender::OfflineHandler.const_set(:RESTART_VOTE_DELAY, old_vote_delay)
+      it "does not delete pending request if it is a Push" do
+        pending_request = RightScale::PendingRequest.new(:send_push, @received_at, @callback)
+        @sender.pending_requests[@token] = pending_request
+        response = RightScale::Result.new(@token, "to", RightScale::OperationResult.success, @target)
+        @sender.send(:deliver_response, response, pending_request).should be_true
+        @sender.pending_requests[@token].should_not be_nil
       end
-    end
 
-    it 'should not flush queued requests until back online' do
-      old_flush_delay = RightScale::Sender::OfflineHandler::MAX_QUEUE_FLUSH_DELAY
-      begin
-        RightScale::Sender::OfflineHandler.const_set(:MAX_QUEUE_FLUSH_DELAY, 0.1)
-        EM.run do
-          @instance.enable_offline_mode
-          @instance.send_push('/dummy', 'payload')
-          EM.add_timer(0.5) { EM.stop }
-        end
-      ensure
-        RightScale::Sender::OfflineHandler.const_set(:MAX_QUEUE_FLUSH_DELAY, old_flush_delay)
+      it "deletes any associated retry requests" do
+        @parent_token = RightSupport::Data::UUID.generate
+        pending_request = RightScale::PendingRequest.new(:send_request, @received_at, @callback)
+        @sender.pending_requests[@token] = pending_request
+        @sender.pending_requests[@token].retry_parent_token = @parent_token
+        @sender.pending_requests[@parent_token] = @sender.pending_requests[@token].dup
+        response = RightScale::Result.new(@token, "to", RightScale::OperationResult.success, @target)
+        @sender.send(:deliver_response, response, pending_request).should be_true
+        @sender.pending_requests[@token].should be_nil
+        @sender.pending_requests[@parent_token].should be_nil
       end
     end
 
-    it 'should flush queued requests once back online' do
-      old_flush_delay = RightScale::Sender::OfflineHandler::MAX_QUEUE_FLUSH_DELAY
-      @broker.should_receive(:publish).once.and_return { EM.stop }
-      begin
-        RightScale::Sender::OfflineHandler.const_set(:MAX_QUEUE_FLUSH_DELAY, 0.1)
-        EM.run do
-          @instance.enable_offline_mode
-          @instance.send_push('/dummy', 'payload')
-          @instance.disable_offline_mode
-          EM.add_timer(1) { EM.stop }
-        end
-      ensure
-        RightScale::Sender::OfflineHandler.const_set(:MAX_QUEUE_FLUSH_DELAY, old_flush_delay)
+    context :queueing? do
+      it "returns true if offline handling enabled and currently in queueing mode" do
+        @sender = create_sender(:http, :offline_queueing => true)
+        flexmock(@sender.offline_handler).should_receive(:queueing?).and_return(true)
+        @sender.send(:queueing?).should be_true
       end
-    end
 
-    it 'should stop flushing when going back to offline mode' do
-      old_flush_delay = RightScale::Sender::OfflineHandler::MAX_QUEUE_FLUSH_DELAY
-      begin
-        RightScale::Sender::OfflineHandler.const_set(:MAX_QUEUE_FLUSH_DELAY, 0.1)
-        EM.run do
-          @instance.enable_offline_mode
-          @instance.send_push('/dummy', 'payload')
-          @instance.disable_offline_mode
-          @instance.offline_handler.state.should == :flushing
-          @instance.offline_handler.mode.should == :offline
-          @instance.enable_offline_mode
-          @instance.offline_handler.state.should == :running
-          @instance.offline_handler.mode.should == :offline
-          EM.add_timer(1) do
-            @instance.offline_handler.state.should == :running
-            @instance.offline_handler.mode.should == :offline
-            EM.stop
-          end
-        end
-      ensure
-        RightScale::Sender::OfflineHandler.const_set(:MAX_QUEUE_FLUSH_DELAY, old_flush_delay)
+      it "returns false if offline handling disabled" do
+        flexmock(@sender.offline_handler).should_receive(:queueing?).and_return(true)
+        @sender.send(:queueing?).should be_false
+      end
+
+      it "returns false if offline handling enabled but not in queueing mode" do
+        @sender = create_sender(:http, :offline_queueing => true)
+        flexmock(@sender.offline_handler).should_receive(:queueing?).and_return(false)
+        @sender.send(:queueing?).should be_false
       end
     end
   end
-
 end