sidekiq-unique-jobs 4.0.18 → 7.1.28

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

@@ -1,321 +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
-    before do
-      Sidekiq.redis = REDIS
-      Sidekiq.redis(&:flushdb)
-    end
-
-    describe 'when a job is already scheduled' do
-      it 'processes jobs properly', sidekiq_ver: '>= 4.0.0' 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', sidekiq_ver: '>= 3.5.3' 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(Sidekiq.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

data/spec/lib/sidekiq_unique_jobs/core_ext_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Hash do
-  subject { { test: :me, not: :me } }
-
-  describe '#slice' do
-    specify { expect(subject.slice(:test)).to eq(test: :me) }
-  end
-
-  describe '#slice!' do
-    specify { expect { subject.slice!(:test) }.to change { subject }.to(test: :me) }
-  end
-end
-
-RSpec.describe String do
-  describe '#classify' do
-    subject { 'under_scored_string' }
-    its(:classify) { is_expected.to eq('UnderScoredString') }
-  end
-
-  describe '#camelize' do
-    subject { 'under_scored_string' }
-    its(:camelize) { is_expected.to eq('UnderScoredString') }
-  end
-end

data/spec/lib/sidekiq_unique_jobs/lock/until_and_while_executing_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SidekiqUniqueJobs::Lock::UntilAndWhileExecuting do
-  let(:item) do
-    {
-      'jid' => 'maaaahjid',
-      'queue' => 'dupsallowed',
-      'class' => 'UntilAndWhileExecuting',
-      'unique' => 'until_executed',
-      'args' => [1]
-    }
-  end
-  let(:callback) { -> {} }
-  subject { described_class.new(item) }
-  describe '#execute' do
-    before do
-      Sidekiq.redis(&:flushdb)
-      Sidekiq::Worker.clear_all
-      subject.lock(:client)
-    end
-    let(:runtime_lock) { SidekiqUniqueJobs::Lock::WhileExecuting.new(item, nil) }
-
-    it 'unlocks the unique key before yielding' do
-      expect(SidekiqUniqueJobs::Lock::WhileExecuting)
-        .to receive(:new).with(item, nil)
-        .and_return(runtime_lock)
-
-      expect(callback).to receive(:call)
-
-      subject.execute(callback) do
-        Sidekiq.redis do |c|
-          expect(c.keys('uniquejobs:*').size).to eq(1)
-        end
-
-        10.times { Sidekiq::Client.push(item) }
-
-        Sidekiq.redis do |c|
-          expect(c.keys('uniquejobs:*').size).to eq(2)
-        end
-      end
-    end
-  end
-end

data/spec/lib/sidekiq_unique_jobs/lock/until_executed_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SidekiqUniqueJobs::Lock::UntilExecuted do
-  describe '#execute' do
-    subject { described_class.new(item) }
-    let(:item) do
-      { 'jid' => 'maaaahjid', 'class' => 'UntilExecutedJob', 'unique' => 'until_executed' }
-    end
-    let(:empty_callback) { -> {} }
-
-    def execute
-      subject.execute(empty_callback)
-    end
-
-    context 'when yield fails with Sidekiq::Shutdown' do
-      before do
-        allow(subject).to receive(:after_yield_yield) { raise Sidekiq::Shutdown }
-        allow(subject).to receive(:unlock).and_return(true)
-        expect(subject).not_to receive(:unlock)
-        expect(subject.logger).to receive(:fatal)
-        expect(empty_callback).not_to receive(:call)
-      end
-
-      specify { expect { subject.execute(empty_callback) }.to raise_error(Sidekiq::Shutdown) }
-    end
-
-    context 'when yield fails with other errors' do
-      before do
-        allow(subject).to receive(:after_yield_yield) { raise 'Hell' }
-        expect(subject).to receive(:unlock).and_return(true)
-        expect(empty_callback).to receive(:call)
-      end
-
-      specify { expect { subject.execute(empty_callback) }.to raise_error('Hell') }
-    end
-  end
-end

data/spec/lib/sidekiq_unique_jobs/lock/until_timeout_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SidekiqUniqueJobs::Lock::UntilTimeout do
-  subject { described_class.new(item) }
-  let(:item) do
-    { 'jid' => 'maaaahjid',
-      'class' => 'UntilExecutedJob',
-      'unique' => 'until_timeout' }
-  end
-  let(:empty_callback) { -> {} }
-
-  describe '#unlock' do
-    context 'when provided :server' do
-      it 'returns true' do
-        expect(subject.unlock(:server)).to eq(true)
-      end
-    end
-
-    context 'when provided with anything else than :server' do
-      it 'raises a helpful error message' do
-        expect { subject.unlock(:client) }
-          .to raise_error(ArgumentError, /client middleware can't unlock uniquejobs:*/)
-      end
-    end
-  end
-end

data/spec/lib/sidekiq_unique_jobs/lock/while_executing_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SidekiqUniqueJobs::Lock::WhileExecuting do
-  let(:item) do
-    {
-      'jid' => 'maaaahjid',
-      'queue' => 'dupsallowed',
-      'class' => 'UntilAndWhileExecuting',
-      'unique' => 'until_executed',
-      'unique_digest' => 'test_mutex_key',
-      'args' => [1]
-    }
-  end
-
-  it 'allows only one mutex object to have the lock at a time' do
-    mutexes = (1..10).map do
-      described_class.new(item)
-    end
-
-    x = 0
-    mutexes.map do |m|
-      Thread.new do
-        m.synchronize do
-          y = x
-          sleep 0.001
-          x = y + 1
-        end
-      end
-    end.map(&:join)
-
-    expect(x).to eq(10)
-  end
-
-  it 'expires the lock on the mutex object after run_lock_expiration if specified' do
-    mutexes = (1..10).map do
-      described_class.new(item)
-    end
-
-    worker = SidekiqUniqueJobs.worker_class_constantize(item[SidekiqUniqueJobs::CLASS_KEY])
-    allow(worker).to receive(:get_sidekiq_options)
-      .and_return('retry'               => true,
-                  'queue'               => :dupsallowed,
-                  'run_lock_expiration' => 0,
-                  'unique'              => :until_and_while_executing)
-
-    start_times = []
-    sleep_time = 0.1
-    mutexes.each_with_index.map do |m, i|
-      Thread.new do
-        m.synchronize do
-          start_times[i] = Time.now
-          sleep sleep_time
-        end
-      end
-    end.map(&:join)
-
-    expect(start_times.size).to be 10
-    expect(start_times.sort.last - start_times.sort.first).to be < sleep_time * 10
-  end
-
-  it 'handles auto cleanup correctly' do
-    m = described_class.new(item)
-
-    SidekiqUniqueJobs.connection do |conn|
-      conn.set 'test_mutex_key:run', Time.now.to_i - 1, nx: true
-    end
-
-    start = Time.now.to_i
-    m.synchronize do
-      'nop'
-    end
-
-    # no longer than a second
-    expect(Time.now.to_i).to be <= start + 1
-  end
-
-  it 'maintains mutex semantics' do
-    m = described_class.new(item)
-
-    expect do
-      m.synchronize do
-        m.synchronize {}
-      end
-    end.to raise_error(ThreadError)
-  end
-end

data/spec/lib/sidekiq_unique_jobs/normalizer_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SidekiqUniqueJobs::Normalizer do
-  def jsonify(args)
-    described_class.jsonify(args)
-  end
-
-  describe '.jsonify' do
-    specify do
-      original = [1, :test, [test: :test]]
-      expected = [1, 'test', ['test' => 'test']]
-      expect(jsonify(original)).to eq(expected)
-    end
-
-    specify do
-      original = [1, :test, [test: [test: :test]]]
-      expected = [1, 'test', ['test' => ['test' => 'test']]]
-      expect(jsonify(original)).to eq(expected)
-    end
-  end
-end

data/spec/lib/sidekiq_unique_jobs/options_with_fallback_spec.rb

@@ -1,113 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SidekiqUniqueJobs::OptionsWithFallback do
-  include described_class
-  subject { self }
-
-  describe '#unique_lock' do
-    context 'when options have `unique: true`' do
-      let(:options) { { 'unique' => true } }
-
-      it 'warns when unique is set to true' do
-        expect(subject)
-          .to receive(:warn)
-          .with(
-            'unique: true is no longer valid. Please set it to the type of lock required like: ' \
-            '`unique: :until_executed`'
-          )
-
-        subject.unique_lock
-      end
-    end
-
-    context 'when options have `unique: :while_executing`' do
-      let(:options) { { 'unique' => 'while_executing' } }
-    end
-  end
-
-  describe '#unique_enabled?' do
-    let(:options) { {} }
-    let(:item) { {} }
-    its(:unique_enabled?) { is_expected.to eq(nil) }
-
-    context 'when options["unique"] is present' do
-      let(:options) { { 'unique' => 'while_executing' } }
-      let(:item) { { 'unique' => 'until_executed' } }
-      its(:unique_enabled?) { is_expected.to eq('while_executing') }
-    end
-
-    context 'when item["unique"] is present' do
-      let(:options) { {} }
-      let(:item) { { 'unique' => 'until_executed' } }
-      its(:unique_enabled?) { is_expected.to eq('until_executed') }
-
-      context 'when true' do
-        let(:options) { {} }
-        let(:item) { { 'unique' => true } }
-        its(:unique_enabled?) { is_expected.to eq(true) }
-      end
-    end
-  end
-
-  describe '#unique_disabled?' do
-    let(:options) { {} }
-    let(:item) { {} }
-    its(:unique_disabled?) { is_expected.to be_truthy }
-
-    context 'when options["unique"] is present' do
-      let(:options) { { 'unique' => 'while_executing' } }
-      let(:item) { { 'unique' => 'until_executed' } }
-      its(:unique_disabled?) { is_expected.to be_falsey }
-    end
-
-    context 'when item["unique"] is present' do
-      let(:options) { {} }
-      let(:item) { { 'unique' => 'until_executed' } }
-      its(:unique_disabled?) { is_expected.to be_falsey }
-    end
-  end
-
-  describe '#lock_type' do
-    context 'when options["unique"] is while_executing' do
-      let(:options) { { 'unique' => 'while_executing' } }
-      let(:item) { { 'unique' => 'until_executed' } }
-      its(:lock_type) { is_expected.to eq('while_executing') }
-    end
-
-    context 'when options["unique"] is true' do
-      let(:options) { { 'unique' => true } }
-      let(:item) { { 'unique' => 'until_executed' } }
-      its(:lock_type) { is_expected.to eq('until_executed') }
-    end
-
-    context 'when item["unique"] is until_executed' do
-      let(:options) { {} }
-      let(:item) { { 'unique' => 'until_executed' } }
-      its(:lock_type) { is_expected.to eq('until_executed') }
-    end
-
-    context 'when item["unique"] is true' do
-      let(:options) { { 'unique' => true } }
-      let(:item) { { 'unique' => true } }
-      its(:lock_type) { is_expected.to eq(nil) }
-    end
-  end
-
-  describe '#options' do
-    context 'when worker_class respond_to get_sidekiq_options' do
-      let(:worker_class) { SimpleWorker }
-      its(:options) { is_expected.to eq(SimpleWorker.get_sidekiq_options) }
-    end
-
-    context 'when default_worker_options has been configured' do
-      let(:worker_class) { PlainClass }
-      before do
-        allow(Sidekiq)
-          .to receive(:default_worker_options)
-          .and_return('unique' => 'while_executing')
-      end
-
-      its(:options) { is_expected.to eq(Sidekiq.default_worker_options) }
-    end
-  end
-end