delayed_job 4.0.4 → 4.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 458beb66285efe46237b4f094fc7eadbbecf3e79
-  data.tar.gz: 85e801616a1d8ad319b705386adcd602e3045234
+  metadata.gz: 7aeb53385b816641ccbee1ffeb9571f8a9fc277f
+  data.tar.gz: 54d26795c4f7f72f5c70e63e8ec0eca4c937def8
 SHA512:
-  metadata.gz: e375922727337f1aa87d578715f5679b1edddc3c15f3505cfb8d084ef063eeeace708ee32c85291bff340996662751640c0627babe0e8c0beb3bb55856e83432
-  data.tar.gz: 9da95592d2f8999d8ddb7365234791a117641bba32edb13361ec177b6a2f4d094a75707be4bdbee0eeacb0f7015fd7e4b072a222d2bb074b95497f0524eee3be
+  metadata.gz: 5bacca5b8cdb6ebd37341a7f574f00da50b1d201b6f453840b2123a84bd19c865cba84b090d9f2e85d11f75b233f3e0d4ce484cc674627a9146a1f551f89b933
+  data.tar.gz: 85db710c5c82ed12d7d230fbee0be2b3921275c4c174b921620d91491be6d320a7fda7b1335fb8bcfe6a5c878552425d00acfb48d0a1298d62dd7d30f53424f3

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+4.0.5 - 2014-12-22
+==================
+* Support for Rails 4.2
+* Allow user to override where DJ writes log output
+* First attempt at automatic code reloading
+* Clearer error message when ActiveRecord object no longer exists
+* Various improvements to the README
+
 4.0.4 - 2014-09-24
 ==================
 * Fix using options passed into delayed_job command

data/README.md

@@ -58,6 +58,11 @@ running the following command:
     rails generate delayed_job:active_record
     rake db:migrate
 
+Development
+===========
+In development mode, if you are using Rails 3.1+, your application code will automatically reload every 100 jobs or when the queue finishes.
+You no longer need to restart Delayed Job every time you update your code in development.
+
 Rails 4
 =======
 If you are using the protected_attributes gem, it must appear before delayed_job in your gemfile.
@@ -119,10 +124,12 @@ class LongTasks
     2.hours.from_now
   end
 
-  def call_a_class_method
-    # Some other code
+  class << self
+    def call_a_class_method
+      # Some other code
+    end
+    handle_asynchronously :call_a_class_method, :run_at => Proc.new { when_to_run }
   end
-  handle_asynchronously :call_a_class_method, :run_at => Proc.new { when_to_run }
 
   attr_reader :how_important
 
@@ -289,6 +296,19 @@ NewsletterJob = Struct.new(:text, :emails) do
 end
 ```
 
+On error, the job is scheduled again in 5 seconds + N ** 4, where N is the number of attempts. You can define your own `reschedule_at` method to override this default behavior.
+
+```ruby
+NewsletterJob = Struct.new(:text, :emails) do
+  def perform
+    emails.each { |e| NewsletterMailer.deliver_text_to_email(text, e) }
+  end
+
+  def reschedule_at(current_time, attempts)
+    current_time + 5.seconds
+  end
+end
+```
 
 Hooks
 =====
@@ -345,7 +365,7 @@ create_table :delayed_jobs, :force => true do |table|
 end
 ```
 
-On failure, the job is scheduled again in 5 seconds + N ** 4, where N is the number of retries.
+On error, the job is scheduled again in 5 seconds + N ** 4, where N is the number of attempts or using the job's defined `reschedule_at` method.
 
 The default `Worker.max_attempts` is 25. After this, the job either deleted (default), or left in the database with "failed_at" set.
 With the default of 25 attempts, the last retry will be 20 days later, with the last interval being almost 100 hours.
@@ -378,6 +398,7 @@ Delayed::Worker.read_ahead = 10
 Delayed::Worker.default_queue_name = 'default'
 Delayed::Worker.delay_jobs = !Rails.env.test?
 Delayed::Worker.raise_signal_exceptions = :term
+Delayed::Worker.logger = Logger.new(File.join(Rails.root, 'log', 'delayed_job.log'))
 ```
 
 Cleaning up

data/delayed_job.gemspec

@@ -1,15 +1,14 @@
 Gem::Specification.new do |spec|
-  spec.add_dependency 'activesupport', ['>= 3.0', '< 4.2']
+  spec.add_dependency 'activesupport', ['>= 3.0', '< 5.0']
   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 Rakefile delayed_job.gemspec]
-  spec.files         += Dir.glob('{contrib,lib,recipes,spec}/**/*')
+  spec.files          = %w[CHANGELOG.md CONTRIBUTING.md LICENSE.md README.md delayed_job.gemspec]
+  spec.files         += Dir['{contrib,lib,recipes}/**/*']
   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.test_files     = Dir.glob('spec/**/*')
-  spec.version        = '4.0.4'
+  spec.version        = '4.0.5'
 end

data/lib/delayed/psych_ext.rb

@@ -34,8 +34,10 @@ module Delayed
         when /^!ruby\/object/
           result = super
           if defined?(ActiveRecord::Base) && result.is_a?(ActiveRecord::Base)
+            klass = result.class
+            id = result[klass.primary_key]
             begin
-              result.class.find(result[result.class.primary_key])
+              klass.find(id)
             rescue ActiveRecord::RecordNotFound => error # rubocop:disable BlockNesting
               raise Delayed::DeserializationError, "ActiveRecord::RecordNotFound, class: #{klass}, primary key: #{id} (#{error.message})"
             end

data/lib/delayed/railtie.rb

@@ -8,7 +8,7 @@ module Delayed
         ActionMailer::Base.extend(Delayed::DelayMail)
       end
 
-      Delayed::Worker.logger = if defined?(Rails)
+      Delayed::Worker.logger ||= if defined?(Rails)
         Rails.logger
       elsif defined?(RAILS_DEFAULT_LOGGER)
         RAILS_DEFAULT_LOGGER

data/lib/delayed/tasks.rb

@@ -35,7 +35,5 @@ namespace :jobs do
     if unprocessed_jobs > 0
       raise "#{unprocessed_jobs} jobs older than #{args[:max_age]} seconds have not been processed yet"
     end
-
   end
-
 end

data/lib/delayed/worker.rb

@@ -100,6 +100,10 @@ module Delayed
       @lifecycle ||= Delayed::Lifecycle.new
     end
 
+    def self.reload_app?
+      defined?(ActionDispatch::Reloader) && Rails.application.config.cache_classes == false
+    end
+
     def initialize(options = {})
       @quiet = options.key?(:quiet) ? options[:quiet] : true
       @failed_reserve_count = 0
@@ -155,6 +159,7 @@ module Delayed
               break
             elsif !stop?
               sleep(self.class.sleep_delay)
+              reload!
             end
           else
             say format("#{count} jobs processed at %.4f j/s, %d failed", count / @realtime, @result.last)
@@ -286,5 +291,11 @@ module Delayed
       raise FatalBackendError if @failed_reserve_count >= 10
       nil
     end
+
+    def reload!
+      return unless self.class.reload_app?
+      ActionDispatch::Reloader.cleanup!
+      ActionDispatch::Reloader.prepare!
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: delayed_job
 version: !ruby/object:Gem::Version
-  version: 4.0.4
+  version: 4.0.5
 platform: ruby
 authors:
 - Brandon Keepers
@@ -15,7 +15,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-24 00:00:00.000000000 Z
+date: 2014-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -26,7 +26,7 @@ dependencies:
         version: '3.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -36,7 +36,7 @@ dependencies:
         version: '3.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.0'
 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.
@@ -50,7 +50,6 @@ files:
 - CONTRIBUTING.md
 - LICENSE.md
 - README.md
-- Rakefile
 - contrib/delayed_job.monitrc
 - contrib/delayed_job_multiple.monitrc
 - contrib/delayed_job_rails_4.monitrc
@@ -80,23 +79,6 @@ 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
@@ -117,25 +99,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.4
 signing_key: 
 specification_version: 4
 summary: Database-backed asynchronous priority queue system -- Extracted from Shopify
-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
+test_files: []

data/Rakefile

@@ -1,15 +0,0 @@
-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/spec/autoloaded/clazz.rb

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

data/spec/autoloaded/instance_clazz.rb

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

data/spec/autoloaded/instance_struct.rb

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

data/spec/autoloaded/struct.rb

@@ -1,7 +0,0 @@
-# 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

@@ -1,117 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,122 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,144 +0,0 @@
-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
-
-    %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 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, [])
-      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
-
-      %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 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
-        Delayed::Worker.delay_jobs = false
-        method = Delayed::PerformableMethod.new('object', :size, [])
-        expect(method.object).to receive(:failure)
-        method.failure
-      end
-    end
-  end
-end

data/spec/psych_ext_spec.rb

@@ -1,12 +0,0 @@
-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

@@ -1,109 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,157 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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