kulesa-sidekiq 1.2.2

data/test/test_manager.rb

@@ -0,0 +1,51 @@
+require 'helper'
+require 'sidekiq'
+require 'sidekiq/manager'
+
+# for TimedQueue
+require 'connection_pool'
+
+class TestManager < MiniTest::Unit::TestCase
+  describe 'with redis' do
+    before do
+      Sidekiq.redis = REDIS
+      Sidekiq.redis {|c| c.flushdb }
+      $processed = 0
+      $mutex = Mutex.new
+    end
+
+    class IntegrationWorker
+      include Sidekiq::Worker
+      sidekiq_options :queue => 'foo'
+
+      def perform(a, b)
+        $mutex.synchronize do
+          $processed += 1
+        end
+        a + b
+      end
+    end
+
+    it 'processes messages' do
+      IntegrationWorker.perform_async(1, 2)
+      IntegrationWorker.perform_async(1, 3)
+
+      q = TimedQueue.new
+      mgr = Sidekiq::Manager.new(:queues => [:foo], :concurrency => 2)
+      mgr.when_done do |_|
+        q << 'done' if $processed == 2
+      end
+      mgr.start!
+      result = q.timed_pop(1.0)
+      assert_equal 'done', result
+      mgr.stop
+      mgr.terminate
+
+      # Gross bloody hack because I can't get the actor threads
+      # to shut down cleanly in the test.  Need @bascule's help here.
+      (Thread.list - [Thread.current]).each do |t|
+        t.raise Interrupt
+      end
+    end
+  end
+end

data/test/test_middleware.rb

@@ -0,0 +1,92 @@
+require 'helper'
+require 'sidekiq/middleware/chain'
+require 'sidekiq/middleware/server/unique_jobs'
+require 'sidekiq/processor'
+
+class TestMiddleware < MiniTest::Unit::TestCase
+  describe 'middleware chain' do
+    before do
+      $errors = []
+      Sidekiq.redis = REDIS
+    end
+
+    it 'handles errors' do
+      handler = Sidekiq::Middleware::Server::ExceptionHandler.new
+
+      assert_raises ArgumentError do
+        handler.call('', { :a => 1 }, 'default') do
+          raise ArgumentError
+        end
+      end
+      assert_equal 1, $errors.size
+      assert_equal({ :a => 1 }, $errors[0][:parameters])
+    end
+
+    class CustomMiddleware
+      def initialize(name, recorder)
+        @name = name
+        @recorder = recorder
+      end
+
+      def call(*args)
+        @recorder << [@name, 'before']
+        yield
+        @recorder << [@name, 'after']
+      end
+    end
+
+    it 'supports custom middleware' do
+      chain = Sidekiq::Middleware::Chain.new
+      chain.add CustomMiddleware, 1, []
+
+      assert_equal CustomMiddleware, chain.entries.last.klass
+    end
+
+    class CustomWorker
+      include Sidekiq::Worker
+      def perform(recorder)
+        recorder << ['work_performed']
+      end
+    end
+
+    class NonYieldingMiddleware
+      def call(*args)
+      end
+    end
+
+    it 'executes middleware in the proper order' do
+      recorder = []
+      msg = { 'class' => CustomWorker.to_s, 'args' => [recorder] }
+
+      Sidekiq.server_middleware do |chain|
+        # should only add once, second should be ignored
+        2.times { |i| chain.add CustomMiddleware, i.to_s, recorder }
+      end
+
+      boss = MiniTest::Mock.new
+      processor = Sidekiq::Processor.new(boss)
+      boss.expect(:processor_done!, nil, [processor])
+      processor.process(msg, 'default')
+      assert_equal %w(0 before work_performed 0 after), recorder.flatten
+    end
+
+    it 'allows middleware to abruptly stop processing rest of chain' do
+      recorder = []
+      chain = Sidekiq::Middleware::Chain.new
+      chain.add NonYieldingMiddleware
+      chain.add CustomMiddleware, 1, recorder
+
+      final_action = nil
+      chain.invoke { final_action = true }
+      assert_equal nil, final_action
+      assert_equal [], recorder
+    end
+  end
+end
+
+class FakeAirbrake
+  def self.notify(ex, hash)
+    $errors << hash
+  end
+end
+Airbrake = FakeAirbrake

data/test/test_processor.rb

@@ -0,0 +1,32 @@
+require 'helper'
+require 'sidekiq/processor'
+
+class TestProcessor < MiniTest::Unit::TestCase
+  describe 'with mock setup' do
+    before do
+      $invokes = 0
+      $errors = []
+      @boss = MiniTest::Mock.new
+      Celluloid.logger = nil
+      Sidekiq.redis = REDIS
+    end
+
+    class MockWorker
+      include Sidekiq::Worker
+      def perform(args)
+        raise "kerboom!" if args == 'boom'
+        $invokes += 1
+      end
+    end
+
+    it 'processes as expected' do
+      msg = { 'class' => MockWorker.to_s, 'args' => ['myarg'] }
+      processor = ::Sidekiq::Processor.new(@boss)
+      @boss.expect(:processor_done!, nil, [processor])
+      processor.process(msg, 'default')
+      @boss.verify
+      assert_equal 1, $invokes
+      assert_equal 0, $errors.size
+    end
+  end
+end

data/test/test_retry.rb

@@ -0,0 +1,125 @@
+require 'helper'
+require 'multi_json'
+require 'sidekiq/retry'
+require 'sidekiq/middleware/server/retry_jobs'
+
+class TestRetry < MiniTest::Unit::TestCase
+  describe 'middleware' do
+    before do
+      @redis = MiniTest::Mock.new
+      # Ugh, this is terrible.
+      Sidekiq.instance_variable_set(:@redis, @redis)
+
+      def @redis.with; yield self; end
+    end
+
+    it 'allows disabling retry' do
+      msg = { 'class' => 'Bob', 'args' => [1,2,'foo'], 'retry' => false }
+      msg2 = msg.dup
+      handler = Sidekiq::Middleware::Server::RetryJobs.new
+      assert_raises RuntimeError do
+        handler.call('', msg2, 'default') do
+          raise "kerblammo!"
+        end
+      end
+      assert_equal msg, msg2
+    end
+
+    it 'saves backtraces' do
+      @redis.expect :zadd, 1, ['retry', String, String]
+      msg = { 'class' => 'Bob', 'args' => [1,2,'foo'], 'retry' => true, 'backtrace' => true }
+      handler = Sidekiq::Middleware::Server::RetryJobs.new
+      c = nil
+      assert_raises RuntimeError do
+        handler.call('', msg, 'default') do
+          c = caller(0); raise "kerblammo!"
+        end
+      end
+      assert msg["error_backtrace"]
+      assert_equal c, msg["error_backtrace"]
+    end
+
+    it 'saves partial backtraces' do
+      @redis.expect :zadd, 1, ['retry', String, String]
+      msg = { 'class' => 'Bob', 'args' => [1,2,'foo'], 'retry' => true, 'backtrace' => 3 }
+      handler = Sidekiq::Middleware::Server::RetryJobs.new
+      c = nil
+      assert_raises RuntimeError do
+        handler.call('', msg, 'default') do
+          c = caller(0)[0..3]; raise "kerblammo!"
+        end
+      end
+      assert msg["error_backtrace"]
+      assert_equal c, msg["error_backtrace"]
+    end
+
+    it 'handles a new failed message' do
+      @redis.expect :zadd, 1, ['retry', String, String]
+      msg = { 'class' => 'Bob', 'args' => [1,2,'foo'], 'retry' => true }
+      handler = Sidekiq::Middleware::Server::RetryJobs.new
+      assert_raises RuntimeError do
+        handler.call('', msg, 'default') do
+          raise "kerblammo!"
+        end
+      end
+      assert_equal 'default', msg["queue"]
+      assert_equal 'kerblammo!', msg["error_message"]
+      assert_equal 'RuntimeError', msg["error_class"]
+      assert_equal 0, msg["retry_count"]
+      refute msg["error_backtrace"]
+      assert msg["failed_at"]
+      @redis.verify
+    end
+
+    it 'handles a recurring failed message' do
+      @redis.expect :zadd, 1, ['retry', String, String]
+      now = Time.now.utc
+      msg = {"class"=>"Bob", "args"=>[1, 2, "foo"], 'retry' => true, "queue"=>"default", "error_message"=>"kerblammo!", "error_class"=>"RuntimeError", "failed_at"=>now, "retry_count"=>10}
+      handler = Sidekiq::Middleware::Server::RetryJobs.new
+      assert_raises RuntimeError do
+        handler.call('', msg, 'default') do
+          raise "kerblammo!"
+        end
+      end
+      assert_equal 'default', msg["queue"]
+      assert_equal 'kerblammo!', msg["error_message"]
+      assert_equal 'RuntimeError', msg["error_class"]
+      assert_equal 11, msg["retry_count"]
+      assert msg["failed_at"]
+      @redis.verify
+    end
+
+    it 'throws away old messages after too many retries' do
+      now = Time.now.utc
+      msg = {"class"=>"Bob", "args"=>[1, 2, "foo"], "queue"=>"default", "error_message"=>"kerblammo!", "error_class"=>"RuntimeError", "failed_at"=>now, "retry_count"=>25}
+      handler = Sidekiq::Middleware::Server::RetryJobs.new
+      assert_raises RuntimeError do
+        handler.call('', msg, 'default') do
+          raise "kerblammo!"
+        end
+      end
+      @redis.verify
+    end
+  end
+
+  describe 'poller' do
+    before do
+      @redis = MiniTest::Mock.new
+      Sidekiq.instance_variable_set(:@redis, @redis)
+
+      def @redis.with; yield self; end
+    end
+
+    it 'should poll like a bad mother...SHUT YO MOUTH' do
+      fake_msg = Sidekiq.dump_json({ 'class' => 'Bob', 'args' => [1,2], 'queue' => 'someq' })
+      @redis.expect :multi, [[fake_msg], 1], []
+      @redis.expect :rpush, 1, ['queue:someq', fake_msg]
+
+      inst = Sidekiq::Retry::Poller.new
+      inst.poll
+
+      @redis.verify
+    end
+  end
+
+end

data/test/test_stats.rb

@@ -0,0 +1,68 @@
+require 'helper'
+require 'sidekiq'
+require 'sidekiq/processor'
+
+class TestStats < MiniTest::Unit::TestCase
+  describe 'with redis' do
+    before do
+      @redis = Sidekiq.redis = REDIS
+      Sidekiq.redis {|c| c.flushdb }
+    end
+
+    class DumbWorker
+      include Sidekiq::Worker
+
+      def perform(arg)
+        raise 'bang' if arg == nil
+      end
+    end
+
+    it 'updates global stats in the success case' do
+      msg = { 'class' => DumbWorker.to_s, 'args' => [""] }
+      boss = MiniTest::Mock.new
+
+      @redis.with do |conn|
+
+        set = conn.smembers('workers')
+        assert_equal 0, set.size
+
+        processor = Sidekiq::Processor.new(boss)
+        boss.expect(:processor_done!, nil, [processor])
+        boss.expect(:processor_done!, nil, [processor])
+        boss.expect(:processor_done!, nil, [processor])
+
+        assert_equal 0, conn.get('stat:failed').to_i
+        assert_equal 0, conn.get('stat:processed').to_i
+
+        processor.process(msg, 'xyzzy')
+        processor.process(msg, 'xyzzy')
+        processor.process(msg, 'xyzzy')
+
+        assert_equal 0, conn.get('stat:failed').to_i
+        assert_equal 3, conn.get('stat:processed').to_i
+      end
+    end
+
+    it 'updates global stats in the error case' do
+      msg = { 'class' => DumbWorker.to_s, 'args' => [nil] }
+      boss = MiniTest::Mock.new
+
+      @redis.with do |conn|
+        assert_equal [], conn.smembers('workers')
+        assert_equal 0, conn.get('stat:failed').to_i
+        assert_equal 0, conn.get('stat:processed').to_i
+
+        processor = Sidekiq::Processor.new(boss)
+
+        pstr = processor.to_s
+        assert_raises RuntimeError do
+          processor.process(msg, 'xyzzy')
+        end
+
+        assert_equal 1, conn.get('stat:failed').to_i
+        assert_equal 1, conn.get('stat:processed').to_i
+      end
+    end
+
+  end
+end

data/test/test_testing.rb

@@ -0,0 +1,97 @@
+require 'helper'
+require 'sidekiq'
+require 'sidekiq/worker'
+require 'active_record'
+require 'action_mailer'
+require 'sidekiq/rails'
+require 'sidekiq/extensions/action_mailer'
+require 'sidekiq/extensions/active_record'
+
+Sidekiq.hook_rails!
+
+class TestTesting < MiniTest::Unit::TestCase
+  describe 'sidekiq testing' do
+    class PerformError < RuntimeError; end
+
+    class DirectWorker
+      include Sidekiq::Worker
+      def perform(a, b)
+        a + b
+      end
+    end
+
+    class EnqueuedWorker
+      include Sidekiq::Worker
+      def perform(a, b)
+        a + b
+      end
+    end
+
+    class StoredWorker
+      include Sidekiq::Worker
+      def perform(error)
+        raise PerformError if error
+      end
+    end
+
+    class FooMailer < ActionMailer::Base
+      def bar(str)
+        str
+      end
+    end
+
+    class FooModel < ActiveRecord::Base
+      def bar(str)
+        str
+      end
+    end
+
+    before do
+      load 'sidekiq/testing.rb'
+    end
+
+    after do
+      # Undo override
+      Sidekiq::Worker::ClassMethods.class_eval do
+        remove_method :perform_async
+        alias_method :perform_async, :perform_async_old
+        remove_method :perform_async_old
+      end
+    end
+
+    it 'stubs the async call' do
+      assert_equal 0, DirectWorker.jobs.size
+      assert DirectWorker.perform_async(1, 2)
+      assert_equal 1, DirectWorker.jobs.size
+    end
+
+    it 'stubs the delay call on mailers' do
+      assert_equal 0, Sidekiq::Extensions::DelayedMailer.jobs.size
+      FooMailer.delay.bar('hello!')
+      assert_equal 1, Sidekiq::Extensions::DelayedMailer.jobs.size
+    end
+
+    it 'stubs the delay call on models' do
+      assert_equal 0, Sidekiq::Extensions::DelayedModel.jobs.size
+      FooModel.delay.bar('hello!')
+      assert_equal 1, Sidekiq::Extensions::DelayedModel.jobs.size
+    end
+
+    it 'stubs the enqueue call' do
+      assert_equal 0, EnqueuedWorker.jobs.size
+      assert Sidekiq::Client.enqueue(EnqueuedWorker, 1, 2)
+      assert_equal 1, EnqueuedWorker.jobs.size
+    end
+
+    it 'executes all stored jobs' do
+      assert StoredWorker.perform_async(false)
+      assert StoredWorker.perform_async(true)
+
+      assert_equal 2, StoredWorker.jobs.size
+      assert_raises PerformError do
+        StoredWorker.drain
+      end
+      assert_equal 0, StoredWorker.jobs.size
+    end
+  end
+end