sidekiq-unique-jobs 5.0.2 → 5.0.4

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

data/spec/lib/sidekiq_unique_jobs/unique_args_spec.rb

@@ -1,257 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SidekiqUniqueJobs::UniqueArgs do
-  let(:item) { { 'class' => 'UntilExecutedJob', 'queue' => 'myqueue', 'args' => [[1, 2]] } }
-  subject { described_class.new(item) }
-  describe '#unique_digest' do
-    context 'when args are empty' do
-      let(:item) { { 'class' => 'WithoutArgumentJob', 'args' => [] } }
-      let(:another_subject) { described_class.new(item) }
-
-      context 'with the same unique args' do
-        it 'equals to unique_digest for that item' do
-          expect(subject.unique_digest).to eq(another_subject.unique_digest)
-        end
-      end
-    end
-
-    shared_examples 'unique digest' do
-      subject { described_class.new(item_options) }
-      context 'given another item' do
-        let(:another_subject) { described_class.new(another_item) }
-
-        context 'with the same unique args' do
-          let(:another_item) { item_options.merge('args' => [1, 2, 'type' => 'it']) }
-          it 'equals to unique_digest for that item' do
-            expect(subject.unique_digest).to eq(another_subject.unique_digest)
-          end
-        end
-
-        context 'with different unique args' do
-          let(:another_item) { item_options.merge('args' => [1, 3, 'type' => 'that']) }
-          it 'differs from unique_digest for that item' do
-            expect(subject.unique_digest).not_to eq(another_subject.unique_digest)
-          end
-        end
-      end
-    end
-
-    context 'when unique_args is a proc' do
-      let(:item_options) do
-        {
-          'class' => 'MyUniqueJobWithFilterProc',
-          'queue' => 'customqueue',
-          'args' => [1, 2, 'type' => 'it'],
-        }
-      end
-
-      it_behaves_like 'unique digest'
-    end
-
-    context 'when unique_args is a symbol' do
-      let(:item_options) do
-        {
-          'class' => 'MyUniqueJobWithFilterMethod',
-          'queue' => 'customqueue',
-          'args' => [1, 2, 'type' => 'it'],
-        }
-      end
-
-      it_behaves_like 'unique digest'
-    end
-  end
-
-  describe '#unique_args_enabled?' do
-    with_default_worker_options(unique: :until_executed, unique_args: ->(args) { args[1]['test'] }) do
-      with_sidekiq_options_for(UntilExecutedJob, unique_args: :unique_args) do
-        its(:unique_args_enabled?) { is_expected.to eq(:unique_args) }
-      end
-
-      with_sidekiq_options_for(UntilExecutedJob, unique_args: false) do
-        its(:unique_args_enabled?) { is_expected.to be_a(Proc) }
-      end
-    end
-
-    with_default_worker_options(unique: false, unique_args: nil) do
-      with_sidekiq_options_for(UntilExecutedJob, unique_args: :unique_args) do
-        its(:unique_args_enabled?) { is_expected.to eq(:unique_args) }
-      end
-
-      with_sidekiq_options_for(UntilExecutedJob, unique_args: false) do
-        its(:unique_args_enabled?) { is_expected.to be_falsy }
-      end
-
-      its(:unique_args_enabled?) { is_expected.to be_falsy }
-    end
-  end
-
-  describe '#unique_on_all_queues?' do
-    with_global_config(unique_args_enabled: true) do
-      its(:unique_on_all_queues?) { is_expected.to eq(nil) }
-
-      with_sidekiq_options_for(UntilExecutedJob, unique_args: :unique_args, unique_on_all_queues: true) do
-        its(:unique_on_all_queues?) { is_expected.to eq(true) }
-      end
-
-      with_sidekiq_options_for(UntilExecutedJob, unique_args: :unique_args, unique_on_all_queues: false) do
-        its(:unique_on_all_queues?) { is_expected.to be_falsy }
-      end
-    end
-
-    with_global_config(unique_args_enabled: false) do
-      its(:unique_on_all_queues?) { is_expected.to eq(nil) }
-
-      with_sidekiq_options_for(UntilExecutedJob, unique_args: :unique_args, unique_on_all_queues: false) do
-        its(:unique_on_all_queues?) { is_expected.to eq(false) }
-      end
-
-      with_sidekiq_options_for(UntilExecutedJob, unique_args: :unique_args, unique_on_all_queues: true) do
-        its(:unique_on_all_queues?) { is_expected.to eq(true) }
-      end
-    end
-  end
-
-  describe '#filter_by_proc' do
-    let(:filter) { ->(args) { args[1]['test'] } }
-    let(:args) { [1, 'test' => 'it'] }
-    let(:unique_args) { described_class.new(item) }
-
-    subject { unique_args.filter_by_proc(args) }
-
-    context 'without any default worker options configured' do
-      before do
-        allow(unique_args).to receive(:unique_args_method).and_return(filter)
-      end
-
-      it 'returns the value of theoptions hash ' do
-        expect(subject).to eq('it')
-      end
-    end
-
-    context 'when #unique_args_method is nil' do
-      before do
-        allow(unique_args).to receive(:unique_args_method).and_return(nil)
-      end
-
-      it 'returns the value of theoptions hash ' do
-        expect(SidekiqUniqueJobs.logger).to receive(:warn) do |&block|
-          expect(block.call).to eq('filter_by_proc : unique_args_method is nil. Returning ([1, {"test"=>"it"}])')
-        end
-        expect(subject).to eq(args)
-      end
-    end
-
-    with_default_worker_options(unique: :until_executed, unique_args: ->(args) { args[1]['test'] }) do
-      it 'returns the value of the provided options' do
-        expect(subject).to eq('it')
-      end
-    end
-  end
-
-  describe '#filter_by_symbol' do
-    let(:unique_args) { described_class.new(item) }
-
-    context 'when filter is a working symbol' do
-      let(:item) do
-        { 'class' => 'UniqueJobWithFilterMethod',
-          'queue' => 'myqueue',
-          'args' => [[1, 2]] }
-      end
-
-      let(:args) { ['name', 2, 'whatever' => nil, 'type' => 'test'] }
-      subject { unique_args.filter_by_symbol(args) }
-
-      it 'returns the value of the provided class method' do
-        expected = %w[name test]
-        expect(unique_args.logger).to receive(:debug) do |&block|
-          expect(block.call).to eq("filter_by_symbol : filtered_args(#{args}) => #{expected}")
-        end
-        expect(subject).to eq(expected)
-      end
-    end
-
-    context 'when worker takes conditional parameters' do
-      let(:item) do
-        { 'class' => 'UniqueJobWithoutUniqueArgsParameter',
-          'queue' => 'myqueue',
-          'args' => [1] }
-      end
-      let(:args) { [1] }
-
-      subject { unique_args.filter_by_symbol(args) }
-
-      it 'returns the value of the provided class method' do
-        expect(subject).to eq(args)
-      end
-
-      context 'when provided nil' do
-        let(:args) { [] }
-        it 'returns the value of the provided class method' do
-          expect(subject).to eq(args)
-        end
-      end
-    end
-
-    context "when workers unique_args method doesn't take parameters" do
-      let(:item) do
-        { 'class' => 'UniqueJobWithoutUniqueArgsParameter',
-          'queue' => 'myqueue',
-          'args' => [[1, 2]] }
-      end
-
-      let(:args) { ['name', 2, 'whatever' => nil, 'type' => 'test'] }
-      subject { unique_args.filter_by_symbol(args) }
-
-      it 'returns the value of the provided class method' do
-        expect(unique_args.logger)
-          .to receive(:fatal)
-          .with('filter_by_symbol : UniqueJobWithoutUniqueArgsParameter\'s unique_args needs at least one argument')
-        expect(unique_args.logger).to receive(:fatal).with a_kind_of(ArgumentError)
-
-        expect(subject).to eq(args)
-      end
-    end
-
-    context 'when @worker_class does not respond_to unique_args_method' do
-      let(:item) do
-        { 'class' => 'UniqueJobWithNoUniqueArgsMethod',
-          'queue' => 'myqueue',
-          'args' => [[1, 2]] }
-      end
-
-      let(:args) { ['name', 2, 'whatever' => nil, 'type' => 'test'] }
-      subject { unique_args.filter_by_symbol(args) }
-
-      it 'returns the value of the provided class method' do
-        expect(unique_args.logger).to receive(:warn) do |&block|
-          expect(block.call)
-            .to eq(
-              "filter_by_symbol : UniqueJobWithNoUniqueArgsMethod does not respond to filtered_args). " \
-              "Returning (#{args})",
-            )
-        end
-
-        expect(subject).to eq(args)
-      end
-    end
-
-    context 'when workers unique_args method returns nil' do
-      let(:item) do
-        { 'class' => 'UniqueJobWithNilUniqueArgs',
-          'queue' => 'myqueue',
-          'args' => [[1, 2]] }
-      end
-
-      let(:args) { ['name', 2, 'whatever' => nil, 'type' => 'test'] }
-      subject { unique_args.filter_by_symbol(args) }
-
-      it 'returns the value of the provided class method' do
-        expect(unique_args.logger).to receive(:debug) do |&block|
-          expect(block.call).to eq("filter_by_symbol : unique_args(#{args}) => ")
-        end
-
-        expect(subject).to eq(nil)
-      end
-    end
-  end
-end

data/spec/lib/sidekiq_unique_jobs/unlockable_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SidekiqUniqueJobs::Unlockable do
-  def item_with_digest
-    SidekiqUniqueJobs::UniqueArgs.digest(item)
-    item
-  end
-  let(:item) do
-    { 'class' => MyUniqueJob,
-      'queue' => 'customqueue',
-      'args' => [1, 2] }
-  end
-
-  let(:unique_digest) { item_with_digest[SidekiqUniqueJobs::UNIQUE_DIGEST_KEY] }
-  describe '.unlock_by_key' do
-    before do
-    end
-
-    specify do
-      expect(SidekiqUniqueJobs::Util.keys.count).to eq(0)
-      jid = Sidekiq::Client.push(item_with_digest)
-
-      expect(SidekiqUniqueJobs::Util.keys.count).to eq(1)
-      expect(SidekiqUniqueJobs::Util.keys).to match_array([unique_digest])
-      expect(SidekiqUniqueJobs::Util.unique_key(jid)).to eq(unique_digest)
-
-      described_class.unlock_by_key(
-        unique_digest,
-        jid,
-      )
-
-      expect(SidekiqUniqueJobs::Util.keys.count).to eq(0)
-      expect(SidekiqUniqueJobs::Util.keys).not_to match_array([unique_digest])
-      expect(SidekiqUniqueJobs::Util.unique_key(jid)).to eq(nil)
-    end
-  end
-end