nebulous_stomp 3.0.3 → 3.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d829397b774f8ca1f753608232eb30c093b472aa
-  data.tar.gz: 96cf42699373c6a8aa211a438070bc2ef80987fb
+  metadata.gz: 8263873ebd87c126cae0e78178a0c3b5e6388429
+  data.tar.gz: 266d35ec2d7e97741865635443cc24399539dbeb
 SHA512:
-  metadata.gz: 0462b28f99ac571c52ea71af2cc8fac798236f9241fdb8b1d674a0e17e058b09a63faa0293d1bb40799d9944c04c8524752f055214d06495ac107f61a7a97081
-  data.tar.gz: aa2a93daddef2ace0a6c8460bcd824caef96805e340b566d9aa3bb08ba378a71bfe735d4053051ac08f48dace6a73b3b52b73d0f44be9fb31bc1cf0ca93f3142
+  metadata.gz: aa8eae3582fec3acfd756e3a5f0840068c7d7043794032a918cda932fe2e6a8538c34b65bab87ca96e9cab877ed1a841699786b18ffd789909814e92b0a72e7f
+  data.tar.gz: 6c5e70125308561d3e19a7c2683feb5cd70cb31be44b42d4a7d37b9ae9ec532357ed702e0dbc4e0a48b6c58edb072f3774cf8697c0d866146bbc1a912490ba9d

data/lib/nebulous_stomp/request.rb

@@ -25,7 +25,8 @@ module NebulousStomp
     attr_reader :message
 
     # If you are testing you can write these with a test object like StompHandlerNull for example
-    attr_writer :stomp_handler, :redis_handler
+    attr_reader :stomp_handler
+    attr_writer :redis_handler
 
     ##
     # :call-seq:
@@ -37,9 +38,11 @@ module NebulousStomp
       @target  = parse_target(target)
       @message = parse_message(message, @target)
       NebulousStomp.logger.debug(__FILE__) { "New Request for verb #{@message.verb}" }
+    end
 
-      # Get a connection to StompHandler ASAP and set reply_id on @message
-      ensure_stomp_connected if NebulousStomp.on?
+    def stomp_handler=(handler)
+      @stomp_handler = handler
+      ensure_stomp_connected # so that we get a reply_id on the message ASAP.
     end
 
     ##

data/lib/nebulous_stomp/version.rb

@@ -1,5 +1,5 @@
 module NebulousStomp
 
   # Nebulous version number
-  VERSION = "3.0.3"
+  VERSION = "3.0.4"
 end

data/spec/listener_spec.rb

@@ -1,5 +1,5 @@
-require 'nebulous_stomp/listener'
-require 'nebulous_stomp/stomp_handler_null'
+require "nebulous_stomp/listener"
+require "nebulous_stomp/stomp_handler_null"
 
 include NebulousStomp
 
@@ -10,6 +10,13 @@ describe Listener do
   let(:listener1) { Listener.new(target1) }
   let(:handler)   { StompHandlerNull.new }
 
+  before(:each) do
+    # These tests should not call the Stomp gem.  Now if they do, we get an error, because our
+    # fakestomp object doesn't have any methods.
+    fakestomp = double("fakestomp")
+    allow( Stomp::Client ).to receive(:new).and_return( fakestomp )
+  end
+
 
   describe "#new" do
 
@@ -20,7 +27,7 @@ describe Listener do
       expect{ Listener.new "alpha" }.not_to raise_error
     end
 
-  end
+  end # of #new
 
 
   describe "#queue" do
@@ -33,7 +40,7 @@ describe Listener do
       expect( Listener.new(target1).queue ).to eq target1.receive_queue
     end
 
-  end
+  end # of #queue
 
 
   describe "#stomp_handler" do
@@ -47,12 +54,11 @@ describe Listener do
       expect( listener1.send(:stomp_handler).class ).to eq StompHandler
     end
 
-  end
+  end # of #stomp_handler
 
 
   describe "#consume_messages" do
-
-    before do
+    before(:each) do
       listener1.stomp_handler = handler
       handler.insert_fake "foo"
       handler.insert_fake "bar"
@@ -63,14 +69,11 @@ describe Listener do
       expect{|b| listener1.consume_messages &b }.to yield_successive_args("foo", "bar", "baz")
     end
     
-  end
+  end # of consume_messages
 
 
   describe "#reply" do
-
-    before do
-      listener1.stomp_handler = handler
-    end
+    before(:each) { listener1.stomp_handler = handler }
 
     it "takes a queue name and a Message object" do
       expect{ listener1.reply        }.to raise_error ArgumentError
@@ -85,7 +88,7 @@ describe Listener do
       listener1.reply("beta", "bar")
     end
 
-  end
+  end # of #reply
 
 
   describe "#quit" do
@@ -95,9 +98,8 @@ describe Listener do
       expect( handler ).to receive(:stomp_disconnect)
       listener1.quit
     end
-      
     
-  end
+  end # of #quit
   
 
 end

data/spec/message_spec.rb

@@ -1,6 +1,6 @@
-require 'nebulous_stomp/message'
+require "nebulous_stomp/message"
 
-require_relative 'helpers'
+require_relative "helpers"
 
 include NebulousStomp
 
@@ -25,7 +25,6 @@ describe Message do
 
   end
 
-
   let(:new_hash_body) do
     { verb: 'Velma', parameters: 'Shaggy', description:'Scooby' }
   end
@@ -66,14 +65,21 @@ describe Message do
 
   let(:msg_cache) { Message.from_cache( json_hash.to_json ) }
 
+  before(:each) do
+    # These tests should not call the Stomp gem.  Now if they do, we get an error, because our
+    # fakestomp object doesn't have any methods.
+    fakestomp = double("fakestomp")
+    allow( Stomp::Client ).to receive(:new).and_return( fakestomp )
+  end
+
 
-  describe 'Message.new' do
+  describe "Message.new" do
 
-    it 'returns a Message object' do
+    it "returns a Message object" do
       expect( msg_new ).to be_a_kind_of(Message)
     end
 
-    it 'sets protocol attributes when they are given' do
+    it "sets protocol attributes when they are given" do
       expect( msg_new.reply_to    ).to eq new_hash[:replyTo]
       expect( msg_new.in_reply_to ).to eq new_hash[:inReplyTo]
       expect( msg_new.verb        ).to eq new_hash[:verb]
@@ -126,7 +132,7 @@ describe Message do
       expect( m.body ).to eq([])
     end
 
-    it 'takes the content type from the input arguments' do
+    it "takes the content type from the input arguments" do
       msg = Message.new( new_hash.merge(contentType: 'foo') )
       expect( msg.content_type ).to eq "foo"
     end
@@ -141,11 +147,10 @@ describe Message do
       expect{ Message.new(body: 'bar')                 }.not_to raise_exception
     end
 
-  end
-  ##
+  end # of Message.new
 
 
-  describe 'Message.in_reply_to' do
+  describe "Message.in_reply_to" do
 
     it "requires a message to reply to and a hash" do
       expect{ Message.in_reply_to()             }.to raise_error ArgumentError
@@ -170,24 +175,23 @@ describe Message do
       expect( msg.in_reply_to ).to eq msg_new2.reply_id
     end
 
-  end
-  ##
+  end # of Message.in_reply_to
 
 
-  describe 'Message.from_stomp' do
+  describe "Message.from_stomp" do
 
-    it 'requires a Stomp::Message' do
+    it "requires a Stomp::Message" do
       expect{ Message.from_stomp        }.to raise_exception ArgumentError
       expect{ Message.from_stomp('foo') }.to raise_exception ArgumentError
       expect{ Message.from_stomp(smess) }.not_to raise_exception
     end
 
-    it 'sets stomp attributes' do
+    it "sets stomp attributes" do
       expect( msg_stomp.stomp_headers ).to include smess.headers
       expect( msg_stomp.stomp_body    ).to eq smess.body
     end
 
-    it 'still works if there are no Protocol attributes to set' do
+    it "still works if there are no Protocol attributes to set" do
       expect( msg_stomp.verb        ).to eq nil
       expect( msg_stomp.params      ).to eq nil
       expect( msg_stomp.desc        ).to eq nil
@@ -195,7 +199,7 @@ describe Message do
       expect( msg_stomp.in_reply_to ).to eq nil
     end
 
-    it 'sets the content type to whatever the headers say it is' do
+    it "sets the content type to whatever the headers say it is" do
       b = { verb:   'tom',
             params: 'dick',
             desc:   'harry' }.to_json
@@ -205,12 +209,11 @@ describe Message do
     end
 
     context "when the message body is text" do
-
-      it 'returns a Message object' do
+      it "returns a Message object" do
         expect( msg_stomp ).to be_a_kind_of Message
       end
 
-      it 'sets Protocol attributes if it can' do
+      it "sets Protocol attributes if it can" do
         body = {verb: 'Dougal', params: 'Florence', desc: 'Ermintrude'}
         mess = stomp_message('application/json', body.to_json, '23')
         msg  = Message.from_stomp(mess)
@@ -219,37 +222,31 @@ describe Message do
         expect( msg.desc        ).to eq 'Ermintrude'
         expect( msg.in_reply_to ).to eq '23'
       end
-
     end
 
-
     context "when the message body is JSON" do
-      
       let(:msg_stomp_json) do
         m = {verb: 'one', params: 'two', desc: 'three'}.to_json
         x = stomp_message('application/json', m, '19')
         Message.from_stomp(x)
       end
 
-      it 'returns a Message object' do
+      it "returns a Message object" do
         expect( msg_stomp_json ).to be_a_kind_of Message
       end
 
-      it 'sets Protocol attributes if it can' do
+      it "sets Protocol attributes if it can" do
         expect( msg_stomp_json.verb        ).to eq 'one'
         expect( msg_stomp_json.params      ).to eq 'two'
         expect( msg_stomp_json.desc        ).to eq 'three'
         expect( msg_stomp_json.in_reply_to ).to eq '19'
       end
-
     end
 
-  end
-  ##
-
+  end # of Message.from_stomp
 
-  describe 'Message.from_cache' do
 
+  describe "Message.from_cache" do
     let(:msg2) do
       x = { replyId:      '1234',
             contentType:  'application/json' }.to_json
@@ -257,8 +254,7 @@ describe Message do
       Message.from_cache(x)
     end
 
-
-    it 'requires some json in the right format' do
+    it "requires some json in the right format" do
       expect{ Message.from_cache              }.to raise_exception ArgumentError
       expect{ Message.from_cache('foo')       }.to raise_exception ArgumentError
       expect{ Message.from_cache({})          }.to raise_exception ArgumentError
@@ -277,7 +273,7 @@ describe Message do
       expect{ Message.from_cache(loony2.to_json) }.not_to raise_exception
     end
 
-    it 'still works if there are no Protocol attributes to set' do
+    it "still works if there are no Protocol attributes to set" do
       expect( msg2.verb        ).to eq nil
       expect( msg2.params      ).to eq nil
       expect( msg2.desc        ).to eq nil
@@ -285,7 +281,7 @@ describe Message do
       expect( msg2.in_reply_to ).to eq nil
     end
 
-    it 'sets Protocol attributes if it can' do 
+    it "sets Protocol attributes if it can" do 
       expect( msg_cache.verb        ).to eq 'tom'
       expect( msg_cache.params      ).to eq 'dick'
       expect( msg_cache.desc        ).to eq 'harry'
@@ -293,30 +289,27 @@ describe Message do
       expect( msg_cache.in_reply_to ).to eq '4321'
     end
 
-
     context "when the message body is JSON" do
       # msg_cache has a json body
 
-      it 'returns a Message object' do
+      it "returns a Message object" do
         expect( msg_cache ).to be_a_kind_of Message
       end
 
-      it 'sets the stomp attributes' do
+      it "sets the stomp attributes" do
         expect( msg_cache.stomp_headers ).
           to eq symbolise( json_hash[:stompHeaders] )
 
         expect( msg_cache.stomp_body    ).to eq json_hash[:stompBody]
       end
 
-      it 'sets the content type' do
+      it "sets the content type" do
         expect( msg_cache.content_type ).to eq json_hash[:contentType]
       end
 
     end
 
-
     context "when the message body is text" do
-
       let(:msg3_cache) do
           { stompHeaders: msg_stomp.stomp_headers,
             stompBody:    msg_stomp.stomp_body,
@@ -332,12 +325,11 @@ describe Message do
 
       let(:msg3) { Message.from_cache( msg3_cache.to_json ) }
 
-
-      it 'returns a Message object' do
+      it "returns a Message object" do
         expect( msg3 ).to be_a_kind_of Message
       end
 
-      it 'sets the stomp attributes' do
+      it "sets the stomp attributes" do
         heads = msg3_cache[:stompHeaders].each_with_object({}) do |(k,v),m|
           m[k.to_sym] = v
         end
@@ -346,34 +338,33 @@ describe Message do
         expect( msg3.stomp_body    ).to eq msg3_cache[:stompBody]
       end
 
-      it 'sets the content type' do
+      it "sets the content type" do
         expect( msg3.content_type ).to eq msg3_cache[:contentType]
       end
-
     end
 
+  end # of Message.from_cache
 
-  end
-  ##
 
+  describe "#parameters" do
 
-  describe '#parameters' do
-    it 'returns the same as @param' do
+    it "returns the same as @param" do
       expect(msg_new.parameters).to eq msg_new.params
     end
-  end
-  ##
+
+  end # of #parameters
 
 
-  describe '#description' do
-    it 'returns the same as @desc' do
+  describe "#description" do
+
+    it "returns the same as @desc" do
       expect(msg_new.description).to eq msg_new.desc
     end
-  end
-  ##
 
+  end # of #description
 
-  describe '#content_is_json?' do 
+
+  describe "#content_is_json?" do 
 
     it "returns true if the content type is JSON" do
       expect( msg_new.content_is_json? ).to be true
@@ -384,13 +375,12 @@ describe Message do
       expect( msg.content_type ).to eq "foo"
     end
 
-  end
-  ##
+  end # of #content_is_json?
 
 
-  describe '#to_h' do
+  describe "#to_h" do
 
-    it 'returns the message as a hash' do
+    it "returns the message as a hash" do
       hash = msg_new.to_h
 
       expect( hash ).to be_a_kind_of Hash
@@ -403,11 +393,11 @@ describe Message do
       expect( hash[:contentType] ).to match /json$/i 
     end
 
-    it 'always returns all the keys' do
+    it "always returns all the keys" do
       expect( msg_stomp.to_h.keys ).to include(*json_hash.keys)
     end
 
-    it "returns a hash that Message.from_cache doesn''t freak out over" do
+    it "returns a hash that Message.from_cache doesn't freak out over" do
       expect{ Message.from_cache(msg_cache.to_h.to_json) }.
         not_to raise_exception
 
@@ -415,12 +405,11 @@ describe Message do
       expect(mess.to_h).to include symbolise(json_hash)
     end
       
+  end # of #to_h
 
-  end
-  ##
 
+  describe "#protocol_json" do
 
-  describe '#protocol_json' do
     it "returns the Protocol as a JSON string" do
       hash = JSON.parse( msg_new.protocol_json, symbolize_names: true )
 
@@ -433,8 +422,8 @@ describe Message do
                      or include(description: 'Scooby')
 
     end
-  end
-  ##
+
+  end # of #protocol_json 
 
 
   describe "#body" do
@@ -462,13 +451,12 @@ describe Message do
       expect( nr.body ).to eq "foo"
     end
 
-  end
-  ##
+  end # of #body
 
 
-  describe '#headers_for_stomp' do
+  describe "#headers_for_stomp" do
 
-    it 'always returns a Hash' do
+    it "always returns a Hash" do
       expect( msg_new.headers_for_stomp   ).to be_a_kind_of Hash
       expect( msg_stomp.headers_for_stomp ).to be_a_kind_of Hash
       expect( msg_cache.headers_for_stomp ).to be_a_kind_of Hash
@@ -488,11 +476,10 @@ describe Message do
       expect( hdrs ).to include("neb-reply-id" => nil)
     end
 
-  end
-  ##
+  end # of #headers_for_stomp
 
 
-  describe '#body_for_stomp' do
+  describe "#body_for_stomp" do
 
     it "returns a JSON string for content type JSON" do
       expect{ JSON.parse(msg_cache.body_for_stomp) }.not_to raise_exception
@@ -533,11 +520,10 @@ describe Message do
 
     end
 
-  end
-  ##
+  end # of #body_for_stomp
 
 
-  describe '#respond_with_success' do
+  describe "#respond_with_success" do
 
     it "raises an error if we have no @reply_to" do
       expect{ msg_stomp.respond_with_success }.to raise_exception NebulousError
@@ -554,16 +540,15 @@ describe Message do
       expect( m.verb ).to eq 'success'
     end
 
-    it 'sets the content type from the source message' do
+    it "sets the content type from the source message" do
       _,m = msg_cache.respond_with_success
       expect( m.content_type ).to eq msg_cache.content_type
     end
 
-  end
-  ##
+  end # of #respond_with_success
 
 
-  describe '#respond_with_error' do
+  describe "#respond_with_error" do
     let(:err) { NebulousError.new("test error") }
 
     it "raises an error if we have no @reply_to" do
@@ -605,16 +590,15 @@ describe Message do
       expect( m.desc ).to eq err.message
     end
 
-    it 'sets the content type from the source message' do
+    it "sets the content type from the source message" do
       _,m = msg_cache.respond_with_error('foo')
       expect( m.content_type ).to eq msg_cache.content_type
     end
 
-  end
-  ##
+  end # of #respond_with_error
 
 
-  describe '#respond_with_protocol' do
+  describe "#respond_with_protocol" do
      
     it "raises an error if we have no @reply_to" do
       expect{ msg_stomp.respond_with_protocol('foo') }.to raise_exception NebulousError
@@ -644,16 +628,15 @@ describe Message do
       expect( m.desc   ).to eq 'flang'
     end
 
-    it 'sets the content type from the source message' do
+    it "sets the content type from the source message" do
       _,m = msg_cache.respond_with_protocol('bleem', 'drort', 'flang')
       expect( m.content_type ).to eq msg_cache.content_type
     end
 
-  end
-  ##
+  end # of #respond_with_protocol
   
   
-  describe '#respond' do
+  describe "#respond" do
 
     let(:msg) { msg_cache.respond("desmond") }
      
@@ -677,13 +660,12 @@ describe Message do
       expect( m.body ).to eq 'desmond'
     end
 
-    it 'sets the content type from the source message' do
+    it "sets the content type from the source message" do
       _,m = msg
       expect( m.content_type ).to eq msg_cache.content_type
     end
 
-  end
-  ##
+  end # of #respond
   
 
 end

data/spec/redis_handler_null_spec.rb

@@ -1,4 +1,4 @@
-require 'nebulous_stomp/redis_handler_null'
+require "nebulous_stomp/redis_handler_null"
 
 include NebulousStomp
 
@@ -11,61 +11,64 @@ describe RedisHandlerNull do
 
   let(:handler) { RedisHandlerNull.new(redis_hash) }
 
+  before(:each) do
+    # by definition we should not be calling the Redis gem.
+    # Arrange that if we do we get an error; because our double has no methods on it
+    redisfake = double("redisfake")
+    allow( Redis ).to receive(:new).and_return( redisfake )
+  end
+
 
-  describe '#connect' do
+  describe "#connect" do
 
-    it 'returns self' do
+    it "returns self" do
       expect( handler.connect ).to eq handler
     end
 
-  end
-  ##
+  end 
 
 
-  describe '#insert_fake' do
+  describe "#insert_fake" do
 
-    it 'sets the key/value to return' do
+    it "sets the key/value to return" do
       handler.insert_fake('one', 'two')
       expect( handler.fake_pair ).to eq({"one" => "two"})
     end
 
   end
-  ##
 
 
-  describe '#connected?' do
+  describe "#connected?" do
 
-    it 'returns false if we didnt call run insert_fake' do
+    it "returns false if we didnt call run insert_fake" do
       expect( handler.connected? ).to be_falsey
     end
 
-    it 'returns true if we did call insert_fake' do
+    it "returns true if we did call insert_fake" do
       handler.insert_fake('one', 'two')
       expect( handler.connected? ).to be_truthy
     end
 
   end
-  ##
   
   
-  describe '#set#' do
+  describe "#set#" do
 
-    it 'supports a key, value, option parameter like the real thing' do
+    it "supports a key, value, option parameter like the real thing" do
       expect{ handler.set('foo', 'bar', {baz: 1}) }.not_to raise_exception
     end
 
-    it 'acts like insert_fake' do
+    it "acts like insert_fake" do
       handler.set('alice', 'tom')
       expect( handler.fake_pair ).to eq({'alice' => 'tom'})
     end
 
   end
-  ##
 
 
-  describe '#get#' do
+  describe "#get#" do
 
-    it 'retreives the fake message regardless' do
+    it "retreives the fake message regardless" do
       handler.insert_fake('grr', 'arg')
       expect( handler.get('woo') ).to eq 'arg'
     end
@@ -75,19 +78,17 @@ describe RedisHandlerNull do
     end
 
   end
-  ##
 
 
-  describe '#del#' do
+  describe "#del#" do
 
-    it 'resets the fake message' do
+    it "resets the fake message" do
       handler.insert_fake('grr', 'arg')
       handler.del('woo')
       expect( handler.fake_pair ).to eq({})
     end
 
   end
-  ##
 
 end
 

data/spec/request_spec.rb

@@ -1,37 +1,13 @@
-require 'nebulous_stomp/request'
-require 'nebulous_stomp/stomp_handler_null'
-require 'nebulous_stomp/redis_handler_null'
+require "stomp"
+require "nebulous_stomp/request"
+require "nebulous_stomp/stomp_handler_null"
+require "nebulous_stomp/redis_handler_null"
 
 include NebulousStomp
 
 
 describe Request do
 
-  before do
-    @stomp_hash = { hosts: [{ login:    'guest',
-                              passcode: 'guest',
-                              host:     '10.0.0.150',
-                              port:     61613,
-                              ssl:      false }],
-                    reliable: false }
-
-    @redis_hash = {host: '127.0.0.1', port: 6379, db: 0}
-
-    @stomp_handler = StompHandlerNull.new(@stomp_hash)
-    @redis_handler = RedisHandlerNull.new(@redis_hash)
-
-    NebulousStomp.init( :stompConnectHash => @stomp_hash, 
-                        :redisConnectHash => @redis_hash,
-                        :messageTimeout   => 5,
-                        :cacheTimeout     => 20 )
-
-    NebulousStomp.add_target( :accord, 
-                              :sendQueue      => "/queue/laplace.dev",
-                              :receiveQueue   => "/queue/laplace.out",
-                              :messageTimeout => 1 )
-
-  end
-
   def new_request(target, message)
     r = Request.new(target, message)
     r.stomp_handler = @stomp_handler
@@ -78,6 +54,37 @@ describe Request do
     request
   end
 
+  before(:each) do
+    # We shouldn't be calling Stomp or Redis in these tests. If we are, this will give us an error.
+    fakestomp = double("fakestomp")
+    fakeredis = double("fakeredis")
+    allow( Stomp::Client ).to receive(:new).and_return( fakestomp )
+    allow( Redis         ).to receive(:new).and_return( fakeredis )
+
+    @stomp_hash = { hosts: [{ login:    'guest',
+                              passcode: 'guest',
+                              host:     '10.0.0.150',
+                              port:     61613,
+                              ssl:      false }],
+                    reliable: false }
+
+    @redis_hash = {host: '127.0.0.1', port: 6379, db: 0}
+
+    @stomp_handler = StompHandlerNull.new(@stomp_hash)
+    @redis_handler = RedisHandlerNull.new(@redis_hash)
+
+    NebulousStomp.init( :stompConnectHash => @stomp_hash, 
+                        :redisConnectHash => @redis_hash,
+                        :messageTimeout   => 5,
+                        :cacheTimeout     => 20 )
+
+    NebulousStomp.add_target( :accord, 
+                              :sendQueue      => "/queue/laplace.dev",
+                              :receiveQueue   => "/queue/laplace.out",
+                              :messageTimeout => 1 )
+
+  end
+
 
   describe "Request.new" do
      
@@ -114,10 +121,10 @@ describe Request do
       expect( r.message.reply_to ).to eq target1.send_queue
     end
 
-  end
+  end # of Request.new
 
 
-  describe "message_timeout" do
+  describe "#message_timeout" do
 
     it "takes the timeout on the target over the default" do
       r = new_request(target2, message1)
@@ -129,20 +136,20 @@ describe Request do
       expect( r.message_timeout ).to eq 5
     end
 
-  end
+  end # of #message_timeout
 
 
-  describe "cache_timeout" do
+  describe "#cache_timeout" do
 
     it "returns the cache timeout value stored in Param" do
       r = new_request(target1, message1)
       expect( r.cache_timeout ).to eq 20
     end
 
-  end
+  end # of #cache_timeout
 
 
-  describe "send_no_cache" do
+  describe "#send_no_cache" do
 
     it "returns a response from StompHandler" do
       response = request1.send_no_cache
@@ -163,10 +170,10 @@ describe Request do
       expect( request.send_no_cache ).to be_nil
     end
 
-  end
+  end # of #send_no_cache
   
 
-  describe "clear_cache" do
+  describe "#clear_cache" do
 
     it "removes the redis cache for a single request" do
       @redis_handler.insert_fake('foo', 'bar')
@@ -189,10 +196,10 @@ describe Request do
       expect( r.clear_cache ).to eq r
     end
 
-  end
+  end # of #clear_cache
 
   
-  describe "send" do
+  describe "#send" do
 
     it "returns a Message object from STOMP the first time" do
       response = request1.send
@@ -216,7 +223,7 @@ describe Request do
       expect( response.verb ).to eq "frog"
     end
 
-    fit "writes the response to the cache as JSON" do
+    it "writes the response to the cache as JSON" do
       response = request1.send
       expect{ JSON.parse @redis_handler.fake_pair.values.first }.not_to raise_exception
     end
@@ -247,7 +254,7 @@ describe Request do
       expect( request.send ).to be_nil
     end
 
-  end
+  end # of #send
   
 
 end

data/spec/stomp_handler_null_spec.rb

@@ -1,21 +1,60 @@
-require 'time'
-require 'nebulous_stomp/stomp_handler_null'
+require "time"
+require "nebulous_stomp/stomp_handler_null"
+require "nebulous_stomp/stomp_handler"
 
 include NebulousStomp
 
 
 describe StompHandlerNull do
 
+  def run_listen(secs)
+    got = []
+
+    handler.listen('/queue/foo') do |m|
+      got << m
+    end
+    sleep secs
+
+    got
+  end
+
+  def run_listen_with_timeout(secs)
+    got = []
+    handler.listen_with_timeout('/queue/foo', secs) do |m|
+      got << m
+    end
+
+    got
+  end
+
+  # Actually these are the real connection params, but we are going to stub, so
+  # hopefully it doesn't matter.
+  let(:stomp_hash) do
+    { hosts: [{ login:    'guest',
+                 passcode: 'guest',
+                 host:     '10.0.0.150',
+                 port:     61613,
+                 ssl:      false }],
+       reliable: false }
+  end
+
+  let(:fakestomp) { double("fakestomp") }
+
   let(:handler) do
-    StompHandlerNull.new
+    allow(Stomp::Client).to receive(:new).and_return(fakestomp)
+
+    # Normally you wouldn't bother passing a stomp connection hash to StompHandlerNull, but we need
+    # to test that we don't connect to Stomp, so we need to give the ("presumably") underlying
+    # StompHandler class something to work with.
+    StompHandlerNull.new(stomp_hash)
   end
 
   let(:msg1) do
-    stomp_message('application/text', 'verb:Foo', client.calc_reply_id)
+    stomp_message("application/text", "verb:Foo", client.calc_reply_id)
   end
 
   let(:msg2) do
-    stomp_message('application/text', 'verb:Bar', client.calc_reply_id)
+    stomp_message("application/text", "verb:Bar", client.calc_reply_id)
   end
 
 
@@ -25,36 +64,39 @@ describe StompHandlerNull do
       expect{ StompHandlerNull.new(foo: 'bar') }.not_to raise_exception
     end
 
-  end
-  ##
+  end # of #initialize
   
 
   describe '#insert_fake' do
 
-    it 'sets the message to send' do
+    it "sets the message to send" do
       handler.insert_fake( Message.new(verb: 'foo', params: 'bar', desc: 'baz') )
       expect( handler.fake_messages            ).to be_a_kind_of Array
       expect( handler.fake_messages.first      ).to be_a_kind_of NebulousStomp::Message
       expect( handler.fake_messages.first.verb ).to eq 'foo'
     end
 
-  end
-  ##
+  end # of #insert_fake
   
 
-  describe '#connected?' do
+  describe "#connected?" do
 
-    it 'returns false if fake_message was not called' do
+    it "returns false if fake_message was not called" do
       expect( handler.connected? ).to be_falsey
     end
 
-    it 'returns true if fake_message was called' do
+    it "returns true if fake_message was called" do
       handler.insert_fake( Message.new(verb: 'one', params: 'two', desc: 'three') )
       expect( handler.connected? ).to be_truthy
     end
 
-  end
-  ##
+    it "does not call Stomp" do
+      # More generally if we call anything on our Stomp::Client.new fake, we'll get an error
+      expect( fakestomp ).not_to receive(:open?)
+      handler.connected?
+    end
+
+  end # of #connected?
 
 
   describe "#stomp_connect" do
@@ -63,8 +105,13 @@ describe StompHandlerNull do
       expect(handler.stomp_connect).to eq handler
     end
 
-  end
-  ##
+    it "does not call Stomp" do
+      # More generally if we call anything on our Stomp::Client.new fake, we'll get an error
+      expect( fakestomp ).not_to receive(:connection_frame)
+      handler.stomp_connect
+    end
+
+  end # of #stomp_connect
 
 
   describe "#calc_reply_id" do
@@ -74,11 +121,17 @@ describe StompHandlerNull do
       expect( handler.calc_reply_id ).to respond_to :upcase
       expect( handler.calc_reply_id.size ).to be > 12
     end
-  end
-  ##
+
+    it "does not call Stomp" do
+      # More generally if we call anything on our Stomp::Client.new fake, we'll get an error
+      expect( fakestomp ).not_to receive(:connection_frame)
+      handler.calc_reply_id
+    end
+
+  end # of #calc_reply_id
 
 
-  describe "send_message" do
+  describe "#send_message" do
     let(:mess) { NebulousStomp::Message.new(verb: 'foo') }
 
     it "accepts a queue name and a Message" do
@@ -89,23 +142,16 @@ describe StompHandlerNull do
       expect( handler.send_message('foo', mess) ).to eq mess
     end
 
-  end
-  ##
-
-
-  describe "#listen" do
+    it "does not call Stomp" do
+      # More generally if we call anything on our Stomp::Client.new fake, we'll get an error
+      expect( fakestomp ).not_to receive(:publish)
+      handler.send_message('foo', mess)
+    end
 
-    def run_listen(secs)
-      got = []
+  end # of #send_message
 
-      handler.listen('/queue/foo') do |m|
-        got << m
-      end
-      sleep secs
-
-      got
-    end
 
+  describe "#listen" do
 
     it "yields each Message" do
       handler.insert_fake( Message.new(verb: 'foo', params: 'bar', desc: 'baz') )
@@ -121,23 +167,21 @@ describe StompHandlerNull do
       expect(messages.last.verb).to eq "one"
     end
 
-  end
-  ##
+    it "does not call Stomp" do
+      # More generally if we call anything on our Stomp::Client.new fake, we'll get an error
+      expect( fakestomp ).not_to receive(:subscribe)
 
+      handler.insert_fake( Message.new(verb: 'foo', params: 'bar', desc: 'baz') )
+      handler.insert_fake( Message.new(verb: 'one', params: 'two', desc: 'three') )
+      messages = run_listen(1)
+    end
 
-  describe "listen_with_timeout" do
+  end # of #listen
 
-    def run_listen_with_timeout(secs)
-      got = []
-      handler.listen_with_timeout('/queue/foo', secs) do |m|
-        got << m
-      end
 
-      got
-    end
+  describe "listen_with_timeout" do
 
     context "when there are messages" do
-
       it "yields each Message" do
         handler.insert_fake( Message.new(verb: 'foo', params: 'bar', desc: 'baz') )
         handler.insert_fake( Message.new(verb: 'one', params: 'two', desc: 'three') )
@@ -151,21 +195,26 @@ describe StompHandlerNull do
         expect(messages.last).to be_a_kind_of NebulousStomp::Message
         expect(messages.last.verb).to eq "one"
       end
-
     end
 
     context "when there is no message" do
-
-      it 'raises NebulousTimeout' do
+      it "raises NebulousTimeout" do
         expect{handler.listen_with_timeout('foo', 2)}.
           to raise_exception NebulousStomp::NebulousTimeout
 
       end
+    end
+
+    it "does not call Stomp" do
+      # More generally if we call anything on our Stomp::Client.new fake, we'll get an error
+      expect( fakestomp ).not_to receive(:subscribe)
 
+      handler.insert_fake( Message.new(verb: 'foo', params: 'bar', desc: 'baz') )
+      handler.insert_fake( Message.new(verb: 'one', params: 'two', desc: 'three') )
+      messages = run_listen_with_timeout(1)
     end
 
-  end
-  ##
+  end # of #listen_with_timeout
 
 
 end 

data/tags

@@ -17,14 +17,22 @@ Nebulous	lib/nebulous/stomp_handler.rb	/^module Nebulous$/;"	m
 Nebulous	lib/nebulous/stomp_handler_null.rb	/^module Nebulous$/;"	m
 Nebulous	lib/nebulous/version.rb	/^module Nebulous$/;"	m
 NebulousError	lib/nebulous.rb	/^  class NebulousError < StandardError; end$/;"	c	class:Nebulous	inherits:StandardError
+NebulousStomp	lib/nebulous_stomp/redis_handler.rb	/^module NebulousStomp$/;"	m
+NebulousStomp	lib/nebulous_stomp/request.rb	/^module NebulousStomp$/;"	m
+NebulousStomp	lib/nebulous_stomp/stomp_handler.rb	/^module NebulousStomp$/;"	m
+NebulousStomp	lib/nebulous_stomp/stomp_handler_null.rb	/^module NebulousStomp$/;"	m
 NebulousStomp	lib/nebulous_stomp/version.rb	/^module NebulousStomp$/;"	m
 NebulousTimeout	lib/nebulous.rb	/^  class NebulousTimeout < StandardError; end$/;"	c	class:Nebulous	inherits:StandardError
 Param	lib/nebulous/param.rb	/^  module Param$/;"	m	class:Nebulous
 ParamDefaults	lib/nebulous/param.rb	/^    ParamDefaults = { stompConnectHash: {},$/;"	C	class:Nebulous.Param
 RedisHandler	lib/nebulous/redis_handler.rb	/^  class RedisHandler$/;"	c	class:Nebulous
+RedisHandler	lib/nebulous_stomp/redis_handler.rb	/^  class RedisHandler$/;"	c	class:NebulousStomp
 RedisHandlerNull	lib/nebulous/redis_handler_null.rb	/^  class RedisHandlerNull < RedisHandler$/;"	c	class:Nebulous	inherits:RedisHandler
+Request	lib/nebulous_stomp/request.rb	/^  class Request$/;"	c	class:NebulousStomp
 StompHandler	lib/nebulous/stomp_handler.rb	/^  class StompHandler$/;"	c	class:Nebulous
+StompHandler	lib/nebulous_stomp/stomp_handler.rb	/^  class StompHandler$/;"	c	class:NebulousStomp
 StompHandlerNull	lib/nebulous/stomp_handler_null.rb	/^  class StompHandlerNull < StompHandler$/;"	c	class:Nebulous	inherits:StompHandler
+StompHandlerNull	lib/nebulous_stomp/stomp_handler_null.rb	/^  class StompHandlerNull < StompHandler$/;"	c	class:NebulousStomp
 TargetDefaults	lib/nebulous/param.rb	/^    TargetDefaults = { sendQueue:      nil,$/;"	C	class:Nebulous.Param
 VERSION	lib/nebulous/version.rb	/^  VERSION = "1.1.5"$/;"	C	class:Nebulous
 add_target	lib/nebulous.rb	/^  def self.add_target(name, targetHash) # -> nil$/;"	F	class:Nebulous
@@ -33,22 +41,34 @@ body_for_stomp	lib/nebulous/message.rb	/^    def body_for_stomp$/;"	f	class:Nebu
 body_to_h	lib/nebulous/message.rb	/^    def body_to_h$/;"	f	class:Nebulous.Message
 body_to_hash	lib/nebulous/stomp_handler.rb	/^      def body_to_hash(headers, body, contentType=nil)$/;"	F	class:Nebulous.StompHandler
 cTimeout	lib/nebulous/nebrequest.rb	/^    attr_reader :cTimeout$/;"	f	class:Nebulous.NebRequest
+cache_read	lib/nebulous_stomp/request.rb	/^    def cache_read$/;"	f	class:NebulousStomp.Request
+cache_timeout	lib/nebulous_stomp/request.rb	/^    def cache_timeout$/;"	f	class:NebulousStomp.Request
+cache_write	lib/nebulous_stomp/request.rb	/^    def cache_write(response, timeout)$/;"	f	class:NebulousStomp.Request
 calc_reply_id	lib/nebulous/stomp_handler.rb	/^    def calc_reply_id$/;"	f	class:Nebulous.StompHandler
 calc_reply_id	lib/nebulous/stomp_handler_null.rb	/^    def calc_reply_id; 'ABCD123456789'; end$/;"	f	class:Nebulous.StompHandlerNull
+calc_reply_id	lib/nebulous_stomp/stomp_handler.rb	/^    def calc_reply_id$/;"	f	class:send_message
+calc_reply_id	lib/nebulous_stomp/stomp_handler_null.rb	/^    def calc_reply_id; 'ABCD123456789'; end$/;"	f	class:NebulousStomp.StompHandlerNull
 clear_cache	lib/nebulous/nebrequest.rb	/^    def clear_cache$/;"	f	class:Nebulous.NebRequest
+clear_cache	lib/nebulous_stomp/request.rb	/^    def clear_cache$/;"	f	class:NebulousStomp.Request
 client	lib/nebulous/stomp_handler.rb	/^    attr_reader :client$/;"	f	class:Nebulous.StompHandler
 connect	lib/nebulous/redis_handler.rb	/^    def connect$/;"	f	class:Nebulous.RedisHandler
 connect	lib/nebulous/redis_handler_null.rb	/^    def connect$/;"	f	class:Nebulous.RedisHandlerNull
+connect	lib/nebulous_stomp/redis_handler.rb	/^    def connect$/;"	f	class:NebulousStomp.RedisHandler
 connected?	lib/nebulous/redis_handler.rb	/^    def connected?$/;"	f	class:Nebulous.RedisHandler
 connected?	lib/nebulous/redis_handler_null.rb	/^    def connected?$/;"	f	class:Nebulous.RedisHandlerNull
 connected?	lib/nebulous/stomp_handler.rb	/^    def connected?$/;"	f	class:Nebulous.StompHandler
 connected?	lib/nebulous/stomp_handler_null.rb	/^    def connected? $/;"	f	class:Nebulous.StompHandlerNull
+connected?	lib/nebulous_stomp/redis_handler.rb	/^    def connected?$/;"	f	class:NebulousStomp.RedisHandler
+connected?	lib/nebulous_stomp/stomp_handler.rb	/^    def connected?$/;"	f	class:NebulousStomp
+connected?	lib/nebulous_stomp/stomp_handler_null.rb	/^    def connected? $/;"	f	class:NebulousStomp.StompHandlerNull
 content_is_json?	lib/nebulous/message.rb	/^    def content_is_json?$/;"	f	class:Nebulous.Message
 content_type	lib/nebulous/message.rb	/^    attr_reader :content_type$/;"	f	class:Nebulous.Message
 del	lib/nebulous/redis_handler_null.rb	/^    def del(key); @fake_pair = {}; end$/;"	f	class:Nebulous.RedisHandlerNull
 desc	lib/nebulous/message.rb	/^    attr_reader :verb, :params, :desc$/;"	f	class:Nebulous.Message
 desc	lib/nebulous/nebrequest.rb	/^    attr_reader :desc$/;"	f	class:Nebulous.NebRequest
 description	lib/nebulous/message.rb	/^    alias :description :desc$/;"	a	class:Nebulous.Message
+ensure_redis_connected	lib/nebulous_stomp/request.rb	/^    def ensure_redis_connected$/;"	f	class:NebulousStomp.Request
+ensure_stomp_connected	lib/nebulous_stomp/request.rb	/^    def ensure_stomp_connected$/;"	f	class:NebulousStomp.Request
 example_pending	spec/doc_no_pending.rb	/^  def example_pending(notifications); end$/;"	f	class:DocNoPending
 fake_mess	lib/nebulous/stomp_handler_null.rb	/^    attr_reader :fake_mess$/;"	f	class:Nebulous.StompHandlerNull
 fake_pair	lib/nebulous/redis_handler_null.rb	/^    attr_reader :fake_pair$/;"	f	class:Nebulous.RedisHandlerNull
@@ -72,34 +92,54 @@ initialize	lib/nebulous/redis_handler.rb	/^    def initialize(connectHash, testR
 initialize	lib/nebulous/redis_handler_null.rb	/^    def initialize(connectHash={})$/;"	f	class:Nebulous.RedisHandlerNull
 initialize	lib/nebulous/stomp_handler.rb	/^    def initialize(connectHash, testClient=nil)$/;"	f	class:Nebulous.StompHandler
 initialize	lib/nebulous/stomp_handler_null.rb	/^    def initialize(hash={})$/;"	f	class:Nebulous.StompHandlerNull
+initialize	lib/nebulous_stomp/redis_handler.rb	/^    def initialize(connectHash=nil, testRedis=nil)$/;"	f	class:NebulousStomp.RedisHandler
+initialize	lib/nebulous_stomp/request.rb	/^    def initialize(target, message)$/;"	f	class:NebulousStomp.Request
+initialize	lib/nebulous_stomp/stomp_handler.rb	/^    def initialize(connectHash=nil, testClient=nil)$/;"	f	class:NebulousStomp
+initialize	lib/nebulous_stomp/stomp_handler_null.rb	/^    def initialize(hash={})$/;"	f	class:NebulousStomp.StompHandlerNull
 insert_fake	lib/nebulous/redis_handler_null.rb	/^    def insert_fake(key, value)$/;"	f	class:Nebulous.RedisHandlerNull
 insert_fake	lib/nebulous/stomp_handler_null.rb	/^    def insert_fake(message)$/;"	f	class:Nebulous.StompHandlerNull
+insert_fake	lib/nebulous_stomp/stomp_handler_null.rb	/^    def insert_fake(message)$/;"	f	class:NebulousStomp.StompHandlerNull
+insert_fake	spec/redis_helper_spec.rb	/^  def insert_fake( value={woof: true} )$/;"	f
 insert_fake_redis	lib/nebulous/nebrequest_null.rb	/^    def insert_fake_redis(key, value)$/;"	f	class:Nebulous.NebRequestNull
 insert_fake_stomp	lib/nebulous/nebrequest_null.rb	/^    def insert_fake_stomp(message)$/;"	f	class:Nebulous.NebRequestNull
 listen	lib/nebulous/stomp_handler.rb	/^    def listen(queue)$/;"	f	class:Nebulous.StompHandler
 listen	lib/nebulous/stomp_handler_null.rb	/^    def listen(queue)$/;"	f	class:Nebulous.StompHandlerNull
+listen	lib/nebulous_stomp/stomp_handler.rb	/^    def listen(queue)$/;"	f	class:NebulousStomp
+listen	lib/nebulous_stomp/stomp_handler_null.rb	/^    def listen(queue)$/;"	f	class:NebulousStomp.StompHandlerNull
 listen_with_timeout	lib/nebulous/stomp_handler.rb	/^    def listen_with_timeout(queue, timeout)$/;"	f	class:Nebulous.StompHandler
 listen_with_timeout	lib/nebulous/stomp_handler_null.rb	/^    def listen_with_timeout(queue, timeout)$/;"	f	class:Nebulous.StompHandlerNull
+listen_with_timeout	lib/nebulous_stomp/stomp_handler.rb	/^    def listen_with_timeout(queue, timeout)$/;"	f
+listen_with_timeout	lib/nebulous_stomp/stomp_handler_null.rb	/^    def listen_with_timeout(queue, timeout)$/;"	f	class:NebulousStomp.StompHandlerNull
 logger	lib/nebulous.rb	/^  def self.logger$/;"	F	class:Nebulous
 mTimeout	lib/nebulous/nebrequest.rb	/^    attr_reader :mTimeout$/;"	f	class:Nebulous.NebRequest
 message	lib/nebulous/nebrequest.rb	/^    attr_reader :message$/;"	f	class:Nebulous.NebRequest
+message_timeout	lib/nebulous_stomp/request.rb	/^    def message_timeout$/;"	f	class:NebulousStomp.Request
 method_missing	lib/nebulous/redis_handler.rb	/^    def method_missing(meth, *args)$/;"	f	class:Nebulous.RedisHandler
+method_missing	lib/nebulous_stomp/redis_handler.rb	/^    def method_missing(meth, *args)$/;"	f	class:NebulousStomp.RedisHandler
 neb_connect	lib/nebulous/nebrequest.rb	/^    def neb_connect$/;"	f	class:Nebulous.NebRequest
 neb_qna	lib/nebulous/nebrequest.rb	/^    def neb_qna(mTimeout)$/;"	f	class:Nebulous.NebRequest
+neb_qna	lib/nebulous_stomp/request.rb	/^    def neb_qna(mTimeout)$/;"	f	class:NebulousStomp.Request
 nebulous_on?	lib/nebulous/nebrequest.rb	/^    def nebulous_on?$/;"	f	class:Nebulous.NebRequest
 nebulous_on?	lib/nebulous/stomp_handler.rb	/^    def nebulous_on?$/;"	f	class:Nebulous.StompHandler
+nebulous_on?	lib/nebulous_stomp/stomp_handler.rb	/^    def nebulous_on?$/;"	f	class:NebulousStomp
+new_request	spec/request_spec.rb	/^  def new_request(target, message)$/;"	f
 on?	lib/nebulous.rb	/^  def self.on?$/;"	F	class:Nebulous
 parameters	lib/nebulous/message.rb	/^    alias :parameters  :params$/;"	a	class:Nebulous.Message
 params	lib/nebulous/message.rb	/^    attr_reader :verb, :params, :desc$/;"	f	class:Nebulous.Message
 params	lib/nebulous/nebrequest.rb	/^    attr_reader :params    $/;"	f	class:Nebulous.NebRequest
+parse_message	lib/nebulous_stomp/request.rb	/^    def parse_message(message, target)$/;"	f	class:NebulousStomp.Request
+parse_target	lib/nebulous_stomp/request.rb	/^    def parse_target(target)$/;"	f	class:NebulousStomp.Request
 protocol_hash	lib/nebulous/message.rb	/^    def protocol_hash$/;"	f	class:Nebulous.Message
 protocol_json	lib/nebulous/message.rb	/^    def protocol_json$/;"	f	class:Nebulous.Message
 quit	lib/nebulous/redis_handler.rb	/^    def quit$/;"	f	class:Nebulous.RedisHandler
 quit	lib/nebulous/redis_handler_null.rb	/^    def quit$/;"	f	class:Nebulous.RedisHandlerNull
+quit	lib/nebulous_stomp/redis_handler.rb	/^    def quit$/;"	f	class:NebulousStomp.RedisHandler
 redis	lib/nebulous/redis_handler.rb	/^    attr_reader :redis$/;"	f	class:Nebulous.RedisHandler
+redis_handler	lib/nebulous_stomp/request.rb	/^    def redis_handler$/;"	f	class:NebulousStomp.Request
 redis_on?	lib/nebulous.rb	/^  def self.redis_on?$/;"	F	class:Nebulous
 redis_on?	lib/nebulous/nebrequest.rb	/^    def redis_on?$/;"	f	class:Nebulous.NebRequest
 redis_on?	lib/nebulous/redis_handler.rb	/^    def redis_on?$/;"	f	class:Nebulous.RedisHandler
+redis_on?	lib/nebulous_stomp/redis_handler.rb	/^    def redis_on?$/;"	f	class:NebulousStomp.RedisHandler
 replyID	lib/nebulous/nebrequest.rb	/^    attr_reader :replyID$/;"	f	class:Nebulous.NebRequest
 reply_id	lib/nebulous/message.rb	/^    attr_accessor :reply_id$/;"	f	class:Nebulous.Message
 reply_id=	lib/nebulous/message.rb	/^    attr_accessor :reply_id$/;"	f	class:Nebulous.Message
@@ -108,13 +148,21 @@ requestQ	lib/nebulous/nebrequest.rb	/^    attr_reader :requestQ$/;"	f	class:Nebu
 reset	lib/nebulous/param.rb	/^    def reset$/;"	f	class:Nebulous.Param
 respond_error	lib/nebulous/message.rb	/^    def respond_error(err,fields=[])$/;"	f	class:Nebulous.Message
 respond_error	lib/nebulous/stomp_handler_null.rb	/^    def respond_error(nebMess,err,fields=[])$/;"	f	class:Nebulous.StompHandlerNull
+respond_error	lib/nebulous_stomp/stomp_handler_null.rb	/^    def respond_error(nebMess,err,fields=[])$/;"	f	class:NebulousStomp.StompHandlerNull
 respond_success	lib/nebulous/message.rb	/^    def respond_success$/;"	f	class:Nebulous.Message
 respond_success	lib/nebulous/stomp_handler_null.rb	/^    def respond_success(nebMess)$/;"	f	class:Nebulous.StompHandlerNull
+respond_success	lib/nebulous_stomp/stomp_handler_null.rb	/^    def respond_success(nebMess)$/;"	f	class:NebulousStomp.StompHandlerNull
 responseQ	lib/nebulous/nebrequest.rb	/^    attr_reader :responseQ$/;"	f	class:Nebulous.NebRequest
+run_listen	spec/stomp_handler_null_spec.rb	/^  def run_listen(secs)$/;"	f
+run_listen_with_timeout	spec/stomp_handler_null_spec.rb	/^  def run_listen_with_timeout(secs)$/;"	f
 send	lib/nebulous/nebrequest.rb	/^    def send(mTimeout=@mTimeout, cTimeout=@cTimeout)$/;"	f	class:Nebulous.NebRequest
+send	lib/nebulous_stomp/request.rb	/^    def send(mtimeout=message_timeout, ctimeout=cache_timeout)$/;"	f	class:NebulousStomp.Request
 send_message	lib/nebulous/stomp_handler.rb	/^    def send_message(queue, mess)$/;"	f	class:Nebulous.StompHandler
 send_message	lib/nebulous/stomp_handler_null.rb	/^    def send_message(queue, nebMess)$/;"	f	class:Nebulous.StompHandlerNull
+send_message	lib/nebulous_stomp/stomp_handler.rb	/^    def send_message(queue, mess)$/;"	f
+send_message	lib/nebulous_stomp/stomp_handler_null.rb	/^    def send_message(queue, nebMess)$/;"	f	class:NebulousStomp.StompHandlerNull
 send_no_cache	lib/nebulous/nebrequest.rb	/^    def send_no_cache(mTimeout=@mTimeout)$/;"	f	class:Nebulous.NebRequest
+send_no_cache	lib/nebulous_stomp/request.rb	/^    def send_no_cache(mtimeout=message_timeout)$/;"	f	class:NebulousStomp.Request
 set	lib/nebulous/param.rb	/^    def set(p={})$/;"	f	class:Nebulous.Param
 set	lib/nebulous/redis_handler_null.rb	/^    def set(key, value, hash=nil); insert_fake(key, value); end$/;"	f	class:Nebulous.RedisHandlerNull
 set_logger	lib/nebulous.rb	/^  def self.set_logger(logger)$/;"	F	class:Nebulous
@@ -122,14 +170,24 @@ set_logger	lib/nebulous/param.rb	/^    def set_logger(lg)$/;"	f	class:Nebulous.P
 stomp_body	lib/nebulous/message.rb	/^    attr_reader :stomp_headers, :stomp_body$/;"	f	class:Nebulous.Message
 stomp_connect	lib/nebulous/stomp_handler.rb	/^    def stomp_connect$/;"	f	class:Nebulous.StompHandler
 stomp_connect	lib/nebulous/stomp_handler_null.rb	/^    def stomp_connect$/;"	f	class:Nebulous.StompHandlerNull
+stomp_connect	lib/nebulous_stomp/stomp_handler.rb	/^    def stomp_connect$/;"	f	class:NebulousStomp
+stomp_connect	lib/nebulous_stomp/stomp_handler_null.rb	/^    def stomp_connect$/;"	f	class:NebulousStomp.StompHandlerNull
 stomp_disconnect	lib/nebulous/stomp_handler.rb	/^    def stomp_disconnect$/;"	f	class:Nebulous.StompHandler
 stomp_disconnect	lib/nebulous/stomp_handler_null.rb	/^    def stomp_disconnect$/;"	f	class:Nebulous.StompHandlerNull
+stomp_disconnect	lib/nebulous_stomp/stomp_handler.rb	/^    def stomp_disconnect$/;"	f	class:NebulousStomp
+stomp_disconnect	lib/nebulous_stomp/stomp_handler_null.rb	/^    def stomp_disconnect$/;"	f	class:NebulousStomp.StompHandlerNull
+stomp_handler	lib/nebulous_stomp/request.rb	/^    def stomp_handler$/;"	f	class:NebulousStomp.Request
+stomp_handler=	lib/nebulous_stomp/request.rb	/^    def stomp_handler=(handler)$/;"	f	class:NebulousStomp.Request
 stomp_headers	lib/nebulous/message.rb	/^    attr_reader :stomp_headers, :stomp_body$/;"	f	class:Nebulous.Message
 stomp_message	spec/helpers.rb	/^  def stomp_message(contentType, body, inReplyTo=nil)$/;"	f	class:Helpers
+symbolise	spec/message_spec.rb	/^  def symbolise(hash)$/;"	f
 target	lib/nebulous/nebrequest.rb	/^    attr_reader :target$/;"	f	class:Nebulous.NebRequest
 to_cache	lib/nebulous/message.rb	/^    def to_cache$/;"	f	class:Nebulous.Message
 to_s	lib/nebulous/message.rb	/^    def to_s$/;"	f	class:Nebulous.Message
+turn_off_nebulous	spec/request_spec.rb	/^  def turn_off_nebulous$/;"	f
+turn_off_redis	spec/request_spec.rb	/^  def turn_off_redis$/;"	f
 validate	lib/nebulous/param.rb	/^    def validate(exemplar, hash, message)$/;"	f	class:Nebulous.Param
 verb	lib/nebulous/message.rb	/^    attr_reader :verb, :params, :desc$/;"	f	class:Nebulous.Message
 verb	lib/nebulous/nebrequest.rb	/^    attr_reader :verb      $/;"	f	class:Nebulous.NebRequest
 with_timeout	lib/nebulous/stomp_handler.rb	/^      def with_timeout(secs)$/;"	F	class:Nebulous.StompHandler
+with_timeout	lib/nebulous_stomp/stomp_handler.rb	/^      def with_timeout(secs)$/;"	f	class:NebulousStomp.StompHandler

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nebulous_stomp
 version: !ruby/object:Gem::Version
-  version: 3.0.3
+  version: 3.0.4
 platform: ruby
 authors:
 - Andy Jones
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-02 00:00:00.000000000 Z
+date: 2019-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler