rspec-sidekiq 3.1.0 → 4.0.1

data/.simplecov

@@ -1,5 +0,0 @@
-SimpleCov.start do
-  add_filter '/spec/'
-
-  coverage_dir 'tmp/spec_coverage'
-end

data/Gemfile

@@ -1,9 +0,0 @@
-source 'https://rubygems.org'
-
-platforms :rbx do
-  gem 'rubysl', '~> 2.0'
-  gem 'psych'
-  gem 'rubinius-developer_tools'
-end
-
-gemspec

data/lib/rspec/sidekiq/matchers/have_enqueued_job.rb

@@ -1,183 +0,0 @@
-module RSpec
-  module Sidekiq
-    module Matchers
-      def have_enqueued_sidekiq_job(*expected_arguments)
-        HaveEnqueuedJob.new expected_arguments
-      end
-
-      def have_enqueued_job(*expected_arguments)
-        warn "[DEPRECATION] `have_enqueued_job` is deprecated.  Please use `have_enqueued_sidekiq_job` instead."
-        have_enqueued_sidekiq_job(*expected_arguments)
-      end
-
-      class JobOptionParser
-        attr_reader :job
-
-        def initialize(job)
-          @job = job
-        end
-
-        def matches?(option, value)
-          raise ArgumentError, "Option `#{option}` is not defined." unless %w(in at).include?(option.to_s)
-          send("#{option}_evaluator", value)
-        end
-
-        private
-
-        def at_evaluator(value)
-          return false if job['at'].to_s.empty?
-          value.to_time.to_i == Time.at(job['at']).to_i
-        end
-
-        def in_evaluator(value)
-          return false if job['at'].to_s.empty?
-          (Time.now + value).to_i == Time.at(job['at']).to_i
-        end
-      end
-
-      class JobMatcher
-        attr_reader :jobs
-
-        def initialize(klass)
-          @jobs = unwrap_jobs(klass.jobs)
-        end
-
-        def present?(arguments, options)
-          !!find_job(arguments, options)
-        end
-
-        private
-
-        def matches?(job, arguments, options)
-          arguments_matches?(job, arguments) &&
-            options_matches?(job, options)
-        end
-
-        def arguments_matches?(job, arguments)
-          arguments_got = job_arguments(job)
-          contain_exactly?(arguments, arguments_got)
-        end
-
-        def options_matches?(job, options)
-          options.all? do |option, value|
-            parser = JobOptionParser.new(job)
-            parser.matches?(option, value)
-          end
-        end
-
-        def find_job(arguments, options)
-          jobs.find { |job| matches?(job, arguments, options) }
-        end
-
-        def job_arguments(job)
-          args = job['args']
-          return args[0]['arguments'] if args.is_a?(Array) && args[0].is_a?(Hash) && args[0].has_key?('arguments')
-          args
-        end
-
-        def unwrap_jobs(jobs)
-          return jobs if jobs.is_a?(Array)
-          jobs.values.flatten
-        end
-
-        def contain_exactly?(expected, got)
-          exactly = RSpec::Matchers::BuiltIn::ContainExactly.new(expected)
-          exactly.matches?(got)
-        end
-      end
-
-      class HaveEnqueuedJob
-        attr_reader :klass, :expected_arguments, :actual_arguments, :expected_options, :actual_options
-
-        def initialize(expected_arguments)
-          @expected_arguments = normalize_arguments(expected_arguments)
-          @expected_options = {}
-        end
-
-        def matches?(klass)
-          @klass = klass
-          @actual_arguments = unwrapped_job_arguments(klass.jobs)
-          @actual_options = unwrapped_job_options(klass.jobs)
-          JobMatcher.new(klass).present?(expected_arguments, expected_options)
-        end
-
-        def at(timestamp)
-          @expected_options['at'] = timestamp
-          self
-        end
-
-        def in(interval)
-          @expected_options['in'] = interval
-          self
-        end
-
-        def description
-          "have an enqueued #{klass} job with arguments #{expected_arguments}"
-        end
-
-        def failure_message
-          message = ["expected to have an enqueued #{klass} job"]
-          message << "  arguments: #{expected_arguments}" if expected_arguments
-          message << "  options: #{expected_options}" if expected_options.any?
-          message << "found"
-          message << "  arguments: #{actual_arguments}" if expected_arguments
-          message << "  options: #{actual_options}" if expected_options.any?
-          message.join("\n")
-        end
-
-        def failure_message_when_negated
-          message = ["expected not to have an enqueued #{klass} job"]
-          message << "  arguments: #{expected_arguments}" if expected_arguments.any?
-          message << "  options: #{expected_options}" if expected_options.any?
-          message.join("\n")
-        end
-
-        private
-
-        def unwrapped_job_options(jobs)
-          jobs = jobs.values if jobs.is_a?(Hash)
-          jobs.flatten.map do |job|
-            { 'at' => job['at'] }
-          end
-        end
-
-        def unwrapped_job_arguments(jobs)
-          if jobs.is_a? Hash
-            jobs.values.flatten.map do |job|
-              map_arguments(job)
-            end
-          else
-            map_arguments(jobs)
-          end.map { |job| job.flatten }
-        end
-
-        def map_arguments(job)
-          args = job_arguments(job) || job
-          if args.respond_to?(:any?) && args.any? { |e| e.is_a? Hash }
-            args.map { |a| map_arguments(a) }
-          else
-            args
-          end
-        end
-
-        def job_arguments(hash)
-          hash['arguments'] || hash['args'] if hash.is_a? Hash
-        end
-
-        def normalize_arguments(args)
-          if args.is_a?(Array)
-            args.map{ |x| normalize_arguments(x) }
-          elsif args.is_a?(Hash)
-            args.each_with_object({}) do |(key, value), hash|
-              hash[key.to_s] = normalize_arguments(value)
-            end
-          elsif args.is_a?(Symbol)
-            args.to_s
-          else
-            args
-          end
-        end
-      end
-    end
-  end
-end

data/rspec-sidekiq.gemspec

@@ -1,39 +0,0 @@
-require File.expand_path('../lib/rspec/sidekiq/version', __FILE__)
-
-Gem::Specification.new do |s|
-  s.name        = 'rspec-sidekiq'
-  s.version     = RSpec::Sidekiq::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.author      = 'Phil Ostler'
-  s.email       = 'github@philostler.com'
-  s.homepage    = 'http://github.com/philostler/rspec-sidekiq'
-  s.summary     = 'RSpec for Sidekiq'
-  s.description = 'Simple testing of Sidekiq jobs via a collection of matchers and helpers'
-  s.license     = 'MIT'
-
-  s.add_dependency 'rspec-core', '~> 3.0', '>= 3.0.0'
-  s.add_dependency 'sidekiq', '>= 2.4.0'
-
-  s.add_development_dependency 'rspec'
-  s.add_development_dependency 'coveralls'
-  s.add_development_dependency 'fuubar'
-  s.add_development_dependency 'activejob'
-  s.add_development_dependency 'actionmailer'
-  s.add_development_dependency 'activerecord'
-  s.add_development_dependency 'activemodel'
-  s.add_development_dependency 'activesupport'
-
-
-  s.files = Dir['.gitattributes'] +
-            Dir['.gitignore'] +
-            Dir['.rspec'] +
-            Dir['.simplecov'] +
-            Dir['.travis'] +
-            Dir['CHANGES.md'] +
-            Dir['Gemfile'] +
-            Dir['LICENSE'] +
-            Dir['README.md'] +
-            Dir['rspec-sidekiq.gemspec'] +
-            Dir['**/*.rb']
-  s.require_paths = ['lib']
-end

data/spec/rspec/sidekiq/batch_spec.rb

@@ -1,83 +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
-
-      class OtherCallback
-        def foo(status, options); end
-      end
-
-      before(:each) do
-        batch.on(:event, MyCallback, my_arg: 42)
-        batch.on(:event, 'OtherCallback#foo', my_arg: 23)
-      end
-
-      it 'executes callbacks' do
-        expect_any_instance_of(MyCallback).to receive(:on_event).with(subject, { my_arg: 42 })
-        expect_any_instance_of(OtherCallback).to receive(:foo).with(subject, { my_arg: 23 })
-        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