rspec-sidekiq 3.0.3 → 4.0.0.pre

data/spec/rspec/sidekiq/batch_spec.rb

@@ -1,77 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'Batch' do
-  module Sidekiq
-    module Batch
-      class Status
-      end
-    end
-  end
-
-  load File.expand_path(File.join(File.dirname(__FILE__), '../../../lib/rspec/sidekiq/batch.rb'))
-
-  describe 'NullObject' do
-    describe '#method_missing' do
-      it 'returns itself' do
-        batch = Sidekiq::Batch.new
-        expect(batch.non_existent_method).to eq(batch)
-      end
-    end
-  end
-
-  describe 'NullBatch' do
-  end
-
-  describe 'NullStatus' do
-    let(:batch) {  Sidekiq::Batch.new }
-
-    subject { batch.status }
-
-    describe '#total' do
-      it 'returns 0 when no jobs' do
-        expect(subject.total).to eq(0)
-      end
-
-      it 'returns 1 when 1 job' do
-        batch.jobs do
-          TestWorker.perform_async('5')
-        end
-
-        expect(subject.total).to eq(1)
-      end
-    end
-
-    describe '#failures' do
-      it 'returns 0' do
-        expect(subject.failures).to eq(0)
-      end
-    end
-
-    describe '#bid' do
-      it 'returns a bid' do
-        expect(subject.bid).to_not be_nil
-      end
-    end
-
-    describe '#join' do
-      class MyCallback
-        def on_event(status, options); end
-      end
-
-      before(:each) do
-        batch.on(:event, MyCallback, my_arg: 42)
-      end
-
-      it 'executes callbacks' do
-        expect_any_instance_of(MyCallback).to receive(:on_event).with(subject, { my_arg: 42 })
-        subject.join
-      end
-    end
-
-    describe '#initialize' do
-      it 'uses default argument values when none are provided' do
-        expect { Sidekiq::Batch::Status.new }.to_not raise_error
-      end
-    end
-  end
-end

data/spec/rspec/sidekiq/helpers/retries_exhausted_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'Retries Exhausted block' do
-  class FooClass < TestWorkerAlternative
-    sidekiq_retries_exhausted do |msg, exception|
-      bar('hello')
-      foo(msg)
-      baz(exception)
-    end
-
-    def self.bar(input)
-    end
-
-    def self.foo(msg)
-    end
-
-    def self.baz(exception)
-    end
-  end
-
-  it 'executes whatever is within the block' do
-    FooClass.within_sidekiq_retries_exhausted_block { expect(FooClass).to receive(:bar).with('hello') }
-  end
-
-  it 'passes message and exception to the block' do
-    args = { 'args' => ['a', 'b']}
-    exception = StandardError.new('something went wrong')
-    FooClass.within_sidekiq_retries_exhausted_block(args, exception) do
-      expect(FooClass).to receive(:foo).with(FooClass.default_retries_exhausted_message.merge(args))
-      expect(FooClass).to receive(:baz).with(exception)
-    end
-  end
-
-  it 'sets a default value for the message and exception' do
-    FooClass.within_sidekiq_retries_exhausted_block do
-      expect(FooClass).to receive(:foo).with(FooClass.default_retries_exhausted_message)
-      expect(FooClass).to receive(:baz).with(FooClass.default_retries_exhausted_exception)
-    end
-  end
-end

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

@@ -1,238 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe RSpec::Sidekiq::Matchers::BeDelayed do
-  let(:delay_subject) { RSpec::Sidekiq::Matchers::BeDelayed.new }
-  let(:delay_with_arguments_subject) { RSpec::Sidekiq::Matchers::BeDelayed.new Object }
-  let(:delay_for_subject) { RSpec::Sidekiq::Matchers::BeDelayed.new.for 3600 }
-  let(:delay_for_with_arguments_subject) { RSpec::Sidekiq::Matchers::BeDelayed.new(Object).for 3600 }
-  let(:delay_until_subject) { RSpec::Sidekiq::Matchers::BeDelayed.new.until Time.now + 3600 }
-  let(:delay_until_with_arguments_subject) { RSpec::Sidekiq::Matchers::BeDelayed.new(Object).until Time.now + 3600 }
-  before(:each) do
-    delay_subject.matches? Object.method :nil?
-    delay_with_arguments_subject.matches? Object.method :is_a?
-
-    delay_for_subject.matches? Object.method :nil?
-    delay_for_with_arguments_subject.matches? Object.method :is_a?
-
-    delay_until_subject.matches? Object.method :nil?
-    delay_until_with_arguments_subject.matches? Object.method :is_a?
-  end
-
-  describe 'expected usage' do
-    it 'matches' do
-      Object.delay_for(3600).is_a? Object
-
-      expect(Object.method :is_a?).to be_delayed(Object).for 3600
-    end
-  end
-
-  describe '#be_delayed_job' do
-    it 'returns instance' do
-      expect(be_delayed).to be_a RSpec::Sidekiq::Matchers::BeDelayed
-    end
-  end
-
-  describe '#description' do
-    context 'when expected is a delay' do
-      it 'returns description' do
-        expect(delay_subject.description).to eq 'be delayed'
-      end
-    end
-
-    context 'when expected is a delay with arguments' do
-      it 'returns description' do
-        expect(delay_with_arguments_subject.description).to eq 'be delayed with arguments [Object]'
-      end
-    end
-
-    context 'when expected is a delay for' do
-      it 'returns description' do
-        expect(delay_for_subject.description).to eq 'be delayed for 3600 seconds'
-      end
-    end
-
-    context 'when expected is a delay for with arguments' do
-      it 'returns description' do
-        expect(delay_for_with_arguments_subject.description).to eq 'be delayed for 3600 seconds with arguments [Object]'
-      end
-    end
-
-    context 'when expected is a delay until' do
-      it 'returns description' do
-        expect(delay_until_subject.description).to eq "be delayed until #{Time.now + 3600}"
-      end
-    end
-
-    context 'when expected is a delay until with arguments' do
-      it 'returns description' do
-        expect(delay_until_with_arguments_subject.description).to eq "be delayed until #{Time.now + 3600} with arguments [Object]"
-      end
-    end
-  end
-
-  describe '#failure_message' do
-    context 'when expected is a delay' do
-      it 'returns message' do
-        expect(delay_subject.failure_message).to eq 'expected Object.nil? to be delayed'
-      end
-    end
-
-    context 'when expected is a delay with arguments' do
-      it 'returns message' do
-        expect(delay_with_arguments_subject.failure_message).to eq 'expected Object.is_a? to be delayed with arguments [Object]'
-      end
-    end
-
-    context 'when expected is a delay for' do
-      it 'returns message' do
-        expect(delay_for_subject.failure_message).to eq 'expected Object.nil? to be delayed for 3600 seconds'
-      end
-    end
-
-    context 'when expected is a delay for with arguments' do
-      it 'returns message' do
-        expect(delay_for_with_arguments_subject.failure_message).to eq 'expected Object.is_a? to be delayed for 3600 seconds with arguments [Object]'
-      end
-    end
-
-    context 'when expected is a delay until' do
-      it 'returns message' do
-        expect(delay_until_subject.failure_message).to eq "expected Object.nil? to be delayed until #{Time.now + 3600}"
-      end
-    end
-
-    context 'when expected is a delay until with arguments' do
-      it 'returns message' do
-        expect(delay_until_with_arguments_subject.failure_message).to eq "expected Object.is_a? to be delayed until #{Time.now + 3600} with arguments [Object]"
-      end
-    end
-  end
-
-  describe '#matches?' do
-    context 'when condition matches' do
-      context 'when expected is a delay' do
-        it 'returns true' do
-          Object.delay.nil?
-
-          expect(delay_subject.matches? Object.method :nil?).to be true
-        end
-      end
-
-      context 'when expected is a delay with arguments' do
-        it 'returns true' do
-          Object.delay.is_a? Object
-
-          expect(delay_with_arguments_subject.matches? Object.method :is_a?).to be true
-        end
-      end
-
-      context 'when expected is a delay for' do
-        it 'returns true' do
-          Object.delay_for(3600).nil?
-
-          expect(delay_for_subject.matches? Object.method :nil?).to be true
-        end
-      end
-
-      context 'when expected is a delay for with arguments' do
-        it 'returns true' do
-          Object.delay_for(3600).is_a? Object
-
-          expect(delay_for_with_arguments_subject.matches? Object.method :is_a?).to be true
-        end
-      end
-
-      context 'when expected is a delay until' do
-        it 'returns true' do
-          Object.delay_until(Time.now + 3600).nil?
-
-          expect(delay_until_subject.matches? Object.method :nil?).to be true
-        end
-      end
-
-      context 'when expected is a delay until with arguments' do
-        it 'returns true' do
-          Object.delay_until(Time.now + 3600).is_a? Object
-
-          expect(delay_until_with_arguments_subject.matches? Object.method :is_a?).to be true
-        end
-      end
-    end
-
-    context 'when condition does not match' do
-      context 'when expected is a delay' do
-        it 'returns false' do
-          expect(delay_subject.matches? Object.method :nil?).to be false
-        end
-      end
-
-      context 'when expected is a delay with arguments' do
-        it 'returns false' do
-          expect(delay_with_arguments_subject.matches? Object.method :is_a?).to be false
-        end
-      end
-
-      context 'when expected is a delay for' do
-        it 'returns false' do
-          expect(delay_for_subject.matches? Object.method :nil?).to be false
-        end
-      end
-
-      context 'when expected is a delay for with arguments' do
-        it 'returns false' do
-          expect(delay_for_with_arguments_subject.matches? Object.method :is_a?).to be false
-        end
-      end
-
-      context 'when expected is a delay until' do
-        it 'returns false' do
-          expect(delay_until_subject.matches? Object.method :nil?).to be false
-        end
-      end
-
-      context 'when expected is a delay until with arguments' do
-        it 'returns false' do
-          expect(delay_until_with_arguments_subject.matches? Object.method :is_a?).to be false
-        end
-      end
-    end
-  end
-
-  describe '#failure_message_when_negated' do
-    context 'when expected is a delay' do
-      it 'returns message' do
-        expect(delay_subject.failure_message_when_negated).to eq 'expected Object.nil? to not be delayed'
-      end
-    end
-
-    context 'when expected is a delay with arguments' do
-      it 'returns message' do
-        expect(delay_with_arguments_subject.failure_message_when_negated).to eq 'expected Object.is_a? to not be delayed with arguments [Object]'
-      end
-    end
-
-    context 'when expected is a delay for' do
-      it 'returns message' do
-        expect(delay_for_subject.failure_message_when_negated).to eq 'expected Object.nil? to not be delayed for 3600 seconds'
-      end
-    end
-
-    context 'when expected is a delay for with arguments' do
-      it 'returns message' do
-        expect(delay_for_with_arguments_subject.failure_message_when_negated).to eq 'expected Object.is_a? to not be delayed for 3600 seconds with arguments [Object]'
-      end
-    end
-
-    context 'when expected is a delay until' do
-      it 'returns message' do
-        expect(delay_until_subject.failure_message_when_negated).to eq "expected Object.nil? to not be delayed until #{Time.now + 3600}"
-      end
-    end
-
-    context 'when expected is a delay until with arguments' do
-      it 'returns message' do
-        expect(delay_until_with_arguments_subject.failure_message_when_negated).to eq "expected Object.is_a? to not be delayed until #{Time.now + 3600} with arguments [Object]"
-      end
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe RSpec::Sidekiq::Matchers::BeExpiredIn do
-  let(:subject) { RSpec::Sidekiq::Matchers::BeExpiredIn.new 1 }
-  let(:worker) { create_worker expires_in: 1 }
-
-  describe '#be_expired_in' do
-    it 'returns instance' do
-      expect(be_expired_in 1).to be_a RSpec::Sidekiq::Matchers::BeExpiredIn
-    end
-  end
-
-  describe 'expected usage' do
-    it 'matches' do
-      expect(worker).to be_expired_in 1
-    end
-
-    context 'with negated' do
-      it 'matches' do
-        expect(worker).to_not be_expired_in 2
-      end
-    end
-  end
-
-  describe '#failure_message' do
-    it 'returns message' do
-      subject.matches? worker
-      expect(subject.failure_message).to eq "expected to expire in #{worker.sidekiq_options['expires_in']} but expired in #{subject.instance_variable_get(:@expected_argument)}"
-    end
-  end
-
-  describe '#matches?' do
-    context 'when expected equals actual' do
-      it 'returns true' do
-        expect(subject.matches? worker).to be true
-      end
-    end
-    context 'when expected is not equal to actual' do
-      it 'returns false' do
-        expect(RSpec::Sidekiq::Matchers::BeExpiredIn.new(2).matches? worker). to be false
-      end
-    end
-  end
-
-  describe '#failure_message_when_negated' do
-    it 'returns message' do
-      subject.matches? worker
-      expect(subject.failure_message_when_negated).to eq "expected to not expire in #{subject.instance_variable_get(:@expected_argument)}"
-    end
-  end
-
-  describe '#description' do
-    it 'returns message' do
-      expect(subject.description).to eq "to expire in #{subject.instance_variable_get(:@expected_argument)}"
-    end
-  end
-end

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