sidekiq 0.10.0 → 7.2.0

data/test/test_extensions.rb

@@ -1,68 +0,0 @@
-require 'helper'
-require 'sidekiq'
-require 'active_record'
-require 'action_mailer'
-require 'sidekiq/extensions/action_mailer'
-require 'sidekiq/extensions/active_record'
-
-Sidekiq.hook_rails!
-
-class TestExtensions < MiniTest::Unit::TestCase
-  describe 'sidekiq extensions' do
-    before do
-      Sidekiq.redis = REDIS
-      Sidekiq.redis.flushdb
-    end
-
-    class MyModel < ActiveRecord::Base
-      def self.long_class_method
-        raise "Should not be called!"
-      end
-    end
-
-    it 'allows delayed exection of ActiveRecord class methods' do
-      assert_equal [], Sidekiq::Client.registered_queues
-      assert_equal 0, Sidekiq.redis.llen('queue:default')
-      MyModel.delay.long_class_method
-      assert_equal ['default'], Sidekiq::Client.registered_queues
-      assert_equal 1, Sidekiq.redis.llen('queue:default')
-    end
-
-    class UserMailer < ActionMailer::Base
-      def greetings(a, b)
-        raise "Should not be called!"
-      end
-    end
-
-    it 'allows delayed delivery of ActionMailer mails' do
-      assert_equal [], Sidekiq::Client.registered_queues
-      assert_equal 0, Sidekiq.redis.llen('queue:default')
-      UserMailer.delay.greetings(1, 2)
-      assert_equal ['default'], Sidekiq::Client.registered_queues
-      assert_equal 1, Sidekiq.redis.llen('queue:default')
-    end
-  end
-
-  describe 'sidekiq rails extensions configuration' do
-    before do
-      @options = Sidekiq.options
-    end
-
-    after do
-      Sidekiq.options = @options
-    end
-
-    it 'should set enable_rails_extensions option to true by default' do
-      assert Sidekiq.options[:enable_rails_extensions]
-    end
-
-    it 'should extend ActiveRecord and ActiveMailer if enable_rails_extensions is true' do
-      assert Sidekiq.hook_rails!
-    end
-
-    it 'should not extend ActiveRecord and ActiveMailer if enable_rails_extensions is false' do
-      Sidekiq.options = { :enable_rails_extensions => false }
-      refute Sidekiq.hook_rails!
-    end
-  end
-end

data/test/test_manager.rb

@@ -1,43 +0,0 @@
-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.flushdb
-      $processed = 0
-      $mutex = Mutex.new
-    end
-
-    class IntegrationWorker
-      include Sidekiq::Worker
-
-      def perform(a, b)
-        $mutex.synchronize do
-          $processed += 1
-        end
-        a + b
-      end
-    end
-
-    it 'processes messages' do
-      Sidekiq::Client.push(:foo, 'class' => IntegrationWorker, 'args' => [1, 2])
-      Sidekiq::Client.push(:foo, 'class' => IntegrationWorker, 'args' => [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
-    end
-  end
-end

data/test/test_middleware.rb

@@ -1,92 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,83 +0,0 @@
-require 'helper'
-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 'handles a new failed message' do
-      @redis.expect :zadd, 1, ['retry', String, String]
-      msg = { 'class' => 'Bob', 'args' => [1,2,'foo'] }
-      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"]
-      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"], "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 = MultiJson.encode({ '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

@@ -1,78 +0,0 @@
-require 'helper'
-require 'sidekiq'
-require 'sidekiq/processor'
-
-class TestStats < MiniTest::Unit::TestCase
-  describe 'with redis' do
-    before do
-      @redis = Sidekiq.redis = REDIS
-      Sidekiq.redis.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])
-
-        # adds to the workers set upon initialize
-        set = conn.smembers('workers')
-        assert_equal 1, set.size
-        assert_match(/#{Regexp.escape(`hostname`.strip)}/, set.first)
-
-        assert_equal 0, conn.get('stat:failed').to_i
-        assert_equal 0, conn.get('stat:processed').to_i
-        assert_equal 0, conn.get("stat:processed:#{processor}").to_i
-
-        processor.process(msg, 'xyzzy')
-        processor.process(msg, 'xyzzy')
-        processor.process(msg, 'xyzzy')
-
-        set = conn.smembers('workers')
-        assert_equal 1, set.size
-        assert_match(/#{Regexp.escape(`hostname`.strip)}/, set.first)
-        assert_equal 0, conn.get('stat:failed').to_i
-        assert_equal 3, conn.get('stat:processed').to_i
-        assert_equal 3, conn.get("stat:processed:#{processor}").to_i
-      end
-    end
-
-    it 'updates global stats in the error case' do
-      msg = { 'class' => DumbWorker.to_s, 'args' => [nil] }
-      boss = MiniTest::Mock.new
-
-      assert_equal [], @redis.smembers('workers')
-      assert_equal 0, @redis.get('stat:failed').to_i
-      assert_equal 0, @redis.get('stat:processed').to_i
-
-      processor = Sidekiq::Processor.new(boss)
-      assert_equal 1, @redis.smembers('workers').size
-
-      pstr = processor.to_s
-      assert_raises RuntimeError do
-        processor.process(msg, 'xyzzy')
-      end
-
-      set = @redis.smembers('workers')
-      assert_equal 0, set.size
-      assert_equal 1, @redis.get('stat:failed').to_i
-      assert_equal 1, @redis.get('stat:processed').to_i
-      assert_equal nil, @redis.get("stat:processed:#{pstr}")
-    end
-
-  end
-end

data/test/test_testing.rb

@@ -1,65 +0,0 @@
-require 'helper'
-require 'sidekiq'
-require 'sidekiq/worker'
-require 'active_record'
-require 'action_mailer'
-require 'sidekiq/extensions/action_mailer'
-require 'sidekiq/extensions/active_record'
-
-Sidekiq.hook_rails!
-
-class TestTesting < MiniTest::Unit::TestCase
-  describe 'sidekiq testing' do
-
-    class DirectWorker
-      include Sidekiq::Worker
-      def perform(a, b)
-        a + b
-      end
-    end
-
-    class FooMailer < ActionMailer::Base
-      def bar(str)
-        str
-      end
-    end
-
-    class FooModel < ActiveRecord::Base
-      def bar(str)
-        str
-      end
-    end
-
-    before do
-      require 'sidekiq/testing'
-    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 when in testing mode' do
-      # We can only have one it block here so all 'testing' tests
-      # have to go here because require 'sidekiq/testing' changes
-      # how Sidekiq works and we need to roll back those changes
-      # when the test is done.
-      assert_equal 0, DirectWorker.jobs.size
-      assert DirectWorker.perform_async(1, 2)
-      assert_equal 1, DirectWorker.jobs.size
-
-      assert_equal 0, Sidekiq::Extensions::DelayedMailer.jobs.size
-      FooMailer.delay.bar('hello!')
-      assert_equal 1, Sidekiq::Extensions::DelayedMailer.jobs.size
-
-      assert_equal 0, Sidekiq::Extensions::DelayedModel.jobs.size
-      FooModel.delay.bar('hello!')
-      assert_equal 1, Sidekiq::Extensions::DelayedModel.jobs.size
-    end
-
-  end
-end

data/test/test_web.rb

@@ -1,61 +0,0 @@
-require 'helper'
-require 'sidekiq'
-require 'sidekiq/web'
-require 'rack/test'
-
-class TestWeb < MiniTest::Unit::TestCase
-  describe 'sidekiq web' do
-    include Rack::Test::Methods
-
-    def app
-      Sidekiq::Web
-    end
-
-    before do
-      Sidekiq.redis = REDIS
-      Sidekiq.redis.flushdb
-    end
-
-    class WebWorker
-      include Sidekiq::Worker
-
-      def perform(a, b)
-        a + b
-      end
-    end
-
-    it 'shows active queues' do
-      get '/'
-      assert_equal 200, last_response.status
-      assert_match last_response.body, /Sidekiq is down/
-      refute_match last_response.body, /default/
-
-      assert WebWorker.perform_async(1, 2)
-
-      get '/'
-      assert_equal 200, last_response.status
-      assert_match last_response.body, /Sidekiq is down/
-      assert_match last_response.body, /default/
-      refute_match last_response.body, /foo/
-
-      assert Sidekiq::Client.push(:foo, 'class' => WebWorker, 'args' => [1, 3])
-
-      get '/'
-      assert_equal 200, last_response.status
-      assert_match last_response.body, /Sidekiq is down/
-      assert_match last_response.body, /default/
-      assert_match last_response.body, /foo/
-    end
-
-    it 'handles queues with no name' do
-      get '/queues'
-      assert_equal 404, last_response.status
-    end
-
-    it 'handles queue view' do
-      get '/queues/default'
-      assert_equal 200, last_response.status
-    end
-
-  end
-end

data/web/assets/javascripts/vendor/bootstrap/bootstrap-alert.js

@@ -1,91 +0,0 @@
-/* ==========================================================
- * bootstrap-alert.js v2.0.0
- * http://twitter.github.com/bootstrap/javascript.html#alerts
- * ==========================================================
- * Copyright 2012 Twitter, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ========================================================== */
-
-
-!function( $ ){
-
-  "use strict"
-
- /* ALERT CLASS DEFINITION
-  * ====================== */
-
-  var dismiss = '[data-dismiss="alert"]'
-    , Alert = function ( el ) {
-        $(el).on('click', dismiss, this.close)
-      }
-
-  Alert.prototype = {
-
-    constructor: Alert
-
-  , close: function ( e ) {
-      var $this = $(this)
-        , selector = $this.attr('data-target')
-        , $parent
-
-      if (!selector) {
-        selector = $this.attr('href')
-        selector = selector && selector.replace(/.*(?=#[^\s]*$)/, '') //strip for ie7
-      }
-
-      $parent = $(selector)
-      $parent.trigger('close')
-
-      e && e.preventDefault()
-
-      $parent.length || ($parent = $this.hasClass('alert') ? $this : $this.parent())
-
-      $parent.removeClass('in')
-
-      function removeElement() {
-        $parent.remove()
-        $parent.trigger('closed')
-      }
-
-      $.support.transition && $parent.hasClass('fade') ?
-        $parent.on($.support.transition.end, removeElement) :
-        removeElement()
-    }
-
-  }
-
-
- /* ALERT PLUGIN DEFINITION
-  * ======================= */
-
-  $.fn.alert = function ( option ) {
-    return this.each(function () {
-      var $this = $(this)
-        , data = $this.data('alert')
-      if (!data) $this.data('alert', (data = new Alert(this)))
-      if (typeof option == 'string') data[option].call($this)
-    })
-  }
-
-  $.fn.alert.Constructor = Alert
-
-
- /* ALERT DATA-API
-  * ============== */
-
-  $(function () {
-    $('body').on('click.alert.data-api', dismiss, Alert.prototype.close)
-  })
-
-}( window.jQuery )