nebulous_stomp 2.0.2 → 3.0.0

data/spec/param_spec.rb

@@ -1,4 +1,3 @@
-require 'spec_helper'
 require 'nebulous_stomp/param'
 
 include NebulousStomp
@@ -6,8 +5,10 @@ include NebulousStomp
 
 describe Param do
 
-  before      { Param.reset }
-  after(:all) { Param.reset }
+  before      { Param.send :reset }
+  after(:all) { Param.send :reset }
+
+  let(:target1) { Target.new(name: 'foo', receiveQueue: '/queue/foo', sendQueue: '/queue/bar') }
 
 
   describe "Param.set" do
@@ -35,30 +36,13 @@ describe Param do
 
   describe "Param.add_target" do
 
-    let(:hash1) { {receiveQueue: '/queue/foo', sendQueue: '/queue/bar'} }
-
-    it "rejects unkown values in the param string for the target" do
-      expect { Param.add_target(:foo, {:notAValidThing => 14}) }.to \
-        raise_exception NebulousError
-
-    end
-
-    it "expects both a send queue and a receive queue" do
-      h = {receiveQueue: '/queue/foo'}
-      expect{ Param.add_target(:foo, h) }.to raise_exception(NebulousError)
-
-      h = {sendQueue: '/queue/foo'}
-      expect{ Param.add_target(:foo, h) }.to raise_exception(NebulousError)
+    it "rejects a target that's not a Target" do
+      expect { Param.add_target(:notAValidThing => 14) }.to raise_exception NebulousError
     end
 
     it 'works even when set has not been called' do
-      Param.reset
-      expect{ Param.add_target(:foo, hash1) }.not_to raise_exception
-    end
-
-    it "adds legitimate parameters to the target hash" do
-      Param.add_target(:foo, hash1)
-      expect( Param.get_all[:targets][:foo] ).to include(hash1)
+      Param.send :reset
+      expect{ Param.add_target(target1) }.not_to raise_exception
     end
 
   end # of Param:add_target
@@ -89,21 +73,20 @@ describe Param do
   describe "Param.get_target" do
 
     before do
-      @targ = {receiveQueue: 'foo', sendQueue: 'bar'}
-      Param.add_target(:one, @targ)
+      Param.add_target(target1)
     end
 
-    it "throws an exception if you ask for a target it doesn't have" do
-      expect{ Param.get_target(:two) }.to raise_exception(NebulousError)
+    it "returns nil if you ask for a target it doesn't have" do
+      expect( Param.get_target(:two) ).to be_nil
     end
 
-    it "returns the target hash corresponding to the name" do
-      expect( Param.get_target(:one) ).to include(@targ)
+    it "returns the Target corresponding to the name" do
+      expect( Param.get_target(:foo) ).to eq target1
     end
 
     it 'does not freak out if set() was never called' do
-      Param.reset
-      expect{ Param.get_target(:one) }.not_to raise_exception
+      Param.send :reset
+      expect{ Param.get_target(:foo) }.not_to raise_exception
     end
       
   end # of get_target
@@ -120,7 +103,7 @@ describe Param do
     end
 
     it 'does not freak out if set_logger() was never called' do
-      Param.reset
+      Param.send :reset
       expect{ Param.get_logger }.not_to raise_exception
     end
 

data/spec/redis_handler_null_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 require 'nebulous_stomp/redis_handler_null'
 
 include NebulousStomp

data/spec/redis_handler_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 require 'nebulous_stomp/redis_handler'
 
 include NebulousStomp

data/spec/redis_helper_spec.rb

@@ -0,0 +1,107 @@
+require 'json'
+
+require 'nebulous_stomp/redis_helper'
+require 'nebulous_stomp/redis_handler_null'
+
+include NebulousStomp
+
+
+describe RedisHelper do
+
+  before do
+    @redis_hash = {host: '127.0.0.1', port: 6379, db: 0}
+    NebulousStomp.init(:redisConnectHash => @redis_hash)
+    @redis_handler = RedisHandlerNull.new(@redis_hash)
+  end
+
+  let(:helper) do
+    helper = RedisHelper.new
+    helper.redis_handler = @redis_handler
+    helper
+  end
+
+  def insert_fake( value={woof: true} )
+    @redis_handler.insert_fake( "bark", {value: value}.to_json )
+  end
+
+
+
+  describe "set" do
+
+    it "takes a key and a value" do
+      expect{ helper.set(:foo, "bar") }.not_to raise_error
+    end
+
+    it "takes an optional timeout" do
+      expect{ helper.set(:foo, "bar", "baz") }.to raise_error ArgumentError
+      expect{ helper.set(:foo, "bar", 14)    }.not_to raise_error
+    end
+
+    it "calls RedisHandler.set to write the value" do
+      expect( @redis_handler ).to receive(:set).with("foo", {value:"bar"}.to_json)
+      helper.set(:foo, "bar")
+
+      expect( @redis_handler ).to receive(:set).with("foo", {value:"bar"}.to_json, {ex: 14})
+      helper.set(:foo, "bar", 14)
+    end
+
+  end
+  ##
+
+
+  describe "get" do
+
+    it "takes a key" do
+      insert_fake
+      expect{ helper.get("bark") }.not_to raise_error
+    end
+
+    it "calls RedisHandler.get to retreive the value" do
+      insert_fake
+      expect( @redis_handler ).to receive(:get).with("bark")
+      helper.get "bark"
+    end
+
+    it "returns the corresponding value" do
+      insert_fake
+      expect( helper.get("bark") ).to eq( {woof: true} )
+      expect( helper.get(:bark)  ).to eq( {woof: true} )
+
+      insert_fake("baaah")
+      expect( helper.get("bark") ).to eq "baaah"
+
+      insert_fake(woof: "loud")
+      expect( helper.get("bark") ).to eq( {woof: "loud"} )
+    end
+
+    it "returns nil if the key does not exist in the store" do
+      expect( helper.get(:bark) ).to be_nil
+    end
+
+  end
+  ##
+
+
+  describe "del" do
+
+    it "takes a key" do
+      insert_fake
+      expect{ helper.del(:bark) }.not_to raise_error
+    end
+
+    it "calls RedisHandler.del on that key" do
+      insert_fake
+      expect( @redis_handler ).to receive(:del).with("bark")
+      helper.del(:bark)
+    end
+
+    it "raises NebulousError if the key does not exist in the store" do
+      expect{ helper.del(:bark) }.to raise_error ArgumentError
+    end
+    
+  end
+  ##
+  
+end
+
+

data/spec/request_spec.rb

@@ -0,0 +1,249 @@
+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
+    r.redis_handler = @redis_handler
+    r
+  end
+
+  def turn_off_redis
+    Param.set(:stompConnectHash => @stomp_hash, :redisConnectHash => nil)
+    @redis_handler = nil
+  end
+
+  def turn_off_nebulous
+    Param.set(:stompConnectHash => nil, :redisConnectHash => @redis_hash)
+    @nebulous_handler = nil
+  end
+
+  let(:target1) do 
+    Target.new( name:         "target1", 
+                sendQueue:    "/queue/foo", 
+                receiveQueue: "/queue/bar" )
+
+  end
+
+  let(:target2) do 
+    Target.new( name:          "target1", 
+                sendQueue:     "/queue/foo", 
+                receiveQueue:  "/queue/bar",
+                messageTimeout: 1 )
+
+  end
+
+  let(:message1) do
+    Message.new( verb: "boop", params: "booper", desc: "booping")
+  end
+
+  let(:message2) do
+    Message.new( verb: "parp", params: "parper", desc: "parping", replyTo: "parps" )
+  end
+
+  let(:request1) do
+    request = new_request(target1, message1)
+    @stomp_handler.insert_fake Message.new(inReplyTo: request.message.reply_id, verb: "foo")
+    request
+  end
+
+
+  describe "Request.new" do
+     
+    it "requires a Target or a target name as the first parameter" do
+      expect{ Request.new(nil, message1) }.to raise_error ArgumentError
+      expect{ Request.new(14,  message1) }.to raise_error ArgumentError
+
+      expect{ Request.new(target1,  message1) }.not_to raise_error
+      expect{ Request.new("accord", message1) }.not_to raise_error
+    end
+
+    it "requires a Message as the second parameter" do
+      expect{ Request.new(target1, :foo) }.to raise_error ArgumentError
+      expect{ Request.new(target1, nil)  }.to raise_error ArgumentError
+
+      expect{ Request.new(target1, message1) }.not_to raise_error
+    end
+
+    it "expects the message parameter to follow The Protocol" do
+      m = Message.new(body: "blarg")
+      expect{ Request.new(target1, m) }.to raise_error ArgumentError
+    end
+
+    it "stores the given message if it has a reply_to" do
+      expect( Request.new(target1, message2).message ).to eq message2
+    end
+
+    it "stores a new message with a reply_to from the target if the given one is missing it" do
+      r = new_request(target1, message1)
+      expect( r.message ).not_to eq message1
+      expect( r.message.verb     ).to eq message1.verb
+      expect( r.message.params   ).to eq message1.params
+      expect( r.message.desc     ).to eq message1.desc
+      expect( r.message.reply_to ).to eq target1.send_queue
+    end
+
+  end
+
+
+  describe "message_timeout" do
+
+    it "takes the timeout on the target over the default" do
+      r = new_request(target2, message1)
+      expect( r.message_timeout ).to eq 1
+    end
+
+    it "falls back to the default if the timeout on the target is not set" do
+      r = new_request(target1, message1)
+      expect( r.message_timeout ).to eq 5
+    end
+
+  end
+
+
+  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
+
+
+  describe "send_no_cache" do
+
+    it "returns a response from StompHandler" do
+      response = request1.send_no_cache
+      expect( response ).to be_a NebulousStomp::Message
+      expect( response.verb ).to eq "foo"
+    end
+
+    it "raises a NebulousTimeout if there is no response" do
+      request = new_request('accord', message1)
+
+      # if we don't give StompHandlerNull a response to send, request should time out
+      expect{ request.send_no_cache }.to raise_exception NebulousStomp::NebulousTimeout
+    end
+
+    it "returns nil if Nebulous is disabled in the config" do
+      turn_off_nebulous
+      request = new_request('accord', message1)
+      expect( request.send_no_cache ).to be_nil
+    end
+
+  end
+  
+
+  describe "clear_cache" do
+
+    it "removes the redis cache for a single request" do
+      @redis_handler.insert_fake('foo', 'bar')
+      expect( @redis_handler ).to receive(:del).with( message1.protocol_json )
+
+      new_request(target1, message1).clear_cache
+    end
+
+    it "returns self" do
+      @redis_handler.insert_fake('foo', 'bar')
+      r = new_request(target1, message1)
+      
+      expect( r.clear_cache ).to eq r
+    end
+
+    it "doesn't freak out if Redis is not connected" do
+      turn_off_redis
+      r = new_request(target1, message1)
+      expect{ r.clear_cache }.not_to raise_exception
+      expect( r.clear_cache ).to eq r
+    end
+
+  end
+
+  
+  describe "send" do
+
+    it "returns a Message object from STOMP the first time" do
+      response = request1.send
+      expect( response ).to be_a NebulousStomp::Message
+      expect( response.verb ).to eq "foo"
+    end
+
+    it "returns the answer from the cache the second time" do
+      @stomp_handler.insert_fake Message.new(verb: "foo")
+      @redis_handler.insert_fake( "xxx", {'verb' => 'frog'}.to_json )
+
+      # First time
+      request = new_request(target1, message1)
+      response = request.send
+
+      # Second time
+      request = new_request(target1, message1)
+      response = request.send
+
+      expect( response ).to be_a NebulousStomp::Message
+      expect( response.verb ).to eq "frog"
+    end
+
+    it "allows you to specify a message timeout" do
+      expect{ request1.send(3) }.not_to raise_exception
+    end
+
+    it "allows you to specify a message timeout & cache timeout" do
+      expect{ request1.send(3, 120) }.not_to raise_exception
+    end
+
+    it "raises a NebulousTimeout if there is no response" do
+      request = new_request(target1, message1)
+      expect{ request.send }.to raise_exception NebulousStomp::NebulousTimeout
+    end
+
+    it "still works if Redis is turned off in the config" do
+      turn_off_redis
+      response = request1.send
+      expect( response ).to be_a NebulousStomp::Message
+      expect( response.verb ).to eq "foo"
+    end
+
+    it "returns nil if Nebulous is disabled in the config" do
+      turn_off_nebulous
+      request = new_request(target1, message1)
+      expect( request.send ).to be_nil
+    end
+
+  end
+  
+
+end
+

data/spec/stomp_handler_null_spec.rb

@@ -1,7 +1,4 @@
-require 'spec_helper'
-
 require 'time'
-
 require 'nebulous_stomp/stomp_handler_null'
 
 include NebulousStomp
@@ -22,17 +19,6 @@ describe StompHandlerNull do
   end
 
 
-  describe 'StompHandlerNull.body_to_hash' do
-
-    it "returns a hash" do
-      expect{ StompHandlerNull.body_to_hash({}, 'baz') }.not_to raise_exception
-      expect( StompHandlerNull.body_to_hash({}, 'baz') ).to be_a_kind_of Hash
-    end
-
-  end
-  ##
-
-
   describe "#initialize" do
 
     it "takes an initialization hash" do
@@ -46,9 +32,10 @@ describe StompHandlerNull do
   describe '#insert_fake' do
 
     it 'sets the message to send' do
-      handler.insert_fake( Message.from_parts('', '','foo', 'bar', 'baz') )
-      expect( handler.fake_mess ).to be_a_kind_of NebulousStomp::Message
-      expect( handler.fake_mess.verb ).to eq 'foo'
+      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
@@ -62,7 +49,7 @@ describe StompHandlerNull do
     end
 
     it 'returns true if fake_message was called' do
-      handler.insert_fake( Message.from_parts('','', 'one', 'two', 'three') )
+      handler.insert_fake( Message.new(verb: 'one', params: 'two', desc: 'three') )
       expect( handler.connected? ).to be_truthy
     end
 
@@ -92,7 +79,7 @@ describe StompHandlerNull do
 
 
   describe "send_message" do
-    let(:mess) { NebulousStomp::Message.from_parts(nil, nil, 'foo', nil, nil) }
+    let(:mess) { NebulousStomp::Message.new(verb: 'foo') }
 
     it "accepts a queue name and a Message" do
       expect{ handler.send_message('foo', mess) }.not_to raise_exception
@@ -109,10 +96,10 @@ describe StompHandlerNull do
   describe "#listen" do
 
     def run_listen(secs)
-      got = nil
+      got = []
 
       handler.listen('/queue/foo') do |m|
-        got = m
+        got << m
       end
       sleep secs
 
@@ -120,12 +107,18 @@ describe StompHandlerNull do
     end
 
 
-    it "yields a Message" do
-      handler.insert_fake( Message.from_parts('', '', 'foo', 'bar', 'baz') )
-      gotMessage = run_listen(1)
+    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') )
+      messages = run_listen(1)
 
-      expect(gotMessage).not_to be_nil
-      expect(gotMessage).to be_a_kind_of NebulousStomp::Message
+      expect(messages.first).not_to be_nil
+      expect(messages.first).to be_a_kind_of NebulousStomp::Message
+      expect(messages.first.verb).to eq "foo"
+
+      expect(messages.last).not_to be_nil
+      expect(messages.last).to be_a_kind_of NebulousStomp::Message
+      expect(messages.last.verb).to eq "one"
     end
 
   end
@@ -135,22 +128,28 @@ describe StompHandlerNull do
   describe "listen_with_timeout" do
 
     def run_listen_with_timeout(secs)
-      got = nil
+      got = []
       handler.listen_with_timeout('/queue/foo', secs) do |m|
-        got = m
+        got << m
       end
 
       got
     end
 
-    context "when there is a message" 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') )
+        messages = run_listen_with_timeout(1)
 
-      it "yields a Message" do
-        handler.insert_fake( Message.from_parts('', '', 'foo', 'bar', 'baz') )
-        gotMessage = run_listen_with_timeout(1)
+        expect( messages.first ).not_to be_nil
+        expect( messages.first ).to be_a_kind_of NebulousStomp::Message
+        expect(messages.first.verb).to eq "foo"
 
-        expect( gotMessage ).not_to be_nil
-        expect( gotMessage ).to be_a_kind_of NebulousStomp::Message
+        expect(messages.last).not_to be_nil
+        expect(messages.last).to be_a_kind_of NebulousStomp::Message
+        expect(messages.last.verb).to eq "one"
       end
 
     end

data/spec/stomp_handler_spec.rb

@@ -1,5 +1,4 @@
 require 'time'
-require 'spec_helper'
 
 require 'nebulous_stomp/stomp_handler'
 require 'nebulous_stomp/message'
@@ -57,78 +56,6 @@ describe StompHandler do
   end
 
 
-  describe 'StompHandler.body_to_hash' do
-
-    it "raises an error unless headers is a hash" do
-      expect{ StompHandler.body_to_hash() }.to raise_exception ArgumentError
-
-      expect{ StompHandler.body_to_hash('foo') }.
-        to raise_exception ArgumentError
-
-      expect{ StompHandler.body_to_hash('foo', 'bar') }.
-        to raise_exception ArgumentError
-
-      expect{ StompHandler.body_to_hash({}, 'baz') }.not_to raise_exception
-    end
-
-    context "when the content type is JSON" do
-
-      it "parses the json" do
-        body = {'one' => 'two', 'three' => [4,5]}
-        msg = stomp_message('application/json', body.to_json)
-        expect( StompHandler.body_to_hash(msg.headers, msg.body) ).to eq body
-
-        body = [ {'one' => 2, 'three' => 4}, {'five' => 6} ]
-        msg = stomp_message('application/json', body.to_json)
-        expect( StompHandler.body_to_hash(msg.headers, msg.body) ).to eq body
-      end
-
-    end
-
-    context "when the content type is not JSON" do
-
-      it "assumes text lines in key:value format" do
-        # Note that all values will be strings, and we can't support arrays.
-        result = {'one' => 'two', 'three' => '4'}
-        body = result.map{|k,v| "#{k}:#{v}" }.join("\n")
-        msg = stomp_message('application/text', body )
-
-        expect( StompHandler.body_to_hash(msg.headers, msg.body) ).to eq result
-      end
-
-    end
-
-    it "allows the caller to override the content type" do
-      result = {'one' => 'two', 'three' => '4'}
-      body = result.map{|k,v| "#{k}:#{v}" }.join("\n")
-      msg = stomp_message('application/json', body )
-
-      expect( StompHandler.body_to_hash( msg.headers, 
-                                         msg.body, 
-                                         'application/text') ).to eq result
-
-    end
-
-    it "returns a hash or an array of hashes" do
-      # lets check some corner cases to ensure this
-      msg = stomp_message('appplication/json', ''.to_json)
-      expect( StompHandler.body_to_hash(msg.headers, msg.body) ).to eq({})
-
-      msg = stomp_message('appplication/json', nil.to_json)
-      expect( StompHandler.body_to_hash(msg.headers, msg.body) ).to eq({})
-
-      msg = stomp_message('appplication/text', '')
-      expect( StompHandler.body_to_hash(msg.headers, msg.body) ).to eq({})
-
-      msg = stomp_message('appplication/text', nil)
-      expect( StompHandler.body_to_hash(msg.headers, msg.body) ).to eq({})
-    end
-
-
-  end
-  ##
-
-
   describe "StompHandler.with_timeout" do
 
     it "should hang for the given timeout period" do
@@ -265,7 +192,7 @@ describe StompHandler do
     # We're kind of navel gazing here because send_message is just one line: a
     # call to client.publish. Still, call it a warming up exercise....
     
-    let(:mess) { NebulousStomp::Message.from_parts(nil, nil, 'foo', nil, nil) }
+    let(:mess) { NebulousStomp::Message.new(verb: 'foo', params: nil, desc: nil) }
 
     before do
       handler.stomp_connect