delayed_job_hooked 2.1.5

data/lib/delayed/yaml_ext.rb

@@ -0,0 +1,41 @@
+# These extensions allow properly serializing and autoloading of
+# Classes, Modules and Structs
+
+require 'yaml'
+YAML::ENGINE.yamler = "syck" if defined?(YAML::ENGINE)
+
+class Module
+  yaml_as "tag:ruby.yaml.org,2002:module"
+
+  def self.yaml_new(klass, tag, val)
+    val.constantize
+  end
+
+  def to_yaml( opts = {} )
+    YAML::quick_emit( nil, opts ) { |out|
+      out.scalar(taguri, self.name, :plain)
+    }
+  end
+  
+  def yaml_tag_read_class(name)
+    # Constantize the object so that ActiveSupport can attempt
+    # its auto loading magic. Will raise LoadError if not successful.
+    name.constantize
+    name
+  end
+  
+end
+
+class Class
+  yaml_as "tag:ruby.yaml.org,2002:class"
+  remove_method :to_yaml if respond_to?(:to_yaml) && method(:to_yaml).owner == Class # use Module's to_yaml
+end
+
+class Struct
+  def self.yaml_tag_read_class(name)
+    # Constantize the object so that ActiveSupport can attempt
+    # its auto loading magic. Will raise LoadError if not successful.
+    name.constantize
+    "Struct::#{ name }"
+  end
+end

data/lib/delayed_job.rb

@@ -0,0 +1,13 @@
+require 'active_support'
+
+require File.dirname(__FILE__) + '/delayed/message_sending'
+require File.dirname(__FILE__) + '/delayed/performable_method'
+require File.dirname(__FILE__) + '/delayed/performable_mailer' if defined?(ActionMailer)
+require File.dirname(__FILE__) + '/delayed/yaml_ext'
+require File.dirname(__FILE__) + '/delayed/backend/base'
+require File.dirname(__FILE__) + '/delayed/worker'
+require File.dirname(__FILE__) + '/delayed/deserialization_error'
+require File.dirname(__FILE__) + '/delayed/railtie' if defined?(Rails::Railtie)
+
+Object.send(:include, Delayed::MessageSending)
+Module.send(:include, Delayed::MessageSending::ClassMethods)

data/lib/generators/delayed_job/delayed_job_generator.rb

@@ -0,0 +1,34 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+class DelayedJobGenerator < Rails::Generators::Base
+
+  include Rails::Generators::Migration
+  
+  def self.source_root
+     @source_root ||= File.join(File.dirname(__FILE__), 'templates')
+  end
+
+  # Implement the required interface for Rails::Generators::Migration.
+  #
+  def self.next_migration_number(dirname) #:nodoc:
+    next_migration_number = current_migration_number(dirname) + 1
+    if ActiveRecord::Base.timestamped_migrations
+      [Time.now.utc.strftime("%Y%m%d%H%M%S"), "%.14d" % next_migration_number].max
+    else
+      "%.3d" % next_migration_number
+    end
+  end
+  
+  def create_script_file
+    template 'script', 'script/delayed_job'
+    chmod 'script/delayed_job', 0755
+  end
+  
+  def create_migration_file
+    if defined?(ActiveRecord)
+      migration_template 'migration.rb', 'db/migrate/create_delayed_jobs.rb'
+    end
+  end
+
+end

data/lib/generators/delayed_job/templates/migration.rb

@@ -0,0 +1,21 @@
+class CreateDelayedJobs < ActiveRecord::Migration
+  def self.up
+    create_table :delayed_jobs, :force => true do |table|
+      table.integer  :priority, :default => 0      # Allows some jobs to jump to the front of the queue
+      table.integer  :attempts, :default => 0      # Provides for retries, but still fail eventually.
+      table.text     :handler                      # YAML-encoded string of the object that will do work
+      table.text     :last_error                   # reason for last failure (See Note below)
+      table.datetime :run_at                       # When to run. Could be Time.zone.now for immediately, or sometime in the future.
+      table.datetime :locked_at                    # Set when a client is working on this object
+      table.datetime :failed_at                    # Set when all retries have failed (actually, by default, the record is deleted instead)
+      table.string   :locked_by                    # Who is working on this object (if locked)
+      table.timestamps
+    end
+	
+    add_index :delayed_jobs, [:priority, :run_at], :name => 'delayed_jobs_priority'
+  end
+  
+  def self.down
+    drop_table :delayed_jobs  
+  end
+end

data/lib/generators/delayed_job/templates/script

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'config', 'environment'))
+require 'delayed/command'
+Delayed::Command.new(ARGV).daemonize

data/recipes/delayed_job.rb

@@ -0,0 +1 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'delayed', 'recipes'))

data/spec/active_record_job_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'delayed/backend/active_record'
+
+describe Delayed::Backend::ActiveRecord::Job do
+  after do
+    Time.zone = nil
+  end
+
+  it_should_behave_like 'a delayed_job backend'
+
+  context "db_time_now" do
+    it "should return time in current time zone if set" do
+      Time.zone = 'Eastern Time (US & Canada)'
+      %w(EST EDT).should include(Delayed::Job.db_time_now.zone)
+    end
+
+    it "should return UTC time if that is the AR default" do
+      Time.zone = nil
+      ActiveRecord::Base.default_timezone = :utc
+      Delayed::Backend::ActiveRecord::Job.db_time_now.zone.should == 'UTC'
+    end
+
+    it "should return local time if that is the AR default" do
+      Time.zone = 'Central Time (US & Canada)'
+      ActiveRecord::Base.default_timezone = :local
+      %w(CST CDT).should include(Delayed::Backend::ActiveRecord::Job.db_time_now.zone)
+    end
+  end
+
+  describe "after_fork" do
+    it "should call reconnect on the connection" do
+      ActiveRecord::Base.should_receive(:establish_connection)
+      Delayed::Backend::ActiveRecord::Job.after_fork
+    end
+  end
+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/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/database.yml

@@ -0,0 +1,4 @@
+mysql:
+  adapter: mysql
+  database: delayed_job
+  username: root

data/spec/message_sending_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+describe Delayed::MessageSending do
+  describe "handle_asynchronously" do
+    class Story < ActiveRecord::Base
+      def tell!(arg)
+      end
+      handle_asynchronously :tell!
+    end
+
+    it "should alias original method" do
+      Story.new.should respond_to(:tell_without_delay!)
+      Story.new.should respond_to(:tell_with_delay!)
+    end
+
+    it "should create a PerformableMethod" do
+      story = Story.create!
+      lambda {
+        job = story.tell!(1)
+        job.payload_object.class.should   == Delayed::PerformableMethod
+        job.payload_object.method_name.should  == :tell_without_delay!
+        job.payload_object.args.should    == [1]
+      }.should change { Delayed::Job.count }
+    end
+
+    describe 'with options' do
+      class Fable
+        class << self
+          attr_accessor :importance
+        end
+        def tell
+        end
+        handle_asynchronously :tell, :priority => Proc.new { self.importance }
+      end
+
+      it 'should set the priority based on the Fable importance' do
+        Fable.importance = 10
+        job = Fable.new.tell
+        job.priority.should == 10
+
+        Fable.importance = 20
+        job = Fable.new.tell
+        job.priority.should == 20
+      end
+
+      describe 'using a proc with parament' do
+        class Yarn
+          attr_accessor :importance
+          def spin
+          end
+          handle_asynchronously :spin, :priority => Proc.new {|y| y.importance }
+        end
+
+        it 'should set the priority based on the Fable importance' do
+          job = Yarn.new.tap {|y| y.importance = 10 }.spin
+          job.priority.should == 10
+
+          job = Yarn.new.tap {|y| y.importance = 20 }.spin
+          job.priority.should == 20
+        end
+      end
+    end
+  end
+
+  context "delay" do
+    it "should create a new PerformableMethod job" do
+      lambda {
+        job = "hello".delay.count('l')
+        job.payload_object.class.should   == Delayed::PerformableMethod
+        job.payload_object.method_name.should  == :count
+        job.payload_object.args.should    == ['l']
+      }.should change { Delayed::Job.count }.by(1)
+    end
+
+    it "should set default priority" do
+      Delayed::Worker.default_priority = 99
+      job = Object.delay.to_s
+      job.priority.should == 99
+      Delayed::Worker.default_priority = 0
+    end
+
+    it "should set job options" do
+      run_at = Time.parse('2010-05-03 12:55 AM')
+      job = Object.delay(:priority => 20, :run_at => run_at).to_s
+      job.run_at.should == run_at
+      job.priority.should == 20
+    end
+    
+    class FairyTail
+      attr_accessor :happy_ending
+      def tell
+        @happy_ending = true
+      end
+    end
+    
+    it "should not delay the job when delay_jobs is false" do
+      Delayed::Worker.delay_jobs = false
+      fairy_tail = FairyTail.new
+      lambda {
+        lambda {
+          fairy_tail.delay.tell
+        }.should change(fairy_tail, :happy_ending).from(nil).to(true)
+      }.should_not change { Delayed::Job.count }
+    end
+    
+    it "should delay the job when delay_jobs is true" do
+      Delayed::Worker.delay_jobs = true
+      fairy_tail = FairyTail.new
+      lambda {
+        lambda {
+          fairy_tail.delay.tell
+        }.should_not change(fairy_tail, :happy_ending)
+      }.should change { Delayed::Job.count }.by(1)
+    end
+  end
+end

data/spec/performable_mailer_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+require 'action_mailer'
+class MyMailer < ActionMailer::Base
+  def signup(email)
+    mail :to => email, :subject => "Delaying Emails"
+  end
+end
+
+describe ActionMailer::Base do
+  describe "delay" do
+    it "should enqueue a PerformableEmail job" do
+      lambda {
+        job = MyMailer.delay.signup('john@example.com')
+        job.payload_object.class.should   == Delayed::PerformableMailer
+        job.payload_object.method_name.should  == :signup
+        job.payload_object.args.should    == ['john@example.com']
+      }.should change { Delayed::Job.count }.by(1)
+    end
+  end
+
+  describe "delay on a mail object" do
+    it "should raise an exception" do
+      lambda {
+        MyMailer.signup('john@example.com').delay
+      }.should raise_error(RuntimeError)
+    end
+  end
+
+  describe Delayed::PerformableMailer do
+    describe "perform" do
+      before do
+        @email = mock('email', :deliver => true)
+        @mailer_class = mock('MailerClass', :signup => @email)
+        @mailer = Delayed::PerformableMailer.new(@mailer_class, :signup, ['john@example.com'])
+      end
+
+      it "should call the method and #deliver on the mailer" do
+        @mailer_class.should_receive(:signup).with('john@example.com')
+        @email.should_receive(:deliver)
+        @mailer.perform
+      end
+    end
+  end
+
+end

data/spec/performable_method_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_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 "should be a no-op if object is nil" do
+        lambda { @method.perform }.should_not raise_error
+      end
+    end
+
+    it "should call the method on the object" do
+      @method.object.should_receive(:count).with('o')
+      @method.perform
+    end
+  end
+
+  it "should raise a NoMethodError if target method doesn't exist" do
+    lambda {
+      Delayed::PerformableMethod.new(Object, :method_that_does_not_exist, [])
+    }.should raise_error(NoMethodError)
+  end
+
+  it "should not raise NoMethodError if target method is private" do
+    clazz = Class.new do
+      def private_method
+      end
+      private :private_method
+    end
+    lambda {
+      Delayed::PerformableMethod.new(clazz.new, :private_method, [])
+    }.should_not raise_error(NoMethodError)
+  end
+
+  describe "hooks" do
+    %w(enqueue before after success).each do |hook|
+      it "should delegate #{hook} hook to object" do
+        story = Story.new
+        story.should_receive(hook).with(an_instance_of(Delayed::Job))
+        story.delay.tell.invoke_job
+      end
+    end
+
+    it "should delegate error hook to object" do
+      story = Story.new
+      story.should_receive(:error).with(an_instance_of(Delayed::Job), an_instance_of(RuntimeError))
+      story.should_receive(:tell).and_raise(RuntimeError)
+      lambda { story.delay.tell.invoke_job }.should raise_error
+    end
+
+    it "should delegate failure hook to object" do
+      method = Delayed::PerformableMethod.new("object", :size, [])
+      method.object.should_receive(:failure)
+      method.failure
+    end
+  end
+end

data/spec/sample_jobs.rb

@@ -0,0 +1,73 @@
+class NamedJob < Struct.new(:perform)
+  def display_name
+    'named_job'
+  end
+end
+
+class SimpleJob
+  cattr_accessor :runs; self.runs = 0
+  def perform; @@runs += 1; end
+end
+
+class ErrorJob
+  cattr_accessor :runs; self.runs = 0
+  def perform; raise 'did not work'; end
+end
+
+class CustomRescheduleJob < Struct.new(:offset)
+  cattr_accessor :runs; self.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
+  def failure; end
+  def max_attempts; 1; end
+end
+
+module M
+  class ModuleJob
+    cattr_accessor :runs; self.runs = 0
+    def perform; @@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
+  
+  def completed(job)
+    self.class.messages << 'completed'
+  end
+end