nebulous_stomp 2.0.2 → 3.0.0

data/spec/message_spec.rb

@@ -1,6 +1,3 @@
-require 'stomp'
-
-require 'spec_helper'
 require 'nebulous_stomp/message'
 
 require_relative 'helpers'
@@ -20,6 +17,7 @@ describe Message do
   # headers; we're stuck with that. So for comparison purposes this helper
   # function deep-converts all keys in a hash to symbols.
   def symbolise(hash)
+    return nil unless hash.is_a? Hash
 
     hash.each_with_object({}) do |(k,v),m| 
       m[k.to_sym] = v.kind_of?(Hash) ? symbolise(v) : v
@@ -28,17 +26,26 @@ describe Message do
   end
 
 
-  let(:msg_pts) do
-    x = Message.from_parts('Daphne', 'Fred', 'Velma', 'Shaggy', 'Scooby')
-    x.reply_id = 42
-    x
+  let(:new_hash_body) do
+    { verb: 'Velma', parameters: 'Shaggy', description:'Scooby' }
+  end
+
+  let(:new_hash) do
+    { replyTo:     'Daphne', 
+      inReplyTo:   'Fred', 
+      verb:        'Velma', 
+      parameters:  'Shaggy', 
+      description: 'Scooby' }
+
   end
 
+  let(:msg_new)  { Message.new new_hash }
+  let(:msg_new2) { Message.new new_hash.merge(replyId: 42) }
+
   let(:smess)     { stomp_message('application/text', 'foo') } 
   let(:msg_stomp) { Message.from_stomp(smess) }
 
   let(:json_hash) do
-
       b = { verb:   'tom',
             params: 'dick',
             desc:   'harry' }.to_json
@@ -60,66 +67,101 @@ describe Message do
   let(:msg_cache) { Message.from_cache( json_hash.to_json ) }
 
 
-  describe 'Message.from_parts' do
+  describe 'Message.new' do
 
     it 'returns a Message object' do
-      expect( msg_pts ).to be_a_kind_of(Message)
+      expect( msg_new ).to be_a_kind_of(Message)
     end
 
-    it 'sets protocol attributes if it can, raises hell otherwise' do
-      expect{ Message.from_parts }.to raise_exception ArgumentError
+    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]
+      expect( msg_new.params      ).to eq new_hash[:parameters]
+      expect( msg_new.desc        ).to eq new_hash[:description]
+      expect( symbolise msg_new.body ).to eq new_hash_body
+    end
 
-      expect{ Message.from_parts(nil, nil, nil, nil, nil) }.
-        to raise_exception ArgumentError
+    it "prefers to build a body from protocol attributes" do
+      m = Message.new new_hash.merge(body: "foo")
+      expect( m.verb   ).to eq new_hash[:verb]
+      expect( m.params ).to eq new_hash[:parameters]
+      expect( m.desc   ).to eq new_hash[:description]
+      expect( symbolise m.body ).to eq new_hash_body
+    end
 
-      expect( msg_pts.reply_to    ).to eq 'Daphne'
-      expect( msg_pts.in_reply_to ).to eq 'Fred'
-      expect( msg_pts.verb        ).to eq 'Velma'
-      expect( msg_pts.params      ).to eq 'Shaggy'
-      expect( msg_pts.desc        ).to eq 'Scooby'
+    it "takes the body attribute as given if there is no verb" do
+      m = Message.new(body: "foo", params: "bar", desc: "baz")
+      expect( m.verb   ).to be_nil
+      expect( m.params ).to be_nil
+      expect( m.desc   ).to be_nil
+      expect( m.body   ).to eq "foo"
     end
 
-    it "assumes a content type of JSON" do
-      expect( msg_pts.content_type ).to match(/json$/i)
+    it "builds the body and protocol from stompBody if they are missing" do
+      m = Message.new(stompBody: new_hash_body.to_json, contentType: 'application/json')
+      expect( m.verb   ).to eq new_hash[:verb]
+      expect( m.params ).to eq new_hash[:parameters]
+      expect( m.desc   ).to eq new_hash[:description]
+      expect( symbolise m.body ).to eq new_hash_body
     end
 
-  end
-  ##
+    it "sets body from stompbody if body/verb are missing, and stompbody is not protocol" do
+      m = Message.new(stompBody: "waga waga")
+      expect( m.verb   ).to be_nil
+      expect( m.params ).to be_nil
+      expect( m.desc   ).to be_nil
+      expect( m.body   ).to eq "waga waga"
 
+      m = Message.new(stompBody: "wigi wigi", contentType: "text")
+      expect( m.verb   ).to be_nil
+      expect( m.params ).to be_nil
+      expect( m.desc   ).to be_nil
+      expect( m.body   ).to eq "wigi wigi"
+    end
 
-  describe 'Message.in_reply_to' 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
 
-    let(:msg) do 
-      Message.in_reply_to(msg_pts, 'Buffy', 'Willow', 'Xander', 'Ripper')
+    it "assumes a content type of JSON if one is not given" do
+      expect( msg_new.content_type ).to match(/json$/i)
     end
 
+    it "is fine with messages not having a replyTo or a verb" do
+      expect{ Message.new(verb: 'thing'              ) }.not_to raise_exception
+      expect{ Message.new(replyTo: 'foo', body: 'bar') }.not_to raise_exception
+      expect{ Message.new(body: 'bar')                 }.not_to raise_exception
+    end
+
+  end
+  ##
+
 
-    it 'requires another Message object and a verb' do
-      expect{ Message.in_reply_to('foo') }.to raise_exception ArgumentError
+  describe 'Message.in_reply_to' do
 
-      expect{ Message.in_reply_to('foo', 'bar') }.
-        to raise_exception ArgumentError
+    it "requires a message to reply to and a hash" do
+      expect{ Message.in_reply_to()             }.to raise_error ArgumentError
+      expect{ Message.in_reply_to("foo")        }.to raise_error ArgumentError
+      expect{ Message.in_reply_to(msg_new2)     }.to raise_error ArgumentError
+      expect{ Message.in_reply_to(msg_new2, 14) }.to raise_error ArgumentError
 
-      expect{ Message.in_reply_to(msg_pts, 'bar') }.not_to raise_exception
+      expect{ Message.in_reply_to(msg_new2, body: "foo") }.not_to raise_error
     end
 
-    it 'returns a fresh Message object' do
-      expect( msg ).to be_a_kind_of(Message)
-      expect( msg ).not_to eq(msg_pts)
+    it "raises ArgumentError if the initial message has no reply_id" do
+      expect{ Message.in_reply_to(msg_stomp, verb: 'foo') }.to raise_exception ArgumentError
     end
 
-    it 'sets Protocol attributes' do
-      expect( msg.verb     ).to eq 'Buffy'
-      expect( msg.params   ).to eq 'Willow'
-      expect( msg.desc     ).to eq 'Xander'
-      expect( msg.reply_to ).to eq 'Ripper'
-
-      # NB the reply_id (message ID) not the reply_to (the queue)
-      expect( msg.in_reply_to ).to eq 42 
+    it "sets the content type from the initial message" do
+      msg = Message.in_reply_to(msg_new2, body: 'foo')
+      expect( msg.content_type ).to eq msg_new.content_type
     end
 
-    it 'sets the content type from the source message' do
-      expect( msg.content_type ).to eq msg_pts.content_type
+    it "sets the in_reply_to to the initial message reply_id" do
+      msg = Message.in_reply_to(msg_new2, body: 'foo')
+      expect( msg.in_reply_to ).to eq msg_new2.reply_id
     end
 
   end
@@ -147,6 +189,14 @@ 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
+      b = { verb:   'tom',
+            params: 'dick',
+            desc:   'harry' }.to_json
+
+      x = Message.from_stomp( stomp_message('barry', b) )
+      expect( x.content_type ).to eq 'barry'
+    end
 
     context "when the message body is text" do
 
@@ -303,7 +353,7 @@ describe Message do
 
   describe '#parameters' do
     it 'returns the same as @param' do
-      expect(msg_pts.parameters).to eq msg_pts.params
+      expect(msg_new.parameters).to eq msg_new.params
     end
   end
   ##
@@ -311,38 +361,31 @@ describe Message do
 
   describe '#description' do
     it 'returns the same as @desc' do
-      expect(msg_pts.description).to eq msg_pts.desc
+      expect(msg_new.description).to eq msg_new.desc
     end
   end
   ##
 
 
-  describe '#content_is_json?' do
+  describe '#content_is_json?' do 
 
-    it 'returns true if the body is supposed to be JSON' do
-      expect( msg_pts.content_is_json? ).to be true
+    it "returns true if the content type is JSON" do
+      expect( msg_new.content_is_json? ).to be true
     end
 
-    it 'returns false unless the body is supposed to be JSON' do
-      smess = stomp_message('application/text', 'foo') 
-      mess  = Message.from_stomp(smess) 
-      expect( mess.content_is_json? ).to be false
-
-      mess = Message.from_cache( {contentType: 'dunno'}.to_json )
-      expect( mess.content_is_json? ).to be false
-
-      mess = Message.from_cache( {horse: 'badger'}.to_json )
-      expect( mess.content_is_json? ).to be false
+    it "returns false if the content type is non-json" do
+      msg = Message.new( new_hash.merge(contentType: 'foo') )
+      expect( msg.content_type ).to eq "foo"
     end
 
   end
   ##
 
 
-  describe '#to_cache' do
+  describe '#to_h' do
 
     it 'returns the message as a hash' do
-      hash = msg_pts.to_cache
+      hash = msg_new.to_h
 
       expect( hash ).to be_a_kind_of Hash
       expect( hash ).to include( replyTo:   'Daphne',
@@ -355,15 +398,15 @@ describe Message do
     end
 
     it 'always returns all the keys' do
-      expect( msg_stomp.to_cache.keys ).to include(*json_hash.keys)
+      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
-      expect{ Message.from_cache(msg_cache.to_cache.to_json) }.
+      expect{ Message.from_cache(msg_cache.to_h.to_json) }.
         not_to raise_exception
 
-      mess = Message.from_cache(msg_cache.to_cache.to_json)
-      expect(mess.to_cache).to eq symbolise(json_hash)
+      mess = Message.from_cache(msg_cache.to_h.to_json)
+      expect(mess.to_h).to include symbolise(json_hash)
     end
       
 
@@ -373,7 +416,7 @@ describe Message do
 
   describe '#protocol_json' do
     it "returns the Protocol as a JSON string" do
-      hash = JSON.parse( msg_pts.protocol_json, symbolize_names: true )
+      hash = JSON.parse( msg_new.protocol_json, symbolize_names: true )
 
       expect( hash ).to include(verb: 'Velma')
 
@@ -388,46 +431,29 @@ describe Message do
   ##
 
 
-  describe "#body_to_h" do
-
-    context "if the body is in JSON" do
-
-      it "returns a hash"  do
-        x = {}
-        x[:stompHeaders] = {}
-        x[:stompBody]    = @datH.to_json # JSONd twice?
-        x[:contentType]  = "JSON"
-
-        nr = Message.from_cache(x.to_json)
-        expect( nr.body_to_h ).to eq @datH
-      end
+  describe "#body" do
 
+    it "returns a hash if the stomp body is in JSON" do
+      nr = Message.new(stompBody: new_hash.to_json, contentType: "JSON")
+      expect( symbolise nr.body ).to eq new_hash
     end
 
-    context "If the body is not in JSON" do
-      it "returns nil" do
-
-        x = {}
-        x["body"] = @datS
-        x["content-type"] = "text"
-
-        nr = Message.from_cache(x.to_json)
-        expect( nr.body_to_h ).to be_nil
+    it "returns a hash if the stomp body is not in JSON" do
+      x = new_hash.map{|k,v| "#{k}: #{v}" }.join("\n")
 
-      end
+      nr = Message.new(stompBody: x, contentType: "text")
+      expect( symbolise nr.body ).to eq new_hash
     end
 
-    context "If the body is nil(!)" do
-      it "returns nil" do
-        x = {}
-        x["body"] = nil
-        x["content-type"] = "JSON"
-
-        nr = Message.from_cache(x.to_json)
+    it "returns nil if the stomp body is nil(!)" do
+      nr = Message.new(stompBody: nil, contentType: "JSON")
+      expect{ nr.body }.to_not raise_exception
+      expect( nr.body ).to be_nil
+    end
 
-        expect{ nr.body_to_h }.to_not raise_exception
-        expect( nr.body_to_h ).to be_nil
-      end
+    it "returns the body if given and no stomp_body or verb given" do
+      nr = Message.new(body: "foo")
+      expect( nr.body ).to eq "foo"
     end
 
   end
@@ -437,13 +463,13 @@ describe Message do
   describe '#headers_for_stomp' do
 
     it 'always returns a Hash' do
-      expect( msg_pts.headers_for_stomp   ).to be_a_kind_of Hash
+      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
     end
 
     it "returns the custom headers for the Stomp gem" do
-      hdrs = msg_pts.headers_for_stomp
+      hdrs = msg_new2.headers_for_stomp
       expect( hdrs ).to include("content-type"    => 'application/json')
       expect( hdrs ).to include("neb-reply-id"    => 42)
       expect( hdrs ).to include("neb-reply-to"    => 'Daphne')
@@ -451,6 +477,8 @@ describe Message do
 
       hdrs = msg_stomp.headers_for_stomp
       expect( hdrs ).to include("content-type" => 'application/text')
+
+      # The point of this test is?
       expect( hdrs ).to include("neb-reply-id" => nil)
     end
 
@@ -503,71 +531,154 @@ describe Message do
   ##
 
 
-  describe '#respond_success' do
+  describe '#respond_with_success' do
 
     it "raises an error if we have no @reply_to" do
-      expect{ msg_stomp.respond_success }.to raise_exception NebulousError
+      expect{ msg_stomp.respond_with_success }.to raise_exception NebulousError
     end
 
     it "returns the queue to respond on" do
-      q,_ = msg_cache.respond_success
+      q,_ = msg_cache.respond_with_success
       expect( q ).to eq '/queue/thing'
     end
 
     it "returns a new message that has the success verb" do
-      _,m = msg_cache.respond_success
+      _,m = msg_cache.respond_with_success
       expect( m ).to be_a_kind_of Message
       expect( m.verb ).to eq 'success'
     end
 
+    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
   ##
 
 
-  describe '#respond_error' do
+  describe '#respond_with_error' do
     let(:err) { NebulousError.new("test error") }
 
     it "raises an error if we have no @reply_to" do
-      expect{ msg_stomp.respond_error('foo') }.to raise_exception NebulousError
+      expect{ msg_stomp.respond_with_error('foo') }.to raise_exception NebulousError
     end
 
     it "requires an error parameter" do
-      expect{ msg_cache.respond_error() }.to raise_exception ArgumentError
-      expect{ msg_cache.respond_error('foo') }.not_to raise_exception
+      expect{ msg_cache.respond_with_error() }.to raise_exception ArgumentError
+      expect{ msg_cache.respond_with_error('foo') }.not_to raise_exception
     end
 
     it "accepts an exception object" do
-      expect{ msg_cache.respond_error(err) }.not_to raise_exception
+      expect{ msg_cache.respond_with_error(err) }.not_to raise_exception
     end
 
     it "accepts an optional error field" do
-      expect{ msg_cache.respond_error('foo', :bar) }.not_to raise_exception
+      expect{ msg_cache.respond_with_error('foo', :bar) }.not_to raise_exception
     end
 
     it "returns the queue to respond on" do
-      q,_ = msg_cache.respond_error('foo')
+      q,_ = msg_cache.respond_with_error('foo')
       expect( q ).to eq '/queue/thing'
 
-      q,_ = msg_cache.respond_error(err, :foo)
+      q,_ = msg_cache.respond_with_error(err, :foo)
       expect( q ).to eq '/queue/thing'
     end
 
     it "returns a new message with the failure verb and details" do
-      _,m = msg_cache.respond_error('foo')
+      _,m = msg_cache.respond_with_error('foo')
       expect( m ).to be_a_kind_of Message
       expect( m.verb ).to eq 'error'
       expect( m.params ).to eq []
       expect( m.desc ).to eq 'foo'
 
-      _,m = msg_cache.respond_error(err, :foo)
+      _,m = msg_cache.respond_with_error(err, :foo)
       expect( m ).to be_a_kind_of Message
       expect( m.verb ).to eq 'error'
-      expect( m.params ).to eq "foo"
+      expect( m.params ).to eq ["foo"]
       expect( m.desc ).to eq err.message
     end
 
+    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
+  ##
+
+
+  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
+    end
+
+    it "requires a verb parameter" do
+      expect{ msg_cache.respond_with_protocol() }.to raise_exception ArgumentError
+      expect{ msg_cache.respond_with_protocol('foo') }.not_to raise_exception
+    end
+
+    it "accepts optional 'parameters' and 'description' parameters" do
+      expect{ msg_cache.respond_with_protocol('foo', "bar")        }.not_to raise_exception
+      expect{ msg_cache.respond_with_protocol('foo', [:a, :b])     }.not_to raise_exception
+      expect{ msg_cache.respond_with_protocol('foo', 'bar', 'baz') }.not_to raise_exception
+    end
+
+    it "returns a queue to respond on" do
+      q,_ = msg_cache.respond_with_protocol('foo')
+      expect( q ).to eq '/queue/thing'
+    end
+
+    it "returns a new message with the verb, params, and desc" do
+      _,m = msg_cache.respond_with_protocol('bleem', 'drort', 'flang')
+      expect( m ).to be_a_kind_of Message
+      expect( m.verb   ).to eq 'bleem'
+      expect( m.params ).to eq 'drort'
+      expect( m.desc   ).to eq 'flang'
+    end
+
+    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
+  ##
+  
+  
+  describe '#respond' do
+
+    let(:msg) { msg_cache.respond("desmond") }
+     
+    it "raises an error if we have no @reply_to" do
+      expect{ msg_stomp.respond('foo') }.to raise_exception NebulousError
+    end
+
+    it "requires a message body" do
+      expect{ msg_cache.respond() }.to raise_exception ArgumentError
+      expect{ msg }.not_to raise_exception
+    end
+
+    it "returns a queue to respond on" do
+      q,_ = msg
+      expect( q ).to eq '/queue/thing'
+    end
+
+    it "returns a new message with the given body" do
+      _,m = msg
+      expect( m ).to be_a_kind_of Message
+      expect( m.body ).to eq 'desmond'
+    end
+
+    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
 

data/spec/nebulous_spec.rb

@@ -1,19 +1,18 @@
-require 'spec_helper'
-
-require 'logger'
-
 require 'nebulous_stomp/param'
 
 
 describe NebulousStomp do
 
-  before      { NebulousStomp::Param.reset }
-  after(:all) { NebulousStomp::Param.reset }
+  before      { NebulousStomp::Param.send :reset }
+  after(:all) { NebulousStomp::Param.send :reset }
 
 
   # Magically replaces the real Param module
   let(:param) { class_double(NebulousStomp::Param).as_stubbed_const }
 
+  let(:tname) {:foo}
+  let(:thash) { {sendQueue: "foo", receiveQueue: "bar"} }
+
 
   it 'has a version number' do
     expect(NebulousStomp::VERSION).not_to be nil
@@ -66,15 +65,50 @@ describe NebulousStomp do
   describe 'NebulousStomp.add_target' do
 
     it 'calls Param.add_target' do
-      t1 = :foo; t2 = {bar: 'baz'}
-      expect(param).to receive(:add_target).with(t1, t2)
-      NebulousStomp.add_target(t1, t2)
+      expect(param).to receive(:add_target) do | t|
+        expect(t.name).to eq tname
+        expect(t.send_queue).to eq thash[:sendQueue]
+        expect(t.receive_queue).to eq thash[:receiveQueue]
+      end
+
+      NebulousStomp.add_target(tname, thash)
+    end
+
+    it 'returns the target object' do
+      t = NebulousStomp.add_target(tname, thash)
+      expect( t ).to be_kind_of(NebulousStomp::Target)
+    end
+
+    it "adds the name to the target hash" do
+      t = NebulousStomp.add_target(tname, thash)
+      expect( t.name ).to eq tname
     end
 
   end
   ##
 
 
+  describe 'NebulousStomp.get_target' do
+
+    before do
+      NebulousStomp.add_target(tname, thash)
+    end
+     
+    it "calls Param.get_target" do
+      expect(param).to receive(:get_target).with(tname)
+      NebulousStomp.get_target(tname)
+    end
+
+    it "returns the target object" do
+      t = NebulousStomp.get_target(tname)
+      expect( t ).to be_kind_of(NebulousStomp::Target)
+      expect( t.name ).to eq tname
+    end
+    
+  end
+  ##
+  
+
   describe 'NebulousStomp.on?' do
 
     it 'should be true if there is anything in the stomp hash' do
@@ -119,6 +153,7 @@ describe NebulousStomp do
   end
   ##
 
+
 end