nebulous_stomp 2.0.2 → 3.0.0

data/spec/nebrequest_spec.rb

@@ -1,239 +0,0 @@
-require 'spec_helper'
-
-include NebulousStomp
-
-require 'nebulous_stomp/nebrequest'
-require 'nebulous_stomp/message'
-require 'nebulous_stomp/stomp_handler_null'
-require 'nebulous_stomp/redis_handler_null'
-
-
-describe NebRequest do
-
-  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} }
-
-  let(:stomp_h) { StompHandlerNull.new(stomp_hash) }
-  let(:redis_h) { RedisHandlerNull.new(redis_hash) }
-
-  def new_request(target, verb, params=nil, desc=nil)
-    NebRequest.new(target, verb, params, desc, stomp_h, redis_h)
-  end
-
-  before do
-    NebulousStomp.init( :stompConnectHash => @stomph, 
-                   :redisConnectHash => @redish,
-                   :messageTimeout   => 5,
-                   :cacheTimeout     => 20 )
-
-    NebulousStomp.add_target( :accord, 
-                         :sendQueue      => "/queue/laplace.dev",
-                         :receiveQueue   => "/queue/laplace.out",
-                         :messageTimeout => 1 )
-
-  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
-      sh = StompHandlerNull.new({})
-
-      expect{ NebRequest.new('accord','foo',nil,nil,sh,redis_h) }.
-        not_to raise_exception
-
-    end
-      
-  end
-  ##
-
-
-  describe "#clear_cache" do
-
-    it "removes the redis cache for a single request" do
-      redis_h.insert_fake('foo', 'bar')
-      expect( redis_h ).to receive(:del).with( {"verb"=>"foo"}.to_json )
-
-      new_request('accord', 'foo').clear_cache
-    end
-
-    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
-      rh = RedisHandlerNull.new({})
-      r = NebRequest.new( 'accord', 'foo', nil, nil, stomp_h, rh)
-
-      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
-      request = new_request('accord', 'foo')
-      stomp_h.insert_fake( Message.from_parts(nil, request.replyID, 'foo', 'bar', 'baz') )
-      response = request.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
-      sh = StompHandlerNull.new({})
-      r = NebRequest.new('accord', 'foo', nil, nil, sh, redis_h)
-
-      expect( r.send_no_cache ).to eq nil
-    end
-
-  end
-  ##
-
-
-  describe "#send" do
-
-    it "returns a Message object from STOMP the first time" do
-      request = new_request('accord', 'foo')
-      stomp_h.insert_fake( Message.from_parts(nil, request.replyID, 'foo', 'bar', 'baz') )
-
-      response = request.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_h.insert_fake( Message.from_parts(nil, nil, 'foo', 'bar', 'baz') )
-      redis_h.insert_fake('xxx', {'verb' => 'frog'}.to_json)
-
-      # First time
-      request = new_request('accord', 'foo')
-      response = request.send
-
-      # Second time
-      request = new_request('accord', 'foo')
-      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
-      request = new_request('accord', 'foo')
-      stomp_h.insert_fake( Message.from_parts(nil, request.replyID, 'foo', 'bar', 'baz') )
-
-      expect{ request.send(3) }.not_to raise_exception
-    end
-
-    it "allows you to specify a message timeout & cache timeout" do
-      request = new_request('accord', 'foo')
-      stomp_h.insert_fake( Message.from_parts(nil, request.replyID, 'foo', 'bar', 'baz') )
-
-      expect{ request.send(3, 120) }.not_to raise_exception
-    end
-
-    it 'returns a nebulous timeout if there is no response' do
-      request = new_request('accord', 'foo')
-      expect{ request.send }.to raise_exception NebulousStomp::NebulousTimeout
-    end
-
-    it 'still works if Redis is turned off in the config' do
-      rh = RedisHandlerNull.new({})
-      r = NebRequest.new('accord', 'tom', nil, nil, stomp_h, rh)
-      stomp_h.insert_fake( 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
-      sh = StompHandlerNull.new({})
-      r = NebRequest.new('accord', 'foo', nil, nil, sh, redis_h)
-
-      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
-      rh = RedisHandlerNull.new({})
-      r = NebRequest.new('accord', 'foo', nil, nil, stomp_h, rh)
-
-      expect( r.redis_on? ).to be_falsy
-    end
-
-  end
-  ##
-
-
-  describe '#nebulous_on?' do
-
-    it 'is true if there is a nebulous connection hash' do
-      sh = StompHandlerNull.new({foo: 'bar'})
-      r = NebRequest.new('accord', 'foo', nil, nil, sh, redis_h)
-
-      expect( r.nebulous_on? ).to be_truthy
-    end
-
-    it 'is false if there is no nebulous connection hash' do
-      sh = StompHandlerNull.new({})
-      r = NebRequest.new('accord', 'foo', nil, nil, sh, redis_h)
-
-      expect( r.nebulous_on? ).to be_falsy
-    end
-
-  end
-  ##
-
-
-end # of NebRequest
-

data/spec/through_test_spec.rb

@@ -1,80 +0,0 @@
-require 'nebulous_stomp'
-
-
-##
-# This is a through test against the JH development stomp server.
-# It's really only here to double check that the Stomp gem hasn't moved the 
-# goalposts (again).
-#
-# In order for it to work, the JH RabbitMQ server has to be where we left it. And you need a
-# responder listening to /queue/nebulout.test for the 'ping' verb. So this test won't work for you
-# out of the box, unless you are me.
-#
-describe 'through test' do
-
-  def connect_hash
-    host = { login:    'guest',
-             passcode: 'guest',
-             host:     '10.0.0.150',
-             port:     61613,
-             ssl:      false        }
-
-    {hosts: [host], reliable: false}
-  end
-
-  def target_hash
-    { sendQueue:    "/queue/nebulous.test",
-      receiveQueue: "/queue/nebulous.test.response" }
-
-  end
-
-  def init_stomp
-    NebulousStomp.init(stompConnectHash: connect_hash, messageTimeout: 5)
-    NebulousStomp.add_target(:target, target_hash)
-  end
-
-  ##
-  # a little method to receive a message and send one back, for testinng 
-  # sending one.
-  #
-  def qna
-    Thread.new do
-
-      begin
-        sh = NebulousStomp::StompHandler.new(connect_hash)
-        sh.listen_with_timeout( target_hash[:sendQueue], 10 ) do |m| 
-          sh.send_message( *m.respond_success )
-        end
-      ensure
-        sh.stomp_disconnect if sh
-      end
-
-    end
-
-  rescue
-    nil
-  end
-
-
-  let(:request) { NebulousStomp::NebRequest.new(:target, "ping") }
-
-  before do
-    init_stomp
-  end
-
-
-  it "sends a request" do
-    expect{ request.send_no_cache }.to raise_exception NebulousStomp::NebulousTimeout
-  end
-
-
-  it "receives a response" do
-    r = NebulousStomp::NebRequest.new(:target, "ping")
-    qna; response = r.send_no_cache
-
-    expect( response ).to be_a_kind_of NebulousStomp::Message
-    expect( response.verb ).to eq 'success'
-  end
-
-end
-