sidekiq-unique-jobs 5.0.2 → 5.0.11

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

data/spec/lib/sidekiq_unique_jobs/sidekiq_unique_ext_spec.rb

@@ -1,75 +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
-  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 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 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

data/spec/lib/sidekiq_unique_jobs/timeout_calculator_spec.rb

@@ -1,70 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SidekiqUniqueJobs::TimeoutCalculator do
-  shared_context 'undefined worker class' do
-    subject { described_class.new('class' => 'test') }
-  end
-
-  shared_context 'item not scheduled' do
-    subject { described_class.new('class' => 'MyUniqueJob') }
-  end
-
-  describe 'public api' do
-    subject { described_class.new(nil) }
-    it { is_expected.to respond_to(:time_until_scheduled) }
-    it { is_expected.to respond_to(:worker_class_queue_lock_expiration) }
-    it { is_expected.to respond_to(:worker_class_run_lock_expiration) }
-    it { is_expected.to respond_to(:worker_class) }
-    it { is_expected.to respond_to(:seconds) }
-  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 '#time_until_scheduled' do
-    it_behaves_like 'item not scheduled' do
-      its(:time_until_scheduled) { is_expected.to eq(0) }
-    end
-
-    subject { described_class.new('class' => 'MyUniqueJob', 'at' => schedule_time) }
-    let(:schedule_time) { Time.now.utc.to_i + 24 * 60 * 60 }
-    let(:now_in_utc) { Time.now.utc.to_i }
-
-    its(:time_until_scheduled) do
-      Timecop.travel(Time.at(now_in_utc)) do
-        is_expected.to be_within(1).of(schedule_time - now_in_utc)
-      end
-    end
-  end
-
-  describe '#worker_class_queue_lock_expiration' do
-    it_behaves_like 'undefined worker class' do
-      its(:worker_class_queue_lock_expiration) { is_expected.to eq(nil) }
-    end
-
-    subject { described_class.new('class' => 'MyUniqueJob') }
-    its(:worker_class_queue_lock_expiration) { is_expected.to eq(7_200) }
-  end
-
-  describe '#worker_class_run_lock_expiration' do
-    it_behaves_like 'undefined worker class' do
-      its(:worker_class_run_lock_expiration) { is_expected.to eq(nil) }
-    end
-
-    subject { described_class.new('class' => 'LongRunningJob') }
-    its(:worker_class_run_lock_expiration) { is_expected.to eq(7_200) }
-  end
-
-  describe '#worker_class' do
-    it_behaves_like 'undefined worker class' do
-      its(:worker_class) { is_expected.to eq('test') }
-    end
-
-    subject { described_class.new('class' => 'MyJob') }
-    its(:worker_class) { is_expected.to eq(MyJob) }
-  end
-end