rspec-sidekiq 3.1.0 → 4.0.1

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

@@ -1,114 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe RSpec::Sidekiq::Matchers::BeProcessedIn do
-  let(:symbol_subject) { RSpec::Sidekiq::Matchers::BeProcessedIn.new :a_queue }
-  let(:symbol_worker) { create_worker queue: :a_queue }
-  let(:string_subject) { RSpec::Sidekiq::Matchers::BeProcessedIn.new 'a_queue' }
-  let(:string_worker) { create_worker queue: 'a_queue' }
-  let(:active_job) { create_active_job :mailers }
-
-  before(:each) do
-    symbol_subject.matches? symbol_worker
-    string_subject.matches? string_worker
-  end
-
-  describe 'expected usage' do
-    it 'matches' do
-      expect(symbol_worker).to be_processed_in :a_queue
-    end
-
-    it 'matches on an ActiveJob' do
-      expect(active_job).to be_processed_in :mailers
-    end
-  end
-
-  describe '#be_processed_in' do
-    it 'returns instance' do
-      expect(be_processed_in :a_queue).to be_a RSpec::Sidekiq::Matchers::BeProcessedIn
-    end
-  end
-
-  describe '#description' do
-    context 'when expected is a symbol' do
-      it 'returns description' do
-        expect(symbol_subject.description).to eq "be processed in the \"a_queue\" queue"
-      end
-    end
-
-    context 'when expected is a string' do
-      it 'returns description' do
-        expect(string_subject.description).to eq "be processed in the \"a_queue\" queue"
-      end
-    end
-  end
-
-  describe '#failure_message' do
-    context 'when expected is a symbol' do
-      it 'returns message' do
-        expect(symbol_subject.failure_message).to eq "expected #{symbol_worker} to be processed in the \"a_queue\" queue but got \"a_queue\""
-      end
-    end
-
-    context 'when expected is a string' do
-      it 'returns message' do
-        expect(string_subject.failure_message).to eq "expected #{string_worker} to be processed in the \"a_queue\" queue but got \"a_queue\""
-      end
-    end
-  end
-
-  describe '#matches?' do
-    context 'when condition matches' do
-      context 'when expected is a symbol' do
-        it 'returns true' do
-          expect(symbol_subject.matches? symbol_worker).to be true
-        end
-      end
-
-      context 'when expected is a symbol and actual is string' do
-        it 'returns true' do
-          expect(symbol_subject.matches? string_worker).to be true
-        end
-      end
-
-      context 'when expected is a string' do
-        it 'returns true' do
-          expect(string_subject.matches? string_worker).to be true
-        end
-      end
-
-      context 'when expected is a string and actual is symbol' do
-        it 'returns true' do
-          expect(string_subject.matches? symbol_worker).to be true
-        end
-      end
-    end
-
-    context 'when condition does not match' do
-      context 'when expected is a symbol' do
-        it 'returns false' do
-          expect(symbol_subject.matches? create_worker queue: :another_queue).to be false
-        end
-      end
-
-      context 'when expected is a string' do
-        it 'returns false' do
-          expect(string_subject.matches? create_worker queue: 'another_queue').to be false
-        end
-      end
-    end
-  end
-
-  describe '#failure_message_when_negated' do
-    context 'when expected is a symbol' do
-      it 'returns message' do
-        expect(symbol_subject.failure_message_when_negated).to eq "expected #{symbol_worker} to not be processed in the \"a_queue\" queue"
-      end
-    end
-
-    context 'when expected is a string' do
-      it 'returns message' do
-        expect(string_subject.failure_message_when_negated).to eq "expected #{string_worker} to not be processed in the \"a_queue\" queue"
-      end
-    end
-  end
-end

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

@@ -1,129 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe RSpec::Sidekiq::Matchers::BeRetryable do
-  let(:specific_subject) { RSpec::Sidekiq::Matchers::BeRetryable.new 2 }
-  let(:specific_worker) { create_worker retry: 2 }
-  let(:default_subject) { RSpec::Sidekiq::Matchers::BeRetryable.new true }
-  let(:default_worker) { create_worker retry: true }
-  let(:negative_subject) { RSpec::Sidekiq::Matchers::BeRetryable.new false }
-  let(:negative_worker) { create_worker retry: 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 be_retryable true
-    end
-  end
-
-  describe '#be_retryable' do
-    it 'returns instance' do
-      expect(be_retryable true).to be_a RSpec::Sidekiq::Matchers::BeRetryable
-    end
-  end
-
-  describe '#description' do
-    context 'when expected is a number' do
-      it 'returns description' do
-        expect(specific_subject.description).to eq 'retry 2 times'
-      end
-    end
-
-    context 'when expected is true' do
-      it 'returns description' do
-        expect(default_subject.description).to eq 'retry the default number of times'
-      end
-    end
-
-    context 'when expected is false' do
-      it 'returns description' do
-        expect(negative_subject.description).to eq 'not retry'
-      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 retry 2 times 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 retry the default number of times 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 retry 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 retry 2 times"
-      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 retry the default number of times"
-      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 retry"
-      end
-    end
-  end
-end

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 RuntimeError, 'No support found for Sidekiq unique jobs'
-      end
-    end
-  end
-end

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

@@ -1,229 +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(Integer), 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
-    GlobalID.app = 'rspec-sidekiq'
-    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