nebulous_stomp 2.0.2 → 3.0.0

data/spec/target_spec.rb

@@ -0,0 +1,97 @@
+require 'nebulous_stomp/target'
+
+include NebulousStomp
+
+
+describe Target do
+
+  let(:hash) do
+    { sendQueue:     'sendy',
+      receiveQueue:  'receivy',
+      messageTimeout: 42,
+      name:           'test' }
+
+  end
+
+  def hash_minus(key)
+    hash.delete_if{|k,_| k == key }
+  end
+
+
+  describe "#new" do
+
+    it "accepts a hash" do
+      expect{ Target.new    }.to raise_error ArgumentError
+      expect{ Target.new 14 }.to raise_error ArgumentError
+
+      expect{ Target.new(name:'fred', sendQueue:'foo', receiveQueue:'bar') }.not_to raise_error 
+    end
+
+    it "raises ArgumentError if the hash does not have :sendQueue" do
+      expect{ Target.new(hash_minus :sendQueue) }.to raise_error ArgumentError
+    end
+
+    it "raises ArgumentError if the hash does not have :receiveQueue" do
+      expect{ Target.new(hash_minus :receiveQueue) }.to raise_error ArgumentError
+    end
+
+    it "raises ArgumentError if the has does not have a :name" do
+      expect{ Target.new(hash_minus :name) }.to raise_error ArgumentError
+    end
+
+    it "accepts an optional :messageTimeout" do
+      expect{ Target.new hash                        }.not_to raise_error
+      expect{ Target.new(hash_minus :messageTimeout) }.not_to raise_error
+    end
+
+
+    it "rejects unknown values in the hash" do
+      h = hash.merge(:notavalidthing => 14)
+      expect { Target.new h }.to raise_error ArgumentError
+    end
+
+  end
+
+
+  describe "#send_queue" do
+
+    it "returns the send queue" do
+      expect( Target.new(hash).send_queue ).to eq hash[:sendQueue]
+    end
+
+  end
+
+
+  describe "#receive_queue" do
+
+    it "returns the receive queue" do
+      expect( Target.new(hash).receive_queue ).to eq hash[:receiveQueue]
+    end
+
+  end
+
+
+  describe "#message_timeout" do
+     
+    it "returns the timeout" do
+      expect( Target.new(hash).message_timeout ).to eq hash[:messageTimeout]
+    end
+
+    it "defaults the message timeout to nil" do
+      expect( Target.new(hash_minus :messageTimeout).message_timeout ).to be_nil
+    end
+    
+  end
+  
+
+  describe "#name" do
+     
+    it "returns the name" do
+      expect( Target.new(hash).name ).to eq hash[:name]
+    end
+
+  end
+  
+  
+end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nebulous_stomp
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 3.0.0
 platform: ruby
 authors:
 - Andy Jones
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-23 00:00:00.000000000 Z
+date: 2016-12-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -174,32 +174,40 @@ files:
 - Guardfile
 - README.md
 - Rakefile
+- feature/connection_example.yaml
+- feature/feature_test_spec.rb
+- feature/gimme.rb
 - lib/nebulous_stomp.rb
+- lib/nebulous_stomp/listener.rb
 - lib/nebulous_stomp/message.rb
-- lib/nebulous_stomp/nebrequest.rb
-- lib/nebulous_stomp/nebrequest_null.rb
+- lib/nebulous_stomp/msg/body.rb
+- lib/nebulous_stomp/msg/header.rb
 - lib/nebulous_stomp/param.rb
 - lib/nebulous_stomp/redis_handler.rb
 - lib/nebulous_stomp/redis_handler_null.rb
+- lib/nebulous_stomp/redis_helper.rb
+- lib/nebulous_stomp/request.rb
 - lib/nebulous_stomp/stomp_handler.rb
 - lib/nebulous_stomp/stomp_handler_null.rb
+- lib/nebulous_stomp/target.rb
 - lib/nebulous_stomp/version.rb
 - md/LICENSE.txt
 - md/nebulous_protocol.md
 - nebulous.gemspec
 - spec/doc_no_pending.rb
 - spec/helpers.rb
+- spec/listener_spec.rb
 - spec/message_spec.rb
-- spec/nebrequest_null_spec.rb
-- spec/nebrequest_spec.rb
 - spec/nebulous_spec.rb
 - spec/param_spec.rb
 - spec/redis_handler_null_spec.rb
 - spec/redis_handler_spec.rb
+- spec/redis_helper_spec.rb
+- spec/request_spec.rb
 - spec/spec_helper.rb
 - spec/stomp_handler_null_spec.rb
 - spec/stomp_handler_spec.rb
-- spec/through_test_spec.rb
+- spec/target_spec.rb
 - tags
 homepage: https://bitbucket.org/andy-twosticks/nebulous_stomp
 licenses:
@@ -225,22 +233,23 @@ requirements:
 - STOMP Messaging server
 - Redis server (optional)
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Handles request-and-response messaging via STOMP
 test_files:
 - spec/doc_no_pending.rb
 - spec/helpers.rb
+- spec/listener_spec.rb
 - spec/message_spec.rb
-- spec/nebrequest_null_spec.rb
-- spec/nebrequest_spec.rb
 - spec/nebulous_spec.rb
 - spec/param_spec.rb
 - spec/redis_handler_null_spec.rb
 - spec/redis_handler_spec.rb
+- spec/redis_helper_spec.rb
+- spec/request_spec.rb
 - spec/spec_helper.rb
 - spec/stomp_handler_null_spec.rb
 - spec/stomp_handler_spec.rb
-- spec/through_test_spec.rb
+- spec/target_spec.rb
 has_rdoc: 

data/lib/nebulous_stomp/nebrequest.rb

@@ -1,259 +0,0 @@
-require_relative 'stomp_handler'
-require_relative 'redis_handler'
-require_relative 'message'
-
-
-module NebulousStomp
-
-
-  ##
-  # Class to handle a request which returns a Message
-  #
-  # Note that this has changed since 0.1.0. The principal difference is we
-  # return a Nebulous::Message; the NebResponse class no longer exists.
-  #
-  class NebRequest
-
-    
-    # The target name as set up by call to Nebulous::add_target
-    attr_reader :target
-    
-    # Message timeout in seconds
-    attr_reader :mTimeout
-
-    # Cache timeout (fade and forget) in seconds
-    attr_reader :cTimeout
-
-    # The message
-    attr_reader :message
-
-    # The STOMP queue to send the request to
-    attr_reader :requestQ
-
-    # The STOMP queue to listen for responses on
-    attr_reader :responseQ
-
-
-    ##
-    # :call-seq:
-    #   NebRequest.new(target, verb) 
-    #   NebRequest.new(target, verb, params) 
-    #   NebRequest.new(target, verb, params, desc) 
-    #
-    # Create a new request. Raises Nebulous::NebulousError if anything goes
-    # wrong.
-    #
-    # Parameters:
-    #  target [Symbol] the target name to send the request to
-    #  verb   [String] the 'verb' part of the message
-    #  params [String] the 'parameters' part of the message
-    #  desc   [String] the 'description' part of the message
-    #  stompHandler    ONLY FOR TESTING
-    #  redisHandler    ONLY FOR TESTING
-    #
-    def initialize( target, 
-                    verb, 
-                    params=nil, 
-                    desc=nil, 
-                    stompHandler=nil, 
-                    redisHandler=nil )
-
-      NebulousStomp.logger.debug(__FILE__) {"New NebRequest for verb #{verb}"}
-
-      @target        = target.to_s
-      @stomp_handler = stompHandler 
-      @redis_handler = redisHandler 
-      @requestQ      = nil
-      @responseQ     = nil
-      @message       = nil
-      @mTimeout      = 0
-      @cTimeout      = 0
-
-      xverb   = verb.to_s
-      xparams = params.nil? ? nil : params.to_s
-      xdesc   = desc.nil?   ? nil : desc.to_s
-
-      @redis_handler ||= RedisHandler.new( Param.get(:redisConnectHash) )
-      @stomp_handler ||= StompHandler.new( Param.get(:stompConnectHash) )
-
-      neb_setup if nebulous_on?
-      @message = Message.from_parts(@responseQ, nil, xverb, xparams, xdesc)
-      neb_connect if nebulous_on?
-    end
-
-
-    ##
-    # :call-seq:
-    #     request.send_no_cache           -> (Message)
-    #     request.send_no_cache(mTimeout) -> (Message)
-    #
-    # Send a request and return the response, without using the cache.
-    #
-    # Parameters:
-    #  mTimeout [Fixnum] Message timout in seconds - defaults to @mTimeout
-    #
-    # Raises NebulousTimeout or NebulousError as necessary.
-    #
-    # Note that this routine completely ignores Redis. It doesn't just not
-    # check the cache; it also doesn't update it.
-    #
-    def send_no_cache(mTimeout=@mTimeout)
-      return nil unless nebulous_on?
-
-      # If we've lost the connection then reconnect but *keep replyID*
-      @stomp_handler.stomp_connect unless @stomp_handler.connected?
-      @message.reply_id = @stomp_handler.calc_reply_id if @message.reply_id.nil? 
-
-      neb_qna(mTimeout)
-
-    ensure
-      @stomp_handler.stomp_disconnect if @stomp_handler
-    end
-
-
-    ##
-    # ::call-seq::
-    #     request.send                    -> (Message)
-    #     request.send(mTimeout)          -> (Message)
-    #     request.send(mTimeout,cTimeout) -> (Message)
-    #
-    # As send_nocache, but without not using the cache :)
-    #
-    # Parameters:
-    #  mTimeout  [Fixnum] Message timout in seconds - defaults to @mTimeout
-    #  cTimeout  [Fixnum] Cache timout in seconds - defaults to @cTimeout
-    #
-    # Raises NebulousTimeout, NebulousError as necessary.
-    #
-    # We use Redis for the cache. This is possibly like using a sledgehammer
-    # to crack a nut, but it certainly makes things very simple.
-    #
-    def send(mTimeout=@mTimeout, cTimeout=@cTimeout)
-      return nil unless nebulous_on?
-      return send_no_cache(mTimeout) unless redis_on?
-
-      @redis_handler.connect unless @redis_handler.connected?
-
-      found = @redis_handler.get(@message.protocol_json)
-      return Message.from_cache(found) unless found.nil?
-
-      # No answer in Redis -- ask Nebulous
-      nebMess = send_no_cache(mTimeout)
-      @redis_handler.set(@message.protocol_json, nebMess.to_cache, ex: cTimeout)
-
-      nebMess
-
-    ensure
-      @redis_handler.quit if @redis_handler
-    end
-
-
-    ##
-    # :call-seq:
-    #   request.clear_cache -> self
-    #
-    # Clear the cache of responses to this request - just this request.
-    #
-    def clear_cache
-      return self unless redis_on?
-      @redis_handler.connect unless @redis_handler.connected?
-      @redis_handler.del(@message.protocol_json)
-
-      self
-
-    ensure
-      @redis_handler.quit if @redis_handler
-    end
-
-
-    ##
-    # :call-seq:
-    #   request.redis_on? -> (boolean)
-    #
-    # Return true if Redis is turned on in the *config*
-    #
-    # (If you want to know if we are conected to Redis, try
-    # `@redis_handler.connected?`)
-    #
-    def redis_on?
-      @redis_handler && @redis_handler.redis_on?
-    end
-
-
-    ##
-    # :call-seq:
-    #   request.nebulous_on? -> (boolean)
-    #
-    # Return true if Nebulous is turned on in the *config*
-    #
-    def nebulous_on?
-      @stomp_handler && @stomp_handler.nebulous_on?
-    end
-
-
-    #
-    # Some of our attributes are actually on Message
-    #
-
-    def verb;    @message ? @message.verb     : nil; end
-    def params;  @message ? @message.params   : nil; end
-    def desc;    @message ? @message.desc     : nil; end
-    def replyID; @message ? @message.reply_id : nil; end
-
-
-    private
-
-
-    ##
-    # Connect to STOMP etc and do initial setup
-    #
-    def neb_setup
-      targetHash = Param.get_target(@target)
-      raise NebulousError, "Unknown target #{target}" if targetHash.nil?
-
-      @cTimeout  = Param.get(:cacheTimeout)
-      @mTimeout  = targetHash[:messageTimeout] || Param.get(:messageTimeout)
-      @requestQ  = targetHash[:sendQueue]
-      @responseQ = targetHash[:receiveQueue]
-
-      self
-    end
-
-
-    # Called automatically by initialize, if Nebulous is 'on' in the config.
-    #
-    def neb_connect
-      @stomp_handler.stomp_connect
-      @message.reply_id = @stomp_handler.calc_reply_id 
-      self
-    end
-
-    
-    ##
-    # Send a message via STOMP and wait for a response
-    #
-    # Note: this used to return a Stomp::Message, but now it returns a
-    # Nebulous::Message.
-    #
-    def neb_qna(mTimeout)
-      @stomp_handler.send_message(@requestQ, @message)
-
-      response = nil
-      @stomp_handler.listen_with_timeout(@responseQ, mTimeout) do |msg|
-        if replyID && msg.in_reply_to != replyID
-          false
-        else
-          response = msg
-          true
-        end
-      end
-
-      response
-    end
-
-
-  end # of NebRequest
-
-
-end
-

data/lib/nebulous_stomp/nebrequest_null.rb

@@ -1,37 +0,0 @@
-require 'nebulous_stomp'
-
-require_relative 'nebrequest'
-require_relative 'stomp_handler_null'
-require_relative 'redis_handler_null'
-
-
-module NebulousStomp
-
-
-  ## 
-  # Class to fake a NebRequest
-  #
-  class NebRequestNull < NebRequest
-
-    def initialize( target, verb, params=nil, desc=nil )
-      sh = StompHandlerNull.new( Param.get(:stompConnectHash) )
-      rh = RedisHandlerNull.new( Param.get(:redisConnectHash) )
-      super(target, verb, params, desc, sh, rh)
-    end
-
-
-    def insert_fake_stomp(message)
-      @stomp_handler.insert_fake(message)
-    end
-
-
-    def insert_fake_redis(key, value)
-      @redis_handler.insert_fake(key, value)
-    end
-
-
-  end 
-
-
-end
-

data/spec/nebrequest_null_spec.rb

@@ -1,219 +0,0 @@
-require 'spec_helper'
-
-include NebulousStomp
-
-require 'nebulous_stomp/nebrequest_null'
-require 'nebulous_stomp/message'
-
-
-describe NebRequestNull do
-
-  def new_request(target, verb, params=nil, desc=nil)
-    NebRequestNull.new(target, verb, params, desc)
-  end
-
-  def disable(thing)
-    NebulousStomp.init( :stompConnectHash => thing == :stomp ? {} : stomp_hash,
-                        :redisConnectHash => thing == :redis ? {} : redis_hash,
-                        :messageTimeout   => 5,
-                        :cacheTimeout     => 20 )
-
-    NebulousStomp.add_target( :accord, 
-                         :sendQueue      => "/queue/laplace.dev",
-                         :receiveQueue   => "/queue/laplace.out",
-                         :messageTimeout => 1 )
-  end
-
-  let(:stomp_hash) do
-    { hosts: [{ login:    'guest',
-                passcode: 'guest',
-                host:     '10.0.0.150',
-                port:     61613,
-                ssl:      false }],
-      reliable: false }
-
-  end
-
-  let(:redis_hash) { {host: '127.0.0.1', port: 6379, db: 0} }
-
-
-  before do
-    disable(:nothing)
-  end
-
-
-  describe "#initialize" do
-
-    it "raises an exception for a bad target" do
-      expect{ new_request('badtarget', 'foo') }.
-        to raise_exception(NebulousError)
-
-    end
-
-    it "takes the timeout on the target over the default" do
-      expect( new_request('accord', 'foo').mTimeout ).to eq(1)
-    end
-
-    it "falls back to the default if the timeout on the target is not set" do
-      NebulousStomp.add_target( :dracula, 
-                           :sendQueue      => "/queue/laplace.dev",
-                           :receiveQueue   => "/queue/laplace.out" )
-
-      expect( new_request('dracula', 'foo').mTimeout ).to eq(5)
-    end
-
-    it 'doesn''t freak out if Nebulous is not "on"' do
-      disable(:stomp)
-      expect{ NebRequestNull.new('accord', 'foo', nil, nil) }.
-        not_to raise_exception
-
-    end
-      
-  end
-  ##
-
-
-  describe "#clear_cache" do
-
-    it 'returns self' do
-      r = new_request('accord', 'foo')
-      expect( r.clear_cache ).to eq r
-    end
-
-    it 'doesn''t freak out if Redis is not connected' do
-      disable(:redis)
-      r = NebRequestNull.new( 'accord', 'foo', nil, nil)
-
-      expect{ r.clear_cache }.not_to raise_exception
-      expect( r.clear_cache ).to eq r
-    end
-
-  end
-  ##
-
-
-  describe "#send_no_cache" do
-
-    it "returns something from STOMP" do
-      req = new_request('accord', 'foo')
-      req.insert_fake_stomp( Message.from_parts(nil, req.replyID, 'foo', 'bar', 'baz') )
-      response = req.send_no_cache
-
-      expect( response ).to be_a NebulousStomp::Message
-      expect( response.verb ).to eq('foo')
-    end
-
-    it 'returns a nebulous timeout if there is no response' do
-      request = new_request('accord', 'foo')
-      expect{ request.send_no_cache }.
-        to raise_exception NebulousStomp::NebulousTimeout
-
-    end
-
-    it 'returns nil if Nebulous is disabled in the config' do
-      disable(:stomp)
-      r = new_request('accord', 'foo')
-
-      expect( r.send_no_cache ).to eq nil
-    end
-
-  end
-  ##
-
-
-  describe "#send" do
-
-    it "returns a Message object from STOMP the first time" do
-      req = new_request('accord', 'foo')
-      req.insert_fake_stomp( Message.from_parts(nil, req.replyID, 'foo', 'bar', 'baz') )
-
-      response = req.send
-      expect( response ).to be_a NebulousStomp::Message
-      expect( response.verb ).to eq('foo')
-    end
-
-    it "returns the answer from the cache if there is one" do
-      req = new_request('accord', 'foo')
-      req.insert_fake_stomp( Message.from_parts(nil, req.replyID, 'foo', 'bar', 'baz') )
-      req.insert_fake_redis('xxx', {'verb' => 'frog'}.to_json)
-      response = req.send
-
-      expect( response ).to be_a NebulousStomp::Message
-      expect( response.verb ).to eq('frog')
-    end
-
-    it "allows you to specify a message timeout" do
-      req = new_request('accord', 'foo')
-      req.insert_fake_stomp( Message.from_parts(nil, req.replyID, 'foo', 'bar', 'baz') )
-
-      expect{ req.send(3) }.not_to raise_exception
-    end
-
-    it "allows you to specify a message timeout & cache timeout" do
-      req = new_request('accord', 'foo')
-      req.insert_fake_stomp( Message.from_parts(nil, req.replyID, 'foo', 'bar', 'baz') )
-
-      expect{ req.send(3, 120) }.not_to raise_exception
-    end
-
-    it 'returns a nebulous timeout if there is no response' do
-      req = new_request('accord', 'foo')
-      expect{ req.send }.to raise_exception NebulousStomp::NebulousTimeout
-    end
-
-    it 'still works if Redis is turned off in the config' do
-      disable(:redis)
-      r = new_request('accord', 'tom')
-      r.insert_fake_stomp( Message.from_parts(nil, r.replyID, 'foo', 'bar', 'baz') )
-
-      response = r.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
-      disable(:stomp)
-      r = new_request('accord', 'foo')
-
-      expect( r.send ).to eq nil
-    end
-
-  end 
-  ##
-
-
-  describe '#redis_on?' do
-
-    it 'is true if there is a redis connection hash' do
-      request = new_request('accord', 'foo')
-      expect( request.redis_on? ).to be_truthy
-    end
-
-    it 'is false if there is no redis connection hash' do
-      disable(:redis)
-      r = new_request('accord', 'foo')
-      expect( r.redis_on? ).to be_falsy
-    end
-
-  end
-  ##
-
-
-  describe '#nebulous_on?' do
-
-    it 'is true if there is a nebulous connection hash' do
-      r = new_request('accord', 'foo')
-      expect( r.nebulous_on? ).to be_truthy
-    end
-
-    it 'is false if there is no nebulous connection hash' do
-      disable(:stomp)
-      r = new_request('accord', 'foo')
-      expect( r.nebulous_on? ).to be_falsy
-    end
-
-  end
-  ##
-
-end # of NebRequestNull
-