sidekiq 3.4.1 → 4.0.0

data/test/test_cli.rb

@@ -128,7 +128,7 @@ class TestCli < Sidekiq::Test
 
       it 'appends messages to a logfile' do
         File.open(@tmp_log_path, 'w') do |f|
-          f.puts 'already existant log message'
+          f.puts 'already existent log message'
         end
 
         @cli.parse(['sidekiq', '-L', @tmp_log_path, '-r', './test/fake_env.rb'])
@@ -136,7 +136,7 @@ class TestCli < Sidekiq::Test
         Sidekiq.logger.info('test message')
 
         log_file_content = File.read(@tmp_log_path)
-        assert_match(/already existant/, log_file_content, "didn't include the old message")
+        assert_match(/already existent/, log_file_content, "didn't include the old message")
         assert_match(/test message/, log_file_content, "didn't include the new message")
       end
     end
@@ -168,35 +168,14 @@ class TestCli < Sidekiq::Test
         @cli.parse(['sidekiq', '-C', './test/config.yml'])
       end
 
-      it 'takes a path' do
+      it 'parses as expected' do
         assert_equal './test/config.yml', Sidekiq.options[:config_file]
-      end
-
-      it 'sets verbose' do
         refute Sidekiq.options[:verbose]
-      end
-
-      it 'sets require file' do
         assert_equal './test/fake_env.rb', Sidekiq.options[:require]
-      end
-
-      it 'does not set environment' do
         assert_equal nil, Sidekiq.options[:environment]
-      end
-
-      it 'sets concurrency' do
         assert_equal 50, Sidekiq.options[:concurrency]
-      end
-
-      it 'sets pid file' do
         assert_equal '/tmp/sidekiq-config-test.pid', Sidekiq.options[:pidfile]
-      end
-
-      it 'sets logfile' do
         assert_equal '/tmp/sidekiq.log', Sidekiq.options[:logfile]
-      end
-
-      it 'sets queues' do
         assert_equal 2, Sidekiq.options[:queues].count { |q| q == 'very_often' }
         assert_equal 1, Sidekiq.options[:queues].count { |q| q == 'seldom' }
       end
@@ -207,35 +186,14 @@ class TestCli < Sidekiq::Test
         @cli.parse(['sidekiq', '-e', 'staging', '-C', './test/env_based_config.yml'])
       end
 
-      it 'takes a path' do
+      it 'parses as expected' do
         assert_equal './test/env_based_config.yml', Sidekiq.options[:config_file]
-      end
-
-      it 'sets verbose' do
         refute Sidekiq.options[:verbose]
-      end
-
-      it 'sets require file' do
         assert_equal './test/fake_env.rb', Sidekiq.options[:require]
-      end
-
-      it 'sets environment' do
         assert_equal 'staging', Sidekiq.options[:environment]
-      end
-
-      it 'sets concurrency' do
         assert_equal 5, Sidekiq.options[:concurrency]
-      end
-
-      it 'sets pid file' do
         assert_equal '/tmp/sidekiq-config-test.pid', Sidekiq.options[:pidfile]
-      end
-
-      it 'sets logfile' do
         assert_equal '/tmp/sidekiq.log', Sidekiq.options[:logfile]
-      end
-
-      it 'sets queues' do
         assert_equal 2, Sidekiq.options[:queues].count { |q| q == 'very_often' }
         assert_equal 1, Sidekiq.options[:queues].count { |q| q == 'seldom' }
       end
@@ -297,23 +255,11 @@ class TestCli < Sidekiq::Test
         File.unlink @tmp_path if File.exist? @tmp_path
       end
 
-      it 'uses concurrency flag' do
+      it 'gives the expected options' do
         assert_equal 100, Sidekiq.options[:concurrency]
-      end
-
-      it 'uses require file flag' do
         assert_equal @tmp_lib_path, Sidekiq.options[:require]
-      end
-
-      it 'uses environment flag' do
         assert_equal 'snoop', Sidekiq.options[:environment]
-      end
-
-      it 'uses pidfile flag' do
         assert_equal @tmp_path, Sidekiq.options[:pidfile]
-      end
-
-      it 'sets queues' do
         assert_equal 7, Sidekiq.options[:queues].count { |q| q == 'often' }
         assert_equal 3, Sidekiq.options[:queues].count { |q| q == 'seldom' }
       end
@@ -362,4 +308,28 @@ class TestCli < Sidekiq::Test
     end
   end
 
+  describe 'misc' do
+    it 'handles interrupts' do
+      cli = Sidekiq::CLI.new
+      assert_raises Interrupt do
+        cli.handle_signal('INT')
+      end
+      assert_raises Interrupt do
+        cli.handle_signal('TERM')
+      end
+      cli.handle_signal('USR2')
+      cli.handle_signal('TTIN')
+    end
+
+    it 'can fire events' do
+      count = 0
+      Sidekiq.options[:lifecycle_events][:startup] = [proc {
+        count += 1
+      }]
+      cli = Sidekiq::CLI.new
+      cli.fire_event(:startup)
+      assert_equal 1, count
+    end
+  end
+
 end

data/test/test_client.rb

@@ -1,33 +1,7 @@
 require_relative 'helper'
-require 'sidekiq/client'
-require 'sidekiq/worker'
 
 class TestClient < Sidekiq::Test
-  describe 'with mock redis' do
-    before do
-      @redis = Minitest::Mock.new
-      def @redis.multi; [yield] * 2 if block_given?; end
-      def @redis.set(*); true; end
-      def @redis.sadd(*); true; end
-      def @redis.srem(*); true; end
-      def @redis.get(*); nil; end
-      def @redis.del(*); nil; end
-      def @redis.incrby(*); nil; end
-      def @redis.setex(*); true; end
-      def @redis.expire(*); true; end
-      def @redis.watch(*); true; end
-      def @redis.with_connection; yield self; end
-      def @redis.with; yield self; end
-      def @redis.exec; true; end
-      Sidekiq.instance_variable_set(:@redis, @redis)
-      Sidekiq::Client.instance_variable_set(:@default, nil)
-    end
-
-    after do
-      Sidekiq.redis = REDIS
-      Sidekiq::Client.instance_variable_set(:@default, nil)
-    end
-
+  describe 'errors' do
     it 'raises ArgumentError with invalid params' do
       assert_raises ArgumentError do
         Sidekiq::Client.push('foo', 1)
@@ -49,112 +23,71 @@ class TestClient < Sidekiq::Test
         Sidekiq::Client.push('queue' => 'foo', 'class' => MyWorker, 'args' => 1)
       end
     end
+  end
 
-    describe 'as instance' do
-      it 'can push' do
-        @redis.expect :lpush, 1, ['queue:default', Array]
-        client = Sidekiq::Client.new
-        jid = client.push('class' => 'Blah', 'args' => [1,2,3])
-        assert_equal 24, jid.size
-      end
-
-      it 'allows local middleware modification' do
-        @redis.expect :lpush, 1, ['queue:default', Array]
-        $called = false
-        mware = Class.new { def call(worker_klass,msg,q,r); $called = true; msg;end }
-        client = Sidekiq::Client.new
-        client.middleware do |chain|
-          chain.add mware
-        end
-        client.push('class' => 'Blah', 'args' => [1,2,3])
+  describe 'as instance' do
+    it 'can push' do
+      client = Sidekiq::Client.new
+      jid = client.push('class' => 'Blah', 'args' => [1,2,3])
+      assert_equal 24, jid.size
+    end
 
-        assert $called
-        assert client.middleware.exists?(mware)
-        refute Sidekiq.client_middleware.exists?(mware)
+    it 'allows local middleware modification' do
+      $called = false
+      mware = Class.new { def call(worker_klass,msg,q,r); $called = true; msg;end }
+      client = Sidekiq::Client.new
+      client.middleware do |chain|
+        chain.add mware
       end
+      client.push('class' => 'Blah', 'args' => [1,2,3])
+
+      assert $called
+      assert client.middleware.exists?(mware)
+      refute Sidekiq.client_middleware.exists?(mware)
     end
+  end
 
+  describe 'client' do
     it 'pushes messages to redis' do
-      @redis.expect :lpush, 1, ['queue:foo', Array]
-      pushed = Sidekiq::Client.push('queue' => 'foo', 'class' => MyWorker, 'args' => [1, 2])
-      assert pushed
-      assert_equal 24, pushed.size
-      @redis.verify
+      q = Sidekiq::Queue.new('foo')
+      pre = q.size
+      jid = Sidekiq::Client.push('queue' => 'foo', 'class' => MyWorker, 'args' => [1, 2])
+      assert jid
+      assert_equal 24, jid.size
+      assert_equal pre + 1, q.size
     end
 
     it 'pushes messages to redis using a String class' do
-      @redis.expect :lpush, 1, ['queue:foo', Array]
-      pushed = Sidekiq::Client.push('queue' => 'foo', 'class' => 'MyWorker', 'args' => [1, 2])
-      assert pushed
-      assert_equal 24, pushed.size
-      @redis.verify
+      q = Sidekiq::Queue.new('foo')
+      pre = q.size
+      jid = Sidekiq::Client.push('queue' => 'foo', 'class' => 'MyWorker', 'args' => [1, 2])
+      assert jid
+      assert_equal 24, jid.size
+      assert_equal pre + 1, q.size
     end
 
     class MyWorker
       include Sidekiq::Worker
     end
 
-    it 'has default options' do
-      assert_equal Sidekiq.default_worker_options, MyWorker.get_sidekiq_options
-    end
-
-    it 'handles perform_async' do
-      @redis.expect :lpush, 1, ['queue:default', Array]
-      pushed = MyWorker.perform_async(1, 2)
-      assert pushed
-      @redis.verify
-    end
-
-    it 'enqueues messages to redis' do
-      @redis.expect :lpush, 1, ['queue:default', Array]
-      pushed = Sidekiq::Client.enqueue(MyWorker, 1, 2)
-      assert pushed
-      @redis.verify
-    end
-
-    it 'enqueues messages to redis' do
-      @redis.expect :lpush, 1, ['queue:custom_queue', Array]
-      pushed = Sidekiq::Client.enqueue_to(:custom_queue, MyWorker, 1, 2)
-      assert pushed
-      @redis.verify
-    end
-
-    it 'enqueues messages to redis (delayed, custom queue)' do
-      @redis.expect :zadd, 1, ['schedule', Array]
-      pushed = Sidekiq::Client.enqueue_to_in(:custom_queue, 3.minutes, MyWorker, 1, 2)
-      assert pushed
-      @redis.verify
-    end
-
-    it 'enqueues messages to redis (delayed into past, custom queue)' do
-      @redis.expect :lpush, 1, ['queue:custom_queue', Array]
-      pushed = Sidekiq::Client.enqueue_to_in(:custom_queue, -3.minutes, MyWorker, 1, 2)
-      assert pushed
-      @redis.verify
-    end
-
-    it 'enqueues messages to redis (delayed)' do
-      @redis.expect :zadd, 1, ['schedule', Array]
-      pushed = Sidekiq::Client.enqueue_in(3.minutes, MyWorker, 1, 2)
-      assert pushed
-      @redis.verify
-    end
-
     class QueuedWorker
       include Sidekiq::Worker
       sidekiq_options :queue => :flimflam
     end
 
-    it 'enqueues to the named queue' do
-      @redis.expect :lpush, 1, ['queue:flimflam', Array]
-      pushed = QueuedWorker.perform_async(1, 2)
-      assert pushed
-      @redis.verify
-    end
-
-    it 'retrieves queues' do
-      @redis.expect :smembers, ['bob'], ['queues']
-      assert_equal ['bob'], Sidekiq::Queue.all.map(&:name)
+    it 'enqueues' do
+      Sidekiq.redis {|c| c.flushdb }
+      assert_equal Sidekiq.default_worker_options, MyWorker.get_sidekiq_options
+      assert MyWorker.perform_async(1, 2)
+      assert Sidekiq::Client.enqueue(MyWorker, 1, 2)
+      assert Sidekiq::Client.enqueue_to(:custom_queue, MyWorker, 1, 2)
+      assert_equal 1, Sidekiq::Queue.new('custom_queue').size
+      assert Sidekiq::Client.enqueue_to_in(:custom_queue, 3.minutes, MyWorker, 1, 2)
+      assert Sidekiq::Client.enqueue_to_in(:custom_queue, -3.minutes, MyWorker, 1, 2)
+      assert_equal 2, Sidekiq::Queue.new('custom_queue').size
+      assert Sidekiq::Client.enqueue_in(3.minutes, MyWorker, 1, 2)
+      assert QueuedWorker.perform_async(1, 2)
+      assert_equal 1, Sidekiq::Queue.new('flimflam').size
     end
   end
 
@@ -191,24 +124,23 @@ class TestClient < Sidekiq::Test
   end
 
   describe 'client middleware' do
-
     class Stopper
-      def call(worker_class, message, queue, r)
+      def call(worker_class, job, queue, r)
         raise ArgumentError unless r
-        yield if message['args'].first.odd?
+        yield if job['args'].first.odd?
       end
     end
 
     it 'can stop some of the jobs from pushing' do
-      Sidekiq.client_middleware.add Stopper
-      begin
-        assert_equal nil, Sidekiq::Client.push('class' => MyWorker, 'args' => [0])
-        assert_match(/[0-9a-f]{12}/, Sidekiq::Client.push('class' => MyWorker, 'args' => [1]))
-        Sidekiq::Client.push_bulk('class' => MyWorker, 'args' => [[0], [1]]).each do |jid|
-          assert_match(/[0-9a-f]{12}/, jid)
-        end
-      ensure
-        Sidekiq.client_middleware.remove Stopper
+      client = Sidekiq::Client.new
+      client.middleware do |chain|
+        chain.add Stopper
+      end
+
+      assert_equal nil, client.push('class' => MyWorker, 'args' => [0])
+      assert_match(/[0-9a-f]{12}/, client.push('class' => MyWorker, 'args' => [1]))
+      client.push_bulk('class' => MyWorker, 'args' => [[0], [1]]).each do |jid|
+        assert_match(/[0-9a-f]{12}/, jid)
       end
     end
   end
@@ -220,19 +152,10 @@ class TestClient < Sidekiq::Test
     end
   end
 
-  describe 'item normalization' do
-    it 'defaults retry to true' do
-      assert_equal true, Sidekiq::Client.new.__send__(:normalize_item, 'class' => QueuedWorker, 'args' => [])['retry']
-    end
-
-    it "does not normalize numeric retry's" do
-      assert_equal 2, Sidekiq::Client.new.__send__(:normalize_item, 'class' => CWorker, 'args' => [])['retry']
-    end
-  end
-
   describe 'sharding' do
     class DWorker < BaseWorker
     end
+
     it 'allows sidekiq_options to point to different Redi' do
       conn = MiniTest::Mock.new
       conn.expect(:multi, [0, 1])
@@ -240,6 +163,7 @@ class TestClient < Sidekiq::Test
       DWorker.perform_async(1,2,3)
       conn.verify
     end
+
     it 'allows #via to point to different Redi' do
       conn = MiniTest::Mock.new
       conn.expect(:multi, [0, 1])
@@ -257,6 +181,7 @@ class TestClient < Sidekiq::Test
       assert_equal default, Sidekiq::Client.new.redis_pool
       conn.verify
     end
+
     it 'allows Resque helpers to point to different Redi' do
       conn = MiniTest::Mock.new
       conn.expect(:multi, []) { |*args, &block| block.call }

data/test/test_extensions.rb

@@ -23,30 +23,34 @@ class TestExtensions < Sidekiq::Test
 
     it 'allows delayed execution of ActiveRecord class methods' do
       assert_equal [], Sidekiq::Queue.all.map(&:name)
-      assert_equal 0, Sidekiq.redis {|c| c.llen('queue:default') }
+      q = Sidekiq::Queue.new
+      assert_equal 0, q.size
       MyModel.delay.long_class_method
       assert_equal ['default'], Sidekiq::Queue.all.map(&:name)
-      assert_equal 1, Sidekiq.redis {|c| c.llen('queue:default') }
+      assert_equal 1, q.size
     end
 
     it 'uses and stringifies specified options' do
       assert_equal [], Sidekiq::Queue.all.map(&:name)
-      assert_equal 0, Sidekiq.redis {|c| c.llen('queue:notdefault') }
+      q = Sidekiq::Queue.new('notdefault')
+      assert_equal 0, q.size
       MyModel.delay(queue: :notdefault).long_class_method
       assert_equal ['notdefault'], Sidekiq::Queue.all.map(&:name)
-      assert_equal 1, Sidekiq.redis {|c| c.llen('queue:notdefault') }
+      assert_equal 1, q.size
     end
 
     it 'allows delayed scheduling of AR class methods' do
-      assert_equal 0, Sidekiq.redis {|c| c.zcard('schedule') }
+      ss = Sidekiq::ScheduledSet.new
+      assert_equal 0, ss.size
       MyModel.delay_for(5.days).long_class_method
-      assert_equal 1, Sidekiq.redis {|c| c.zcard('schedule') }
+      assert_equal 1, ss.size
     end
 
     it 'allows until delayed scheduling of AR class methods' do
-      assert_equal 0, Sidekiq.redis {|c| c.zcard('schedule') }
+      ss = Sidekiq::ScheduledSet.new
+      assert_equal 0, ss.size
       MyModel.delay_until(1.day.from_now).long_class_method
-      assert_equal 1, Sidekiq.redis {|c| c.zcard('schedule') }
+      assert_equal 1, ss.size
     end
 
     class UserMailer < ActionMailer::Base
@@ -57,22 +61,25 @@ class TestExtensions < Sidekiq::Test
 
     it 'allows delayed delivery of ActionMailer mails' do
       assert_equal [], Sidekiq::Queue.all.map(&:name)
-      assert_equal 0, Sidekiq.redis {|c| c.llen('queue:default') }
+      q = Sidekiq::Queue.new
+      assert_equal 0, q.size
       UserMailer.delay.greetings(1, 2)
       assert_equal ['default'], Sidekiq::Queue.all.map(&:name)
-      assert_equal 1, Sidekiq.redis {|c| c.llen('queue:default') }
+      assert_equal 1, q.size
     end
 
     it 'allows delayed scheduling of AM mails' do
-      assert_equal 0, Sidekiq.redis {|c| c.zcard('schedule') }
+      ss = Sidekiq::ScheduledSet.new
+      assert_equal 0, ss.size
       UserMailer.delay_for(5.days).greetings(1, 2)
-      assert_equal 1, Sidekiq.redis {|c| c.zcard('schedule') }
+      assert_equal 1, ss.size
     end
 
     it 'allows until delay scheduling of AM mails' do
-      assert_equal 0, Sidekiq.redis {|c| c.zcard('schedule') }
+      ss = Sidekiq::ScheduledSet.new
+      assert_equal 0, ss.size
       UserMailer.delay_until(5.days.from_now).greetings(1, 2)
-      assert_equal 1, Sidekiq.redis {|c| c.zcard('schedule') }
+      assert_equal 1, ss.size
     end
 
     class SomeClass
@@ -81,9 +88,10 @@ class TestExtensions < Sidekiq::Test
     end
 
     it 'allows delay of any ole class method' do
-      assert_equal 0, queue_size
+      q = Sidekiq::Queue.new
+      assert_equal 0, q.size
       SomeClass.delay.doit(Date.today)
-      assert_equal 1, queue_size
+      assert_equal 1, q.size
     end
 
     module SomeModule
@@ -92,18 +100,16 @@ class TestExtensions < Sidekiq::Test
     end
 
     it 'allows delay of any module class method' do
-      assert_equal 0, queue_size
+      q = Sidekiq::Queue.new
+      assert_equal 0, q.size
       SomeModule.delay.doit(Date.today)
-      assert_equal 1, queue_size
-    end
-
-    def queue_size(name='default')
-      Sidekiq::Queue.new(name).size
+      assert_equal 1, q.size
     end
 
     it 'allows removing of the #delay methods' do
+      q = Sidekiq::Queue.new
       Sidekiq.remove_delay!
-      assert_equal 0, queue_size
+      assert_equal 0, q.size
       assert_raises NoMethodError do
         SomeModule.delay.doit(Date.today)
       end

data/test/test_fetch.rb

@@ -20,7 +20,7 @@ class TestFetcher < Sidekiq::Test
       uow = fetch.retrieve_work
       refute_nil uow
       assert_equal 'basic', uow.queue_name
-      assert_equal 'msg', uow.message
+      assert_equal 'msg', uow.job
       q = Sidekiq::Queue.new('basic')
       assert_equal 0, q.size
       uow.requeue
@@ -31,7 +31,7 @@ class TestFetcher < Sidekiq::Test
     it 'retrieves with strict setting' do
       fetch = Sidekiq::BasicFetch.new(:queues => ['basic', 'bar', 'bar'], :strict => true)
       cmd = fetch.queues_cmd
-      assert_equal cmd, ['queue:basic', 'queue:bar', 1]
+      assert_equal cmd, ['queue:basic', 'queue:bar', Sidekiq::BasicFetch::TIMEOUT]
     end
 
     it 'bulk requeues' do
@@ -45,60 +45,5 @@ class TestFetcher < Sidekiq::Test
       assert_equal 1, q2.size
     end
 
-    describe 'fetching' do
-      before do
-        Sidekiq::Fetcher.reset
-      end
-
-      it 'instantiates' do
-        begin
-          Sidekiq.options[:fetch] = NullFetch
-          mgr = Minitest::Mock.new
-          fetch = Sidekiq::Fetcher.new(mgr, {})
-          fetch.fetch
-          Sidekiq::Fetcher.done!
-        ensure
-          Sidekiq.options[:fetch] = Sidekiq::BasicFetch
-        end
-      end
-
-      class NullFetch
-        def initialize(opts)
-        end
-        def retrieve_work
-        end
-        def self.bulk_requeue(*args)
-        end
-      end
-
-      it 'handles redis network errors' do
-        begin
-          Sidekiq.logger.level = Logger::FATAL
-          Sidekiq.options[:fetch] = ErrorFetch
-          mgr = Minitest::Mock.new
-          fetch = Sidekiq::Fetcher.new(mgr, {})
-          def fetch.pause
-          end
-          refute fetch.down
-          fetch.fetch
-          Sidekiq::Fetcher.done!
-          assert fetch.down
-        ensure
-          Sidekiq.options[:fetch] = Sidekiq::BasicFetch
-          Sidekiq.logger.level = Logger::ERROR
-        end
-      end
-
-      class ErrorFetch
-        def initialize(opts)
-        end
-        def retrieve_work
-          raise IOError, "ker-BOOM"
-        end
-        def self.bulk_requeue(*args)
-        end
-      end
-    end
-
   end
 end

data/test/test_launcher.rb

@@ -0,0 +1,80 @@
+require_relative 'helper'
+require 'sidekiq/launcher'
+
+class TestLauncher < Sidekiq::Test
+
+  describe 'launcher' do
+    before do
+      Sidekiq.redis {|c| c.flushdb }
+    end
+
+    def new_manager(opts)
+      Sidekiq::Manager.new(opts)
+    end
+
+    describe 'heartbeat' do
+      before do
+        uow = Object.new
+
+        @mgr = new_manager(options)
+        @launcher = Sidekiq::Launcher.new(options)
+        @launcher.manager = @mgr
+
+        Sidekiq::Processor::WORKER_STATE['a'] = {'b' => 1}
+
+        @proctitle = $0
+      end
+
+      after do
+        Sidekiq::Processor::WORKER_STATE.clear
+        $0 = @proctitle
+      end
+
+      describe 'when manager is active' do
+        before do
+          Sidekiq::CLI::PROCTITLES << proc { "xyz" }
+          @launcher.heartbeat('identity', heartbeat_data, Sidekiq.dump_json(heartbeat_data))
+          Sidekiq::CLI::PROCTITLES.pop
+        end
+
+        it 'sets useful info to proctitle' do
+          assert_equal "sidekiq #{Sidekiq::VERSION} myapp [1 of 3 busy] xyz", $0
+        end
+
+        it 'stores process info in redis' do
+          info = Sidekiq.redis { |c| c.hmget('identity', 'busy') }
+          assert_equal ["1"], info
+          expires = Sidekiq.redis { |c| c.pttl('identity') }
+          assert_in_delta 60000, expires, 500
+        end
+      end
+
+      describe 'when manager is stopped' do
+        before do
+          @launcher.quiet
+          @launcher.heartbeat('identity', heartbeat_data, Sidekiq.dump_json(heartbeat_data))
+        end
+
+        it 'indicates stopping status in proctitle' do
+          assert_equal "sidekiq #{Sidekiq::VERSION} myapp [1 of 3 busy] stopping", $0
+        end
+
+        it 'stores process info in redis' do
+          info = Sidekiq.redis { |c| c.hmget('identity', 'busy') }
+          assert_equal ["1"], info
+          expires = Sidekiq.redis { |c| c.pttl('identity') }
+          assert_in_delta 60000, expires, 50
+        end
+      end
+    end
+
+    def options
+      { :concurrency => 3, :queues => ['default'] }
+    end
+
+    def heartbeat_data
+      { 'concurrency' => 3, 'tag' => 'myapp' }
+    end
+  end
+
+end

data/test/test_logging.rb

@@ -1,7 +1,7 @@
 require_relative 'helper'
 require 'sidekiq/logging'
 
-class TestFetcher < Sidekiq::Test
+class TestLogging < Sidekiq::Test
   describe Sidekiq::Logging do
     describe "#with_context" do
       def context