sidekiq-unique-jobs 5.0.2 → 5.0.11

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

data/spec/lib/sidekiq_unique_jobs/util_spec.rb

@@ -1,81 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SidekiqUniqueJobs::Util do
-  let(:job) do
-    {
-      'class' => 'MyUniqueJob',
-      'args' => [[1, 2]],
-      'at' => 1_492_341_850.358196,
-      'retry' => true,
-      'queue' => 'customqueue',
-      'unique' => :until_executed,
-      'unique_expiration' => 7200,
-      'retry_count' => 10,
-      'jid' => jid,
-      'created_at' => 1_492_341_790.358217,
-    }
-  end
-  let(:unique_args) { SidekiqUniqueJobs::UniqueArgs.new(job) }
-  let(:unique_key) { unique_args.unique_digest }
-  let(:jid) { 'e3049b05b0bd9c809182bbe0' }
-
-  def acquire_lock
-    SidekiqUniqueJobs::Scripts::AcquireLock.execute(nil, unique_key, jid, 1)
-  end
-
-  describe '.keys' do
-  end
-
-  describe '.del' do
-    before do
-      acquire_lock
-    end
-
-    it 'deletes the keys by pattern' do
-      expect(described_class.del(described_class::SCAN_PATTERN, 100, false)).to eq(1)
-    end
-
-    it 'deletes the keys by distinct key' do
-      expect(described_class.del(unique_key, 100, false)).to eq(1)
-    end
-  end
-
-  describe '.expire' do
-    before do
-      acquire_lock
-    end
-
-    it 'does some shit' do
-      sleep 1
-      expected = { jid => unique_key }
-      expect(described_class.unique_hash).to match(expected)
-      removed_keys = described_class.expire
-      expect(removed_keys).to match(expected)
-      expect(described_class.unique_hash).not_to match(expected)
-      expect(described_class.keys('*')).not_to include(unique_key)
-    end
-  end
-
-  describe '.prefix' do
-    before do
-      allow(SidekiqUniqueJobs.config).to receive(:unique_prefix).and_return('test-uniqueness')
-    end
-
-    it 'returns a prefixed key' do
-      expect(described_class.prefix('key')).to eq('test-uniqueness:key')
-    end
-
-    context 'when .unique_prefix is nil?' do
-      it 'does not prefix with unique_prefix' do
-        allow(SidekiqUniqueJobs.config).to receive(:unique_prefix).and_return(nil)
-        expect(described_class.prefix('key')).to eq('key')
-      end
-    end
-
-    context 'when key is already prefixed' do
-      it 'does not add another prefix' do
-        expect(described_class.prefix('test-uniqueness:key')).to eq('test-uniqueness:key')
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,92 +0,0 @@
-VERSION_REGEX = /(?<operator>[<>=]+)?\s?(?<version>(\d+.?)+)/m
-if RUBY_ENGINE == 'ruby' && RUBY_VERSION >= '2.4.0'
-  require 'simplecov'
-
-  begin
-    require 'pry-byebug'
-  rescue LoadError
-    puts 'Pry unavailable'
-  end
-end
-
-require 'rspec'
-require 'rspec/its'
-
-require 'sidekiq'
-require 'sidekiq/util'
-require 'sidekiq-unique-jobs'
-require 'timecop'
-require 'sidekiq_unique_jobs/testing'
-require 'sidekiq/simulator'
-
-Sidekiq::Testing.disable!
-SidekiqUniqueJobs.logger.level = "Logger::#{ENV.fetch('LOGLEVEL') { 'error' }.upcase}".constantize
-
-require 'sidekiq/redis_connection'
-
-REDIS_URL ||= ENV['REDIS_URL'] || 'redis://localhost/15'.freeze
-REDIS_NAMESPACE ||= 'unique-test'.freeze
-REDIS_OPTIONS ||= { url: REDIS_URL } # rubocop:disable MutableConstant
-REDIS_OPTIONS[:namespace] = REDIS_NAMESPACE if defined?(Redis::Namespace)
-REDIS ||= Sidekiq::RedisConnection.create(REDIS_OPTIONS)
-
-Sidekiq.configure_client do |config|
-  config.redis = REDIS_OPTIONS
-end
-
-Dir[File.join(File.dirname(__FILE__), 'support', '**', '*.rb')].each { |f| require f }
-
-RSpec.configure do |config| # rubocop:disable BlockLength
-  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.filter_run :focus unless ENV['CI']
-  config.run_all_when_everything_filtered = true
-  config.disable_monkey_patching!
-  config.warnings = false
-  config.default_formatter = 'doc' if config.files_to_run.one?
-  config.order = :random
-  Kernel.srand config.seed
-
-  config.before(:each) do
-    SidekiqUniqueJobs.configure do |unique_config|
-      unique_config.redis_test_mode = :redis
-    end
-    Sidekiq.redis = REDIS
-    Sidekiq.redis(&:flushdb)
-    Sidekiq::Worker.clear_all
-    Sidekiq::Queues.clear_all
-
-    if Sidekiq::Testing.respond_to?(:server_middleware)
-      Sidekiq::Testing.server_middleware do |chain|
-        chain.add SidekiqUniqueJobs::Server::Middleware
-      end
-    end
-    enable_delay = defined?(Sidekiq::Extensions) && Sidekiq::Extensions.respond_to?(:enable_delay!)
-    Sidekiq::Extensions.enable_delay! if enable_delay
-  end
-
-  config.after(:each) do
-    Sidekiq.redis(&:flushdb)
-    respond_to_middleware = defined?(Sidekiq::Testing) && Sidekiq::Testing.respond_to?(:server_middleware)
-    Sidekiq::Testing.server_middleware(&:clear) if respond_to_middleware
-  end
-end
-
-Dir[File.join(File.dirname(__FILE__), 'jobs', '**', '*.rb')].each { |f| require f }
-
-def capture(stream)
-  begin
-    stream = stream.to_s
-    eval "$#{stream} = StringIO.new" # rubocop:disable Security/Eval
-    yield
-    result = eval("$#{stream}").string # rubocop:disable Security/Eval
-  ensure
-    eval("$#{stream} = #{stream.upcase}") # rubocop:disable Security/Eval
-  end
-
-  result
-end

data/spec/support/matchers/redis_matchers.rb

@@ -1,29 +0,0 @@
-require 'rspec/expectations'
-
-RSpec::Matchers.define :have_key do |unique_key|
-  Sidekiq.redis do |redis|
-    match do |_unique_jobs|
-      @value = redis.get(unique_key)
-      @ttl = redis.ttl(unique_key)
-
-      @value && with_value && for_seconds
-    end
-
-    chain :with_value do |value = nil|
-      @expected_value = value
-      @expected_value && @value == @expected_value
-    end
-
-    chain :for_seconds do |ttl = nil|
-      @expected_ttl = ttl
-      @expected_ttl && @ttl == @expected_ttl
-    end
-
-    failure_message do |_actual|
-      msg = "expected Redis to have key #{unique_key}"
-      msg << " with value #{@expected_value} was (#{@value})" if @expected_value
-      msg << " with value #{@expected_ttl} was (#{@ttl})" if @expected_ttl
-      msg
-    end
-  end
-end

data/spec/support/ruby_meta.rb

@@ -1,17 +0,0 @@
-RSpec.configure do |config|
-  config.before(:each) do |example|
-    ruby_ver = example.metadata[:ruby_ver]
-    VERSION_REGEX.match(ruby_ver.to_s) do |match|
-      version  = match[:version]
-      operator = match[:operator]
-      next unless ruby_ver
-
-      raise 'Please specify how to compare the version with >= or < or =' unless operator
-
-      unless RUBY_VERSION.send(operator, version)
-        skip("Skipped due to version check (requirement was that ruby version is " \
-             "#{operator} #{version}; was #{RUBY_VERSION})")
-      end
-    end
-  end
-end

data/spec/support/sidekiq_meta.rb

@@ -1,30 +0,0 @@
-RSpec.configure do |config|
-  config.before(:each) do |example|
-    SidekiqUniqueJobs.configure do |c|
-      c.redis_test_mode = :redis
-    end
-
-    if (sidekiq = example.metadata[:sidekiq])
-      sidekiq = :fake if sidekiq == true
-      Sidekiq::Testing.send("#{sidekiq}!")
-    end
-
-    if (sidekiq_ver = example.metadata[:sidekiq_ver])
-      VERSION_REGEX.match(sidekiq_ver.to_s) do |match|
-        version  = match[:version]
-        operator = match[: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|
-    Sidekiq::Testing.disable! unless example.metadata[:sidekiq].nil?
-  end
-end

data/spec/support/unique_macros.rb

@@ -1,71 +0,0 @@
-module SidekiqUniqueJobs
-  module RSpec
-    module InstanceMethods
-      # enable versioning for specific blocks (at instance-level)
-      def with_global_config(config)
-        was_config = SidekiqUniqueJobs.config
-        SidekiqUniqueJobs.configure(config)
-        yield
-      ensure
-        SidekiqUniqueJobs.configure(was_config)
-      end
-
-      def with_sidekiq_options_for(worker_class, options)
-        worker_class = SidekiqUniqueJobs.worker_class_constantize(worker_class)
-        if worker_class.respond_to?(:sidekiq_options)
-          was_options = worker_class.get_sidekiq_options
-          worker_class.sidekiq_options(options)
-        end
-        yield
-      ensure
-        worker_class.sidekiq_options_hash = was_options if worker_class.respond_to?(:sidekiq_options_hash=)
-      end
-
-      def with_default_worker_options(options)
-        was_options = Sidekiq.default_worker_options
-        Sidekiq.default_worker_options.clear
-        Sidekiq.default_worker_options = options
-        yield
-      ensure
-        Sidekiq.default_worker_options.clear
-        Sidekiq.default_worker_options = was_options
-      end
-    end
-
-    module ClassMethods
-      def with_sidekiq_options_for(worker_class, options = {}, &block)
-        context "with sidekiq options #{options}" do
-          around(:each) do |ex|
-            with_sidekiq_options_for(worker_class, options, &ex)
-          end
-          class_exec(&block)
-        end
-      end
-
-      # enable versioning for specific blocks (at class-level)
-      def with_global_config(config = {}, &block)
-        context "with global configuration #{config}" do
-          around(:each) do |ex|
-            with_global_config(config, &ex)
-          end
-          class_exec(&block)
-        end
-      end
-
-      # enable versioning for specific blocks (at class-level)
-      def with_default_worker_options(config = {}, &block)
-        context "with default sidekiq options #{config}" do
-          around(:each) do |ex|
-            with_default_worker_options(config, &ex)
-          end
-          class_exec(&block)
-        end
-      end
-    end
-  end
-end
-
-RSpec.configure do |config|
-  config.include SidekiqUniqueJobs::RSpec::InstanceMethods
-  config.extend SidekiqUniqueJobs::RSpec::ClassMethods
-end