delayed_job 4.0.2 → 4.0.3

data/spec/helper.rb

@@ -1,3 +1,15 @@
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatters = [SimpleCov::Formatter::HTMLFormatter, Coveralls::SimpleCov::Formatter]
+
+SimpleCov.start do
+  add_filter '/spec/'
+  # Each version of ruby and version of rails test different things
+  # This should probably just be removed.
+  minimum_coverage(85.0)
+end
+
 require 'logger'
 require 'rspec'
 
@@ -8,18 +20,15 @@ require 'active_record'
 require 'delayed_job'
 require 'delayed/backend/shared_spec'
 
-require 'simplecov'
-require 'coveralls'
-
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-  SimpleCov::Formatter::HTMLFormatter,
-  Coveralls::SimpleCov::Formatter
-]
-SimpleCov.start
-
 Delayed::Worker.logger = Logger.new('/tmp/dj.log')
 ENV['RAILS_ENV'] = 'test'
 
+module Rails
+  def self.root
+    '.'
+  end
+end
+
 Delayed::Worker.backend = :test
 
 # Add this directory so the ActiveSupport autoloading works
@@ -28,7 +37,6 @@ ActiveSupport::Dependencies.autoload_paths << File.dirname(__FILE__)
 # Add this to simulate Railtie initializer being executed
 ActionMailer::Base.extend(Delayed::DelayMail)
 
-
 # Used to test interactions between DJ and an ORM
 ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => ':memory:'
 ActiveRecord::Base.logger = Delayed::Worker.logger
@@ -43,8 +51,13 @@ end
 
 class Story < ActiveRecord::Base
   self.primary_key = 'story_id'
-  def tell; text; end
-  def whatever(n, _); tell*n; end
+  def tell
+    text
+  end
+
+  def whatever(n, _)
+    tell * n
+  end
   default_scope { where(:scoped => true) }
 
   handle_asynchronously :whatever

data/spec/lifecycle_spec.rb

@@ -2,36 +2,36 @@ require 'helper'
 
 describe Delayed::Lifecycle do
   let(:lifecycle) { Delayed::Lifecycle.new }
-  let(:callback) { lambda {|*args|} }
+  let(:callback) { lambda { |*_args| } }
   let(:arguments) { [1] }
   let(:behavior) { double(Object, :before! => nil, :after! => nil, :inside! => nil) }
-  let(:wrapped_block) { Proc.new { behavior.inside! } }
+  let(:wrapped_block) { proc { behavior.inside! } }
 
-  describe "before callbacks" do
+  describe 'before callbacks' do
     before(:each) do
       lifecycle.before(:execute, &callback)
     end
 
-    it "executes before wrapped block" do
+    it 'executes before wrapped block' do
       expect(callback).to receive(:call).with(*arguments).ordered
       expect(behavior).to receive(:inside!).ordered
       lifecycle.run_callbacks :execute, *arguments, &wrapped_block
     end
   end
 
-  describe "after callbacks" do
+  describe 'after callbacks' do
     before(:each) do
       lifecycle.after(:execute, &callback)
     end
 
-    it "executes after wrapped block" do
+    it 'executes after wrapped block' do
       expect(behavior).to receive(:inside!).ordered
       expect(callback).to receive(:call).with(*arguments).ordered
       lifecycle.run_callbacks :execute, *arguments, &wrapped_block
     end
   end
 
-  describe "around callbacks" do
+  describe 'around callbacks' do
     before(:each) do
       lifecycle.around(:execute) do |*args, &block|
         behavior.before!
@@ -40,28 +40,36 @@ describe Delayed::Lifecycle do
       end
     end
 
-    it "wraps a block" do
+    it 'wraps a block' do
       expect(behavior).to receive(:before!).ordered
       expect(behavior).to receive(:inside!).ordered
       expect(behavior).to receive(:after!).ordered
       lifecycle.run_callbacks :execute, *arguments, &wrapped_block
     end
 
-    it "executes multiple callbacks in order" do
+    it 'executes multiple callbacks in order' do
       expect(behavior).to receive(:one).ordered
       expect(behavior).to receive(:two).ordered
       expect(behavior).to receive(:three).ordered
 
-      lifecycle.around(:execute) { |*args, &block| behavior.one; block.call(*args) }
-      lifecycle.around(:execute) { |*args, &block| behavior.two; block.call(*args) }
-      lifecycle.around(:execute) { |*args, &block| behavior.three; block.call(*args) }
-
+      lifecycle.around(:execute) do |*args, &block|
+        behavior.one
+        block.call(*args)
+      end
+      lifecycle.around(:execute) do |*args, &block|
+        behavior.two
+        block.call(*args)
+      end
+      lifecycle.around(:execute) do |*args, &block|
+        behavior.three
+        block.call(*args)
+      end
       lifecycle.run_callbacks(:execute, *arguments, &wrapped_block)
     end
   end
 
-  it "raises if callback is executed with wrong number of parameters" do
+  it 'raises if callback is executed with wrong number of parameters' do
     lifecycle.before(:execute, &callback)
-    expect { lifecycle.run_callbacks(:execute, 1,2,3) {} }.to raise_error(ArgumentError, /1 parameter/)
+    expect { lifecycle.run_callbacks(:execute, 1, 2, 3) {} }.to raise_error(ArgumentError, /1 parameter/)
   end
 end

data/spec/message_sending_spec.rb

@@ -1,35 +1,35 @@
 require 'helper'
 
 describe Delayed::MessageSending do
-  describe "handle_asynchronously" do
+  describe 'handle_asynchronously' do
     class Story
-      def tell!(arg);end
+      def tell!(_arg); end
       handle_asynchronously :tell!
     end
 
-    it "aliases original method" do
+    it 'aliases original method' do
       expect(Story.new).to respond_to(:tell_without_delay!)
       expect(Story.new).to respond_to(:tell_with_delay!)
     end
 
-    it "creates a PerformableMethod" do
+    it 'creates a PerformableMethod' do
       story = Story.create
-      expect {
+      expect do
         job = story.tell!(1)
         expect(job.payload_object.class).to eq(Delayed::PerformableMethod)
         expect(job.payload_object.method_name).to eq(:tell_without_delay!)
         expect(job.payload_object.args).to eq([1])
-      }.to change { Delayed::Job.count }
+      end.to change { Delayed::Job.count }
     end
 
-    describe "with options" do
+    describe 'with options' do
       class Fable
         cattr_accessor :importance
-        def tell;end
-        handle_asynchronously :tell, :priority => Proc.new { self.importance }
+        def tell; end
+        handle_asynchronously :tell, :priority => proc { importance }
       end
 
-      it "sets the priority based on the Fable importance" do
+      it 'sets the priority based on the Fable importance' do
         Fable.importance = 10
         job = Fable.new.tell
         expect(job.priority).to eq(10)
@@ -39,29 +39,29 @@ describe Delayed::MessageSending do
         expect(job.priority).to eq(20)
       end
 
-      describe "using a proc with parameters" do
+      describe 'using a proc with parameters' do
         class Yarn
           attr_accessor :importance
           def spin
           end
-          handle_asynchronously :spin, :priority => Proc.new {|y| y.importance }
+          handle_asynchronously :spin, :priority => proc { |y| y.importance }
         end
 
-        it "sets the priority based on the Fable importance" do
-          job = Yarn.new.tap {|y| y.importance = 10 }.spin
+        it 'sets the priority based on the Fable importance' do
+          job = Yarn.new.tap { |y| y.importance = 10 }.spin
           expect(job.priority).to eq(10)
 
-          job = Yarn.new.tap {|y| y.importance = 20 }.spin
+          job = Yarn.new.tap { |y| y.importance = 20 }.spin
           expect(job.priority).to eq(20)
         end
       end
     end
   end
 
-  context "delay" do
+  context 'delay' do
     class FairyTail
       attr_accessor :happy_ending
-      def self.princesses;end
+      def self.princesses; end
       def tell
         @happy_ending = true
       end
@@ -71,52 +71,52 @@ describe Delayed::MessageSending do
       Delayed::Worker.default_queue_name = nil
     end
 
-    it "creates a new PerformableMethod job" do
-      expect {
-        job = "hello".delay.count('l')
+    it 'creates a new PerformableMethod job' do
+      expect do
+        job = 'hello'.delay.count('l')
         expect(job.payload_object.class).to eq(Delayed::PerformableMethod)
         expect(job.payload_object.method_name).to eq(:count)
         expect(job.payload_object.args).to eq(['l'])
-      }.to change { Delayed::Job.count }.by(1)
+      end.to change { Delayed::Job.count }.by(1)
     end
 
-    it "sets default priority" do
+    it 'sets default priority' do
       Delayed::Worker.default_priority = 99
       job = FairyTail.delay.to_s
       expect(job.priority).to eq(99)
     end
 
-    it "sets default queue name" do
+    it 'sets default queue name' do
       Delayed::Worker.default_queue_name = 'abbazabba'
       job = FairyTail.delay.to_s
       expect(job.queue).to eq('abbazabba')
     end
 
-    it "sets job options" do
+    it 'sets job options' do
       run_at = Time.parse('2010-05-03 12:55 AM')
       job = FairyTail.delay(:priority => 20, :run_at => run_at).to_s
       expect(job.run_at).to eq(run_at)
       expect(job.priority).to eq(20)
     end
 
-    it "does not delay the job when delay_jobs is false" do
+    it 'does not delay the job when delay_jobs is false' do
       Delayed::Worker.delay_jobs = false
       fairy_tail = FairyTail.new
-      expect {
-        expect {
+      expect do
+        expect do
           fairy_tail.delay.tell
-        }.to change(fairy_tail, :happy_ending).from(nil).to(true)
-      }.not_to change { Delayed::Job.count }
+        end.to change(fairy_tail, :happy_ending).from(nil).to(true)
+      end.not_to change { Delayed::Job.count }
     end
 
-    it "does delay the job when delay_jobs is true" do
+    it 'does delay the job when delay_jobs is true' do
       Delayed::Worker.delay_jobs = true
       fairy_tail = FairyTail.new
-      expect {
-        expect {
+      expect do
+        expect do
           fairy_tail.delay.tell
-        }.not_to change(fairy_tail, :happy_ending)
-      }.to change { Delayed::Job.count }.by(1)
+        end.not_to change(fairy_tail, :happy_ending)
+      end.to change { Delayed::Job.count }.by(1)
     end
   end
 end

data/spec/performable_mailer_spec.rb

@@ -3,33 +3,33 @@ require 'helper'
 require 'action_mailer'
 class MyMailer < ActionMailer::Base
   def signup(email)
-    mail :to => email, :subject => "Delaying Emails", :from => "delayedjob@example.com",:body => 'Delaying Emails Body'
+    mail :to => email, :subject => 'Delaying Emails', :from => 'delayedjob@example.com', :body => 'Delaying Emails Body'
   end
 end
 
 describe ActionMailer::Base do
-  describe "delay" do
-    it "enqueues a PerformableEmail job" do
-      expect {
+  describe 'delay' do
+    it 'enqueues a PerformableEmail job' do
+      expect do
         job = MyMailer.delay.signup('john@example.com')
         expect(job.payload_object.class).to eq(Delayed::PerformableMailer)
         expect(job.payload_object.method_name).to eq(:signup)
         expect(job.payload_object.args).to eq(['john@example.com'])
-      }.to change { Delayed::Job.count }.by(1)
+      end.to change { Delayed::Job.count }.by(1)
     end
   end
 
-  describe "delay on a mail object" do
-    it "raises an exception" do
-      expect {
+  describe 'delay on a mail object' do
+    it 'raises an exception' do
+      expect do
         MyMailer.signup('john@example.com').delay
-      }.to raise_error(RuntimeError)
+      end.to raise_error(RuntimeError)
     end
   end
 
   describe Delayed::PerformableMailer do
-    describe "perform" do
-      it "calls the method and #deliver on the mailer" do
+    describe 'perform' do
+      it 'calls the method and #deliver on the mailer' do
         email = double('email', :deliver => true)
         mailer_class = double('MailerClass', :signup => email)
         mailer = Delayed::PerformableMailer.new(mailer_class, :signup, ['john@example.com'])

data/spec/performable_method_spec.rb

@@ -1,46 +1,44 @@
 require 'helper'
 
 describe Delayed::PerformableMethod do
-  describe "perform" do
+  describe 'perform' do
     before do
-      @method = Delayed::PerformableMethod.new("foo", :count, ['o'])
+      @method = Delayed::PerformableMethod.new('foo', :count, ['o'])
     end
 
-    context "with the persisted record cannot be found" do
+    context 'with the persisted record cannot be found' do
       before do
         @method.object = nil
       end
 
-      it "does nothing if object is nil" do
-        expect{@method.perform}.not_to raise_error
+      it 'does nothing if object is nil' do
+        expect { @method.perform }.not_to raise_error
       end
     end
 
-    it "calls the method on the object" do
+    it 'calls the method on the object' do
       expect(@method.object).to receive(:count).with('o')
       @method.perform
     end
   end
 
   it "raises a NoMethodError if target method doesn't exist" do
-    expect {
+    expect do
       Delayed::PerformableMethod.new(Object, :method_that_does_not_exist, [])
-    }.to raise_error(NoMethodError)
+    end.to raise_error(NoMethodError)
   end
 
-  it "does not raise NoMethodError if target method is private" do
+  it 'does not raise NoMethodError if target method is private' do
     clazz = Class.new do
       def private_method
       end
       private :private_method
     end
-    expect {
-      Delayed::PerformableMethod.new(clazz.new, :private_method, [])
-    }.not_to raise_error
+    expect { Delayed::PerformableMethod.new(clazz.new, :private_method, []) }.not_to raise_error
   end
 
-  describe "hooks" do
-    %w(before after success).each do |hook|
+  describe 'hooks' do
+    %w[before after success].each do |hook|
       it "delegates #{hook} hook to object" do
         story = Story.create
         job = story.delay.tell
@@ -50,7 +48,7 @@ describe Delayed::PerformableMethod do
       end
     end
 
-    %w(before after success).each do |hook|
+    %w[before after success].each do |hook|
       it "delegates #{hook} hook to object" do
         story = Story.create
         job = story.delay.tell
@@ -60,28 +58,28 @@ describe Delayed::PerformableMethod do
       end
     end
 
-    it "delegates enqueue hook to object" do
+    it 'delegates enqueue hook to object' do
       story = Story.create
       expect(story).to receive(:enqueue).with(an_instance_of(Delayed::Job))
       story.delay.tell
     end
 
-    it "delegates error hook to object" do
+    it 'delegates error hook to object' do
       story = Story.create
       expect(story).to receive(:error).with(an_instance_of(Delayed::Job), an_instance_of(RuntimeError))
       expect(story).to receive(:tell).and_raise(RuntimeError)
       expect { story.delay.tell.invoke_job }.to raise_error
     end
 
-    it "delegates error hook to object when delay_jobs = false" do
+    it 'delegates error hook to object when delay_jobs = false' do
       story = Story.create
       expect(story).to receive(:error).with(an_instance_of(Delayed::Job), an_instance_of(RuntimeError))
       expect(story).to receive(:tell).and_raise(RuntimeError)
       expect { story.delay.tell.invoke_job }.to raise_error
     end
 
-    it "delegates failure hook to object" do
-      method = Delayed::PerformableMethod.new("object", :size, [])
+    it 'delegates failure hook to object' do
+      method = Delayed::PerformableMethod.new('object', :size, [])
       expect(method.object).to receive(:failure)
       method.failure
     end
@@ -95,7 +93,7 @@ describe Delayed::PerformableMethod do
         Delayed::Worker.delay_jobs = true
       end
 
-      %w(before after success).each do |hook|
+      %w[before after success].each do |hook|
         it "delegates #{hook} hook to object" do
           story = Story.create
           expect(story).to receive(hook).with(an_instance_of(Delayed::Job))
@@ -103,7 +101,7 @@ describe Delayed::PerformableMethod do
         end
       end
 
-      %w(before after success).each do |hook|
+      %w[before after success].each do |hook|
         it "delegates #{hook} hook to object" do
           story = Story.create
           expect(story).to receive(hook).with(an_instance_of(Delayed::Job))
@@ -111,23 +109,23 @@ describe Delayed::PerformableMethod do
         end
       end
 
-      it "delegates error hook to object" do
+      it 'delegates error hook to object' do
         story = Story.create
         expect(story).to receive(:error).with(an_instance_of(Delayed::Job), an_instance_of(RuntimeError))
         expect(story).to receive(:tell).and_raise(RuntimeError)
         expect { story.delay.tell }.to raise_error
       end
 
-      it "delegates error hook to object when delay_jobs = false" do
+      it 'delegates error hook to object when delay_jobs = false' do
         story = Story.create
         expect(story).to receive(:error).with(an_instance_of(Delayed::Job), an_instance_of(RuntimeError))
         expect(story).to receive(:tell).and_raise(RuntimeError)
         expect { story.delay.tell }.to raise_error
       end
 
-      it "delegates failure hook to object when delay_jobs = false" do
+      it 'delegates failure hook to object when delay_jobs = false' do
         Delayed::Worker.delay_jobs = false
-        method = Delayed::PerformableMethod.new("object", :size, [])
+        method = Delayed::PerformableMethod.new('object', :size, [])
         expect(method.object).to receive(:failure)
         method.failure
       end