nebulous_stomp 1.1.5

data/spec/param_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+require 'nebulous/param'
+
+include Nebulous
+
+
+describe Param do
+
+  before      { Param.reset }
+  after(:all) { Param.reset }
+
+
+  describe "Param.set" do
+
+    it "resets the param string" do
+      Param.set
+      expect( Param.get_all).to eq(Param::ParamDefaults)
+    end
+
+    it "rejects any weird parameters passed to it" do
+      expect { Param.set({:notARealParameter => 1}) }.to \
+        raise_exception NebulousError
+
+    end
+
+    it "adds legitimate parameters to the param hash" do
+      Param.set( redisConnectHash: {boo: 1} )
+
+      expect( Param.get_all[:redisConnectHash] ).to eq( {boo: 1} )
+    end
+
+  end # of Param::set
+  ##
+
+
+  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)
+    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)
+    end
+
+  end # of Param:add_target
+  ##
+
+
+  describe "Param.get" do
+
+    let(:hash1) { { stompConnectHash: {one: 1, two: 2},
+                    redisConnectHash: {three: 4, five: 6},
+                    messageTimeout:   7,
+                    cacheTimeout:     888 } }
+
+    it "returns the given hash value" do
+      Param.set(hash1)
+      expect( Param.get(:redisConnectHash) ).to eq(hash1[:redisConnectHash])
+      expect( Param.get(:messageTimeout)   ).to eq(7)
+    end
+
+    it 'does not freak out if set() was never called' do
+      expect{ Param.get(:foo) }.not_to raise_exception
+    end
+
+  end # of param::get
+  ##
+
+
+  describe "Param.get_target" do
+
+    before do
+      @targ = {receiveQueue: 'foo', sendQueue: 'bar'}
+      Param.add_target(:one, @targ)
+    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)
+    end
+
+    it "returns the target hash corresponding to the name" do
+      expect( Param.get_target(:one) ).to include(@targ)
+    end
+
+    it 'does not freak out if set() was never called' do
+      Param.reset
+      expect{ Param.get_target(:one) }.not_to raise_exception
+    end
+      
+  end # of get_target
+  ##
+
+
+  describe "Param.get_logger" do
+
+    it "returns the logger instance" do
+      l = Logger.new(STDOUT)
+      Param.set_logger(l)
+
+      expect( Param.get_logger ).to eq l
+    end
+
+    it 'does not freak out if set_logger() was never called' do
+      Param.reset
+      expect{ Param.get_logger }.not_to raise_exception
+    end
+
+  end
+  ##
+
+
+  describe "Param.set_logger" do
+
+    it "requires an instance of Logger, or nil" do
+      expect{ Nebulous.set_logger(:foo) }.to raise_exception NebulousError
+
+      expect{ Nebulous.set_logger(nil) }.not_to raise_exception
+      expect{ Nebulous.set_logger( Logger.new(STDOUT) ) }.not_to raise_exception
+    end
+
+  end
+  ##
+
+
+end
+
+

data/spec/redis_handler_null_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+require 'pry'
+
+require 'nebulous/redis_handler_null'
+
+include Nebulous
+
+
+describe RedisHandlerNull do
+
+  let(:redis_hash) do
+    { "connect" => {"host" => '127.0.0.1', "port" => 6379, "db" => 0} }
+  end
+
+  let(:handler) { RedisHandlerNull.new(redis_hash) }
+
+
+  describe '#connect' do
+
+    it 'returns self' do
+      expect( handler.connect ).to eq handler
+    end
+
+  end
+  ##
+
+
+  describe '#insert_fake' 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
+
+    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
+      handler.insert_fake('one', 'two')
+      expect( handler.connected? ).to be_truthy
+    end
+
+  end
+  ##
+  
+  
+  describe '#set#' 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
+      handler.set('alice', 'tom')
+      expect( handler.fake_pair ).to eq({'alice' => 'tom'})
+    end
+
+  end
+  ##
+
+
+  describe '#get#' do
+
+    it 'retreives the fake message regardless' do
+      handler.insert_fake('grr', 'arg')
+      expect( handler.get('woo') ).to eq 'arg'
+    end
+
+    it "returns nil if the fake message is not set" do
+      expect( handler.get('foo') ).to be_nil
+    end
+
+  end
+  ##
+
+
+  describe '#del#' 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/redis_handler_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+
+require 'pry'
+
+require 'nebulous/redis_handler'
+
+include Nebulous
+
+
+describe RedisHandler do
+
+  let(:redis_hash) do
+    { "connect" => {"host" => '127.0.0.1', "port" => 6379, "db" => 0} }
+  end
+
+  let(:rclient) { double('Redis Client').as_null_object }
+
+  let(:redis) do 
+    # Again, mocking all this is fragile, but I don't know of another way to
+    # test the class except assuming that Redis is up, which is worse. And at
+    # least we are only doing this in the test for this special handler class.
+    r = double(Redis).as_null_object
+    allow(r).to receive(:client).and_return(rclient)
+
+    r
+  end
+
+  let(:handler) { RedisHandler.new(redis_hash, redis) }
+
+
+  describe '#connect' do
+
+    it '...connects...' do
+      expect(rclient).to receive(:connect)
+      handler.connect
+
+      expect(handler.redis).not_to be_nil
+    end
+
+    it 'raises ConnectionError if not then connected' do
+      expect(redis).to receive(:connected?).and_return(false)
+
+      expect{ handler.connect }.to raise_exception ConnectionError
+    end
+
+  end
+  ##
+
+
+  describe '#quit' do
+
+    it 'calls redis.quit when appropriate' do
+      expect(redis).to receive(:quit)
+      handler.connect
+      handler.quit
+
+      expect(handler.redis).to be_nil
+    end
+
+    it 'returns gracefully if we are not connected' do
+      expect(redis).not_to receive(:quit)
+      handler.quit
+    end
+
+  end
+  ##
+ 
+
+  describe '#connected?' do
+
+    it 'returns false if we didnt call connect' do
+      expect( handler.connected? ).to be_falsey
+    end
+
+    it 'passes to redis.client.connected? if we have a redis instance' do
+      expect(redis).to receive(:connected?)
+
+      handler.connect
+      handler.connected?
+    end
+
+  end
+  ##
+  
+
+  describe '#redis_on?' do
+
+    it 'is true if we were passed any connection hash at all' do
+      expect( RedisHandler.new(nil).redis_on? ).to be_falsy
+      expect( RedisHandler.new({}).redis_on? ).to be_falsy
+
+      expect( handler.redis_on? ).to be_truthy
+    end
+
+  end
+  ##
+  
+  
+  context 'when forwarding other methods to Redis' do
+
+    it 'handles only set, get, and del' do
+      expect(redis).to receive(:set)
+      expect(redis).to receive(:get)
+      expect(redis).to receive(:del)
+
+      handler.connect
+      handler.set("foo", {bar:1})
+      handler.get("foo")
+      handler.del("foo")
+
+      # I "happen to know" that we are using method_missing to implement the
+      # above. It's an implementation detail, but let's throw a test in for
+      # that, anyway:
+      expect{ handler.blewit }.to raise_exception NoMethodError
+    end
+
+    it 'raises ConnectionError if connect has not been called' do
+      expect{ handler.set("foo", {bar:1}) }.
+        to raise_exception Nebulous::ConnectionError
+
+      expect{ handler.get("foo") }.to raise_exception Nebulous::ConnectionError
+      expect{ handler.del("foo") }.to raise_exception Nebulous::ConnectionError
+    end
+
+    it 'raises ConnectionError if not connected' do
+      allow(redis).to receive(:connected?).and_return(true,false,false,false)
+      handler.connect
+
+      expect{ handler.set("foo", {bar:1}) }.
+        to raise_exception Nebulous::ConnectionError
+
+      expect{ handler.get("foo") }.to raise_exception Nebulous::ConnectionError
+      expect{ handler.del("foo") }.to raise_exception Nebulous::ConnectionError
+    end
+
+
+  end
+  ##
+
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,100 @@
+require 'pry'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  if config.files_to_run.one?
+    config.default_formatter = 'doc'
+  end
+
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

data/spec/spec_helper_old.rb

@@ -0,0 +1,19 @@
+#$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+#require 'nebulous'
+
+RSpec.configure do |config|
+
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_causes_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  if config.files_to_run.one?
+    config.default_formatter = 'doc'
+  end
+
+end
+~

data/spec/stomp_handler_null_spec.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+
+require 'time'
+
+require 'nebulous/stomp_handler_null'
+
+include Nebulous
+
+
+describe StompHandlerNull do
+
+  let(:handler) do
+    StompHandlerNull.new
+  end
+
+  let(:msg1) do
+    stomp_message('application/text', 'verb:Foo', client.calc_reply_id)
+  end
+
+  let(:msg2) do
+    stomp_message('application/text', 'verb:Bar', client.calc_reply_id)
+  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
+      expect{ StompHandlerNull.new(foo: 'bar') }.not_to raise_exception
+    end
+
+  end
+  ##
+  
+
+  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 Nebulous::Message
+      expect( handler.fake_mess.verb ).to eq 'foo'
+    end
+
+  end
+  ##
+  
+
+  describe '#connected?' 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
+      handler.insert_fake( Message.from_parts('','', 'one', 'two', 'three') )
+      expect( handler.connected? ).to be_truthy
+    end
+
+  end
+  ##
+
+
+  describe "#stomp_connect" do
+
+    it "returns self" do
+      expect(handler.stomp_connect).to eq handler
+    end
+
+  end
+  ##
+
+
+  describe "#calc_reply_id" do
+
+    it "returns a 'unique' string" do
+      handler.stomp_connect
+      expect( handler.calc_reply_id ).to respond_to :upcase
+      expect( handler.calc_reply_id.size ).to be > 12
+    end
+  end
+  ##
+
+
+  describe "send_message" do
+    let(:mess) { Nebulous::Message.from_parts(nil, nil, 'foo', nil, nil) }
+
+    it "accepts a queue name and a Message" do
+      expect{ handler.send_message('foo', mess) }.not_to raise_exception
+    end
+
+    it "returns the message" do
+      expect( handler.send_message('foo', mess) ).to eq mess
+    end
+
+  end
+  ##
+
+
+  describe "#listen" do
+
+    def run_listen(secs)
+      got = nil
+
+      handler.listen('/queue/foo') do |m|
+        got = m
+      end
+      sleep secs
+
+      got
+    end
+
+
+    it "yields a Message" do
+      handler.insert_fake( Message.from_parts('', '', 'foo', 'bar', 'baz') )
+      gotMessage = run_listen(1)
+
+      expect(gotMessage).not_to be_nil
+      expect(gotMessage).to be_a_kind_of Nebulous::Message
+    end
+
+  end
+  ##
+
+
+  describe "listen_with_timeout" do
+
+    def run_listen_with_timeout(secs)
+      got = nil
+      handler.listen_with_timeout('/queue/foo', secs) do |m|
+        got = m
+      end
+
+      got
+    end
+
+    context "when there is a message" do
+
+      it "yields a Message" do
+        handler.insert_fake( Message.from_parts('', '', 'foo', 'bar', 'baz') )
+        gotMessage = run_listen_with_timeout(1)
+
+        expect( gotMessage ).not_to be_nil
+        expect( gotMessage ).to be_a_kind_of Nebulous::Message
+      end
+
+    end
+
+    context "when there is no message" do
+
+      it 'raises NebulousTimeout' do
+        expect{handler.listen_with_timeout('foo', 2)}.
+          to raise_exception Nebulous::NebulousTimeout
+
+      end
+
+    end
+
+  end
+  ##
+
+
+end 
+