delayed_job 4.0.6 → 4.1.8

data/lib/delayed_job.rb

@@ -3,20 +3,24 @@ require 'delayed/compatibility'
 require 'delayed/exceptions'
 require 'delayed/message_sending'
 require 'delayed/performable_method'
-
-if defined?(ActionMailer)
-  require 'action_mailer/version'
-  require 'delayed/performable_mailer'
-end
-
 require 'delayed/yaml_ext'
 require 'delayed/lifecycle'
 require 'delayed/plugin'
 require 'delayed/plugins/clear_locks'
 require 'delayed/backend/base'
+require 'delayed/backend/job_preparer'
 require 'delayed/worker'
 require 'delayed/deserialization_error'
 require 'delayed/railtie' if defined?(Rails::Railtie)
 
+ActiveSupport.on_load(:action_mailer) do
+  require 'delayed/performable_mailer'
+  ActionMailer::Base.extend(Delayed::DelayMail)
+end
+
+module Delayed
+  autoload :PerformableMailer, 'delayed/performable_mailer'
+end
+
 Object.send(:include, Delayed::MessageSending)
-Module.send(:include, Delayed::MessageSending::ClassMethods)
+Module.send(:include, Delayed::MessageSendingClassMethods)

data/lib/generators/delayed_job/delayed_job_generator.rb

@@ -6,6 +6,6 @@ class DelayedJobGenerator < Rails::Generators::Base
 
   def create_executable_file
     template 'script', "#{Delayed::Compatibility.executable_prefix}/delayed_job"
-    chmod "#{Delayed::Compatibility.executable_prefix}/delayed_job", 0755
+    chmod "#{Delayed::Compatibility.executable_prefix}/delayed_job", 0o755
   end
 end

data/spec/autoloaded/clazz.rb

@@ -1,7 +1,6 @@
 # Make sure this file does not get required manually
 module Autoloaded
   class Clazz
-    def perform
-    end
+    def perform; end
   end
 end

data/spec/autoloaded/instance_clazz.rb

@@ -1,6 +1,5 @@
 module Autoloaded
   class InstanceClazz
-    def perform
-    end
+    def perform; end
   end
 end

data/spec/autoloaded/instance_struct.rb

@@ -1,6 +1,6 @@
 module Autoloaded
-  class InstanceStruct < ::Struct.new(nil)
-    def perform
-    end
+  InstanceStruct = ::Struct.new(nil)
+  class InstanceStruct
+    def perform; end
   end
 end

data/spec/autoloaded/struct.rb

@@ -1,7 +1,7 @@
 # Make sure this file does not get required manually
 module Autoloaded
-  class Struct < ::Struct.new(nil)
-    def perform
-    end
+  Struct = ::Struct.new(nil)
+  class Struct
+    def perform; end
   end
 end

data/spec/daemons.rb

@@ -0,0 +1,2 @@
+# Fake "daemons" file on the spec load path to allow spec/delayed/command_spec.rb
+# to test the Delayed::Command class without actually adding daemons as a dependency.

data/spec/delayed/backend/test.rb

@@ -87,11 +87,6 @@ module Delayed
           Time.current
         end
 
-        def update_attributes(attrs = {})
-          attrs.each { |k, v| send(:"#{k}=", v) }
-          save
-        end
-
         def destroy
           self.class.all.delete(self)
         end

data/spec/delayed/command_spec.rb

@@ -2,6 +2,129 @@ require 'helper'
 require 'delayed/command'
 
 describe Delayed::Command do
+  let(:options) { [] }
+  let(:logger) { double('Logger') }
+
+  subject { Delayed::Command.new options }
+
+  before do
+    allow(Delayed::Worker).to receive(:after_fork)
+    allow(Dir).to receive(:chdir)
+    allow(Logger).to receive(:new).and_return(logger)
+    allow_any_instance_of(Delayed::Worker).to receive(:start)
+    allow(Delayed::Worker).to receive(:logger=)
+    allow(Delayed::Worker).to receive(:logger).and_return(nil, logger)
+  end
+
+  shared_examples_for 'uses --log-dir option' do
+    context 'when --log-dir is specified' do
+      let(:options) { ['--log-dir=/custom/log/dir'] }
+
+      it 'creates the delayed_job.log in the specified directory' do
+        expect(Logger).to receive(:new).with('/custom/log/dir/delayed_job.log')
+        subject.run
+      end
+    end
+  end
+
+  describe 'run' do
+    it 'sets the Delayed::Worker logger' do
+      expect(Delayed::Worker).to receive(:logger=).with(logger)
+      subject.run
+    end
+
+    context 'when Rails root is defined' do
+      let(:rails_root) { Pathname.new '/rails/root' }
+      let(:rails) { double('Rails', :root => rails_root) }
+
+      before do
+        stub_const('Rails', rails)
+      end
+
+      it 'runs the Delayed::Worker process in Rails.root' do
+        expect(Dir).to receive(:chdir).with(rails_root)
+        subject.run
+      end
+
+      context 'when --log-dir is not specified' do
+        it 'creates the delayed_job.log in Rails.root/log' do
+          expect(Logger).to receive(:new).with('/rails/root/log/delayed_job.log')
+          subject.run
+        end
+      end
+
+      include_examples 'uses --log-dir option'
+    end
+
+    context 'when Rails root is not defined' do
+      let(:rails_without_root) { double('Rails') }
+
+      before do
+        stub_const('Rails', rails_without_root)
+      end
+
+      it 'runs the Delayed::Worker process in $PWD' do
+        expect(Dir).to receive(:chdir).with(Delayed::Command::DIR_PWD)
+        subject.run
+      end
+
+      context 'when --log-dir is not specified' do
+        it 'creates the delayed_job.log in $PWD/log' do
+          expect(Logger).to receive(:new).with("#{Delayed::Command::DIR_PWD}/log/delayed_job.log")
+          subject.run
+        end
+      end
+
+      include_examples 'uses --log-dir option'
+    end
+
+    context 'when an error is raised' do
+      let(:test_error) { Class.new(StandardError) }
+
+      before do
+        allow(Delayed::Worker).to receive(:new).and_raise(test_error.new('An error'))
+        allow(subject).to receive(:exit_with_error_status)
+        allow(STDERR).to receive(:puts)
+      end
+
+      it 'prints the error message to STDERR' do
+        expect(STDERR).to receive(:puts).with('An error')
+        subject.run
+      end
+
+      it 'exits with an error status' do
+        expect(subject).to receive(:exit_with_error_status)
+        subject.run
+      end
+
+      context 'when Rails logger is not defined' do
+        let(:rails) { double('Rails') }
+
+        before do
+          stub_const('Rails', rails)
+        end
+
+        it 'does not attempt to use the Rails logger' do
+          subject.run
+        end
+      end
+
+      context 'when Rails logger is defined' do
+        let(:rails_logger) { double('Rails logger') }
+        let(:rails) { double('Rails', :logger => rails_logger) }
+
+        before do
+          stub_const('Rails', rails)
+        end
+
+        it 'logs the error to the Rails logger' do
+          expect(rails_logger).to receive(:fatal).with(test_error)
+          subject.run
+        end
+      end
+    end
+  end
+
   describe 'parsing --pool argument' do
     it 'should parse --pool correctly' do
       command = Delayed::Command.new(['--pool=*:1', '--pool=test_queue:4', '--pool=mailers,misc:2'])
@@ -36,17 +159,16 @@ describe Delayed::Command do
   describe 'running worker pools defined by multiple --pool arguments' do
     it 'should run the correct worker processes' do
       command = Delayed::Command.new(['--pool=*:1', '--pool=test_queue:4', '--pool=mailers,misc:2'])
-
-      expect(Dir).to receive(:mkdir).with('./tmp/pids').once
+      expect(FileUtils).to receive(:mkdir_p).with('./tmp/pids').once
 
       [
-        ['delayed_job.0', {:quiet => true, :pid_dir => './tmp/pids', :queues => []}],
-        ['delayed_job.1', {:quiet => true, :pid_dir => './tmp/pids', :queues => ['test_queue']}],
-        ['delayed_job.2', {:quiet => true, :pid_dir => './tmp/pids', :queues => ['test_queue']}],
-        ['delayed_job.3', {:quiet => true, :pid_dir => './tmp/pids', :queues => ['test_queue']}],
-        ['delayed_job.4', {:quiet => true, :pid_dir => './tmp/pids', :queues => ['test_queue']}],
-        ['delayed_job.5', {:quiet => true, :pid_dir => './tmp/pids', :queues => %w[mailers misc]}],
-        ['delayed_job.6', {:quiet => true, :pid_dir => './tmp/pids', :queues => %w[mailers misc]}]
+        ['delayed_job.0', {:quiet => true, :pid_dir => './tmp/pids', :log_dir => './log', :queues => []}],
+        ['delayed_job.1', {:quiet => true, :pid_dir => './tmp/pids', :log_dir => './log', :queues => ['test_queue']}],
+        ['delayed_job.2', {:quiet => true, :pid_dir => './tmp/pids', :log_dir => './log', :queues => ['test_queue']}],
+        ['delayed_job.3', {:quiet => true, :pid_dir => './tmp/pids', :log_dir => './log', :queues => ['test_queue']}],
+        ['delayed_job.4', {:quiet => true, :pid_dir => './tmp/pids', :log_dir => './log', :queues => ['test_queue']}],
+        ['delayed_job.5', {:quiet => true, :pid_dir => './tmp/pids', :log_dir => './log', :queues => %w[mailers misc]}],
+        ['delayed_job.6', {:quiet => true, :pid_dir => './tmp/pids', :log_dir => './log', :queues => %w[mailers misc]}]
       ].each do |args|
         expect(command).to receive(:run_process).with(*args).once
       end

data/spec/helper.rb

@@ -14,7 +14,6 @@ require 'logger'
 require 'rspec'
 
 require 'action_mailer'
-require 'active_support/dependencies'
 require 'active_record'
 
 require 'delayed_job'
@@ -45,9 +44,6 @@ Delayed::Worker.backend = :test
 # Add this directory so the ActiveSupport autoloading works
 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

data/spec/message_sending_spec.rb

@@ -1,6 +1,11 @@
 require 'helper'
 
 describe Delayed::MessageSending do
+  it 'does not include ClassMethods along with MessageSending' do
+    expect { ClassMethods }.to raise_error(NameError)
+    expect(defined?(String::ClassMethods)).to eq(nil)
+  end
+
   describe 'handle_asynchronously' do
     class Story
       def tell!(_arg); end
@@ -19,7 +24,7 @@ describe Delayed::MessageSending do
         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])
-      end.to change { Delayed::Job.count }
+      end.to(change { Delayed::Job.count })
     end
 
     describe 'with options' do
@@ -42,8 +47,7 @@ describe Delayed::MessageSending do
       describe 'using a proc with parameters' do
         class Yarn
           attr_accessor :importance
-          def spin
-          end
+          def spin; end
           handle_asynchronously :spin, :priority => proc { |y| y.importance }
         end
 
@@ -62,6 +66,7 @@ describe Delayed::MessageSending do
     class FairyTail
       attr_accessor :happy_ending
       def self.princesses; end
+
       def tell
         @happy_ending = true
       end
@@ -106,7 +111,7 @@ describe Delayed::MessageSending do
         expect do
           fairy_tail.delay.tell
         end.to change(fairy_tail, :happy_ending).from(nil).to(true)
-      end.not_to change { Delayed::Job.count }
+      end.not_to(change { Delayed::Job.count })
     end
 
     it 'does delay the job when delay_jobs is true' do
@@ -118,5 +123,25 @@ describe Delayed::MessageSending do
         end.not_to change(fairy_tail, :happy_ending)
       end.to change { Delayed::Job.count }.by(1)
     end
+
+    it 'does delay when delay_jobs is a proc returning true' do
+      Delayed::Worker.delay_jobs = ->(_job) { true }
+      fairy_tail = FairyTail.new
+      expect do
+        expect do
+          fairy_tail.delay.tell
+        end.not_to change(fairy_tail, :happy_ending)
+      end.to change { Delayed::Job.count }.by(1)
+    end
+
+    it 'does not delay the job when delay_jobs is a proc returning false' do
+      Delayed::Worker.delay_jobs = ->(_job) { false }
+      fairy_tail = FairyTail.new
+      expect do
+        expect do
+          fairy_tail.delay.tell
+        end.to change(fairy_tail, :happy_ending).from(nil).to(true)
+      end.not_to(change { Delayed::Job.count })
+    end
   end
 end

data/spec/performable_mailer_spec.rb

@@ -1,6 +1,5 @@
 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'

data/spec/performable_method_spec.rb

@@ -30,8 +30,7 @@ describe Delayed::PerformableMethod do
 
   it 'does not raise NoMethodError if target method is private' do
     clazz = Class.new do
-      def private_method
-      end
+      def private_method; end
       private :private_method
     end
     expect { Delayed::PerformableMethod.new(clazz.new, :private_method, []) }.not_to raise_error
@@ -68,7 +67,7 @@ describe Delayed::PerformableMethod 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
+      expect { story.delay.tell.invoke_job }.to raise_error(RuntimeError)
     end
 
     it 'delegates failure hook to object' do
@@ -98,7 +97,7 @@ describe Delayed::PerformableMethod 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
+        expect { story.delay.tell }.to raise_error(RuntimeError)
       end
 
       it 'delegates failure hook to object' do

data/spec/psych_ext_spec.rb

@@ -3,10 +3,32 @@ require 'helper'
 describe 'Psych::Visitors::ToRuby', :if => defined?(Psych::Visitors::ToRuby) do
   context BigDecimal do
     it 'deserializes correctly' do
-      deserialized = YAML.load("--- !ruby/object:BigDecimal 18:0.1337E2\n...\n")
+      deserialized = YAML.load_dj("--- !ruby/object:BigDecimal 18:0.1337E2\n...\n")
 
       expect(deserialized).to be_an_instance_of(BigDecimal)
       expect(deserialized).to eq(BigDecimal('13.37'))
     end
   end
+
+  context 'load_tag handling' do
+    # This only broadly works in ruby 2.0 but will cleanly work through load_dj
+    # here because this class is so simple it only touches our extention
+    YAML.load_tags['!ruby/object:RenamedClass'] = SimpleJob
+    # This is how ruby 2.1 and newer works throughout the yaml handling
+    YAML.load_tags['!ruby/object:RenamedString'] = 'SimpleJob'
+
+    it 'deserializes class tag' do
+      deserialized = YAML.load_dj("--- !ruby/object:RenamedClass\ncheck: 12\n")
+
+      expect(deserialized).to be_an_instance_of(SimpleJob)
+      expect(deserialized.instance_variable_get(:@check)).to eq(12)
+    end
+
+    it 'deserializes string tag' do
+      deserialized = YAML.load_dj("--- !ruby/object:RenamedString\ncheck: 12\n")
+
+      expect(deserialized).to be_an_instance_of(SimpleJob)
+      expect(deserialized.instance_variable_get(:@check)).to eq(12)
+    end
+  end
 end

data/spec/sample_jobs.rb

@@ -1,4 +1,5 @@
-class NamedJob < Struct.new(:perform)
+NamedJob = Struct.new(:perform)
+class NamedJob
   def display_name
     'named_job'
   end
@@ -22,11 +23,12 @@ class ErrorJob
   cattr_accessor :runs
   @runs = 0
   def perform
-    raise 'did not work'
+    raise Exception, 'did not work'
   end
 end
 
-class CustomRescheduleJob < Struct.new(:offset)
+CustomRescheduleJob = Struct.new(:offset)
+class CustomRescheduleJob
   cattr_accessor :runs
   @runs = 0
   def perform

data/spec/worker_spec.rb

@@ -24,15 +24,23 @@ describe Delayed::Worker do
   describe 'job_say' do
     before do
       @worker = Delayed::Worker.new
-      @job = double('job', :id => 123, :name => 'ExampleJob')
+      @job = double('job', :id => 123, :name => 'ExampleJob', :queue => nil)
     end
 
     it 'logs with job name and id' do
+      expect(@job).to receive(:queue)
       expect(@worker).to receive(:say).
         with('Job ExampleJob (id=123) message', Delayed::Worker.default_log_level)
       @worker.job_say(@job, 'message')
     end
 
+    it 'logs with job name, queue and id' do
+      expect(@job).to receive(:queue).and_return('test')
+      expect(@worker).to receive(:say).
+        with('Job ExampleJob (id=123) (queue=test) message', Delayed::Worker.default_log_level)
+      @worker.job_say(@job, 'message')
+    end
+
     it 'has a configurable default log level' do
       Delayed::Worker.default_log_level = 'error'
 
@@ -154,4 +162,22 @@ describe Delayed::Worker do
       @worker.say(@text, Delayed::Worker.default_log_level)
     end
   end
+
+  describe 'plugin registration' do
+    it 'does not double-register plugins on worker instantiation' do
+      performances = 0
+      plugin = Class.new(Delayed::Plugin) do
+        callbacks do |lifecycle|
+          lifecycle.before(:enqueue) { performances += 1 }
+        end
+      end
+      Delayed::Worker.plugins << plugin
+
+      Delayed::Worker.new
+      Delayed::Worker.new
+      Delayed::Worker.lifecycle.run_callbacks(:enqueue, nil) {}
+
+      expect(performances).to eq(1)
+    end
+  end
 end