rspec-sidekiq 3.0.3 → 5.1.0

data/spec/rspec/sidekiq/matchers/be_unique_spec.rb

@@ -1,115 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe RSpec::Sidekiq::Matchers::BeUnique do
-  shared_context 'a unique worker' do
-    before do
-      stub_const(module_constant, true)
-    end
-    before(:each) { subject.matches? @worker }
-
-    describe 'expected usage' do
-      it 'matches' do
-        expect(@worker).to be_unique
-      end
-
-      describe '#failure_message' do
-        it 'returns message' do
-          expect(subject.failure_message).to eq "expected #{@worker} to be unique in the queue"
-        end
-      end
-    end
-
-    describe '#matches?' do
-      context 'when condition matches' do
-        it 'returns true' do
-          expect(subject.matches? @worker).to be true
-        end
-      end
-
-      context 'when condition does not match' do
-        it 'returns false' do
-          expect(subject.matches? create_worker unique: false).to be false
-        end
-      end
-
-      describe '#failure_message_when_negated' do
-        it 'returns message' do
-          expect(subject.failure_message_when_negated).to eq "expected #{@worker} to not be unique in the queue"
-        end
-      end
-    end
-
-    describe '#description' do
-      it 'returns description' do
-        expect(subject.description).to eq 'be unique in the queue'
-      end
-    end
-  end
-
-  context 'a sidekiq-enterprise scheduled worker' do
-    let(:interval) { 3.hours }
-    let(:module_constant) { "Sidekiq::Enterprise" }
-    before { @worker = create_worker unique_for: interval }
-    include_context 'a unique worker'
-  end
-
-  context 'a sidekiq-unique-jobs scheduled worker' do
-    let(:module_constant) { "SidekiqUniqueJobs" }
-    before { @worker = create_worker unique: :all }
-    include_context 'a unique worker'
-  end
-
-  context 'a sidekiq-unique-jobs regular worker' do
-    let(:module_constant) { "SidekiqUniqueJobs" }
-    before { @worker = create_worker unique: true }
-    include_context 'a unique worker'
-  end
-
-  describe '#be_unique' do
-    before do
-      stub_const("SidekiqUniqueJobs", true)
-    end
-
-    it 'returns instance' do
-      expect(be_unique).to be_kind_of RSpec::Sidekiq::Matchers::BeUnique::Base
-    end
-  end
-
-  describe '#failure_message_when_negated' do
-    before do
-      stub_const("SidekiqUniqueJobs", true)
-    end
-
-    it 'returns message' do
-      expect(subject.failure_message_when_negated).to eq "expected #{@worker} to not be unique in the queue"
-    end
-  end
-
-  describe '#unique_key' do
-    context "with Sidekiq Enterprise" do
-      before do
-        stub_const("Sidekiq::Enterprise", true)
-      end
-
-      it "returns the correct key" do
-        expect(subject.unique_key).to eq('unique_for')
-      end
-    end
-
-    context "with sidekiq-unique-jobs" do
-      before do
-        stub_const("SidekiqUniqueJobs", true)
-      end
-
-      it "returns the correct key" do
-        expect(subject.unique_key).to eq('unique')
-      end
-    end
-
-    context "without a uniquing solution" do
-      it "raises an exception" do
-        expect{subject.unique_key}.to raise_error
-      end
-    end
-  end
-end

data/spec/rspec/sidekiq/matchers/have_enqueued_job_spec.rb

@@ -1,228 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe RSpec::Sidekiq::Matchers::HaveEnqueuedJob do
-  let(:tomorrow) { DateTime.now + 1 }
-  let(:interval) { 3.minutes }
-  let(:argument_subject) { RSpec::Sidekiq::Matchers::HaveEnqueuedJob.new worker_args }
-  let(:matcher_subject) { RSpec::Sidekiq::Matchers::HaveEnqueuedJob.new [be_a(String), be_a(Fixnum), true, be_a(Hash)] }
-  let(:worker) { create_worker }
-  let(:worker_args) { ['string', 1, true, { key: 'value', bar: :foo, nested: [{hash: true}] }] }
-  let(:active_job) { create_active_job :mailers }
-  let(:resource) { TestResource.new }
-
-  before(:each) do
-    worker.perform_async *worker_args
-    active_job.perform_later 'someResource'
-    active_job.perform_later(resource)
-    TestActionMailer.testmail.deliver_later
-    TestActionMailer.testmail(resource).deliver_later
-  end
-
-  describe 'expected usage' do
-    context 'Sidekiq' do
-      it 'matches' do
-        expect(worker).to have_enqueued_sidekiq_job *worker_args
-      end
-
-      it 'matches on the global Worker queue' do
-        expect(Sidekiq::Worker).to have_enqueued_sidekiq_job *worker_args
-      end
-
-      context 'perform_in' do
-        let(:worker_args_in) { worker_args + ['in'] }
-
-        before(:each) do
-          worker.perform_in 3.minutes, *worker_args_in
-        end
-
-        it 'matches on an scheduled job with #perform_in' do
-          expect(worker).to have_enqueued_sidekiq_job(*worker_args_in).in(interval)
-        end
-      end
-
-      context 'perform_at' do
-        let(:worker_args_at) { worker_args + ['at'] }
-
-        before(:each) do
-          worker.perform_at tomorrow, *worker_args_at
-        end
-
-        it 'matches on an scheduled job with #perform_at' do
-          expect(worker).to have_enqueued_sidekiq_job(*worker_args_at).at(tomorrow)
-        end
-      end
-    end
-
-    context 'ActiveJob' do
-      it 'matches on an enqueued ActiveJob' do
-        expect(Sidekiq::Worker).to have_enqueued_sidekiq_job 'someResource'
-      end
-
-      it 'matches on an enqueued ActiveJob by global_id' do
-        expect(Sidekiq::Worker).to have_enqueued_sidekiq_job('_aj_globalid' => resource.to_global_id.uri.to_s)
-      end
-    end
-
-    context 'ActionMailer' do
-      it 'matches on ActionMailer Job' do
-        expect(Sidekiq::Worker).to have_enqueued_sidekiq_job(
-          'TestActionMailer',
-          'testmail',
-          'deliver_now'
-        )
-      end
-
-      it 'matches on ActionMailer with a resource Job' do
-        expect(Sidekiq::Worker).to have_enqueued_sidekiq_job(
-          'TestActionMailer',
-          'testmail',
-          'deliver_now',
-          { '_aj_globalid' => resource.to_global_id.uri.to_s }
-        )
-      end
-    end
-  end
-
-  describe '#have_enqueued_sidekiq_job' do
-    it 'returns instance' do
-      expect(have_enqueued_sidekiq_job).to be_a RSpec::Sidekiq::Matchers::HaveEnqueuedJob
-    end
-  end
-
-  describe '#have_enqueued_job' do
-    it 'returns instance' do
-      expect(have_enqueued_job).to be_a RSpec::Sidekiq::Matchers::HaveEnqueuedJob
-    end
-
-    it 'provides deprecation warning' do
-      expect { have_enqueued_job }.to output(/[DEPRECATION]/).to_stderr
-    end
-
-    it 'matches the same way have_enqueued_sidekiq_job does' do
-      expect(worker).to have_enqueued_job *worker_args
-    end
-  end
-
-  describe '#description' do
-    it 'returns description' do
-      argument_subject.matches? worker
-      expect(argument_subject.description).to eq %{have an enqueued #{worker} job with arguments [\"string\", 1, true, {\"key\"=>\"value\", \"bar\"=>\"foo\", \"nested\"=>[{\"hash\"=>true}]}]}
-    end
-  end
-
-  describe '#failure_message' do
-    it 'returns message' do
-      argument_subject.matches? worker
-      expect(argument_subject.failure_message).to eq <<-eos.gsub(/^ {6}/, '').strip
-      expected to have an enqueued #{worker} job
-        arguments: [\"string\", 1, true, {\"key\"=>\"value\", \"bar\"=>\"foo\", \"nested\"=>[{\"hash\"=>true}]}]
-      found
-        arguments: [[\"string\", 1, true, {\"key\"=>\"value\", \"bar\"=>\"foo\", \"nested\"=>[{\"hash\"=>true}]}]]
-      eos
-    end
-  end
-
-  describe '#failure_message_when_negated' do
-    it 'returns message' do
-      argument_subject.matches? worker
-      expect(argument_subject.failure_message_when_negated).to eq <<-eos.gsub(/^ {6}/, '').strip
-      expected not to have an enqueued #{worker} job
-        arguments: [\"string\", 1, true, {\"key\"=>\"value\", \"bar\"=>\"foo\", \"nested\"=>[{\"hash\"=>true}]}]
-      eos
-    end
-  end
-
-  describe '#matches?' do
-    context 'when condition matches' do
-      context 'when expected are arguments' do
-        it 'returns true' do
-          worker.perform_async *worker_args
-          expect(argument_subject.matches? worker).to be true
-        end
-      end
-
-      context 'when expected are matchers' do
-        it 'returns true' do
-          worker.perform_async *worker_args
-          expect(matcher_subject.matches? worker).to be true
-        end
-      end
-
-      context 'when job is scheduled' do
-        context 'with #perform_at' do
-          before(:each) do
-            worker.perform_at(tomorrow, *worker_args)
-          end
-
-          context 'and timestamp matches' do
-            it 'returns true' do
-              expect(matcher_subject.at(tomorrow).matches? worker).to be true
-            end
-          end
-
-          context 'and timestamp does not match' do
-            it 'returns false' do
-              expect(matcher_subject.at(tomorrow + 1).matches? worker).to be false
-            end
-          end
-        end
-
-        context 'with #perform_in' do
-          before(:each) do
-            worker.perform_in(interval, *worker_args)
-          end
-
-          context 'and interval matches' do
-            it 'returns true' do
-              expect(matcher_subject.in(interval).matches? worker).to be true
-            end
-          end
-
-          context 'and interval does not match' do
-            it 'returns false' do
-              expect(matcher_subject.in(interval + 1.minute).matches? worker).to be false
-            end
-          end
-        end
-      end
-    end
-
-    context 'when condition does not match' do
-      before(:each) { Sidekiq::Worker.clear_all }
-
-      context 'when expected are arguments' do
-        it 'returns false' do
-          expect(argument_subject.matches? worker).to be false
-        end
-      end
-
-      context 'when expected are matchers' do
-        it 'returns false' do
-          expect(matcher_subject.matches? worker).to be false
-        end
-      end
-
-      context 'when job is scheduled' do
-        context 'with #perform_at' do
-          before(:each) do
-            allow(matcher_subject).to receive(:options).and_return(at: tomorrow + 1)
-          end
-
-          it 'returns false' do
-            expect(matcher_subject.at(tomorrow).matches? worker).to be false
-          end
-        end
-
-        context 'with #perform_in' do
-          before(:each) do
-            allow(matcher_subject).to receive(:options).and_return(in: interval + 1)
-          end
-
-          it 'returns false' do
-            expect(matcher_subject.in(interval).matches? worker).to be false
-          end
-        end
-      end
-    end
-  end
-end

data/spec/rspec/sidekiq/matchers/save_backtrace_spec.rb

@@ -1,136 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe RSpec::Sidekiq::Matchers::SaveBacktrace do
-  let(:specific_subject) { RSpec::Sidekiq::Matchers::SaveBacktrace.new 2 }
-  let(:specific_worker) { create_worker backtrace: 2 }
-  let(:default_subject) { RSpec::Sidekiq::Matchers::SaveBacktrace.new true }
-  let(:default_worker) { create_worker backtrace: true }
-  let(:negative_subject) { RSpec::Sidekiq::Matchers::SaveBacktrace.new false }
-  let(:negative_worker) { create_worker backtrace: false }
-  before(:each) do
-    specific_subject.matches? specific_worker
-    default_subject.matches? default_worker
-    negative_subject.matches? negative_worker
-  end
-
-  describe 'expected usage' do
-    it 'matches' do
-      expect(default_worker).to save_backtrace true
-      expect(default_worker).to save_backtrace
-    end
-
-    it 'negative usage' do
-      expect(negative_worker).to save_backtrace false
-      expect(negative_worker).to_not save_backtrace
-    end
-  end
-
-  describe '#save_backtrace' do
-    it 'returns instance' do
-      expect(save_backtrace true).to be_a RSpec::Sidekiq::Matchers::SaveBacktrace
-      expect(save_backtrace).to be_a RSpec::Sidekiq::Matchers::SaveBacktrace
-    end
-  end
-
-  describe '#description' do
-    context 'when expected is a number' do
-      it 'returns description' do
-        expect(specific_subject.description).to eq 'save 2 lines of error backtrace'
-      end
-    end
-
-    context 'when expected is true' do
-      it 'returns description' do
-        expect(default_subject.description).to eq 'save error backtrace'
-      end
-    end
-
-    context 'when expected is false' do
-      it 'returns description' do
-        expect(negative_subject.description).to eq 'not save error backtrace'
-      end
-    end
-  end
-
-  describe '#failure_message' do
-    context 'when expected is a number' do
-      it 'returns message' do
-        expect(specific_subject.failure_message).to eq "expected #{specific_worker} to save 2 lines of error backtrace but got 2"
-      end
-    end
-
-    context 'when expected is true' do
-      it 'returns message' do
-        expect(default_subject.failure_message).to eq "expected #{default_worker} to save error backtrace but got true"
-      end
-    end
-
-    context 'when expected is false' do
-      it 'returns message' do
-        expect(negative_subject.failure_message).to eq "expected #{negative_worker} to not save error backtrace but got false"
-      end
-    end
-  end
-
-  describe '#matches?' do
-    context 'when condition matches' do
-      context 'when expected is a number' do
-        it 'returns true' do
-          expect(specific_subject.matches? specific_worker).to be true
-        end
-      end
-
-      context 'when expected is true' do
-        it 'returns true' do
-          expect(default_subject.matches? default_worker).to be true
-        end
-      end
-
-      context 'when expected is false' do
-        it 'returns true' do
-          expect(negative_subject.matches? negative_worker).to be true
-        end
-      end
-    end
-
-    context 'when condition does not match' do
-      context 'when expected is a number' do
-        it 'returns false' do
-          expect(specific_subject.matches? default_worker).to be false
-        end
-      end
-
-      context 'when expected is true' do
-        it 'returns false' do
-          expect(default_subject.matches? negative_worker).to be false
-        end
-      end
-
-      context 'when expected is false' do
-        it 'returns false' do
-          expect(negative_subject.matches? specific_worker).to be false
-        end
-      end
-    end
-  end
-
-  describe '#failure_message_when_negated' do
-    context 'when expected is a number' do
-      it 'returns message' do
-        expect(specific_subject.failure_message_when_negated).to eq "expected #{specific_worker} to not save 2 lines of error backtrace"
-      end
-    end
-
-    context 'when expected is true' do
-      it 'returns message' do
-        expect(default_subject.failure_message_when_negated).to eq "expected #{default_worker} to not save error backtrace"
-      end
-    end
-
-    context 'when expected is false' do
-      it 'returns message' do
-        expect(negative_subject.failure_message_when_negated).to eq "expected #{negative_worker} to save error backtrace"
-      end
-    end
-  end
-end

data/spec/rspec/sidekiq/sidekiq_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe RSpec::Sidekiq do
-  describe '#configure' do
-    it 'yields with configuration' do
-      expect { |block| RSpec::Sidekiq.configure(&block) }.to yield_with_args RSpec::Sidekiq.configuration
-    end
-  end
-
-  describe '#configuration' do
-    it 'returns instance' do
-      expect(RSpec::Sidekiq.configuration).to be_a RSpec::Sidekiq::Configuration
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,29 +0,0 @@
-require 'simplecov'
-require 'coveralls'
-
-require 'sidekiq'
-require 'rspec-sidekiq'
-
-require 'active_job'
-require 'action_mailer'
-
-require_relative 'support/init'
-
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(
-  [Coveralls::SimpleCov::Formatter, SimpleCov::Formatter::HTMLFormatter]
-)
-SimpleCov.start
-
-RSpec.configure do |config|
-  config.disable_monkey_patching!
-
-  config.include RSpec::Sidekiq::Spec::Support::Factories
-end
-
-ActiveJob::Base.queue_adapter = :sidekiq
-
-if Gem::Dependency.new('sidekiq', '>= 5.0.0').matching_specs.any?
-  require 'active_record'
-  ActiveSupport.run_load_hooks(:active_record, ActiveRecord::Base)
-  Sidekiq::Extensions.enable_delay!
-end

data/spec/support/factories.rb

@@ -1,33 +0,0 @@
-module RSpec
-  module Sidekiq
-    module Spec
-      module Support
-        module Factories
-          def create_worker(options = {})
-            clazz_name = "Worker#{ rand(36**10).to_s 36 }"
-            clazz = Class.new do
-              include ::Sidekiq::Worker
-
-              sidekiq_options options
-
-              def perform
-              end
-            end
-            Object.const_set clazz_name, clazz
-          end
-
-          def create_active_job(options = {})
-            clazz_name = "ActiveJob#{ rand(36**10).to_s 36 }"
-            clazz = Class.new(ActiveJob::Base) do
-              queue_as options
-
-              def perform
-              end
-            end
-            Object.const_set clazz_name, clazz
-          end
-        end
-      end
-    end
-  end
-end

data/spec/support/init.rb

@@ -1,6 +0,0 @@
-require_relative 'factories'
-require_relative 'test_worker'
-require_relative 'test_worker_alternative'
-require_relative 'test_job'
-require_relative 'test_resource'
-require_relative 'test_action_mailer'

data/spec/support/test_action_mailer.rb

@@ -1,6 +0,0 @@
-class TestActionMailer < ActionMailer::Base
-  def  testmail(resource = nil)
-    @resource = resource
-    mail(to: 'none@example.com', subject: 'testmail')
-  end
-end

data/spec/support/test_job.rb

@@ -1,6 +0,0 @@
-class TestJob < ActiveJob::Base
-  queue_as :mailers
-
-  def perform
-  end
-end

data/spec/support/test_resource.rb

@@ -1,16 +0,0 @@
-class TestResource
-  include GlobalID::Identification
-
-  attr_reader :global_id
-
-  def initialize
-    @global_id = GlobalID.create(self, { app: 'rspec-sidekiq' })
-  end
-
-  def self.find(id)
-  end
-
-  def id
-    rand(36**10).to_s 36
-  end
-end

data/spec/support/test_worker.rb

@@ -1,8 +0,0 @@
-class TestWorker
-  include Sidekiq::Worker
-
-  sidekiq_options queue: :data, retry: 5, unique: true
-
-  def perform
-  end
-end

data/spec/support/test_worker_alternative.rb

@@ -1,8 +0,0 @@
-class TestWorkerAlternative
-  include Sidekiq::Worker
-
-  sidekiq_options queue: 'data', retry: false, unique: false
-
-  def perform
-  end
-end