sidekiq-unique-jobs 4.0.17 → 4.0.18

data/rails_example/spec/factories/posts.rb

@@ -0,0 +1,8 @@
+FactoryGirl.define do
+  factory :post do
+    title 'MyString'
+    body 'MyText'
+    excerpt 'MyString'
+    read_count 1
+  end
+end

data/rails_example/spec/models/post_spec.rb

@@ -0,0 +1,4 @@
+require 'rails_helper'
+
+describe Post, type: :model do
+end

data/rails_example/spec/rails_helper.rb

@@ -0,0 +1,21 @@
+# This file is copied to spec/ when you run 'rails generate rspec:install'
+ENV['RAILS_ENV'] ||= 'test'
+require File.expand_path('../../config/environment', __FILE__)
+# Prevent database truncation if the environment is production
+abort('The Rails environment is running in production mode!') if Rails.env.production?
+require 'spec_helper'
+require 'rspec/rails'
+require 'sidekiq_unique_jobs/testing'
+
+Dir[Rails.root.join('spec/support/**/*.rb')].each { |f| require f }
+
+ActiveRecord::Migration.maintain_test_schema!
+
+MOCK_REDIS ||= MockRedis.new
+
+RSpec.configure do |config|
+  config.use_transactional_fixtures = true
+  config.infer_spec_type_from_file_location!
+  config.filter_rails_from_backtrace!
+  # config.filter_gems_from_backtrace("gem name")
+end

data/rails_example/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+  config.filter_run_when_matching :focus
+  config.example_status_persistence_file_path = 'spec/examples.txt'
+  # config.disable_monkey_patching!
+
+  config.default_formatter = 'doc' if config.files_to_run.one?
+
+  config.profile_examples = 10
+  config.order = :random
+  Kernel.srand config.seed
+end

data/rails_example/spec/support/sidekiq_meta.rb

@@ -0,0 +1,12 @@
+RSpec.configure do |config|
+  config.before(:each) do |example|
+    if (sidekiq = example.metadata[:sidekiq])
+      sidekiq = :fake if sidekiq == true
+      Sidekiq::Testing.send("#{sidekiq}!")
+    end
+  end
+
+  config.after(:each) do |example|
+    Sidekiq::Testing.disable! unless example.metadata[:sidekiq].nil?
+  end
+end

data/rails_example/spec/workers/simple_worker_spec.rb

@@ -0,0 +1,4 @@
+require 'rails_helper'
+
+describe SimpleWorker do
+end

data/spec/jobs/my_unique_job.rb

@@ -1,7 +1,12 @@
 class MyUniqueJob
   include Sidekiq::Worker
-  sidekiq_options queue: :customqueue, retry: true, unique: :until_executed,
-                  unique_expiration: 7_200, retry_count: 10
+  sidekiq_options(
+    queue: :customqueue,
+    retry: true,
+    unique: :until_executed,
+    unique_expiration: 7_200,
+    retry_count: 10
+  )
   def perform(_one, _two)
   end
 end

data/spec/jobs/my_unique_job_with_filter_method.rb

@@ -0,0 +1,17 @@
+class MyUniqueJobWithFilterMethod
+  include Sidekiq::Worker
+  sidekiq_options queue: :customqueue,
+                  retry: true,
+                  backtrace: true,
+                  unique: :until_executed,
+                  unique_args: :filtered_args
+
+  def perform(*)
+    # NO-OP
+  end
+
+  def self.filtered_args(args)
+    options = args.extract_options!
+    [args.first, options['type']]
+  end
+end

data/spec/jobs/my_unique_job_with_filter_proc.rb

@@ -0,0 +1,15 @@
+class MyUniqueJobWithFilterProc
+  include Sidekiq::Worker
+  sidekiq_options queue: :customqueue,
+                  retry: true,
+                  backtrace: true,
+                  unique: :until_executed,
+                  unique_args: (lambda do |args|
+                    options = args.extract_options!
+                    [args.first, options['type']]
+                  end)
+
+  def perform(*)
+    # NO-OP
+  end
+end

data/spec/jobs/notify_worker.rb

@@ -5,6 +5,6 @@ class NotifyWorker
                   unique: :until_executed
 
   def perform(id, _blob)
-    puts "NotifyWorker -- #{id}"
+    # puts "NotifyWorker -- #{id}"
   end
 end

data/spec/lib/sidekiq_unique_jobs/client/middleware_spec.rb

@@ -117,6 +117,40 @@ RSpec.describe SidekiqUniqueJobs::Client::Middleware do
       end
     end
 
+    it 'does not push duplicate messages when unique_args are filtered with a proc' do
+      10.times { MyUniqueJobWithFilterProc.perform_async(1) }
+      Sidekiq.redis { |c| expect(c.llen('queue:customqueue')).to eq(1) }
+
+      Sidekiq.redis(&:flushdb)
+      Sidekiq.redis { |c| expect(c.llen('queue:customqueue')).to eq(0) }
+
+      10.times do
+        Sidekiq::Client.push(
+          'class' => MyUniqueJobWithFilterProc,
+          'queue' => 'customqueue',
+          'args' => [1, type: 'value', some: 'not used']
+        )
+      end
+      Sidekiq.redis { |c| expect(c.llen('queue:customqueue')).to eq(1) }
+    end
+
+    it 'does not push duplicate messages when unique_args are filtered with a method' do
+      10.times { MyUniqueJobWithFilterMethod.perform_async(1) }
+      Sidekiq.redis do |c|
+        expect(c.llen('queue:customqueue')).to eq(1)
+      end
+      Sidekiq.redis(&:flushdb)
+      Sidekiq.redis { |c| expect(c.llen('queue:customqueue')).to eq(0) }
+      10.times do
+        Sidekiq::Client.push(
+          'class' => MyUniqueJobWithFilterMethod,
+          'queue' => 'customqueue',
+          'args' => [1, type: 'value', some: 'not used']
+        )
+      end
+      Sidekiq.redis { |c| expect(c.llen('queue:customqueue')).to eq(1) }
+    end
+
     it 'does push duplicate messages to different queues' do
       Sidekiq::Client.push('class' => MyUniqueJob, 'queue' => 'customqueue', 'args' => [1, 2])
       Sidekiq::Client.push('class' => MyUniqueJob, 'queue' => 'customqueue2', 'args' => [1, 2])

data/spec/lib/sidekiq_unique_jobs/lock/until_and_while_executing_spec.rb

@@ -13,7 +13,11 @@ RSpec.describe SidekiqUniqueJobs::Lock::UntilAndWhileExecuting do
   let(:callback) { -> {} }
   subject { described_class.new(item) }
   describe '#execute' do
-    before { subject.lock(:client) }
+    before do
+      Sidekiq.redis(&:flushdb)
+      Sidekiq::Worker.clear_all
+      subject.lock(:client)
+    end
     let(:runtime_lock) { SidekiqUniqueJobs::Lock::WhileExecuting.new(item, nil) }
 
     it 'unlocks the unique key before yielding' do

data/spec/lib/sidekiq_unique_jobs/lock/until_executed_spec.rb

@@ -15,26 +15,23 @@ RSpec.describe SidekiqUniqueJobs::Lock::UntilExecuted do
     context 'when yield fails with Sidekiq::Shutdown' do
       before do
         allow(subject).to receive(:after_yield_yield) { raise Sidekiq::Shutdown }
-      end
-
-      it 'raises Sidekiq::Shutdown' do
         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)
-        expect { subject.execute(empty_callback) }.to raise_error(Sidekiq::Shutdown)
       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' }
-      end
-
-      it 'raises Sidekiq::Shutdown' do
         expect(subject).to receive(:unlock).and_return(true)
         expect(empty_callback).to receive(:call)
-        expect { subject.execute(empty_callback) }.to raise_error('Hell')
       end
+
+      specify { expect { subject.execute(empty_callback) }.to raise_error('Hell') }
     end
   end
 end

data/spec/lib/sidekiq_unique_jobs/options_with_fallback_spec.rb

@@ -13,7 +13,8 @@ RSpec.describe SidekiqUniqueJobs::OptionsWithFallback do
           .to receive(:warn)
           .with(
             'unique: true is no longer valid. Please set it to the type of lock required like: ' \
-            '`unique: :until_executed`')
+            '`unique: :until_executed`'
+          )
 
         subject.unique_lock
       end

data/spec/lib/sidekiq_unique_jobs/script_mock_spec.rb

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

@@ -6,6 +6,10 @@ RSpec.describe SidekiqUniqueJobs::Scripts do
   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 }

data/spec/lib/sidekiq_unique_jobs/sidekiq_testing_enabled_spec.rb

@@ -6,14 +6,19 @@ 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
 
@@ -27,18 +32,10 @@ RSpec.describe 'When Sidekiq::Testing is enabled' do
         expect(UntilExecutedJob.jobs.size).to eq(1)
       end
 
-      # it 'does not push duplicate messages', sidekiq_ver: '>= 4' do
-      #   param = 'work'
-      #   expect(UntilExecutedJob.jobs.size).to eq(0)
-      #   expect(UntilExecutedJob.perform_async(param)).to_not be_nil
-      #   expect(Sidekiq::Queues['working'].size).to eq(1)
-      #   expect(UntilExecutedJob.perform_async(param)).to be_nil
-      #   expect(Sidekiq::Queues['working'].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)
@@ -88,12 +85,11 @@ RSpec.describe 'When Sidekiq::Testing is enabled' do
       it 'handles clearing an empty worker queue' do
         param = 'work'
         UntilExecutedJob.perform_async(param)
-        UntilExecutedJob.clear
+        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', :focus do
       it 'unlocks jobs when all workers are cleared' do
         param = 'work'
         expect(UntilExecutedJob.jobs.size).to eq(0)

data/spec/lib/sidekiq_unique_jobs/sidekiq_unique_ext_spec.rb

@@ -22,7 +22,8 @@ RSpec.describe 'Sidekiq::Api' do
       'class' => JustAWorker,
       'queue' => 'testqueue',
       'args'  => [foo: 'bar'],
-      'at'    => (Date.today + 1).to_time.to_i)
+      'at'    => (Date.today + 1).to_time.to_i
+    )
   end
 
   def schedule_job

data/spec/spec_helper.rb

@@ -20,9 +20,8 @@ require 'celluloid_with_fallback'
 require 'sidekiq'
 require 'sidekiq/util'
 require 'sidekiq-unique-jobs'
-require 'sidekiq_unique_jobs/testing'
 require 'timecop'
-
+require 'sidekiq_unique_jobs/testing'
 require 'sidekiq/simulator'
 
 Sidekiq::Testing.disable!

data/spec/support/sidekiq_meta.rb

@@ -1,23 +1,28 @@
 RSpec.configure do |config|
   VERSION_REGEX = /(?<operator>[<>=]+)?\s?(?<version>(\d+.?)+)/m
   config.before(:each) do |example|
-    Sidekiq.redis(&:flushdb)
-    Sidekiq::Worker.clear_all
+    SidekiqUniqueJobs.configure do |config|
+      config.redis_test_mode = :redis
+    end
+
     if (sidekiq = example.metadata[:sidekiq])
       sidekiq = :fake if sidekiq == true
       Sidekiq::Testing.send("#{sidekiq}!")
     end
 
-    sidekiq_ver = example.metadata[:sidekiq_ver]
-    version, operator = VERSION_REGEX.match(sidekiq_ver.to_s) do |m|
-      raise 'Please specify how to compare the version with >= or < or =' unless m[:operator]
-      [m[:version], m[:operator]]
-    end
+    if (sidekiq_ver = example.metadata[:sidekiq_ver])
+      VERSION_REGEX.match(sidekiq_ver.to_s) do |match|
+        version  = match[:version]
+        operator = match[:operator]
 
-    unless Sidekiq::VERSION.send(operator, version)
-      skip('Skipped due to version check (requirement was that sidekiq version is ' \
-           "#{operator} #{version}; was #{Sidekiq::VERSION})")
-    end if version && operator
+        raise 'Please specify how to compare the version with >= or < or =' unless operator
+
+        unless Sidekiq::VERSION.send(operator, version)
+          skip('Skipped due to version check (requirement was that sidekiq version is ' \
+               "#{operator} #{version}; was #{Sidekiq::VERSION})")
+        end
+      end
+    end
   end
 
   config.after(:each) do |example|