sidekiq-unique-jobs 5.0.2 → 5.0.4

data/spec/jobs/unique_on_all_queues_job.rb

@@ -1,13 +0,0 @@
-class UniqueOnAllQueuesJob
-  include Sidekiq::Worker
-  sidekiq_options queue: :working, retry: 1, backtrace: 10,
-                  unique: :until_executed, unique_on_all_queues: true
-
-  sidekiq_retries_exhausted do |msg|
-    logger.warn "Failed #{msg['class']} with #{msg['args']}: #{msg['error_message']}"
-  end
-
-  def perform(*)
-    # NO-OP
-  end
-end

data/spec/jobs/until_and_while_executing_job.rb

@@ -1,7 +0,0 @@
-class UntilAndWhileExecuting
-  include Sidekiq::Worker
-
-  sidekiq_options queue: :working, unique: :until_and_while_executing
-
-  def perform; end
-end

data/spec/jobs/until_executed_job.rb

@@ -1,17 +0,0 @@
-class UntilExecutedJob
-  include Sidekiq::Worker
-  sidekiq_options queue: :working, retry: 1, backtrace: 10
-  sidekiq_options unique: :until_executed
-
-  sidekiq_retries_exhausted do |msg|
-    logger.warn "Failed #{msg['class']} with #{msg['args']}: #{msg['error_message']}"
-  end
-
-  def perform(*)
-    # NO-OP
-  end
-
-  def after_unlock
-    # NO OP
-  end
-end

data/spec/jobs/until_executing_job.rb

@@ -1,7 +0,0 @@
-class UntilExecutingJob
-  include Sidekiq::Worker
-
-  sidekiq_options queue: :working, unique: :until_executing
-
-  def perform; end
-end

data/spec/jobs/until_global_timeout_job.rb

@@ -1,8 +0,0 @@
-class UntilGlobalTimeoutJob
-  include Sidekiq::Worker
-  sidekiq_options unique: :until_timeout
-
-  def perform(x)
-    TestClass.run(x)
-  end
-end

data/spec/jobs/until_timeout_job.rb

@@ -1,8 +0,0 @@
-class UntilTimeoutJob
-  include Sidekiq::Worker
-  sidekiq_options unique: :until_timeout,
-                  unique_expiration: 10 * 60
-  def perform(x)
-    TestClass.run(x)
-  end
-end

data/spec/jobs/while_executing_job.rb

@@ -1,12 +0,0 @@
-class WhileExecutingJob
-  include Sidekiq::Worker
-  sidekiq_options queue: :working, retry: 1, backtrace: 10, unique: :while_executing
-
-  sidekiq_retries_exhausted do |msg|
-    logger.warn "Failed #{msg['class']} with #{msg['args']}: #{msg['error_message']}"
-  end
-
-  def perform(_)
-    # NO OP
-  end
-end

data/spec/jobs/without_argument_job.rb

@@ -1,9 +0,0 @@
-class WithoutArgumentJob
-  include Sidekiq::Worker
-  sidekiq_options unique: :until_executed,
-                  log_duplicate_payload: true
-
-  def perform
-    sleep 20
-  end
-end

data/spec/lib/sidekiq_unique_jobs/cli_spec.rb

@@ -1,183 +0,0 @@
-require 'spec_helper'
-require 'thor/runner'
-
-RSpec.describe SidekiqUniqueJobs::Cli, ruby_ver: '>= 2.4' do
-  describe '#help' do
-    let(:output) { capture(:stdout) { described_class.start(%w[help]) } }
-    let(:banner) do
-      <<~EOS.freeze
-        Commands:
-          jobs  console         # drop into a console with easy access to helper methods
-          jobs  del PATTERN     # deletes unique keys from redis by pattern
-          jobs  expire          # removes all expired unique keys from the hash in redis
-          jobs  help [COMMAND]  # Describe available commands or one specific command
-          jobs  keys PATTERN    # list all unique keys and their expiry time
-      EOS
-    end
-
-    it 'displays help' do
-      expect(output).to include(banner)
-    end
-
-    describe '#help del' do
-      let(:output) { capture(:stdout) { described_class.start(%w[help del]) } }
-      let(:banner) do
-        <<~EOS.freeze
-          Usage:
-            jobs  del PATTERN
-
-          Options:
-            d, [--dry-run], [--no-dry-run]  # set to false to perform deletion
-            c, [--count=N]                  # The max number of keys to return
-                                            # Default: 1000
-
-          deletes unique keys from redis by pattern
-        EOS
-      end
-
-      it 'displays help about the `del` command' do
-        expect(output).to eq(banner)
-      end
-    end
-
-    describe '#help expire' do
-      let(:output) { capture(:stdout) { described_class.start(%w[help expire]) } }
-
-      let(:banner) do
-        <<~EOS.freeze
-          Usage:
-            jobs  expire
-
-          removes all expired unique keys from the hash in redis
-        EOS
-      end
-
-      it 'displays help about the `expire` command' do
-        expect(output).to eq(banner)
-      end
-    end
-
-    describe '#help keys' do
-      let(:output) { capture(:stdout) { described_class.start(%w[help keys]) } }
-      let(:banner) do
-        <<~EOS.freeze
-          Usage:
-            jobs  keys PATTERN
-
-          Options:
-            c, [--count=N]  # The max number of keys to return
-                            # Default: 1000
-
-          list all unique keys and their expiry time
-        EOS
-      end
-
-      it 'displays help about the `key` command' do
-        expect(output).to eq(banner)
-      end
-    end
-  end
-
-  let(:pattern) { '*' }
-  let(:max_lock_time) { 1 }
-  let(:unique_key) { 'uniquejobs:abcdefab' }
-  let(:jid) { 'abcdefab' }
-
-  describe '.keys' do
-    let(:output) { capture(:stdout) { described_class.start(%w[keys * --count 1000]) } }
-
-    context 'when no keys exist' do
-      let(:expected) { "Found 0 keys matching '#{pattern}':\n" }
-      specify { expect(output).to eq(expected) }
-    end
-
-    context 'when a key exists' do
-      let(:keys) { ['defghayl', jid, 'poilkij'].sort }
-      before do
-        keys.each do |jid|
-          unique_key = "uniquejobs:#{jid}"
-          SidekiqUniqueJobs::Scripts::AcquireLock.execute(nil, unique_key, jid, 20)
-          expect(SidekiqUniqueJobs)
-            .to have_key(unique_key)
-            .for_seconds(20)
-            .with_value(jid)
-        end
-      end
-
-      after { SidekiqUniqueJobs::Util.del('*', 1000, false) }
-
-      let(:expected) do
-        <<~EOS
-          Found 3 keys matching '#{pattern}':
-          uniquejobs:abcdefab  uniquejobs:defghayl  uniquejobs:poilkij
-        EOS
-      end
-      specify do
-        expect(output).to eq(expected)
-      end
-    end
-  end
-
-  describe '.del' do
-    let(:expected) do
-      <<~EOS
-        Deleted 1 keys matching '*'
-      EOS
-    end
-
-    before do
-      SidekiqUniqueJobs::Scripts::AcquireLock.execute(nil, unique_key, jid, max_lock_time)
-      expect(SidekiqUniqueJobs)
-        .to have_key(unique_key)
-        .for_seconds(1)
-        .with_value(jid)
-    end
-
-    specify do
-      output = capture(:stdout) { described_class.start(%w[del * --no-dry-run --count 1000]) }
-      expect(output).to eq(expected)
-      expect(SidekiqUniqueJobs).not_to have_key(unique_key)
-    end
-  end
-
-  describe '.expire' do
-    before do
-      SidekiqUniqueJobs::Scripts::AcquireLock.execute(nil, unique_key, jid, max_lock_time)
-      expect(SidekiqUniqueJobs)
-        .to have_key(unique_key)
-        .for_seconds(1)
-        .with_value(jid)
-    end
-    let(:expected) do
-      <<~EOS
-        Removed 1 left overs from redis.
-        uniquejobs:abcdefab
-      EOS
-    end
-
-    specify do
-      sleep 1
-      output = capture(:stdout) { described_class.start(%w[expire]) }
-      expect(output).to eq(expected)
-    end
-  end
-
-  describe '.console' do
-    let(:expected) do
-      <<~EOS
-        Use `keys '*', 1000 to display the first 1000 unique keys matching '*'
-        Use `del '*', 1000, true (default) to see how many keys would be deleted for the pattern '*'
-        Use `del '*', 1000, false to delete the first 1000 keys matching '*'
-      EOS
-    end
-    let(:output) { capture(:stdout) { described_class.start(%w[console]) } }
-
-    specify do
-      expect(Object).to receive(:include).with(SidekiqUniqueJobs::Util).and_return(true)
-      console = double(:console)
-      allow_any_instance_of(SidekiqUniqueJobs::Cli).to receive(:console_class).and_return(console)
-      allow(console).to receive(:start)
-      expect(output).to eq(expected)
-    end
-  end
-end

data/spec/lib/sidekiq_unique_jobs/client/middleware_spec.rb

@@ -1,316 +0,0 @@
-require 'spec_helper'
-require 'sidekiq/worker'
-require 'sidekiq-unique-jobs'
-require 'rspec/wait'
-
-RSpec.describe SidekiqUniqueJobs::Client::Middleware do
-  def digest_for(item)
-    SidekiqUniqueJobs::UniqueArgs.digest(item)
-  end
-
-  describe 'with real redis' do
-    describe 'when a job is already scheduled' do
-      it 'processes jobs properly' do
-        Sidekiq::Testing.disable! do
-          jid = NotifyWorker.perform_in(1, 183, 'xxxx')
-          expect(jid).not_to eq(nil)
-          Sidekiq.redis do |c|
-            expect(c.zcard('schedule')).to eq(1)
-            expected = %w[schedule uniquejobs:6e47d668ad22db2a3ba0afd331514ce2 uniquejobs]
-            expect(c.keys).to match_array(expected)
-          end
-          sleep 1
-          Sidekiq::Scheduled::Enq.new.enqueue_jobs
-
-          Sidekiq.redis do |c|
-            wait(10).for { c.llen('queue:notify_worker') }.to eq(1)
-          end
-
-          Sidekiq::Simulator.process_queue(:notify_worker) do
-            Sidekiq.redis do |c|
-              wait(10).for { c.llen('queue:notify_worker') }.to eq(0)
-            end
-          end
-        end
-      end
-
-      it 'rejects nested subsequent jobs with the same arguments' do
-        Sidekiq::Testing.disable! do
-          expect(SimpleWorker.perform_async(1)).not_to eq(nil)
-          expect(SimpleWorker.perform_async(1)).to eq(nil)
-          expect(SpawnSimpleWorker.perform_async(1)).not_to eq(nil)
-
-          Sidekiq.redis do |c|
-            expect(c.llen('queue:default')).to eq(1)
-            expect(c.llen('queue:not_default')).to eq(1)
-          end
-
-          Sidekiq::Simulator.process_queue(:not_default) do
-            Sidekiq.redis do |c|
-              expect(c.llen('queue:default')).to eq(1)
-              wait(10).for { c.llen('queue:not_default') }.to eq(0)
-              expect(c.llen('queue:default')).to eq(1)
-            end
-          end
-
-          Sidekiq.redis do |c|
-            expect(c.llen('queue:default')).to eq(1)
-          end
-
-          Sidekiq::Simulator.process_queue(:default) do
-            Sidekiq.redis do |c|
-              expect(c.llen('queue:not_default')).to eq(0)
-              wait(10).for { c.llen('queue:default') }.to eq(0)
-            end
-          end
-        end
-      end
-
-      it 'rejects new scheduled jobs with the same argument' do
-        MyUniqueJob.perform_in(3600, 1)
-        expect(MyUniqueJob.perform_in(3600, 1)).to eq(nil)
-      end
-
-      it 'will run a job in real time with the same arguments' do
-        WhileExecutingJob.perform_in(3600, 1)
-        expect(WhileExecutingJob.perform_async(1)).not_to eq(nil)
-      end
-
-      it 'schedules new jobs when arguments differ' do
-        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20].each do |x|
-          MainJob.perform_in(x, x)
-        end
-
-        Sidekiq.redis do |c|
-          count = c.zcount('schedule', -1, Time.now.to_f + 2 * 60)
-          expect(count).to eq(20)
-        end
-      end
-
-      it 'schedules allows jobs to be scheduled ' do
-        class ShitClass
-          def do_it(_arg)
-            # whatever
-          end
-        end
-
-        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20].each do |x|
-          ShitClass.delay_for(x, unique: :while_executing).do_it(1)
-        end
-
-        Sidekiq.redis do |c|
-          count = c.zcount('schedule', -1, Time.now.to_f + 2 * 60)
-          expect(count).to eq(20)
-        end
-      end
-    end
-
-    it 'does not push duplicate messages when configured for unique only' do
-      10.times { MyUniqueJob.perform_async(1, 2) }
-      Sidekiq.redis do |c|
-        expect(c.llen('queue:customqueue')).to eq(1)
-      end
-    end
-
-    it 'does not push duplicate messages when unique_args are filtered with a proc' do
-      10.times { MyUniqueJobWithFilterProc.perform_async(1) }
-      Sidekiq.redis { |c| expect(c.llen('queue:customqueue')).to eq(1) }
-
-      Sidekiq.redis(&:flushdb)
-      Sidekiq.redis { |c| expect(c.llen('queue:customqueue')).to eq(0) }
-
-      10.times do
-        Sidekiq::Client.push(
-          'class' => MyUniqueJobWithFilterProc,
-          'queue' => 'customqueue',
-          'args' => [1, type: 'value', some: 'not used'],
-        )
-      end
-      Sidekiq.redis { |c| expect(c.llen('queue:customqueue')).to eq(1) }
-    end
-
-    it 'does not push duplicate messages when unique_args are filtered with a method' do
-      10.times { MyUniqueJobWithFilterMethod.perform_async(1) }
-      Sidekiq.redis do |c|
-        expect(c.llen('queue:customqueue')).to eq(1)
-      end
-      Sidekiq.redis(&:flushdb)
-      Sidekiq.redis { |c| expect(c.llen('queue:customqueue')).to eq(0) }
-      10.times do
-        Sidekiq::Client.push(
-          'class' => MyUniqueJobWithFilterMethod,
-          'queue' => 'customqueue',
-          'args' => [1, type: 'value', some: 'not used'],
-        )
-      end
-      Sidekiq.redis { |c| expect(c.llen('queue:customqueue')).to eq(1) }
-    end
-
-    it 'does push duplicate messages to different queues' do
-      Sidekiq::Client.push('class' => MyUniqueJob, 'queue' => 'customqueue', 'args' => [1, 2])
-      Sidekiq::Client.push('class' => MyUniqueJob, 'queue' => 'customqueue2', 'args' => [1, 2])
-      Sidekiq.redis do |c|
-        expect(c.llen('queue:customqueue')).to eq 1
-        expect(c.llen('queue:customqueue2')).to eq 1
-      end
-    end
-
-    it 'does not queue duplicates when when calling delay' do
-      10.times { PlainClass.delay(unique: :until_executed, queue: 'customqueue').run(1) }
-      Sidekiq.redis do |c|
-        expect(c.llen('queue:customqueue')).to eq(1)
-      end
-    end
-
-    it 'does not schedule duplicates when calling perform_in' do
-      10.times { MyUniqueJob.perform_in(60, [1, 2]) }
-      Sidekiq.redis do |c|
-        expect(c.zcount('schedule', -1, Time.now.to_f + 2 * 60))
-          .to eq(1)
-      end
-    end
-
-    it 'enqueues previously scheduled job' do
-      jid = WhileExecutingJob.perform_in(60 * 60, 1, 2)
-      item = { 'class' => WhileExecutingJob, 'queue' => 'customqueue', 'args' => [1, 2], 'jid' => jid }
-
-      # time passes and the job is pulled off the schedule:
-      Sidekiq::Client.push(item)
-
-      Sidekiq.redis do |c|
-        expect(c.llen('queue:customqueue')).to eq 1
-      end
-    end
-
-    it 'sets an expiration when provided by sidekiq options' do
-      item = { 'class' => ExpiringJob, 'queue' => 'customqueue', 'args' => [1, 2] }
-      Sidekiq::Client.push(item)
-
-      Sidekiq.redis do |c|
-        expect(c.llen('queue:customqueue')).to eq(1)
-        expect(c.ttl(digest_for(item)))
-          .to eq(ExpiringJob.get_sidekiq_options['unique_expiration'])
-      end
-    end
-
-    it 'does push duplicate messages when not configured for unique only' do
-      10.times do
-        Sidekiq::Client.push('class' => CustomQueueJob, 'queue' => 'customqueue', 'args' => [1, 2])
-      end
-
-      Sidekiq.redis do |c|
-        expect(c.llen('queue:customqueue')).to eq(10)
-      end
-    end
-
-    describe 'when unique_args is defined' do
-      it 'does not push duplicate messages based on args filter method' do
-        expect(CustomQueueJobWithFilterMethod).to respond_to(:args_filter)
-        expect(CustomQueueJobWithFilterMethod.get_sidekiq_options['unique_args']).to eq :args_filter
-
-        (0..10).each do |i|
-          Sidekiq::Client.push(
-            'class' => CustomQueueJobWithFilterMethod,
-            'queue' => 'customqueue',
-            'args' => [1, i],
-          )
-        end
-
-        Sidekiq.redis do |c|
-          expect(c.llen('queue:customqueue')).to eq(1)
-        end
-      end
-
-      it 'does not push duplicate messages based on args filter proc' do
-        expect(CustomQueueJobWithFilterProc.get_sidekiq_options['unique_args']).to be_a(Proc)
-
-        100.times do
-          Sidekiq::Client.push(
-            'class' => CustomQueueJobWithFilterProc,
-            'queue' => 'customqueue',
-            'args' => [1, { random: rand, name: 'foobar' }],
-          )
-        end
-
-        Sidekiq.redis do |c|
-          expect(c.llen('queue:customqueue')).to eq(1)
-        end
-      end
-
-      describe 'when unique_on_all_queues is set' do
-        it 'does not push duplicate messages on different queues' do
-          item = { 'class' => UniqueOnAllQueuesJob, 'args' => [1, 2] }
-          Sidekiq::Client.push(item.merge('queue' => 'customqueue'))
-          Sidekiq::Client.push(item.merge('queue' => 'customqueue2'))
-          Sidekiq.redis do |c|
-            expect(c.llen('queue:customqueue')).to eq(1)
-            expect(c.llen('queue:customqueue2')).to eq(0)
-          end
-        end
-      end
-    end
-
-    # TODO: If anyone know of a better way to check that the expiration for scheduled
-    # jobs are set around the same time as the scheduled job itself feel free to improve.
-    it 'expires the digest when a scheduled job is scheduled at' do
-      expected_expires_at =
-        (Time.at(Time.now.to_i + 15 * 60) - Time.now.utc) +
-        SidekiqUniqueJobs.config.default_queue_lock_expiration
-      jid = MyUniqueJob.perform_in(expected_expires_at, 'mike')
-      item = { 'class' => MyUniqueJob,
-               'queue' => 'customqueue',
-               'args' => ['mike'],
-               'at' => expected_expires_at }
-      digest = digest_for(item.merge('jid' => jid))
-      Sidekiq.redis do |c|
-        expect(c.ttl(digest)).to eq(9_899)
-      end
-    end
-
-    it 'logs duplicate payload when config turned on' do
-      expect(Sidekiq.logger).to receive(:warn).with(/^payload is not unique/)
-      UntilExecutedJob.sidekiq_options log_duplicate_payload: true
-      2.times do
-        Sidekiq::Client.push('class' => UntilExecutedJob, 'queue' => 'customqueue', 'args' => [1, 2])
-      end
-      Sidekiq.redis do |c|
-        expect(c.llen('queue:customqueue')).to eq 1
-      end
-      UntilExecutedJob.sidekiq_options log_duplicate_payload: true
-    end
-
-    it 'does not log duplicate payload when config turned off' do
-      expect(SidekiqUniqueJobs.logger).to_not receive(:warn).with(/^payload is not unique/)
-
-      UntilExecutedJob.sidekiq_options log_duplicate_payload: false
-
-      2.times do
-        Sidekiq::Client.push('class' => UntilExecutedJob, 'queue' => 'customqueue', 'args' => [1, 2])
-      end
-      Sidekiq.redis do |c|
-        expect(c.llen('queue:customqueue')).to eq 1
-      end
-      UntilExecutedJob.sidekiq_options log_duplicate_payload: true
-    end
-  end
-
-  describe '#call' do
-    let(:worker_class) { SimpleWorker }
-    let(:item) do
-      { 'class' => SimpleWorker,
-        'queue' => 'default',
-        'args'  => [1] }
-    end
-    let(:queue) { 'default' }
-    context 'when ordinary_or_locked?' do
-      before do
-        allow(subject).to receive(:disabled_or_successfully_locked?).and_return(false)
-      end
-
-      it 'returns nil' do
-        expect(subject.call(worker_class, item, queue))
-          .to eq(nil)
-      end
-    end
-  end
-end