sneakers_custom_bunny 1.0.4

data/spec/sneakers/concerns/metrics_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'sneakers'
+require 'logger'
+
+
+class Foometrics
+  include Sneakers::Concerns::Metrics
+end
+
+describe Sneakers::Concerns::Metrics do
+  describe ".configure" do
+    before do
+      Foometrics.metrics = nil
+    end
+
+    it "should configure a default logger when included" do
+      Foometrics.metrics.must_be_nil
+      Foometrics.configure_metrics
+      Foometrics.metrics.wont_be_nil
+    end
+
+    it "should supply accessible instance logger" do
+      Foometrics.metrics.must_be_nil
+      Foometrics.configure_metrics
+      f = Foometrics.new
+      f.metrics.must_equal Foometrics.metrics
+      f.metrics.wont_be_nil
+    end
+
+    it "should configure a given metrics when specified" do
+      Foometrics.metrics.must_be_nil
+      o = Object.new
+      Foometrics.configure_metrics(o)
+      Foometrics.metrics.must_equal o
+    end
+  end
+end
+

data/spec/sneakers/configuration_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Sneakers::Configuration do
+
+  it 'should assign a default value for :amqp' do
+    with_env('RABBITMQ_URL', nil) do
+      config = Sneakers::Configuration.new
+      config[:amqp].must_equal 'amqp://guest:guest@localhost:5672'
+    end
+  end
+
+  it 'should assign a default value for :vhost' do
+    with_env('RABBITMQ_URL', nil) do
+      config = Sneakers::Configuration.new
+      config[:vhost].must_equal '/'
+    end
+  end
+
+  it 'should read the value for amqp from RABBITMQ_URL' do
+    url = 'amqp://foo:bar@localhost:5672'
+    with_env('RABBITMQ_URL', url) do
+      config = Sneakers::Configuration.new
+      config[:amqp].must_equal url
+    end
+  end
+
+  it 'should read the value for vhost from RABBITMQ_URL' do
+    url = 'amqp://foo:bar@localhost:5672/foobarvhost'
+    with_env('RABBITMQ_URL', url) do
+      config = Sneakers::Configuration.new
+      config[:vhost].must_equal 'foobarvhost'
+    end
+  end
+
+  it 'should parse vhost from amqp option' do
+    env_url = 'amqp://foo:bar@localhost:5672/foobarvhost'
+    with_env('RABBITMQ_URL', env_url) do
+      url = 'amqp://foo:bar@localhost:5672/testvhost'
+      config = Sneakers::Configuration.new
+      config.merge!({ :amqp => url })
+      config[:vhost].must_equal 'testvhost'
+    end
+  end
+
+  it 'should not parse vhost from amqp option if vhost is specified explicitly' do
+    url = 'amqp://foo:bar@localhost:5672/foobarvhost'
+    config = Sneakers::Configuration.new
+    config.merge!({ :amqp => url, :vhost => 'test_host' })
+    config[:vhost].must_equal 'test_host'
+  end
+
+  it 'should use vhost option if it is specified' do
+    url = 'amqp://foo:bar@localhost:5672/foobarvhost'
+    with_env('RABBITMQ_URL', url) do
+      config = Sneakers::Configuration.new
+      config.merge!({ :vhost => 'test_host' })
+      config[:vhost].must_equal 'test_host'
+    end
+  end
+
+  it 'should use default vhost if vhost is not specified in amqp option' do
+    url = 'amqp://foo:bar@localhost:5672'
+    config = Sneakers::Configuration.new
+    config.merge!({ :amqp => url })
+    config[:vhost].must_equal '/'
+  end
+
+  def with_env(key, value)
+    old_value = ENV[key]
+    ENV[key] = value
+    yield
+  ensure
+    ENV[key] = old_value
+  end
+end

data/spec/sneakers/publisher_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+require 'sneakers'
+
+describe Sneakers::Publisher do
+  describe '#publish' do
+    before do
+      Sneakers.clear!
+      Sneakers.configure(:log => 'sneakers.log')
+    end
+
+    it 'should publish a message to an exchange' do
+      xchg = Object.new
+      mock(xchg).publish('test msg', routing_key: 'downloads')
+
+      p = Sneakers::Publisher.new
+      p.instance_variable_set(:@exchange, xchg)
+
+      mock(p).ensure_connection! {}
+      p.publish('test msg', to_queue: 'downloads')
+    end
+
+    it 'should publish with the persistence specified' do
+      xchg = Object.new
+      mock(xchg).publish('test msg', routing_key: 'downloads', persistence: true)
+
+      p = Sneakers::Publisher.new
+      p.instance_variable_set(:@exchange, xchg)
+
+      mock(p).ensure_connection! {}
+      p.publish('test msg', to_queue: 'downloads', persistence: true)
+    end
+
+    it 'should publish with arbitrary metadata specified' do
+      xchg = Object.new
+      mock(xchg).publish('test msg', routing_key: 'downloads', expiration: 1, headers: {foo: 'bar'})
+
+      p = Sneakers::Publisher.new
+      p.instance_variable_set(:@exchange, xchg)
+
+      mock(p).ensure_connection! {}
+      p.publish('test msg', to_queue: 'downloads', expiration: 1, headers: {foo: 'bar'})
+    end
+
+    it 'should not reconnect if already connected' do
+      xchg = Object.new
+      mock(xchg).publish('test msg', routing_key: 'downloads')
+
+      p = Sneakers::Publisher.new
+      p.instance_variable_set(:@exchange, xchg)
+
+      mock(p).connected? { true }
+      mock(p).ensure_connection!.times(0)
+
+      p.publish('test msg', to_queue: 'downloads')
+    end
+
+    it 'should connect to rabbitmq configured on Sneakers.configure' do
+      logger = Logger.new('/dev/null')
+      Sneakers.configure(
+        amqp: 'amqp://someuser:somepassword@somehost:5672',
+        heartbeat: 1, exchange: 'another_exchange',
+        exchange_type: :topic,
+        log: logger,
+        durable: false)
+
+      channel = Object.new
+      mock(channel).exchange('another_exchange', type: :topic, durable: false) do
+        mock(Object.new).publish('test msg', routing_key: 'downloads')
+      end
+
+      bunny = Object.new
+      mock(bunny).start
+      mock(bunny).create_channel { channel }
+
+      mock(Bunny).new('amqp://someuser:somepassword@somehost:5672', heartbeat: 1, vhost: '/', logger: logger) { bunny }
+
+      p = Sneakers::Publisher.new
+
+      p.publish('test msg', to_queue: 'downloads')
+
+    end
+  end
+end

data/spec/sneakers/queue_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+require 'sneakers'
+
+
+
+describe Sneakers::Queue do
+  let :queue_vars do
+    {
+      :prefetch => 25,
+      :durable => true,
+      :ack => true,
+      :heartbeat => 2,
+      :vhost => '/',
+      :exchange => "sneakers",
+      :exchange_type => :direct
+    }
+  end
+
+  before do
+    Sneakers.configure
+
+    @mkbunny = Object.new
+    @mkchan = Object.new
+    @mkex = Object.new
+    @mkqueue = Object.new
+    @mkqueue_nondurable = Object.new
+    @mkworker = Object.new
+
+    mock(@mkbunny).start {}
+    mock(@mkbunny).create_channel{ @mkchan }
+    mock(Bunny).new(anything, :vhost => '/', :heartbeat => 2){ @mkbunny }
+
+    mock(@mkchan).prefetch(25)
+
+    stub(@mkworker).opts { { :exchange => 'test-exchange' } }
+  end
+
+  describe "#subscribe with sneakers exchange" do
+    before do
+      mock(@mkchan).exchange("sneakers", :type => :direct, :durable => true){ @mkex }
+    end
+
+    it "should setup a bunny queue according to configuration values" do
+      mock(@mkchan).queue("downloads", :durable => true) { @mkqueue }
+      q = Sneakers::Queue.new("downloads", queue_vars)
+
+      mock(@mkqueue).bind(@mkex, :routing_key => "downloads")
+      mock(@mkqueue).subscribe(:block => false, :manual_ack => true)
+
+      q.subscribe(@mkworker)
+    end
+
+    it "supports multiple routing_keys" do
+      mock(@mkchan).queue("downloads", :durable => true) { @mkqueue }
+      q = Sneakers::Queue.new("downloads",
+                              queue_vars.merge(:routing_key => ["alpha", "beta"]))
+
+      mock(@mkqueue).bind(@mkex, :routing_key => "alpha")
+      mock(@mkqueue).bind(@mkex, :routing_key => "beta")
+      mock(@mkqueue).subscribe(:block => false, :manual_ack => true)
+
+      q.subscribe(@mkworker)
+    end
+
+    it "will use whatever handler the worker specifies" do
+      mock(@mkchan).queue("downloads", :durable => true) { @mkqueue }
+      @handler = Object.new
+      worker_opts = { :handler => @handler }
+      stub(@mkworker).opts { worker_opts }
+      mock(@handler).new(@mkchan, @mkqueue, worker_opts).once
+
+      stub(@mkqueue).bind
+      stub(@mkqueue).subscribe
+      q = Sneakers::Queue.new("downloads", queue_vars)
+      q.subscribe(@mkworker)
+    end
+
+    it "creates a non-durable queue if :queue_durable => false" do
+      mock(@mkchan).queue("test_nondurable", :durable => false) { @mkqueue_nondurable }
+      queue_vars[:queue_durable] = false
+      q = Sneakers::Queue.new("test_nondurable", queue_vars)
+
+      mock(@mkqueue_nondurable).bind(@mkex, :routing_key => "test_nondurable")
+      mock(@mkqueue_nondurable).subscribe(:block => false, :manual_ack => true)
+
+      q.subscribe(@mkworker)
+      myqueue = q.instance_variable_get(:@queue)
+    end
+  end
+
+  describe "#subscribe with default exchange" do
+    before do
+      # expect default exchange
+      queue_vars[:exchange] = ""
+      mock(@mkchan).exchange("", :type => :direct, :durable => true){ @mkex }
+    end
+
+    it "does not bind to exchange" do
+      mock(@mkchan).queue("downloads", :durable => true) { @mkqueue }
+      @handler = Object.new
+      worker_opts = { :handler => @handler }
+      stub(@mkworker).opts { worker_opts }
+      mock(@handler).new(@mkchan, @mkqueue, worker_opts).once
+
+      stub(@mkqueue).bind do
+        raise "bind should not be called"
+      end
+
+      stub(@mkqueue).subscribe
+      q = Sneakers::Queue.new("downloads", queue_vars)
+      q.subscribe(@mkworker)
+    end
+  end
+end
+

data/spec/sneakers/runner_spec.rb

@@ -0,0 +1,26 @@
+require 'logger'
+require 'spec_helper'
+require 'sneakers'
+
+describe Sneakers::Runner do
+  let(:logger) { Logger.new('logtest.log') }
+
+  describe "with configuration that specifies a logger object" do
+    before do
+      Sneakers.configure(log: logger)
+      @runner = Sneakers::Runner.new([])
+    end
+
+    it 'passes the logger to serverengine' do
+      # Stub out ServerEngine::Daemon.run so we only exercise the way we invoke
+      # ServerEngine.create
+      any_instance_of(ServerEngine::Daemon) do |daemon|
+        stub(daemon).main{ return 0 }
+      end
+
+      @runner.run
+      # look at @runner's @se instance variable (actually of type Daemon)...and
+      # figure out what it's logger is...
+    end
+  end
+end

data/spec/sneakers/sneakers_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+require 'sneakers'
+
+class EnvWorker
+  include Sneakers::Worker
+  from_queue 'defaults'
+
+  def work(msg)
+  end
+end
+
+
+describe Sneakers do
+  before do
+    Sneakers.clear!
+  end
+
+  describe 'self' do
+    it 'should have defaults set up' do
+      Sneakers::CONFIG[:log].must_equal(STDOUT)
+    end
+
+    it 'should configure itself' do
+      Sneakers.configure
+      Sneakers.logger.wont_be_nil
+      Sneakers.configured?.must_equal(true)
+    end
+  end
+
+  describe '.daemonize!' do
+    it 'should set a logger to a default info level and not daemonize' do
+      Sneakers.daemonize!
+      Sneakers::CONFIG[:log].must_equal('sneakers.log')
+      Sneakers::CONFIG[:daemonize].must_equal(true)
+      Sneakers.logger.level.must_equal(Logger::INFO)
+    end
+
+    it 'should set a logger to a level given that level' do
+      Sneakers.daemonize!(Logger::DEBUG)
+      Sneakers.logger.level.must_equal(Logger::DEBUG)
+    end
+  end
+
+
+  describe '.clear!' do
+    it 'must reset dirty configuration to default' do
+      Sneakers::CONFIG[:log].must_equal(STDOUT)
+      Sneakers.configure(:log => 'foobar.log')
+      Sneakers::CONFIG[:log].must_equal('foobar.log')
+      Sneakers.clear!
+      Sneakers::CONFIG[:log].must_equal(STDOUT)
+    end
+  end
+
+
+  describe '#setup_general_logger' do
+    it 'should detect a string and configure a logger' do
+      Sneakers.configure(:log => 'sneakers.log')
+      Sneakers.logger.kind_of?(Logger).must_equal(true)
+    end
+
+    it 'should detect a file-like thing and configure a logger' do
+      Sneakers.configure(:log => STDOUT)
+      Sneakers.logger.kind_of?(Logger).must_equal(true)
+    end
+
+    it 'should detect an actual logger and configure it' do
+      logger = Logger.new(STDOUT)
+      Sneakers.configure(:log => logger)
+      Sneakers.logger.must_equal(logger)
+    end
+  end
+
+end
+

data/spec/sneakers/support/utils_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'sneakers'
+
+describe Sneakers::Utils do
+  describe '::parse_workers' do
+    before(:all) do
+      class Foo; end
+      class Bar; end
+      class Baz
+        class Quux; end
+        class Corge; end
+      end
+    end
+
+    describe 'given a single class name' do
+      describe 'without namespace' do
+        it 'returns the worker class name' do
+          Sneakers::Utils.parse_workers('Foo').must_equal([[Foo],[]])
+        end
+      end
+
+      describe 'with namespace' do
+        it 'returns the worker class name' do
+          Sneakers::Utils.parse_workers('Baz::Quux').must_equal([[Baz::Quux],[]])
+        end
+      end
+    end
+
+    describe 'given a list of class names' do
+      describe 'without namespaces' do
+        it 'returns all worker class names' do
+          Sneakers::Utils.parse_workers('Foo,Bar').must_equal([[Foo,Bar],[]])
+        end
+      end
+
+      describe 'with namespaces' do
+        it 'returns all worker class names' do
+          workers = Sneakers::Utils.parse_workers('Baz::Quux,Baz::Corge')
+          workers.must_equal([[Baz::Quux,Baz::Corge],[]])
+        end
+      end
+    end
+  end
+end