delayed_job 1.8.5 → 1.9.0pre

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: delayed_job
 version: !ruby/object:Gem::Version 
-  version: 1.8.5
+  version: 1.9.0pre
 platform: ruby
 authors: 
 - Brandon Keepers
@@ -10,11 +10,43 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-15 00:00:00 -05:00
+date: 2010-03-26 00:00:00 -04:00
 default_executable: 
-dependencies: []
-
-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.
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: daemons
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: sqlite3-ruby
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+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.
+  
+  This gem is collectiveidea's fork (http://github.com/collectiveidea/delayed_job).
 email: tobi@leetsoft.com
 executables: []
 
@@ -33,20 +65,29 @@ files:
 - generators/delayed_job/delayed_job_generator.rb
 - generators/delayed_job/templates/migration.rb
 - generators/delayed_job/templates/script
-- init.rb
+- lib/delayed/backend/active_record.rb
+- lib/delayed/backend/base.rb
+- lib/delayed/backend/mongo_mapper.rb
 - lib/delayed/command.rb
-- lib/delayed/job.rb
 - lib/delayed/message_sending.rb
 - lib/delayed/performable_method.rb
 - lib/delayed/recipes.rb
 - lib/delayed/tasks.rb
 - lib/delayed/worker.rb
 - lib/delayed_job.rb
+- rails/init.rb
 - recipes/delayed_job.rb
-- spec/database.rb
+- spec/backend/active_record_job_spec.rb
+- spec/backend/mongo_mapper_job_spec.rb
+- spec/backend/shared_backend_spec.rb
 - spec/delayed_method_spec.rb
-- spec/job_spec.rb
+- spec/performable_method_spec.rb
+- spec/sample_jobs.rb
+- spec/setup/active_record.rb
+- spec/setup/mongo_mapper.rb
+- spec/spec_helper.rb
 - spec/story_spec.rb
+- spec/worker_spec.rb
 - tasks/jobs.rake
 has_rdoc: true
 homepage: http://github.com/collectiveidea/delayed_job
@@ -80,7 +121,14 @@ signing_key:
 specification_version: 3
 summary: Database-backed asynchronous priority queue system -- Extracted from Shopify
 test_files: 
-- spec/database.rb
+- spec/backend/active_record_job_spec.rb
+- spec/backend/mongo_mapper_job_spec.rb
+- spec/backend/shared_backend_spec.rb
 - spec/delayed_method_spec.rb
-- spec/job_spec.rb
+- spec/performable_method_spec.rb
+- spec/sample_jobs.rb
+- spec/setup/active_record.rb
+- spec/setup/mongo_mapper.rb
+- spec/spec_helper.rb
 - spec/story_spec.rb
+- spec/worker_spec.rb

data/init.rb

@@ -1 +0,0 @@
-require File.dirname(__FILE__) + '/lib/delayed_job'

data/lib/delayed/job.rb

@@ -1,290 +0,0 @@
-require 'timeout'
-
-module Delayed
-
-  class DeserializationError < StandardError
-  end
-
-  # A job object that is persisted to the database.
-  # Contains the work object as a YAML field.
-  class Job < ActiveRecord::Base
-    @@max_attempts = 25
-    @@max_run_time = 4.hours
-    
-    cattr_accessor :max_attempts, :max_run_time
-    
-    set_table_name :delayed_jobs
-
-    # By default failed jobs are destroyed after too many attempts.
-    # If you want to keep them around (perhaps to inspect the reason
-    # for the failure), set this to false.
-    cattr_accessor :destroy_failed_jobs
-    self.destroy_failed_jobs = true
-
-    # Every worker has a unique name which by default is the pid of the process.
-    # There are some advantages to overriding this with something which survives worker retarts:
-    # Workers can safely resume working on tasks which are locked by themselves. The worker will assume that it crashed before.
-    @@worker_name = nil
-
-    def self.worker_name
-      return @@worker_name unless @@worker_name.nil?
-      "host:#{Socket.gethostname} pid:#{Process.pid}" rescue "pid:#{Process.pid}"
-    end
-
-    def self.worker_name=(val)
-      @@worker_name = val
-    end
-
-    def worker_name
-      self.class.worker_name
-    end
-
-    def worker_name=(val)
-      @@worker_name = val
-    end
-
-    NextTaskSQL         = '(run_at <= ? AND (locked_at IS NULL OR locked_at < ?) OR (locked_by = ?)) AND failed_at IS NULL'
-    NextTaskOrder       = 'priority DESC, run_at ASC'
-
-    ParseObjectFromYaml = /\!ruby\/\w+\:([^\s]+)/
-
-    cattr_accessor :min_priority, :max_priority
-    self.min_priority = nil
-    self.max_priority = nil
-
-    # When a worker is exiting, make sure we don't have any locked jobs.
-    def self.clear_locks!
-      update_all("locked_by = null, locked_at = null", ["locked_by = ?", worker_name])
-    end
-
-    def failed?
-      failed_at
-    end
-    alias_method :failed, :failed?
-
-    def payload_object
-      @payload_object ||= deserialize(self['handler'])
-    end
-
-    def name
-      @name ||= begin
-        payload = payload_object
-        if payload.respond_to?(:display_name)
-          payload.display_name
-        else
-          payload.class.name
-        end
-      end
-    end
-
-    def payload_object=(object)
-      self['handler'] = object.to_yaml
-    end
-
-    # Reschedule the job in the future (when a job fails).
-    # Uses an exponential scale depending on the number of failed attempts.
-    def reschedule(message, backtrace = [], time = nil)
-      self.last_error   = message + "\n" + backtrace.join("\n")
-
-      if (self.attempts += 1) < max_attempts
-        time ||= Job.db_time_now + (attempts ** 4) + 5
-
-        self.run_at       = time
-        self.unlock
-        save!
-      else
-        logger.info "* [JOB] PERMANENTLY removing #{self.name} because of #{attempts} consecutive failures."
-        destroy_failed_jobs ? destroy : update_attribute(:failed_at, Delayed::Job.db_time_now)
-      end
-    end
-
-
-    # Try to run one job. Returns true/false (work done/work failed) or nil if job can't be locked.
-    def run_with_lock(max_run_time, worker_name)
-      logger.info "* [JOB] acquiring lock on #{name}"
-      unless lock_exclusively!(max_run_time, worker_name)
-        # We did not get the lock, some other worker process must have
-        logger.warn "* [JOB] failed to acquire exclusive lock for #{name}"
-        return nil # no work done
-      end
-
-      begin
-        runtime =  Benchmark.realtime do
-          Timeout.timeout(max_run_time.to_i) { invoke_job }
-          destroy
-        end
-        # TODO: warn if runtime > max_run_time ?
-        logger.info "* [JOB] #{name} completed after %.4f" % runtime
-        return true  # did work
-      rescue Exception => e
-        reschedule e.message, e.backtrace
-        log_exception(e)
-        return false  # work failed
-      end
-    end
-
-    # Add a job to the queue
-    def self.enqueue(*args, &block)
-      object = block_given? ? EvaledJob.new(&block) : args.shift
-
-      unless object.respond_to?(:perform) || block_given?
-        raise ArgumentError, 'Cannot enqueue items which do not respond to perform'
-      end
-    
-      priority = args.first || 0
-      run_at   = args[1]
-
-      Job.create(:payload_object => object, :priority => priority.to_i, :run_at => run_at)
-    end
-
-    # Find a few candidate jobs to run (in case some immediately get locked by others).
-    def self.find_available(limit = 5, max_run_time = max_run_time)
-
-      time_now = db_time_now
-
-      sql = NextTaskSQL.dup
-
-      conditions = [time_now, time_now - max_run_time, worker_name]
-
-      if self.min_priority
-        sql << ' AND (priority >= ?)'
-        conditions << min_priority
-      end
-
-      if self.max_priority
-        sql << ' AND (priority <= ?)'
-        conditions << max_priority
-      end
-
-      conditions.unshift(sql)
-
-      ActiveRecord::Base.silence do
-        find(:all, :conditions => conditions, :order => NextTaskOrder, :limit => limit)
-      end
-    end
-
-    # Run the next job we can get an exclusive lock on.
-    # If no jobs are left we return nil
-    def self.reserve_and_run_one_job(max_run_time = max_run_time)
-
-      # We get up to 5 jobs from the db. In case we cannot get exclusive access to a job we try the next.
-      # this leads to a more even distribution of jobs across the worker processes
-      find_available(5, max_run_time).each do |job|
-        t = job.run_with_lock(max_run_time, worker_name)
-        return t unless t == nil  # return if we did work (good or bad)
-      end
-
-      nil # we didn't do any work, all 5 were not lockable
-    end
-
-    # Lock this job for this worker.
-    # Returns true if we have the lock, false otherwise.
-    def lock_exclusively!(max_run_time, worker = worker_name)
-      now = self.class.db_time_now
-      affected_rows = if locked_by != worker
-        # We don't own this job so we will update the locked_by name and the locked_at
-        self.class.update_all(["locked_at = ?, locked_by = ?", now, worker], ["id = ? and (locked_at is null or locked_at < ?) and (run_at <= ?)", id, (now - max_run_time.to_i), now])
-      else
-        # We already own this job, this may happen if the job queue crashes.
-        # Simply resume and update the locked_at
-        self.class.update_all(["locked_at = ?", now], ["id = ? and locked_by = ?", id, worker])
-      end
-      if affected_rows == 1
-        self.locked_at    = now
-        self.locked_by    = worker
-        return true
-      else
-        return false
-      end
-    end
-
-    # Unlock this job (note: not saved to DB)
-    def unlock
-      self.locked_at    = nil
-      self.locked_by    = nil
-    end
-
-    # This is a good hook if you need to report job processing errors in additional or different ways
-    def log_exception(error)
-      logger.error "* [JOB] #{name} failed with #{error.class.name}: #{error.message} - #{attempts} failed attempts"
-      logger.error(error)
-    end
-
-    # Do num jobs and return stats on success/failure.
-    # Exit early if interrupted.
-    def self.work_off(num = 100)
-      success, failure = 0, 0
-
-      num.times do
-        case self.reserve_and_run_one_job
-        when true
-            success += 1
-        when false
-            failure += 1
-        else
-          break  # leave if no work could be done
-        end
-        break if $exit # leave if we're exiting
-      end
-
-      return [success, failure]
-    end
-
-    # Moved into its own method so that new_relic can trace it.
-    def invoke_job
-      payload_object.perform
-    end
-
-  private
-
-    def deserialize(source)
-      handler = YAML.load(source) rescue nil
-
-      unless handler.respond_to?(:perform)
-        if handler.nil? && source =~ ParseObjectFromYaml
-          handler_class = $1
-        end
-        attempt_to_load(handler_class || handler.class)
-        handler = YAML.load(source)
-      end
-
-      return handler if handler.respond_to?(:perform)
-
-      raise DeserializationError,
-        'Job failed to load: Unknown handler. Try to manually require the appropriate file.'
-    rescue TypeError, LoadError, NameError => e
-      raise DeserializationError,
-        "Job failed to load: #{e.message}. Try to manually require the required file."
-    end
-
-    # Constantize the object so that ActiveSupport can attempt
-    # its auto loading magic. Will raise LoadError if not successful.
-    def attempt_to_load(klass)
-       klass.constantize
-    end
-
-    # Get the current time (GMT or local depending on DB)
-    # Note: This does not ping the DB to get the time, so all your clients
-    # must have syncronized clocks.
-    def self.db_time_now
-      (ActiveRecord::Base.default_timezone == :utc) ? Time.now.utc : Time.zone.now
-    end
-
-  protected
-
-    def before_save
-      self.run_at ||= self.class.db_time_now
-    end
-
-  end
-
-  class EvaledJob
-    def initialize
-      @job = yield
-    end
-
-    def perform
-      eval(@job)
-    end
-  end
-end

data/spec/job_spec.rb

@@ -1,419 +0,0 @@
-require File.dirname(__FILE__) + '/database'
-
-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 LongRunningJob
-  def perform; sleep 250; end
-end
-
-module M
-  class ModuleJob
-    cattr_accessor :runs; self.runs = 0
-    def perform; @@runs += 1; end    
-  end
-  
-end
-
-describe Delayed::Job do
-  before  do               
-    Delayed::Job.max_priority = nil
-    Delayed::Job.min_priority = nil      
-    
-    Delayed::Job.delete_all
-  end
-  
-  before(:each) do
-    SimpleJob.runs = 0
-  end
-
-  it "should set run_at automatically if not set" do
-    Delayed::Job.create(:payload_object => ErrorJob.new ).run_at.should_not == nil
-  end
-
-  it "should not set run_at automatically if already set" do
-    later = 5.minutes.from_now
-    Delayed::Job.create(:payload_object => ErrorJob.new, :run_at => later).run_at.should == later
-  end
-
-  it "should raise ArgumentError when handler doesn't respond_to :perform" do
-    lambda { Delayed::Job.enqueue(Object.new) }.should raise_error(ArgumentError)
-  end
-
-  it "should increase count after enqueuing items" do
-    Delayed::Job.enqueue SimpleJob.new
-    Delayed::Job.count.should == 1
-  end
-
-  it "should be able to set priority when enqueuing items" do
-    Delayed::Job.enqueue SimpleJob.new, 5
-    Delayed::Job.first.priority.should == 5
-  end
-
-  it "should be able to set run_at when enqueuing items" do
-    later = (Delayed::Job.db_time_now+5.minutes)
-    Delayed::Job.enqueue SimpleJob.new, 5, later
-
-    # use be close rather than equal to because millisecond values cn be lost in DB round trip
-    Delayed::Job.first.run_at.should be_close(later, 1)
-  end
-
-  it "should call perform on jobs when running work_off" do
-    SimpleJob.runs.should == 0
-
-    Delayed::Job.enqueue SimpleJob.new
-    Delayed::Job.work_off
-
-    SimpleJob.runs.should == 1
-  end
-                     
-                     
-  it "should work with eval jobs" do
-    $eval_job_ran = false
-
-    Delayed::Job.enqueue do <<-JOB
-      $eval_job_ran = true
-    JOB
-    end
-
-    Delayed::Job.work_off
-
-    $eval_job_ran.should == true
-  end
-                   
-  it "should work with jobs in modules" do
-    M::ModuleJob.runs.should == 0
-
-    Delayed::Job.enqueue M::ModuleJob.new
-    Delayed::Job.work_off
-
-    M::ModuleJob.runs.should == 1
-  end
-                   
-  it "should re-schedule by about 1 second at first and increment this more and more minutes when it fails to execute properly" do
-    Delayed::Job.enqueue ErrorJob.new
-    Delayed::Job.work_off(1)
-
-    job = Delayed::Job.find(:first)
-
-    job.last_error.should =~ /did not work/
-    job.last_error.should =~ /job_spec.rb:10:in `perform'/
-    job.attempts.should == 1
-
-    job.run_at.should > Delayed::Job.db_time_now - 10.minutes
-    job.run_at.should < Delayed::Job.db_time_now + 10.minutes
-  end
-
-  it "should record last_error when destroy_failed_jobs = false, max_attempts = 1" do
-    Delayed::Job.destroy_failed_jobs = false
-    Delayed::Job::max_attempts = 1
-    job = Delayed::Job.enqueue ErrorJob.new
-    Delayed::Job.work_off
-    job.reload
-    job.last_error.should =~ /did not work/
-    job.last_error.should =~ /job_spec.rb/
-    job.attempts.should == 1
-
-    job.failed_at.should_not == nil
-  end
-
-  it "should raise an DeserializationError when the job class is totally unknown" do
-
-    job = Delayed::Job.new
-    job['handler'] = "--- !ruby/object:JobThatDoesNotExist {}"
-
-    lambda { job.payload_object.perform }.should raise_error(Delayed::DeserializationError)
-  end
-
-  it "should try to load the class when it is unknown at the time of the deserialization" do
-    job = Delayed::Job.new
-    job['handler'] = "--- !ruby/object:JobThatDoesNotExist {}"
-
-    job.should_receive(:attempt_to_load).with('JobThatDoesNotExist').and_return(true)
-
-    lambda { job.payload_object.perform }.should raise_error(Delayed::DeserializationError)
-  end
-
-  it "should try include the namespace when loading unknown objects" do
-    job = Delayed::Job.new
-    job['handler'] = "--- !ruby/object:Delayed::JobThatDoesNotExist {}"
-    job.should_receive(:attempt_to_load).with('Delayed::JobThatDoesNotExist').and_return(true)
-    lambda { job.payload_object.perform }.should raise_error(Delayed::DeserializationError)
-  end
-
-  it "should also try to load structs when they are unknown (raises TypeError)" do
-    job = Delayed::Job.new
-    job['handler'] = "--- !ruby/struct:JobThatDoesNotExist {}"
-
-    job.should_receive(:attempt_to_load).with('JobThatDoesNotExist').and_return(true)
-
-    lambda { job.payload_object.perform }.should raise_error(Delayed::DeserializationError)
-  end
-
-  it "should try include the namespace when loading unknown structs" do
-    job = Delayed::Job.new
-    job['handler'] = "--- !ruby/struct:Delayed::JobThatDoesNotExist {}"
-
-    job.should_receive(:attempt_to_load).with('Delayed::JobThatDoesNotExist').and_return(true)
-    lambda { job.payload_object.perform }.should raise_error(Delayed::DeserializationError)
-  end
-  
-  context "reschedule" do
-    before do
-      @job = Delayed::Job.create :payload_object => SimpleJob.new
-    end
-    
-    context "and we want to destroy jobs" do
-      before do
-        Delayed::Job.destroy_failed_jobs = true
-      end
-      
-      it "should be destroyed if it failed more than Job::max_attempts times" do
-        @job.should_receive(:destroy)
-        Delayed::Job::max_attempts.times { @job.reschedule 'FAIL' }
-      end
-      
-      it "should not be destroyed if failed fewer than Job::max_attempts times" do
-        @job.should_not_receive(:destroy)
-        (Delayed::Job::max_attempts - 1).times { @job.reschedule 'FAIL' }
-      end
-    end
-    
-    context "and we don't want to destroy jobs" do
-      before do
-        Delayed::Job.destroy_failed_jobs = false
-      end
-      
-      it "should be failed if it failed more than Job::max_attempts times" do
-        @job.reload.failed_at.should == nil
-        Delayed::Job::max_attempts.times { @job.reschedule 'FAIL' }
-        @job.reload.failed_at.should_not == nil
-      end
-
-      it "should not be failed if it failed fewer than Job::max_attempts times" do
-        (Delayed::Job::max_attempts - 1).times { @job.reschedule 'FAIL' }
-        @job.reload.failed_at.should == nil
-      end
-      
-    end
-  end
-  
-  it "should fail after Job::max_run_time" do
-    @job = Delayed::Job.create :payload_object => LongRunningJob.new
-    Delayed::Job.reserve_and_run_one_job(1.second)
-    @job.reload.last_error.should =~ /expired/
-    @job.attempts.should == 1
-  end
-
-  it "should never find failed jobs" do
-    @job = Delayed::Job.create :payload_object => SimpleJob.new, :attempts => 50, :failed_at => Delayed::Job.db_time_now
-    Delayed::Job.find_available(1).length.should == 0
-  end
-
-  context "when another worker is already performing an task, it" do
-
-    before :each do
-      Delayed::Job.worker_name = 'worker1'
-      @job = Delayed::Job.create :payload_object => SimpleJob.new, :locked_by => 'worker1', :locked_at => Delayed::Job.db_time_now - 5.minutes
-    end
-
-    it "should not allow a second worker to get exclusive access" do
-      @job.lock_exclusively!(4.hours, 'worker2').should == false
-    end
-
-    it "should allow a second worker to get exclusive access if the timeout has passed" do
-      @job.lock_exclusively!(1.minute, 'worker2').should == true
-    end      
-    
-    it "should be able to get access to the task if it was started more then max_age ago" do
-      @job.locked_at = 5.hours.ago
-      @job.save
-
-      @job.lock_exclusively! 4.hours, 'worker2'
-      @job.reload
-      @job.locked_by.should == 'worker2'
-      @job.locked_at.should > 1.minute.ago
-    end
-
-    it "should not be found by another worker" do
-      Delayed::Job.worker_name = 'worker2'
-
-      Delayed::Job.find_available(1, 6.minutes).length.should == 0
-    end
-
-    it "should be found by another worker if the time has expired" do
-      Delayed::Job.worker_name = 'worker2'
-
-      Delayed::Job.find_available(1, 4.minutes).length.should == 1
-    end
-
-    it "should be able to get exclusive access again when the worker name is the same" do
-      @job.lock_exclusively! 5.minutes, 'worker1'
-      @job.lock_exclusively! 5.minutes, 'worker1'
-      @job.lock_exclusively! 5.minutes, 'worker1'
-    end                                        
-  end
-  
-  context "when another worker has worked on a task since the job was found to be available, it" do
-
-    before :each do
-      Delayed::Job.worker_name = 'worker1'
-      @job = Delayed::Job.create :payload_object => SimpleJob.new
-      @job_copy_for_worker_2 = Delayed::Job.find(@job.id)
-    end
-
-    it "should not allow a second worker to get exclusive access if already successfully processed by worker1" do
-      @job.delete
-      @job_copy_for_worker_2.lock_exclusively!(4.hours, 'worker2').should == false
-    end
-
-    it "should not allow a second worker to get exclusive access if failed to be processed by worker1 and run_at time is now in future (due to backing off behaviour)" do
-      @job.update_attributes(:attempts => 1, :run_at => 1.day.from_now)
-      @job_copy_for_worker_2.lock_exclusively!(4.hours, 'worker2').should == false
-    end
-  end
-
-  context "#name" do
-    it "should be the class name of the job that was enqueued" do
-      Delayed::Job.create(:payload_object => ErrorJob.new ).name.should == 'ErrorJob'
-    end
-
-    it "should be the method that will be called if its a performable method object" do
-      Delayed::Job.send_later(:clear_locks!)
-      Delayed::Job.last.name.should == 'Delayed::Job.clear_locks!'
-
-    end
-    it "should be the instance method that will be called if its a performable method object" do
-      story = Story.create :text => "..."                 
-      
-      story.send_later(:save)
-      
-      Delayed::Job.last.name.should == 'Story#save'
-    end
-  end
-  
-  context "worker prioritization" do
-    
-    before(:each) do
-      Delayed::Job.max_priority = nil
-      Delayed::Job.min_priority = nil      
-    end
-  
-    it "should only work_off jobs that are >= min_priority" do
-      Delayed::Job.min_priority = -5
-      Delayed::Job.max_priority = 5
-      SimpleJob.runs.should == 0
-    
-      Delayed::Job.enqueue SimpleJob.new, -10
-      Delayed::Job.enqueue SimpleJob.new, 0
-      Delayed::Job.work_off
-    
-      SimpleJob.runs.should == 1
-    end
-  
-    it "should only work_off jobs that are <= max_priority" do
-      Delayed::Job.min_priority = -5
-      Delayed::Job.max_priority = 5
-      SimpleJob.runs.should == 0
-    
-      Delayed::Job.enqueue SimpleJob.new, 10
-      Delayed::Job.enqueue SimpleJob.new, 0
-
-      Delayed::Job.work_off
-
-      SimpleJob.runs.should == 1
-    end
-    
-    it "should fetch jobs ordered by priority" do
-      number_of_jobs = 10
-      number_of_jobs.times { Delayed::Job.enqueue SimpleJob.new, rand(10) }
-      jobs = Delayed::Job.find_available(10)
-      ordered = true
-      jobs[1..-1].each_index{ |i| 
-        if (jobs[i].priority < jobs[i+1].priority)
-          ordered = false
-          break
-        end
-      }
-      ordered.should == true
-    end
-   
-  end
-  
-  context "when pulling jobs off the queue for processing, it" do
-    before(:each) do
-      @job = Delayed::Job.create(
-        :payload_object => SimpleJob.new, 
-        :locked_by => 'worker1', 
-        :locked_at => Delayed::Job.db_time_now - 5.minutes)
-    end
-
-    it "should leave the queue in a consistent state and not run the job if locking fails" do
-      SimpleJob.runs.should == 0     
-      @job.stub!(:lock_exclusively!).with(any_args).once.and_return(false)
-      Delayed::Job.should_receive(:find_available).once.and_return([@job])
-      Delayed::Job.work_off(1)
-      SimpleJob.runs.should == 0
-    end
-  
-  end
-  
-  context "while running alongside other workers that locked jobs, it" do
-    before(:each) do
-      Delayed::Job.worker_name = 'worker1'
-      Delayed::Job.create(:payload_object => SimpleJob.new, :locked_by => 'worker1', :locked_at => (Delayed::Job.db_time_now - 1.minutes))
-      Delayed::Job.create(:payload_object => SimpleJob.new, :locked_by => 'worker2', :locked_at => (Delayed::Job.db_time_now - 1.minutes))
-      Delayed::Job.create(:payload_object => SimpleJob.new)
-      Delayed::Job.create(:payload_object => SimpleJob.new, :locked_by => 'worker1', :locked_at => (Delayed::Job.db_time_now - 1.minutes))
-    end
-
-    it "should ingore locked jobs from other workers" do
-      Delayed::Job.worker_name = 'worker3'
-      SimpleJob.runs.should == 0
-      Delayed::Job.work_off
-      SimpleJob.runs.should == 1 # runs the one open job
-    end
-
-    it "should find our own jobs regardless of locks" do
-      Delayed::Job.worker_name = 'worker1'
-      SimpleJob.runs.should == 0
-      Delayed::Job.work_off
-      SimpleJob.runs.should == 3 # runs open job plus worker1 jobs that were already locked
-    end
-  end
-
-  context "while running with locked and expired jobs, it" do
-    before(:each) do
-      Delayed::Job.worker_name = 'worker1'
-      exp_time = Delayed::Job.db_time_now - (1.minutes + Delayed::Job::max_run_time)
-      Delayed::Job.create(:payload_object => SimpleJob.new, :locked_by => 'worker1', :locked_at => exp_time)
-      Delayed::Job.create(:payload_object => SimpleJob.new, :locked_by => 'worker2', :locked_at => (Delayed::Job.db_time_now - 1.minutes))
-      Delayed::Job.create(:payload_object => SimpleJob.new)
-      Delayed::Job.create(:payload_object => SimpleJob.new, :locked_by => 'worker1', :locked_at => (Delayed::Job.db_time_now - 1.minutes))
-    end
-
-    it "should only find unlocked and expired jobs" do
-      Delayed::Job.worker_name = 'worker3'
-      SimpleJob.runs.should == 0
-      Delayed::Job.work_off
-      SimpleJob.runs.should == 2 # runs the one open job and one expired job
-    end
-
-    it "should ignore locks when finding our own jobs" do
-      Delayed::Job.worker_name = 'worker1'
-      SimpleJob.runs.should == 0
-      Delayed::Job.work_off
-      SimpleJob.runs.should == 3 # runs open job plus worker1 jobs
-      # This is useful in the case of a crash/restart on worker1, but make sure multiple workers on the same host have unique names!
-    end
-
-  end
-  
-end