delayed_job 4.0.5 → 4.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7aeb53385b816641ccbee1ffeb9571f8a9fc277f
-  data.tar.gz: 54d26795c4f7f72f5c70e63e8ec0eca4c937def8
+  metadata.gz: 437dd17835ae0e764f1fbd9ce13c55be2b7ddead
+  data.tar.gz: abb136834dd2e39edb5a6cf5c846613734c3b518
 SHA512:
-  metadata.gz: 5bacca5b8cdb6ebd37341a7f574f00da50b1d201b6f453840b2123a84bd19c865cba84b090d9f2e85d11f75b233f3e0d4ce484cc674627a9146a1f551f89b933
-  data.tar.gz: 85db710c5c82ed12d7d230fbee0be2b3921275c4c174b921620d91491be6d320a7fda7b1335fb8bcfe6a5c878552425d00acfb48d0a1298d62dd7d30f53424f3
+  metadata.gz: b89e00ad9d939277b9f2da9e94a1b45310c9b7ea3b7e3f7535f434eb8b9ad46a6589ef541e76501e5c2da07cb982fb337453d6c5b642b2e20274daa1c0321452
+  data.tar.gz: 3cb7e586ac2a1a7ea5967d5e35bf3cd325943bf37e28e913e77a787363c0efa46ab891c07c5f157b88a19f8bfda5444839b9b8071e9bc1feb8bcb715773089f9

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+4.0.6 - 2014-12-22
+==================
+* Revert removing test files from the gem
+
 4.0.5 - 2014-12-22
 ==================
 * Support for Rails 4.2

data/Rakefile

@@ -0,0 +1,15 @@
+require 'bundler/setup'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+desc 'Run the specs'
+RSpec::Core::RakeTask.new do |r|
+  r.verbose = false
+end
+
+task :test => :spec
+
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new
+
+task :default => [:spec, :rubocop]

data/delayed_job.gemspec

@@ -3,12 +3,13 @@ Gem::Specification.new do |spec|
   spec.authors        = ['Brandon Keepers', 'Brian Ryckbost', 'Chris Gaffney', 'David Genord II', 'Erik Michaels-Ober', 'Matt Griffin', 'Steve Richert', 'Tobias Lütke']
   spec.description    = 'Delayed_job (or DJ) encapsulates the common pattern of asynchronously executing longer tasks in the background. It is a direct extraction from Shopify where the job table is responsible for a multitude of core tasks.'
   spec.email          = ['brian@collectiveidea.com']
-  spec.files          = %w[CHANGELOG.md CONTRIBUTING.md LICENSE.md README.md delayed_job.gemspec]
-  spec.files         += Dir['{contrib,lib,recipes}/**/*']
+  spec.files          = %w[CHANGELOG.md CONTRIBUTING.md LICENSE.md README.md Rakefile delayed_job.gemspec]
+  spec.files         += Dir.glob('{contrib,lib,recipes,spec}/**/*')
   spec.homepage       = 'http://github.com/collectiveidea/delayed_job'
   spec.licenses       = ['MIT']
   spec.name           = 'delayed_job'
   spec.require_paths  = ['lib']
   spec.summary        = 'Database-backed asynchronous priority queue system -- Extracted from Shopify'
-  spec.version        = '4.0.5'
+  spec.test_files     = Dir.glob('spec/**/*')
+  spec.version        = '4.0.6'
 end

data/spec/autoloaded/clazz.rb

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

data/spec/autoloaded/instance_clazz.rb

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

data/spec/autoloaded/instance_struct.rb

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

data/spec/autoloaded/struct.rb

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

data/spec/delayed/backend/test.rb

@@ -0,0 +1,117 @@
+require 'ostruct'
+
+# An in-memory backend suitable only for testing. Tries to behave as if it were an ORM.
+module Delayed
+  module Backend
+    module Test
+      class Job
+        attr_accessor :id
+        attr_accessor :priority
+        attr_accessor :attempts
+        attr_accessor :handler
+        attr_accessor :last_error
+        attr_accessor :run_at
+        attr_accessor :locked_at
+        attr_accessor :locked_by
+        attr_accessor :failed_at
+        attr_accessor :queue
+
+        include Delayed::Backend::Base
+
+        cattr_accessor :id
+        self.id = 0
+
+        def initialize(hash = {})
+          self.attempts = 0
+          self.priority = 0
+          self.id = (self.class.id += 1)
+          hash.each { |k, v| send(:"#{k}=", v) }
+        end
+
+        def self.all
+          @jobs ||= []
+        end
+
+        def self.count
+          all.size
+        end
+
+        def self.delete_all
+          all.clear
+        end
+
+        def self.create(attrs = {})
+          new(attrs).tap do |o|
+            o.save
+          end
+        end
+
+        def self.create!(*args)
+          create(*args)
+        end
+
+        def self.clear_locks!(worker_name)
+          all.select { |j| j.locked_by == worker_name }.each do |j|
+            j.locked_by = nil
+            j.locked_at = nil
+          end
+        end
+
+        # Find a few candidate jobs to run (in case some immediately get locked by others).
+        def self.find_available(worker_name, limit = 5, max_run_time = Worker.max_run_time) # rubocop:disable CyclomaticComplexity, PerceivedComplexity
+          jobs = all.select do |j|
+            j.run_at <= db_time_now &&
+              (j.locked_at.nil? || j.locked_at < db_time_now - max_run_time || j.locked_by == worker_name) &&
+              !j.failed?
+          end
+          jobs.select! { |j| j.priority <= Worker.max_priority } if Worker.max_priority
+          jobs.select! { |j| j.priority >= Worker.min_priority } if Worker.min_priority
+          jobs.select! { |j| Worker.queues.include?(j.queue) } if Worker.queues.any?
+          jobs.sort_by! { |j| [j.priority, j.run_at] }[0..limit - 1]
+        end
+
+        # Lock this job for this worker.
+        # Returns true if we have the lock, false otherwise.
+        def lock_exclusively!(_max_run_time, worker)
+          now = self.class.db_time_now
+          if locked_by != worker
+            # We don't own this job so we will update the locked_by name and the locked_at
+            self.locked_at = now
+            self.locked_by = worker
+          end
+
+          true
+        end
+
+        def self.db_time_now
+          Time.current
+        end
+
+        def update_attributes(attrs = {})
+          attrs.each { |k, v| send(:"#{k}=", v) }
+          save
+        end
+
+        def destroy
+          self.class.all.delete(self)
+        end
+
+        def save
+          self.run_at ||= Time.current
+
+          self.class.all << self unless self.class.all.include?(self)
+          true
+        end
+
+        def save!
+          save
+        end
+
+        def reload
+          reset
+          self
+        end
+      end
+    end
+  end
+end

data/spec/delayed/command_spec.rb

@@ -0,0 +1,57 @@
+require 'helper'
+require 'delayed/command'
+
+describe Delayed::Command do
+  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'])
+
+      expect(command.worker_pools).to eq [
+        [[], 1],
+        [['test_queue'], 4],
+        [%w[mailers misc], 2]
+      ]
+    end
+
+    it 'should allow * or blank to specify any pools' do
+      command = Delayed::Command.new(['--pool=*:4'])
+      expect(command.worker_pools).to eq [
+        [[], 4],
+      ]
+
+      command = Delayed::Command.new(['--pool=:4'])
+      expect(command.worker_pools).to eq [
+        [[], 4],
+      ]
+    end
+
+    it 'should default to one worker if not specified' do
+      command = Delayed::Command.new(['--pool=mailers'])
+      expect(command.worker_pools).to eq [
+        [['mailers'], 1],
+      ]
+    end
+  end
+
+  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
+
+      [
+        ['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]}]
+      ].each do |args|
+        expect(command).to receive(:run_process).with(*args).once
+      end
+
+      command.daemonize
+    end
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,85 @@
+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'
+
+require 'action_mailer'
+require 'active_support/dependencies'
+require 'active_record'
+
+require 'delayed_job'
+require 'delayed/backend/shared_spec'
+
+if ENV['DEBUG_LOGS']
+  Delayed::Worker.logger = Logger.new(STDOUT)
+else
+  require 'tempfile'
+
+  tf = Tempfile.new('dj.log')
+  Delayed::Worker.logger = Logger.new(tf.path)
+  tf.unlink
+end
+ENV['RAILS_ENV'] = 'test'
+
+# Trigger AR to initialize
+ActiveRecord::Base # rubocop:disable Void
+
+module Rails
+  def self.root
+    '.'
+  end
+end
+
+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
+ActiveRecord::Migration.verbose = false
+
+ActiveRecord::Schema.define do
+  create_table :stories, :primary_key => :story_id, :force => true do |table|
+    table.string :text
+    table.boolean :scoped, :default => true
+  end
+end
+
+class Story < ActiveRecord::Base
+  self.primary_key = 'story_id'
+  def tell
+    text
+  end
+
+  def whatever(n, _)
+    tell * n
+  end
+  default_scope { where(:scoped => true) }
+
+  handle_asynchronously :whatever
+end
+
+RSpec.configure do |config|
+  config.after(:each) do
+    Delayed::Worker.reset
+  end
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/lifecycle_spec.rb

@@ -0,0 +1,75 @@
+require 'helper'
+
+describe Delayed::Lifecycle do
+  let(:lifecycle) { Delayed::Lifecycle.new }
+  let(:callback) { lambda { |*_args| } }
+  let(:arguments) { [1] }
+  let(:behavior) { double(Object, :before! => nil, :after! => nil, :inside! => nil) }
+  let(:wrapped_block) { proc { behavior.inside! } }
+
+  describe 'before callbacks' do
+    before(:each) do
+      lifecycle.before(:execute, &callback)
+    end
+
+    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
+    before(:each) do
+      lifecycle.after(:execute, &callback)
+    end
+
+    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
+    before(:each) do
+      lifecycle.around(:execute) do |*args, &block|
+        behavior.before!
+        block.call(*args)
+        behavior.after!
+      end
+    end
+
+    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
+      expect(behavior).to receive(:one).ordered
+      expect(behavior).to receive(:two).ordered
+      expect(behavior).to receive(:three).ordered
+
+      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
+    lifecycle.before(:execute, &callback)
+    expect { lifecycle.run_callbacks(:execute, 1, 2, 3) {} }.to raise_error(ArgumentError, /1 parameter/)
+  end
+end

data/spec/message_sending_spec.rb

@@ -0,0 +1,122 @@
+require 'helper'
+
+describe Delayed::MessageSending do
+  describe 'handle_asynchronously' do
+    class Story
+      def tell!(_arg); end
+      handle_asynchronously :tell!
+    end
+
+    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
+      story = Story.create
+      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])
+      end.to change { Delayed::Job.count }
+    end
+
+    describe 'with options' do
+      class Fable
+        cattr_accessor :importance
+        def tell; end
+        handle_asynchronously :tell, :priority => proc { importance }
+      end
+
+      it 'sets the priority based on the Fable importance' do
+        Fable.importance = 10
+        job = Fable.new.tell
+        expect(job.priority).to eq(10)
+
+        Fable.importance = 20
+        job = Fable.new.tell
+        expect(job.priority).to eq(20)
+      end
+
+      describe 'using a proc with parameters' do
+        class Yarn
+          attr_accessor :importance
+          def spin
+          end
+          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
+          expect(job.priority).to eq(10)
+
+          job = Yarn.new.tap { |y| y.importance = 20 }.spin
+          expect(job.priority).to eq(20)
+        end
+      end
+    end
+  end
+
+  context 'delay' do
+    class FairyTail
+      attr_accessor :happy_ending
+      def self.princesses; end
+      def tell
+        @happy_ending = true
+      end
+    end
+
+    after do
+      Delayed::Worker.default_queue_name = nil
+    end
+
+    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'])
+      end.to change { Delayed::Job.count }.by(1)
+    end
+
+    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
+      Delayed::Worker.default_queue_name = 'abbazabba'
+      job = FairyTail.delay.to_s
+      expect(job.queue).to eq('abbazabba')
+    end
+
+    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
+      Delayed::Worker.delay_jobs = 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
+
+    it 'does delay the job when delay_jobs is true' do
+      Delayed::Worker.delay_jobs = 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
+  end
+end

data/spec/performable_mailer_spec.rb

@@ -0,0 +1,43 @@
+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'
+  end
+end
+
+describe ActionMailer::Base do
+  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'])
+      end.to change { Delayed::Job.count }.by(1)
+    end
+  end
+
+  describe 'delay on a mail object' do
+    it 'raises an exception' do
+      expect do
+        MyMailer.signup('john@example.com').delay
+      end.to raise_error(RuntimeError)
+    end
+  end
+
+  describe Delayed::PerformableMailer 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'])
+
+        expect(mailer_class).to receive(:signup).with('john@example.com')
+        expect(email).to receive(:deliver)
+        mailer.perform
+      end
+    end
+  end
+end

data/spec/performable_method_spec.rb

@@ -0,0 +1,111 @@
+require 'helper'
+
+describe Delayed::PerformableMethod do
+  describe 'perform' do
+    before do
+      @method = Delayed::PerformableMethod.new('foo', :count, ['o'])
+    end
+
+    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
+      end
+    end
+
+    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 do
+      Delayed::PerformableMethod.new(Object, :method_that_does_not_exist, [])
+    end.to raise_error(NoMethodError)
+  end
+
+  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
+  end
+
+  describe 'display_name' do
+    it 'returns class_name#method_name for instance methods' do
+      expect(Delayed::PerformableMethod.new('foo', :count, ['o']).display_name).to eq('String#count')
+    end
+
+    it 'returns class_name.method_name for class methods' do
+      expect(Delayed::PerformableMethod.new(Class, :inspect, []).display_name).to eq('Class.inspect')
+    end
+  end
+
+  describe 'hooks' do
+    %w[before after success].each do |hook|
+      it "delegates #{hook} hook to object" do
+        story = Story.create
+        job = story.delay.tell
+
+        expect(story).to receive(hook).with(job)
+        job.invoke_job
+      end
+    end
+
+    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
+      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, [])
+      expect(method.object).to receive(:failure)
+      method.failure
+    end
+
+    context 'with delay_job == false' do
+      before do
+        Delayed::Worker.delay_jobs = false
+      end
+
+      after do
+        Delayed::Worker.delay_jobs = true
+      end
+
+      %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))
+          story.delay.tell
+        end
+      end
+
+      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 failure hook to object' do
+        method = Delayed::PerformableMethod.new('object', :size, [])
+        expect(method.object).to receive(:failure)
+        method.failure
+      end
+    end
+  end
+end

data/spec/psych_ext_spec.rb

@@ -0,0 +1,12 @@
+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")
+
+      expect(deserialized).to be_an_instance_of(BigDecimal)
+      expect(deserialized).to eq(BigDecimal('13.37'))
+    end
+  end
+end

data/spec/sample_jobs.rb

@@ -0,0 +1,109 @@
+class NamedJob < Struct.new(:perform)
+  def display_name
+    'named_job'
+  end
+end
+
+class SimpleJob
+  cattr_accessor :runs
+  @runs = 0
+  def perform
+    self.class.runs += 1
+  end
+end
+
+class NamedQueueJob < SimpleJob
+  def queue_name
+    'job_tracking'
+  end
+end
+
+class ErrorJob
+  cattr_accessor :runs
+  @runs = 0
+  def perform
+    raise 'did not work'
+  end
+end
+
+class CustomRescheduleJob < Struct.new(:offset)
+  cattr_accessor :runs
+  @runs = 0
+  def perform
+    raise 'did not work'
+  end
+
+  def reschedule_at(time, _attempts)
+    time + offset
+  end
+end
+
+class LongRunningJob
+  def perform
+    sleep 250
+  end
+end
+
+class OnPermanentFailureJob < SimpleJob
+  attr_writer :raise_error
+
+  def initialize
+    @raise_error = false
+  end
+
+  def failure
+    raise 'did not work' if @raise_error
+  end
+
+  def max_attempts
+    1
+  end
+end
+
+module M
+  class ModuleJob
+    cattr_accessor :runs
+    @runs = 0
+    def perform
+      self.class.runs += 1
+    end
+  end
+end
+
+class CallbackJob
+  cattr_accessor :messages
+
+  def enqueue(_job)
+    self.class.messages << 'enqueue'
+  end
+
+  def before(_job)
+    self.class.messages << 'before'
+  end
+
+  def perform
+    self.class.messages << 'perform'
+  end
+
+  def after(_job)
+    self.class.messages << 'after'
+  end
+
+  def success(_job)
+    self.class.messages << 'success'
+  end
+
+  def error(_job, error)
+    self.class.messages << "error: #{error.class}"
+  end
+
+  def failure(_job)
+    self.class.messages << 'failure'
+  end
+end
+
+class EnqueueJobMod < SimpleJob
+  def enqueue(job)
+    job.run_at = 20.minutes.from_now
+  end
+end

data/spec/test_backend_spec.rb

@@ -0,0 +1,13 @@
+require 'helper'
+
+describe Delayed::Backend::Test::Job do
+  it_should_behave_like 'a delayed_job backend'
+
+  describe '#reload' do
+    it 'causes the payload object to be reloaded' do
+      job = 'foo'.delay.length
+      o = job.payload_object
+      expect(o.object_id).not_to eq(job.reload.payload_object.object_id)
+    end
+  end
+end

data/spec/worker_spec.rb

@@ -0,0 +1,157 @@
+require 'helper'
+
+describe Delayed::Worker do
+  describe 'backend=' do
+    before do
+      @clazz = Class.new
+      Delayed::Worker.backend = @clazz
+    end
+
+    after do
+      Delayed::Worker.backend = :test
+    end
+
+    it 'sets the Delayed::Job constant to the backend' do
+      expect(Delayed::Job).to eq(@clazz)
+    end
+
+    it 'sets backend with a symbol' do
+      Delayed::Worker.backend = :test
+      expect(Delayed::Worker.backend).to eq(Delayed::Backend::Test::Job)
+    end
+  end
+
+  describe 'job_say' do
+    before do
+      @worker = Delayed::Worker.new
+      @job = double('job', :id => 123, :name => 'ExampleJob')
+    end
+
+    it 'logs with job name and id' do
+      expect(@worker).to receive(:say).
+        with('Job ExampleJob (id=123) 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'
+
+      expect(@worker).to receive(:say).
+        with('Job ExampleJob (id=123) message', 'error')
+      @worker.job_say(@job, 'message')
+    end
+  end
+
+  context 'worker read-ahead' do
+    before do
+      @read_ahead = Delayed::Worker.read_ahead
+    end
+
+    after do
+      Delayed::Worker.read_ahead = @read_ahead
+    end
+
+    it 'reads five jobs' do
+      expect(Delayed::Job).to receive(:find_available).with(anything, 5, anything).and_return([])
+      Delayed::Job.reserve(Delayed::Worker.new)
+    end
+
+    it 'reads a configurable number of jobs' do
+      Delayed::Worker.read_ahead = 15
+      expect(Delayed::Job).to receive(:find_available).with(anything, Delayed::Worker.read_ahead, anything).and_return([])
+      Delayed::Job.reserve(Delayed::Worker.new)
+    end
+  end
+
+  context 'worker exit on complete' do
+    before do
+      Delayed::Worker.exit_on_complete = true
+    end
+
+    after do
+      Delayed::Worker.exit_on_complete = false
+    end
+
+    it 'exits the loop when no jobs are available' do
+      worker = Delayed::Worker.new
+      Timeout.timeout(2) do
+        worker.start
+      end
+    end
+  end
+
+  context 'worker job reservation' do
+    before do
+      Delayed::Worker.exit_on_complete = true
+    end
+
+    after do
+      Delayed::Worker.exit_on_complete = false
+    end
+
+    it 'handles error during job reservation' do
+      expect(Delayed::Job).to receive(:reserve).and_raise(Exception)
+      Delayed::Worker.new.work_off
+    end
+
+    it 'gives up after 10 backend failures' do
+      expect(Delayed::Job).to receive(:reserve).exactly(10).times.and_raise(Exception)
+      worker = Delayed::Worker.new
+      9.times { worker.work_off }
+      expect(lambda { worker.work_off }).to raise_exception Delayed::FatalBackendError
+    end
+
+    it 'allows the backend to attempt recovery from reservation errors' do
+      expect(Delayed::Job).to receive(:reserve).and_raise(Exception)
+      expect(Delayed::Job).to receive(:recover_from).with(instance_of(Exception))
+      Delayed::Worker.new.work_off
+    end
+  end
+
+  context '#say' do
+    before(:each) do
+      @worker = Delayed::Worker.new
+      @worker.name = 'ExampleJob'
+      @worker.logger = double('job')
+      time = Time.now
+      allow(Time).to receive(:now).and_return(time)
+      @text = 'Job executed'
+      @worker_name = '[Worker(ExampleJob)]'
+      @expected_time = time.strftime('%FT%T%z')
+    end
+
+    after(:each) do
+      @worker.logger = nil
+    end
+
+    shared_examples_for 'a worker which logs on the correct severity' do |severity|
+      it "logs a message on the #{severity[:level].upcase} level given a string" do
+        expect(@worker.logger).to receive(:send).
+          with(severity[:level], "#{@expected_time}: #{@worker_name} #{@text}")
+        @worker.say(@text, severity[:level])
+      end
+
+      it "logs a message on the #{severity[:level].upcase} level given a fixnum" do
+        expect(@worker.logger).to receive(:send).
+          with(severity[:level], "#{@expected_time}: #{@worker_name} #{@text}")
+        @worker.say(@text, severity[:index])
+      end
+    end
+
+    severities = [{:index => 0, :level => 'debug'},
+                  {:index => 1, :level => 'info'},
+                  {:index => 2, :level => 'warn'},
+                  {:index => 3, :level => 'error'},
+                  {:index => 4, :level => 'fatal'},
+                  {:index => 5, :level => 'unknown'}]
+    severities.each do |severity|
+      it_behaves_like 'a worker which logs on the correct severity', severity
+    end
+
+    it 'logs a message on the default log\'s level' do
+      expect(@worker.logger).to receive(:send).
+        with('info', "#{@expected_time}: #{@worker_name} #{@text}")
+      @worker.say(@text, Delayed::Worker.default_log_level)
+    end
+  end
+end

data/spec/yaml_ext_spec.rb

@@ -0,0 +1,48 @@
+require 'helper'
+
+describe 'YAML' do
+  it 'autoloads classes' do
+    expect do
+      yaml = "--- !ruby/class Autoloaded::Clazz\n"
+      expect(load_with_delayed_visitor(yaml)).to eq(Autoloaded::Clazz)
+    end.not_to raise_error
+  end
+
+  it 'autoloads the class of a struct' do
+    expect do
+      yaml = "--- !ruby/class Autoloaded::Struct\n"
+      expect(load_with_delayed_visitor(yaml)).to eq(Autoloaded::Struct)
+    end.not_to raise_error
+  end
+
+  it 'autoloads the class for the instance of a struct' do
+    expect do
+      yaml = '--- !ruby/struct:Autoloaded::InstanceStruct {}'
+      expect(load_with_delayed_visitor(yaml).class).to eq(Autoloaded::InstanceStruct)
+    end.not_to raise_error
+  end
+
+  it 'autoloads the class of an anonymous struct' do
+    expect do
+      yaml = "--- !ruby/struct\nn: 1\n"
+      object = YAML.load(yaml)
+      expect(object).to be_kind_of(Struct)
+      expect(object.n).to eq(1)
+    end.not_to raise_error
+  end
+
+  it 'autoloads the class for the instance' do
+    expect do
+      yaml = "--- !ruby/object:Autoloaded::InstanceClazz {}\n"
+      expect(load_with_delayed_visitor(yaml).class).to eq(Autoloaded::InstanceClazz)
+    end.not_to raise_error
+  end
+
+  it 'does not throw an uninitialized constant Syck::Syck when using YAML.load with poorly formed yaml' do
+    expect { YAML.load(YAML.dump('foo: *bar')) }.not_to raise_error
+  end
+
+  def load_with_delayed_visitor(yaml)
+    YAML.load_dj(yaml)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: delayed_job
 version: !ruby/object:Gem::Version
-  version: 4.0.5
+  version: 4.0.6
 platform: ruby
 authors:
 - Brandon Keepers
@@ -50,6 +50,7 @@ files:
 - CONTRIBUTING.md
 - LICENSE.md
 - README.md
+- Rakefile
 - contrib/delayed_job.monitrc
 - contrib/delayed_job_multiple.monitrc
 - contrib/delayed_job_rails_4.monitrc
@@ -79,6 +80,23 @@ files:
 - lib/generators/delayed_job/delayed_job_generator.rb
 - lib/generators/delayed_job/templates/script
 - recipes/delayed_job.rb
+- spec/autoloaded/clazz.rb
+- spec/autoloaded/instance_clazz.rb
+- spec/autoloaded/instance_struct.rb
+- spec/autoloaded/struct.rb
+- spec/delayed/backend/test.rb
+- spec/delayed/command_spec.rb
+- spec/delayed/serialization/test.rb
+- spec/helper.rb
+- spec/lifecycle_spec.rb
+- spec/message_sending_spec.rb
+- spec/performable_mailer_spec.rb
+- spec/performable_method_spec.rb
+- spec/psych_ext_spec.rb
+- spec/sample_jobs.rb
+- spec/test_backend_spec.rb
+- spec/worker_spec.rb
+- spec/yaml_ext_spec.rb
 homepage: http://github.com/collectiveidea/delayed_job
 licenses:
 - MIT
@@ -103,4 +121,21 @@ rubygems_version: 2.4.4
 signing_key: 
 specification_version: 4
 summary: Database-backed asynchronous priority queue system -- Extracted from Shopify
-test_files: []
+test_files:
+- spec/autoloaded/clazz.rb
+- spec/autoloaded/instance_clazz.rb
+- spec/autoloaded/instance_struct.rb
+- spec/autoloaded/struct.rb
+- spec/delayed/backend/test.rb
+- spec/delayed/command_spec.rb
+- spec/delayed/serialization/test.rb
+- spec/helper.rb
+- spec/lifecycle_spec.rb
+- spec/message_sending_spec.rb
+- spec/performable_mailer_spec.rb
+- spec/performable_method_spec.rb
+- spec/psych_ext_spec.rb
+- spec/sample_jobs.rb
+- spec/test_backend_spec.rb
+- spec/worker_spec.rb
+- spec/yaml_ext_spec.rb