sidekiq-unique-jobs 5.0.2 → 5.0.4

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

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

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SidekiqUniqueJobs::Scripts::ReleaseLock 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)
-        .and_return(subject)
-      expect(subject).to receive(:execute).and_return(true)
-
-      described_class.execute(redis_pool, unique_key, jid)
-    end
-  end
-
-  describe '#execute' do
-    context 'when exists' do
-      subject { described_class.execute(redis_pool, unique_key, jid) }
-
-      before do
-        SidekiqUniqueJobs::Scripts::AcquireLock.execute(redis_pool, unique_key, jid, max_lock_time)
-      end
-
-      specify do
-        expect(SidekiqUniqueJobs)
-          .to have_key(unique_key)
-          .for_seconds(max_lock_time)
-          .with_value(jid)
-
-        expect(subject).to eq(true)
-        expect(SidekiqUniqueJobs).not_to have_key(unique_key)
-      end
-    end
-  end
-end

data/spec/lib/sidekiq_unique_jobs/scripts_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-RSpec.describe SidekiqUniqueJobs::Scripts do
-  MD5_DIGEST ||= 'unique'.freeze
-  UNIQUE_KEY ||= 'uniquejobs:unique'.freeze
-  JID ||= 'fuckit'.freeze
-  ANOTHER_JID ||= 'anotherjid'.freeze
-
-  context 'class methods' do
-    subject { SidekiqUniqueJobs::Scripts }
-
-    it { is_expected.to respond_to(:call).with(3).arguments }
-    it { is_expected.to respond_to(:logger) }
-    it { is_expected.to respond_to(:connection).with(1).arguments }
-    it { is_expected.to respond_to(:script_source).with(1).arguments }
-    it { is_expected.to respond_to(:script_path).with(1).arguments }
-
-    describe '.logger' do
-      its(:logger) { is_expected.to eq(Sidekiq.logger) }
-    end
-
-    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(2)).to eq(1)
-          expect(SidekiqUniqueJobs)
-            .to have_key(UNIQUE_KEY)
-            .for_seconds(1)
-            .with_value(JID)
-          sleep 2
-          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, 'anotherjid')).to eq(0) }
-        end
-      end
-    end
-
-    describe '.release_lock' do
-      context 'when job is locked by another jid' do
-        before  { expect(lock_for(10, 'anotherjid')).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/server/middleware_spec.rb

@@ -1,78 +0,0 @@
-require 'spec_helper'
-require 'sidekiq/api'
-require 'sidekiq/cli'
-require 'sidekiq/worker'
-require 'sidekiq_unique_jobs/server/middleware'
-
-RSpec.describe SidekiqUniqueJobs::Server::Middleware do
-  QUEUE ||= 'working'.freeze
-
-  def digest_for(item)
-    SidekiqUniqueJobs::UniqueArgs.digest(item)
-  end
-
-  describe '#call' do
-    context 'when unique is disabled' do
-      it 'does not use locking' do
-        allow(subject).to receive(:unique_enabled?).and_return(false)
-        expect(subject).not_to receive(:lock)
-        args = [WhileExecutingJob, { 'class' => 'WhileExecutingJob' }, 'working', nil]
-        subject.call(*args) {}
-      end
-    end
-
-    context 'when unique is enabled' do
-      it 'executes the lock' do
-        allow(subject).to receive(:unique_enabled?).and_return(true)
-        lock = instance_spy(SidekiqUniqueJobs::Lock::WhileExecuting)
-        expect(lock).to receive(:send).with(:execute, instance_of(Proc)).and_yield
-        expect(subject).to receive(:lock).and_return(lock)
-
-        args = [WhileExecutingJob, { 'class' => 'WhileExecutingJob' }, 'working', nil]
-        subject.call(*args) {}
-      end
-    end
-
-    describe '#unlock' do
-      it 'does not unlock mutexes it does not own' do
-        jid = UntilExecutedJob.perform_async
-        item = Sidekiq::Queue.new(QUEUE).find_job(jid).item
-        Sidekiq.redis do |c|
-          c.set(digest_for(item), 'NOT_DELETED')
-        end
-
-        subject.call(UntilExecutedJob.new, item, QUEUE) do
-          Sidekiq.redis do |c|
-            expect(c.get(digest_for(item))).to eq('NOT_DELETED')
-          end
-        end
-      end
-    end
-
-    describe ':before_yield' do
-      it 'removes the lock before yielding to the worker' do
-        jid = UntilExecutingJob.perform_async
-        item = Sidekiq::Queue.new(QUEUE).find_job(jid).item
-        worker = UntilExecutingJob.new
-        subject.call(worker, item, QUEUE) do
-          Sidekiq.redis do |c|
-            expect(c.ttl(digest_for(item))).to eq(-2) # key does not exist
-          end
-        end
-      end
-    end
-
-    describe ':after_yield' do
-      it 'removes the lock after yielding to the worker' do
-        jid = UntilExecutedJob.perform_async
-        item = Sidekiq::Queue.new(QUEUE).find_job(jid).item
-
-        subject.call('UntilExecutedJob', item, QUEUE) do
-          Sidekiq.redis do |c|
-            expect(c.get(digest_for(item))).to eq jid
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/sidekiq_unique_jobs/sidekiq_testing_enabled_spec.rb

@@ -1,164 +0,0 @@
-require 'spec_helper'
-require 'sidekiq/worker'
-require 'sidekiq-unique-jobs'
-require 'sidekiq/scheduled'
-
-RSpec.describe 'When Sidekiq::Testing is enabled' do
-  describe 'when set to :fake!', sidekiq: :fake do
-    context 'with unique worker' do
-      it 'does not push duplicate messages' do
-        param = 'work'
-        expect(UntilExecutedJob.jobs.size).to eq(0)
-        expect(UntilExecutedJob.perform_async(param)).to_not be_nil
-        expect(UntilExecutedJob.jobs.size).to eq(1)
-        expect(UntilExecutedJob.perform_async(param)).to be_nil
-        expect(UntilExecutedJob.jobs.size).to eq(1)
-      end
-
-      it 'unlocks jobs after draining a worker' do
-        param = 'work'
-        param2 = 'more work'
-
-        expect(UntilExecutedJob.jobs.size).to eq(0)
-        UntilExecutedJob.perform_async(param)
-        UntilExecutedJob.perform_async(param2)
-        expect(UntilExecutedJob.jobs.size).to eq(2)
-        UntilExecutedJob.drain
-        expect(UntilExecutedJob.jobs.size).to eq(0)
-        UntilExecutedJob.perform_async(param)
-        UntilExecutedJob.perform_async(param2)
-        expect(UntilExecutedJob.jobs.size).to eq(2)
-      end
-
-      it 'unlocks a single job when calling perform_one' do
-        param = 'work'
-        param2 = 'more work'
-        expect(UntilExecutedJob.jobs.size).to eq(0)
-        UntilExecutedJob.perform_async(param)
-        UntilExecutedJob.perform_async(param2)
-        expect(UntilExecutedJob.jobs.size).to eq(2)
-        UntilExecutedJob.perform_one
-        expect(UntilExecutedJob.jobs.size).to eq(1)
-        UntilExecutedJob.perform_async(param2)
-        expect(UntilExecutedJob.jobs.size).to eq(1)
-        UntilExecutedJob.perform_async(param)
-        expect(UntilExecutedJob.jobs.size).to eq(2)
-      end
-
-      it 'unlocks jobs cleared from a single worker' do
-        param = 'work'
-        param2 = 'more work'
-        expect(UntilExecutedJob.jobs.size).to eq(0)
-        expect(AnotherUniqueJob.jobs.size).to eq(0)
-        UntilExecutedJob.perform_async(param)
-        UntilExecutedJob.perform_async(param2)
-        AnotherUniqueJob.perform_async(param)
-        expect(UntilExecutedJob.jobs.size).to eq(2)
-        expect(AnotherUniqueJob.jobs.size).to eq(1)
-        UntilExecutedJob.clear
-        expect(UntilExecutedJob.jobs.size).to eq(0)
-        expect(AnotherUniqueJob.jobs.size).to eq(1)
-        UntilExecutedJob.perform_async(param)
-        UntilExecutedJob.perform_async(param2)
-        AnotherUniqueJob.perform_async(param)
-        expect(UntilExecutedJob.jobs.size).to eq(2)
-        expect(AnotherUniqueJob.jobs.size).to eq(1)
-      end
-
-      it 'handles clearing an empty worker queue' do
-        param = 'work'
-        UntilExecutedJob.perform_async(param)
-        UntilExecutedJob.drain
-        expect(UntilExecutedJob.jobs.size).to eq(0)
-        expect { UntilExecutedJob.clear }.not_to raise_error
-      end
-
-      it 'unlocks jobs when all workers are cleared' do
-        param = 'work'
-        expect(UntilExecutedJob.jobs.size).to eq(0)
-        expect(AnotherUniqueJob.jobs.size).to eq(0)
-        UntilExecutedJob.perform_async(param)
-        AnotherUniqueJob.perform_async(param)
-        expect(UntilExecutedJob.jobs.size).to eq(1)
-        expect(AnotherUniqueJob.jobs.size).to eq(1)
-        Sidekiq::Worker.clear_all
-        expect(UntilExecutedJob.jobs.size).to eq(0)
-        expect(AnotherUniqueJob.jobs.size).to eq(0)
-        UntilExecutedJob.perform_async(param)
-        expect(UntilExecutedJob.jobs.size).to eq(1)
-        AnotherUniqueJob.perform_async(param)
-        expect(AnotherUniqueJob.jobs.size).to eq(1)
-      end
-
-      it 'handles clearing all workers when there are no jobs' do
-        param = 'work'
-        UntilExecutedJob.perform_async(param)
-        AnotherUniqueJob.perform_async(param)
-        Sidekiq::Worker.clear_all
-        expect(UntilExecutedJob.jobs.size).to eq(0)
-        expect(AnotherUniqueJob.jobs.size).to eq(0)
-        expect { Sidekiq::Worker.jobs.size }.not_to raise_error
-      end
-
-      it 'adds the unique_digest to the message' do
-        param = 'hash'
-        item = { 'class' => 'UntilExecutedJob', 'queue' => 'working', 'args' => [param] }
-        hash = SidekiqUniqueJobs::UniqueArgs.digest(item)
-        expect(UntilExecutedJob.perform_async(param)).to_not be_nil
-        expect(UntilExecutedJob.jobs.size).to eq(1)
-        expect(UntilExecutedJob.jobs.last['unique_digest']).to eq(hash)
-      end
-    end
-
-    context 'with non-unique worker' do
-      it 'pushes duplicates messages' do
-        param = 'work'
-        expect(MyJob.jobs.size).to eq(0)
-        MyJob.perform_async(param)
-        expect(MyJob.jobs.size).to eq(1)
-        MyJob.perform_async(param)
-        expect(MyJob.jobs.size).to eq(2)
-      end
-    end
-  end
-
-  describe 'when set to :inline!', sidekiq: :inline do
-    it 'once the job is completed allows to run another one' do
-      expect(TestClass).to receive(:run).with('test').twice
-      InlineWorker.perform_async('test')
-      InlineWorker.perform_async('test')
-    end
-
-    it 'if the unique is kept forever it does not allows to run the job again' do
-      expect(TestClass).to receive(:run).with('args').once
-
-      UntilGlobalTimeoutJob.perform_async('args')
-      UntilGlobalTimeoutJob.perform_async('args')
-    end
-
-    describe 'when a job is set to run once in 10 minutes' do
-      context 'when spammed' do
-        it 'only allows 1 call per 10 minutes' do
-          expect(TestClass).to receive(:run).with(1).once
-          100.times do
-            UntilTimeoutJob.perform_async(1)
-          end
-        end
-      end
-
-      context 'with different arguments' do
-        it 'only allows 1 call per 10 minutes' do
-          expect(TestClass).to receive(:run).with(9).once
-          2.times do
-            UntilTimeoutJob.perform_async(9)
-          end
-
-          expect(TestClass).to receive(:run).with(2).once
-          2.times do
-            UntilTimeoutJob.perform_async(2)
-          end
-        end
-      end
-    end
-  end
-end