sidekiq-unique-jobs 5.0.2 → 5.0.11

data/spec/lib/sidekiq_unique_jobs/config_spec.rb

@@ -1,84 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SidekiqUniqueJobs::Config do
-  let(:args) do
-    {
-
-      unique_prefix: 'unique',
-      default_queue_lock_expiration: 30 * 60,
-      default_run_lock_expiration: 60,
-      default_lock: :while_executing,
-      redis_test_mode: :redis,
-    }
-  end
-
-  subject do
-    described_class.new(args)
-  end
-
-  describe '#testing_enabled?' do
-    context 'when Sidekiq::Testing is undefined' do
-      before { hide_const('Sidekiq::Testing') }
-      its(:testing_enabled?) do
-        is_expected.to eq(false)
-      end
-    end
-
-    context 'when Sidekiq::Testing is defined' do
-      context 'and Sidekiq::Testing.enabled? is false' do
-        before { allow(Sidekiq::Testing).to receive(:enabled?).and_return(false) }
-        its(:testing_enabled?) do
-          is_expected.to eq(false)
-        end
-      end
-
-      context 'and Sidekiq::Testing.enabled? is true' do
-        before { allow(Sidekiq::Testing).to receive(:enabled?).and_return(true) }
-        its(:testing_enabled?) do
-          is_expected.to eq(true)
-        end
-      end
-    end
-  end
-
-  describe '#inline_testing_enabled?' do
-    context 'when testing_enabled? is false' do
-      before { allow(subject).to receive(:testing_enabled?).and_return(false) }
-      its(:inline_testing_enabled?) do
-        is_expected.to eq(false)
-      end
-    end
-    context 'when testing_enabled? is true' do
-      before { allow(subject).to receive(:testing_enabled?).and_return(true) }
-
-      context 'and Sidekiq::Testing.inline? is false' do
-        before { allow(Sidekiq::Testing).to receive(:inline?).and_return(false) }
-        its(:inline_testing_enabled?) do
-          is_expected.to eq(false)
-        end
-      end
-
-      context 'and Sidekiq::Testing.inline? is true' do
-        before { allow(Sidekiq::Testing).to receive(:inline?).and_return(true) }
-        its(:inline_testing_enabled?) do
-          is_expected.to eq(true)
-        end
-      end
-    end
-  end
-
-  describe '#mocking?' do
-    context 'when redis_test_mode is :redis' do
-      its(:mocking?) do
-        is_expected.to eq(false)
-      end
-    end
-
-    context 'when redis_test_mode is :mock' do
-      subject { described_class.new(args.merge(redis_test_mode: :mock)) }
-      its(:mocking?) do
-        is_expected.to eq(true)
-      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,42 +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
-      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.1
-          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

data/spec/lib/sidekiq_unique_jobs/queue_lock_timeout_calculator_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SidekiqUniqueJobs::QueueLockTimeoutCalculator do
-  shared_context 'generic unscheduled job' do
-    subject { described_class.new('class' => 'JustAWorker') }
-  end
-
-  describe 'public api' do
-    it_behaves_like 'generic unscheduled job' do
-      it { is_expected.to respond_to(:seconds) }
-      it { is_expected.to respond_to(:queue_lock_expiration) }
-    end
-  end
-
-  describe '.for_item' do
-    it 'initializes a new calculator' do
-      expect(described_class).to receive(:new).with('WAT')
-      described_class.for_item('WAT')
-    end
-  end
-
-  describe '#seconds' do
-    subject { described_class.new(nil) }
-
-    before do
-      allow(subject).to receive(:time_until_scheduled).and_return(10)
-      allow(subject).to receive(:queue_lock_expiration).and_return(9)
-    end
-    its(:seconds) { is_expected.to eq(19) }
-  end
-
-  describe '#queue_lock_expiration' do
-    context 'using default unique_expiration' do
-      subject { described_class.new(nil) }
-      before { allow(subject).to receive(:worker_class_queue_lock_expiration).and_return(nil) }
-
-      its(:queue_lock_expiration) { is_expected.to eq(1_800) }
-    end
-
-    context 'using specified sidekiq option unique_expiration' do
-      subject { described_class.new(nil) }
-      before { allow(subject).to receive(:worker_class_queue_lock_expiration).and_return(9) }
-
-      its(:queue_lock_expiration) { is_expected.to eq(9) }
-    end
-  end
-end

data/spec/lib/sidekiq_unique_jobs/run_lock_timeout_calculator_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SidekiqUniqueJobs::RunLockTimeoutCalculator do
-  shared_context 'generic unscheduled job' do
-    subject { described_class.new('class' => 'JustAWorker') }
-  end
-
-  describe 'public api' do
-    it_behaves_like 'generic unscheduled job' do
-      it { is_expected.to respond_to(:seconds) }
-    end
-  end
-
-  describe '.for_item' do
-    it 'initializes a new calculator' do
-      expect(described_class).to receive(:new).with('WAT')
-      described_class.for_item('WAT')
-    end
-  end
-
-  describe '#seconds' do
-    context 'using default run_lock_expiration' do
-      subject { described_class.new(nil) }
-      before { allow(subject).to receive(:worker_class_run_lock_expiration).and_return(9) }
-
-      its(:seconds) { is_expected.to eq(9) }
-    end
-
-    context 'using specified sidekiq option run_lock_expiration' do
-      subject { described_class.new(nil) }
-      before { allow(subject).to receive(:worker_class_run_lock_expiration).and_return(nil) }
-
-      its(:seconds) { is_expected.to eq(60) }
-    end
-  end
-end

data/spec/lib/sidekiq_unique_jobs/script_mock_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-
-begin
-  require 'mock_redis'
-  MOCK_REDIS ||= MockRedis.new
-rescue LoadError # rubocop:disable Lint/HandleExceptions
-  # This is a known issue (we only run this spec for ruby 2.4.1)
-end
-
-RSpec.describe SidekiqUniqueJobs::ScriptMock, ruby_ver: '>= 2.4.1' do
-  MD5_DIGEST ||= 'unique'.freeze
-  UNIQUE_KEY ||= 'uniquejobs:unique'.freeze
-  JID ||= 'fuckit'.freeze
-  ANOTHER_JID ||= 'anotherjid'.freeze
-
-  before do
-    SidekiqUniqueJobs.configure do |config|
-      config.redis_test_mode = :mock
-    end
-    Sidekiq::Worker.clear_all
-
-    keys = MOCK_REDIS.keys
-    if keys.respond_to?(:each)
-      keys.each do |key|
-        MOCK_REDIS.del(key)
-      end
-    else
-      MOCK_REDIS.del(keys)
-    end
-
-    allow(Sidekiq).to receive(:redis).and_yield(MOCK_REDIS)
-  end
-
-  after do
-    SidekiqUniqueJobs.configure do |config|
-      config.redis_test_mode = :redis
-    end
-  end
-
-  subject { SidekiqUniqueJobs::Scripts }
-
-  def lock_for(seconds = 1, jid = JID, key = UNIQUE_KEY)
-    subject.call(:acquire_lock, nil, keys: [key], argv: [jid, seconds])
-  end
-
-  def unlock(key = UNIQUE_KEY, jid = JID)
-    subject.call(:release_lock, nil, keys: [key], argv: [jid])
-  end
-
-  describe '.acquire_lock' do
-    context 'when job is unique' do
-      specify { expect(lock_for).to eq(1) }
-      specify do
-        expect(lock_for(1)).to eq(1)
-        expect(SidekiqUniqueJobs)
-          .to have_key(UNIQUE_KEY)
-          .for_seconds(1)
-          .with_value('fuckit')
-        sleep 1
-        expect(lock_for).to eq(1)
-      end
-
-      context 'when job is locked' do
-        before  { expect(lock_for(10)).to eq(1) }
-        specify { expect(lock_for(5, ANOTHER_JID)).to eq(0) }
-      end
-    end
-
-    describe '.release_lock' do
-      context 'when job is locked by another jid' do
-        before  { expect(lock_for(10, ANOTHER_JID)).to eq(1) }
-        specify { expect(unlock).to eq(0) }
-        after { unlock(UNIQUE_KEY, ANOTHER_JID) }
-      end
-
-      context 'when job is not locked at all' do
-        specify { expect(unlock).to eq(-1) }
-      end
-
-      context 'when job is locked by the same jid' do
-        specify do
-          expect(lock_for(10)).to eq(1)
-          expect(unlock).to eq(1)
-        end
-      end
-    end
-  end
-end

data/spec/lib/sidekiq_unique_jobs/scripts/acquire_lock_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SidekiqUniqueJobs::Scripts::AcquireLock do
-  let(:redis_pool) { nil }
-  let(:jid) { 'abcdefab' }
-  let(:unique_key) { 'uniquejobs:123asdasd2134' }
-  let(:max_lock_time) { 1 }
-
-  describe '.execute' do
-    subject { instance_double(described_class) }
-
-    it 'delegates to instance' do
-      expect(described_class).to receive(:new)
-        .with(redis_pool, unique_key, jid, max_lock_time)
-        .and_return(subject)
-      expect(subject).to receive(:execute).and_return(true)
-
-      described_class.execute(redis_pool, unique_key, jid, max_lock_time)
-    end
-  end
-
-  describe '#execute' do
-    context 'when job is unique' do
-      def execute(myjid = jid, key = unique_key, max_lock = max_lock_time)
-        described_class.execute(
-          redis_pool,
-          key,
-          myjid,
-          max_lock,
-        )
-      end
-
-      specify { expect(execute(jid, unique_key, max_lock_time)).to eq(true) }
-      specify do
-        expect(execute(jid, unique_key, max_lock_time)).to eq(true)
-        expect(SidekiqUniqueJobs)
-          .to have_key(unique_key)
-          .for_seconds(max_lock_time)
-          .with_value('abcdefab')
-        sleep 0.5
-        expect(execute).to eq(true)
-      end
-
-      context 'when a unique_key exists for another jid' do
-        before  { expect(execute(jid, unique_key, 10)).to eq(true) }
-        specify { expect(execute('anotherjid', unique_key, 5)).to eq(false) }
-      end
-    end
-  end
-end