sidekiq-unique-jobs 4.0.18 → 7.1.28

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,84 +0,0 @@
-require 'spec_helper'
-require 'mock_redis'
-
-MOCK_REDIS ||= MockRedis.new
-
-RSpec.describe SidekiqUniqueJobs::ScriptMock 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(Redis).to receive(:new).and_return(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(Redis)
-          .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, 'anotherjid')).to eq(0) }
-      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/scripts_spec.rb

@@ -1,77 +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
-    before do
-      Sidekiq.redis(&:flushdb)
-      Sidekiq::Worker.clear_all
-    end
-    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(:script_shas) }
-    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 '.script_shas' do
-      its(:script_shas) { is_expected.to be_a(Hash) }
-    end
-
-    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(0.5)).to eq(1)
-          expect(Redis)
-            .to have_key(UNIQUE_KEY)
-            .for_seconds(1)
-            .with_value('fuckit')
-          sleep 0.5
-          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,83 +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
-
-  before do
-    Sidekiq.redis = REDIS
-    Sidekiq.redis(&:flushdb)
-  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,181 +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
-    before do
-      SidekiqUniqueJobs.configure do |config|
-        config.redis_test_mode = :redis
-      end
-      Sidekiq.redis = REDIS
-      Sidekiq.redis(&:flushdb)
-      Sidekiq::Worker.clear_all
-      Sidekiq::Testing.server_middleware do |chain|
-        chain.add SidekiqUniqueJobs::Server::Middleware
-      end if Sidekiq::Testing.respond_to?(:server_middleware)
-    end
-
-    after do
-      Sidekiq.redis(&:flushdb)
-      Sidekiq::Testing.server_middleware(&:clear) if Sidekiq::Testing.respond_to?(:server_middleware)
-    end
-
-    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

data/spec/lib/sidekiq_unique_jobs/sidekiq_unique_ext_spec.rb

@@ -1,80 +0,0 @@
-require 'spec_helper'
-require 'sidekiq/api'
-require 'sidekiq/worker'
-require 'sidekiq_unique_jobs/server/middleware'
-require 'sidekiq_unique_jobs/client/middleware'
-require 'sidekiq_unique_jobs/sidekiq_unique_ext'
-
-RSpec.describe 'Sidekiq::Api' do
-  before do
-    Sidekiq.redis = REDIS
-    Sidekiq.redis(&:flushdb)
-  end
-
-  let(:item) do
-    { 'class' => JustAWorker,
-      'queue' => 'testqueue',
-      'args'  => [foo: 'bar'] }
-  end
-
-  def unique_key
-    SidekiqUniqueJobs::UniqueArgs.digest(
-      'class' => JustAWorker,
-      'queue' => 'testqueue',
-      'args'  => [foo: 'bar'],
-      'at'    => (Date.today + 1).to_time.to_i
-    )
-  end
-
-  def schedule_job
-    JustAWorker.perform_in(60 * 60 * 3, foo: 'bar')
-  end
-
-  def perform_async
-    JustAWorker.perform_async(foo: 'bar')
-  end
-
-  describe Sidekiq::SortedEntry::UniqueExtension, sidekiq_ver: '>= 3.1' do
-    it 'deletes uniqueness lock on delete' do
-      expect(schedule_job).to be_truthy
-
-      Sidekiq::ScheduledSet.new.each(&:delete)
-      Sidekiq.redis do |c|
-        expect(c.exists(unique_key)).to be_falsy
-      end
-
-      expect(schedule_job).to be_truthy
-    end
-  end
-
-  describe Sidekiq::Job::UniqueExtension do
-    it 'deletes uniqueness lock on delete' do
-      jid = perform_async
-      Sidekiq::Queue.new('testqueue').find_job(jid).delete
-      Sidekiq.redis do |c|
-        expect(c.exists(unique_key)).to be_falsy
-      end
-      expect(true).to be_truthy
-    end
-  end
-
-  describe Sidekiq::Queue::UniqueExtension do
-    it 'deletes uniqueness locks on clear' do
-      perform_async
-      Sidekiq::Queue.new('testqueue').clear
-      Sidekiq.redis do |c|
-        expect(c.exists(unique_key)).to be_falsy
-      end
-    end
-  end
-
-  describe Sidekiq::JobSet::UniqueExtension, sidekiq_ver: '>= 3.1' do
-    it 'deletes uniqueness locks on clear' do
-      schedule_job
-      Sidekiq::JobSet.new('schedule').clear
-      Sidekiq.redis do |c|
-        expect(c.exists(unique_key)).to be_falsy
-      end
-    end
-  end
-end

data/spec/lib/sidekiq_unique_jobs/sidekiq_unique_jobs_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-RSpec.describe SidekiqUniqueJobs do
-  describe '.configure_middleware' do
-    it 'configures both client and server middleware' do
-      expect(described_class).to receive(:configure_server_middleware)
-      expect(described_class).to receive(:configure_client_middleware)
-
-      described_class.configure_middleware
-    end
-  end
-
-  describe '.configure_server_middleware' do
-    let(:server_config) { class_double(Sidekiq) }
-    let(:server_middleware) { double(Sidekiq::Middleware::Chain) }
-    let(:client_middleware) { double(Sidekiq::Middleware::Chain) }
-
-    it 'adds client and server middleware when required' do
-      expect(Sidekiq).to receive(:configure_server).and_yield(server_config)
-
-      expect(server_config).to receive(:client_middleware).and_yield(client_middleware)
-      expect(client_middleware).to receive(:add).with(SidekiqUniqueJobs::Client::Middleware)
-
-      expect(server_config).to receive(:server_middleware).and_yield(server_middleware)
-      expect(server_middleware).to receive(:add).with(SidekiqUniqueJobs::Server::Middleware)
-      described_class.configure_server_middleware
-    end
-  end
-
-  describe '.configure_client_middleware' do
-    let(:client_config) { class_double(Sidekiq) }
-    let(:client_middleware) { double(Sidekiq::Middleware::Chain) }
-
-    it 'adds client middleware when required' do
-      expect(Sidekiq).to receive(:configure_client).and_yield(client_config)
-      expect(client_config).to receive(:client_middleware).and_yield(client_middleware)
-      expect(client_middleware).to receive(:add).with(SidekiqUniqueJobs::Client::Middleware)
-
-      described_class.configure_client_middleware
-    end
-  end
-end