delayed_job_unique_key 0.0.1

data/lib/generators/delayed_job/delayed_job_generator.rb

@@ -0,0 +1,11 @@
+require 'rails/generators'
+
+class DelayedJobGenerator < Rails::Generators::Base
+  
+  self.source_paths << File.join(File.dirname(__FILE__), 'templates')
+  
+  def create_script_file
+    template 'script', 'script/delayed_job'
+    chmod 'script/delayed_job', 0755
+  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/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,113 @@
+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
+        attr_accessor :unique_key
+        
+        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
+        
+        @jobs = []
+        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 {|j| j.locked_by = nil; j.locked_at = nil}
+        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)
+          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_at.nil?
+          end
+                    
+          jobs = jobs.select{|j| Worker.queues.include?(j.queue)}   if Worker.queues.any?
+          jobs = jobs.select{|j| j.priority >= Worker.min_priority} if Worker.min_priority
+          jobs = jobs.select{|j| j.priority <= Worker.max_priority} if Worker.max_priority          
+          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
+
+          return 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/fixtures/bad_alias.yml

@@ -0,0 +1 @@
+foo: *bar

data/spec/lifecycle_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe Delayed::Lifecycle do
+  let(:lifecycle) { Delayed::Lifecycle.new }
+  let(:callback) { lambda {|*args|} }
+  let(:arguments) { [1] }
+  let(:behavior) { mock(Object, :before! => nil, :after! => nil, :inside! => nil) }
+  let(:wrapped_block) { Proc.new { behavior.inside! } }
+
+  describe "before callbacks" do
+    before(:each) do
+      lifecycle.before(:execute, &callback)
+    end
+
+    it 'should execute before wrapped block' do
+      callback.should_receive(:call).with(*arguments).ordered
+      behavior.should_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 'should execute after wrapped block' do
+      behavior.should_receive(:inside!).ordered
+      callback.should_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 'should before and after wrapped block' do
+      behavior.should_receive(:before!).ordered
+      behavior.should_receive(:inside!).ordered
+      behavior.should_receive(:after!).ordered
+      lifecycle.run_callbacks :execute, *arguments, &wrapped_block
+    end
+
+    it "should execute multiple callbacks in order" do
+      behavior.should_receive(:one).ordered
+      behavior.should_receive(:two).ordered
+      behavior.should_receive(:three).ordered
+
+      lifecycle.around(:execute) { |*args, &block| behavior.one; block.call(*args) }
+      lifecycle.around(:execute) { |*args, &block| behavior.two; block.call(*args) }
+      lifecycle.around(:execute) { |*args, &block| behavior.three; block.call(*args) }
+
+      lifecycle.run_callbacks(:execute, *arguments, &wrapped_block)
+    end
+  end
+
+  it "should raise 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
+
+  # # This is a spectacularly crappy way to test callbacks. What's a better way?
+  # describe 'arguments callbacks' do
+  #   subject do
+  #     class Testarguments < Delayed::arguments
+  #       def before_execute; end
+  #       def before_loop; end
+  #       def before_perform; end
+  #
+  #       set_callback :execute, :before, :before_execute
+  #       set_callback :loop, :before, :before_loop
+  #       set_callback :perform, :before, :before_perform
+  #     end
+  #
+  #     Testarguments.new.tap { |w| w.stop }
+  #   end
+  #
+  #   it "should trigger for execute event" do
+  #     subject.should_receive(:before_execute).with()
+  #     subject.start
+  #   end
+  #
+  #   it "should trigger for loop event" do
+  #     subject.should_receive(:before_loop).with()
+  #     subject.start
+  #   end
+  #
+  #   it "should trigger for perform event" do
+  #     "foo".delay.length
+  #     subject.should_receive(:before_perform).with()
+  #     subject.start
+  #   end
+  # end
+  #
+  # describe 'job callbacks' do
+  #   it "should trigger for enqueue event" do
+  #     pending 'figure out how to test this'
+  #   end
+  # end
+
+end

data/spec/message_sending_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+describe Delayed::MessageSending do
+  describe "handle_asynchronously" do
+    class Story
+      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.new
+      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,89 @@
+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
+    
+    %w(before after success).each do |hook|
+      it "should delegate #{hook} hook to object when delay_jobs = false" do
+        Delayed::Worker.delay_jobs = false
+        story = Story.new
+        story.should_receive(hook).with(an_instance_of(Delayed::Job))
+        story.delay.tell
+      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 error hook to object when delay_jobs = false" do
+      Delayed::Worker.delay_jobs = false
+      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 }.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
+    
+    it "should delegate failure hook to object when delay_jobs = false" do
+      Delayed::Worker.delay_jobs = false
+      method = Delayed::PerformableMethod.new("object", :size, [])
+      method.object.should_receive(:failure)
+      method.failure
+    end
+    
+  end
+end

data/spec/sample_jobs.rb

@@ -0,0 +1,75 @@
+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
+end
+
+class EnqueueJobMod < SimpleJob
+  def enqueue(job)
+    job.run_at = 20.minutes.from_now
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,45 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'bundler/setup'
+require 'logger'
+
+require 'rails'
+require 'action_mailer'
+require 'active_support/dependencies'
+require 'active_record'
+
+require 'delayed_job'
+require 'delayed/backend/shared_spec'
+
+Delayed::Worker.logger = Logger.new('/tmp/dj.log')
+ENV['RAILS_ENV'] = 'test'
+
+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.send(: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
+  set_primary_key :story_id
+  def tell; text; end
+  def whatever(n, _); tell*n; end
+  default_scope where(:scoped => true)
+
+  handle_asynchronously :whatever
+end

data/spec/test_backend_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Delayed::Backend::Test::Job do
+  it_should_behave_like 'a delayed_job backend'
+  
+  describe "#reload" do
+    it 'should cause the payload object to be reloaded' do
+      job = "foo".delay.length
+      o = job.payload_object
+      o.object_id.should_not == job.reload.payload_object.object_id
+    end
+  end
+end

data/spec/worker_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Delayed::Worker do
+  describe "backend=" do
+    before do
+      @clazz = Class.new
+      Delayed::Worker.backend = @clazz
+    end
+
+    it "should set the Delayed::Job constant to the backend" do
+      Delayed::Job.should == @clazz
+    end
+
+    it "should set backend with a symbol" do
+      Delayed::Worker.backend = :test
+      Delayed::Worker.backend.should == Delayed::Backend::Test::Job
+    end
+  end
+end