kicks 3.0.0.pre

data/spec/sneakers/queue_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+require 'sneakers'
+
+describe Sneakers::Queue do
+  let :queue_vars do
+    {
+      :prefetch => 25,
+      :ack => true,
+      :heartbeat => 2,
+      :vhost => '/',
+      :exchange => "sneakers",
+      :exchange_options => {
+        :type => :direct,
+        durable: true,
+        :arguments => { 'x-arg' => 'value' }
+      },
+      queue_options: {
+        durable: true
+      }
+    }
+  end
+
+  before do
+    Sneakers.clear!
+    Sneakers.configure
+
+    @mkworker = Object.new
+    stub(@mkworker).opts { { :exchange => 'test-exchange' } }
+    @mkchan = Object.new
+    mock(@mkchan).prefetch(25)
+    @mkex = Object.new
+    @mkqueue = Object.new
+  end
+
+  describe 'with our own Bunny object' do
+    before do
+      @mkbunny = Object.new
+      @mkqueue_nondurable = Object.new
+
+      mock(@mkbunny).start {}
+      mock(@mkbunny).create_channel{ @mkchan }
+      mock(Bunny).new(
+        anything,
+        hash_including(:vhost => '/', :heartbeat => 2)
+      ){ @mkbunny }
+    end
+
+    describe "#subscribe with sneakers exchange" do
+      before do
+        mock(@mkchan).exchange("sneakers",
+                               :type => :direct,
+                               :durable => true,
+                               :arguments => { 'x-arg' => 'value' }){ @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 "supports setting arguments when binding" do
+        mock(@mkchan).queue("downloads", :durable => true) { @mkqueue }
+        q = Sneakers::Queue.new("downloads",
+                                queue_vars.merge(:bind_arguments => { "os" => "linux", "cores" => 8 }))
+
+        mock(@mkqueue).bind(@mkex, :routing_key => "downloads", :arguments => { "os" => "linux", "cores" => 8 })
+        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_options][: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,
+                               :arguments => {"x-arg" => "value"}){ @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
+
+  describe 'with an externally-provided connection' do
+    describe '#subscribe' do
+      before do
+        @external_connection = Bunny.new
+        mock(@external_connection).start {}
+        mock(@external_connection).create_channel{ @mkchan }
+        mock(@mkchan).exchange("sneakers",
+                               :type => :direct,
+                               :durable => true,
+                               :arguments => { 'x-arg' => 'value' }){ @mkex }
+
+        queue_name = 'foo'
+        mock(@mkchan).queue(queue_name, :durable => true) { @mkqueue }
+        mock(@mkqueue).bind(@mkex, :routing_key => queue_name)
+        mock(@mkqueue).subscribe(:block => false, :manual_ack => true)
+
+        my_vars = queue_vars.merge(:connection => @external_connection)
+        @q = Sneakers::Queue.new(queue_name, my_vars)
+      end
+
+      it 'uses that object' do
+        @q.subscribe(@mkworker)
+        _(@q.instance_variable_get(:@bunny)).must_equal @external_connection
+      end
+    end
+  end
+end

data/spec/sneakers/runner_spec.rb

@@ -0,0 +1,70 @@
+require 'logger'
+require 'spec_helper'
+require 'sneakers'
+require 'sneakers/runner'
+
+describe Sneakers::Runner do
+  let(:logger) { Logger.new('log/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
+
+describe Sneakers::RunnerConfig do
+  let(:logger) { Logger.new("log/logtest.log") }
+  let(:runner_config) { Sneakers::Runner.new([]).instance_variable_get("@runnerconfig") }
+
+  describe "with a connection" do
+    let(:connection) { Object.new }
+
+    before { Sneakers.configure(log: logger, connection: connection) }
+
+    describe "#reload_config!" do
+      it "does not throw exception" do
+        runner_config.reload_config!
+      end
+
+      it "must not have :log key" do
+        _(runner_config.reload_config!.has_key?(:log)).must_equal false
+      end
+
+      it "must have :logger key as an instance of Logger" do
+        _(runner_config.reload_config![:logger].is_a?(Logger)).must_equal true
+      end
+
+      it "must have :connection" do
+        _(runner_config.reload_config![:connection].is_a?(Object)).must_equal true
+      end
+    end
+  end
+
+  describe "without a connection" do
+    before { Sneakers.configure(log: logger) }
+
+    describe "#reload_config!" do
+      it "must not have :log key" do
+        _(runner_config.reload_config!.has_key?(:log)).must_equal false
+      end
+
+      it "must have :logger key as an instance of Logger" do
+        _(runner_config.reload_config![:logger].is_a?(Logger)).must_equal true
+      end
+    end
+  end
+end

data/spec/sneakers/sneakers_spec.rb

@@ -0,0 +1,77 @@
+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
+    let(:logger_class) { ServerEngine::DaemonLogger }
+
+    it 'should detect a string and configure a logger' do
+      Sneakers.configure(:log => 'sneakers.log')
+      _(Sneakers.logger.kind_of?(logger_class)).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_class)).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

data/spec/sneakers/tasks/sneakers_run_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+require 'sneakers'
+require 'rake'
+require 'sneakers/tasks'
+
+describe 'Worker classes run by rake sneakers:run' do
+  class TestWorker
+    include Sneakers::Worker
+  end
+  class TestClass1 < TestWorker; end
+  class TestClass2 < TestWorker; end
+
+  def with_workers_env(workers)
+    undefine, restore = if ENV.key?('WORKERS')
+                        [false, ENV['WORKERS']]
+                      else
+                        true
+                      end
+    ENV['WORKERS'] = workers
+    yield
+  ensure
+    undefine ? ENV.delete('WORKERS') : ENV['WORKERS'] = restore
+  end
+
+  def with_rake_worker_classes(workers)
+    restore = Sneakers.rake_worker_classes
+    Sneakers.rake_worker_classes = workers
+    yield
+  ensure
+    Sneakers.rake_worker_classes = restore
+  end
+
+  def with_sneakers_worker_classes_reset
+    restore = Sneakers::Worker::Classes.clone
+    Sneakers::Worker::Classes.replace([])
+    yield
+  ensure
+    Sneakers::Worker::Classes.replace(restore)
+  end
+
+  let(:opts) { {} }
+
+  let :runner do
+    mock = Minitest::Mock.new
+    mock.expect(:run, nil)
+    mock.expect(:call, mock, [expected_workers, opts])
+    mock
+  end
+
+  let :run_rake_task do
+    Rake::Task['sneakers:run'].reenable
+    Rake.application.invoke_task 'sneakers:run'
+  end
+
+  describe 'without any settings' do
+    let(:expected_workers) { [worker_class] }
+    let(:worker_class) { Class.new.tap { |klass| klass.send(:include, Sneakers::Worker) } }
+
+    it 'runs classes directly including the Worker' do
+      with_workers_env(nil) do
+        with_sneakers_worker_classes_reset do
+          Sneakers::Runner.stub :new, runner do
+            run_rake_task
+          end
+          runner.verify
+        end
+      end
+    end
+  end
+
+  describe 'with rake_worker_classes set' do
+    let(:expected_workers) { [TestClass1, TestClass2] }
+
+    it 'runs the classes from the setting' do
+      with_workers_env(nil) do
+        with_rake_worker_classes([TestClass1, TestClass2]) do
+          Sneakers::Runner.stub :new, runner do
+            run_rake_task
+          end
+          runner.verify
+        end
+      end
+    end
+  end
+
+  describe 'with rake_worker_classes set, overriden by WORKERS env' do
+    let(:expected_workers) { [TestClass2] }
+
+    it 'runs the classes from the setting' do
+      with_rake_worker_classes([TestClass1, TestClass2]) do
+        with_workers_env('TestClass2') do
+          Sneakers::Runner.stub :new, runner do
+            run_rake_task
+          end
+          runner.verify
+        end
+      end
+    end
+  end
+
+  describe 'with rake_worker_classes responding to call' do
+    let(:expected_workers) { [TestClass1] }
+
+    it 'runs the classes from the setting' do
+      with_workers_env(nil) do
+        with_rake_worker_classes(-> { [TestClass1] }) do
+          Sneakers::Runner.stub :new, runner do
+            run_rake_task
+          end
+          runner.verify
+        end
+      end
+    end
+  end
+end