sidekiq-unique-jobs 5.0.2 → 5.0.4

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