sidekiq-unique-jobs 4.0.18 → 7.1.28

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,131 +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
-    let(:item) { item_options.merge('args' => [1, 2, 'type' => 'it']) }
-
-    shared_examples 'unique digest' do
-      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).to_not eq(another_subject.unique_digest)
-          end
-        end
-      end
-    end
-
-    context 'when unique_args is a proc' do
-      let(:item_options) do
-        { 'class' => 'UntilExecutedJob', 'queue' => 'myqueue',
-          'unique_args' => proc { |args| args[1] } }
-      end
-
-      it_behaves_like 'unique digest'
-    end
-
-    context 'when unique_args is a symbol' do
-      let(:item_options) do
-        { 'class' => 'UniqueJobWithFilterMethod', 'queue' => 'myqueue',
-          'unique_args' => :filtered_args }
-      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'] } }
-    context 'without any default worker options configured' do
-      before do
-        allow(subject).to receive(:unique_args_method).and_return(filter)
-      end
-
-      it 'returns the value of theoptions hash ' do
-        expect(subject.filter_by_proc([1, 'test' => 'it'])).to eq('it')
-      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.filter_by_proc([1, 'test' => 'it'])).to eq('it')
-      end
-    end
-  end
-
-  describe '#filter_by_symbol' do
-    let(:item) do
-      { 'class' => 'UniqueJobWithFilterMethod',
-        'queue' => 'myqueue',
-        'args' => [[1, 2]] }
-    end
-    subject { described_class.new(item) }
-
-    it 'returns the value of the provided class method' do
-      expect(subject.filter_by_symbol(['name', 2, 'whatever' => nil, 'type' => 'test']))
-        .to eq(%w(name test))
-    end
-  end
-end

data/spec/lib/sidekiq_unique_jobs/unlockable_spec.rb

@@ -1,4 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SidekiqUniqueJobs::Unlockable do
-end

data/spec/lib/sidekiq_unique_jobs/util_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SidekiqUniqueJobs::Util do
-  let(:keys) { %w(uniquejobs:keyz) }
-
-  def set(key, value)
-    described_class.connection do |c|
-      c.set(key, value)
-      expect(c.keys('*')).to match_array([key])
-    end
-  end
-
-  before(:each) do
-    Sidekiq.redis = REDIS
-    Sidekiq.redis(&:flushdb)
-  end
-
-  describe '.keys' do
-  end
-
-  describe '.del' do
-    context 'given a key named "keyz" with value "valz"' do
-      before do
-        set('uniquejobs:keyz', 'valz')
-      end
-
-      it 'deletes the keys by pattern' do
-        expect(described_class.del('*', 100, false)).to eq(1)
-      end
-
-      it 'deletes the keys by pattern' do
-        expect(described_class.del('keyz', 100, false)).to eq(1)
-      end
-    end
-  end
-
-  describe '.prefix' do
-    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
-
-    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
-  end
-end

data/spec/spec_helper.rb

@@ -1,65 +0,0 @@
-if RUBY_ENGINE == 'ruby' && RUBY_VERSION >= '2.3.0'
-  if ENV['CI']
-    require 'codeclimate-test-reporter'
-    CodeClimate::TestReporter.start
-  else
-    require 'simplecov'
-  end
-
-  begin
-    require 'pry-byebug'
-  rescue LoadError
-    puts 'Pry unavailable'
-  end
-end
-
-require 'rspec'
-require 'rspec/its'
-
-require 'celluloid_with_fallback'
-require 'sidekiq'
-require 'sidekiq/util'
-require 'sidekiq-unique-jobs'
-require 'timecop'
-require 'sidekiq_unique_jobs/testing'
-require 'sidekiq/simulator'
-
-Sidekiq::Testing.disable!
-Sidekiq.logger.level = "Logger::#{ENV.fetch('LOGLEVEL') { 'error' }.upcase}".constantize
-
-require 'sidekiq/redis_connection'
-
-begin
-  require 'redis-namespace'
-rescue LoadError
-  puts 'Redis Namespace unavailable'
-end
-
-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|
-  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
-end
-
-Dir[File.join(File.dirname(__FILE__), 'jobs', '**', '*.rb')].each { |f| require f }

data/spec/support/matchers/redis_matchers.rb

@@ -1,19 +0,0 @@
-require 'rspec/expectations'
-
-RSpec::Matchers.define :have_key do |unique_key|
-  Sidekiq.redis do |redis|
-    match do |_actual|
-      with_value && for_seconds
-    end
-
-    chain :with_value do |value = nil|
-      value.nil? ||
-        redis.get(unique_key) == value
-    end
-
-    chain :for_seconds do |ttl = nil|
-      ttl.nil? ||
-        redis.ttl(unique_key) == ttl
-    end
-  end
-end

data/spec/support/ruby_meta.rb

@@ -1,10 +0,0 @@
-RSpec.configure do |config|
-  config.before(:each) do |example|
-    ruby_ver = example.metadata[:ruby_ver]
-    next unless ruby_ver
-
-    if Gem::Version.new(ruby_ver) >= Gem::Version.new(RUBY_VERSION)
-      skip("Not relevant for version less than #{ruby_ver}")
-    end
-  end
-end

data/spec/support/sidekiq_meta.rb

@@ -1,31 +0,0 @@
-RSpec.configure do |config|
-  VERSION_REGEX = /(?<operator>[<>=]+)?\s?(?<version>(\d+.?)+)/m
-  config.before(:each) do |example|
-    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
-
-    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