blaxter-delayed_job 1.7.0 → 1.7.99

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/README.textile

@@ -1,6 +1,6 @@
 h1. Delayed::Job
 
-Delated_job (or DJ) encapsulates the common pattern of asynchronously executing longer tasks in the background. 
+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. Amongst those tasks are:
 
@@ -15,39 +15,43 @@ It is a direct extraction from Shopify where the job table is responsible for a
 h2. Setup
             
 The library evolves around a delayed_jobs table which looks as follows: 
-
-  create_table :delayed_jobs, :force => true do |table|
+<pre><code>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.string   :job_type                     # Class name of the job object, for type-specific workers
     table.string   :last_error                   # reason for last failure (See Note below)
     table.datetime :run_at                       # When to run. Could be Time.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.datetime :finished_at			 # Used for statiscics / monitoring
     table.timestamps
   end
-
+</code></pre>
 On failure, the job is scheduled again in 5 seconds + N ** 4, where N is the number of retries.
 
-The default 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.
+The default MAX_ATTEMPTS is 25- jobs can override this value by responding to :max_attempts. 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.
 
 The default MAX_RUN_TIME is 4.hours. If your job takes longer than that, another computer could pick it up. It's up to you to
 make sure your job doesn't exceed this time. You should set this to the longest time you think the job could take.
 
-By default, it will delete failed jobs (and it always deletes successful jobs). If you want to keep failed jobs, set
-Delayed::Job.destroy_failed_jobs = false. The failed jobs will be marked with non-null failed_at.
+By default, it will delete failed jobs. If you want to keep failed jobs, set
+@Delayed::Job.destroy_failed_jobs = false@. The failed jobs will be marked with non-null failed_at.
 
-Here is an example of changing job parameters in Rails:
+Same thing for successful jobs. They're deleted by default and, to keep them, set @Delayed::Job.destroy_successful_jobs = false@. They will be marked with finished_at. This is useful for gathering statistics like how long jobs took between entering the queue (created_at) and being finished (finished_at).
 
-  # config/initializers/delayed_job_config.rb
+Here is an example of changing job parameters in Rails:
+<pre><code># config/initializers/delayed_job_config.rb
   Delayed::Job.destroy_failed_jobs = false
+  Delayed::Job.destroy_successful_jobs = false
   silence_warnings do
     Delayed::Job.const_set("MAX_ATTEMPTS", 3)
     Delayed::Job.const_set("MAX_RUN_TIME", 5.minutes)
   end
-
+</code></pre>
 Note: If your error messages are long, consider changing last_error field to a :text instead of a :string (255 character limit).
 
 
@@ -55,20 +59,18 @@ h2. Usage
 
 Jobs are simple ruby objects with a method called perform. Any object which responds to perform can be stuffed into the jobs table.
 Job objects are serialized to yaml so that they can later be resurrected by the job runner. 
-
-  class NewsletterJob < Struct.new(:text, :emails)
+<pre><code>class NewsletterJob < Struct.new(:text, :emails)
     def perform
       emails.each { |e| NewsletterMailer.deliver_text_to_email(text, e) }
     end    
   end  
   
   Delayed::Job.enqueue NewsletterJob.new('lorem ipsum...', Customers.find(:all).collect(&:email))
-           
+</code></pre>
 There is also a second way to get jobs in the queue: send_later. 
 
-  
-  BatchImporter.new(Shop.find(1)).send_later(:import_massive_csv, massive_csv)                                                    
-  
+<pre><code>BatchImporter.new(Shop.find(1)).send_later(:import_massive_csv, massive_csv)
+</code></pre>
 
 This will simply create a Delayed::PerformableMethod job in the jobs table which serializes all the parameters you pass to it. There are some special smarts for active record objects
 which are stored as their text representation and loaded from the database fresh when the job is actually run later.
@@ -80,8 +82,7 @@ You can invoke @rake jobs:work@ which will start working off jobs. You can cance
 
 You can also run by writing a simple @script/job_runner@, and invoking it externally:
   
-<pre><code>
-  #!/usr/bin/env ruby
+<pre><code>#!/usr/bin/env ruby
   require File.dirname(__FILE__) + '/../config/environment'
   
   Delayed::Worker.new.start  
@@ -93,6 +94,13 @@ Keep in mind that each worker will check the database at least every 5 seconds.
 
 Note: The rake task will exit if the database has any network connectivity problems.
 
+If you only want to run specific types of jobs in a given worker, include them when initializing the worker:
+
+<pre><code>
+  Delayed::Worker.new(:job_types => "SimpleJob").start
+  Delayed::Worker.new(:job_types => ["SimpleJob", "NewsletterJob"]).start
+</pre></code>
+
 h3. Cleaning up
 
 You can invoke @rake jobs:clear@ to delete all jobs in the queue.

data/Rakefile

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+begin
+  require 'jeweler'
+
+  Jeweler::Tasks.new do |s|
+    s.name     = "delayed_job"
+    s.summary  = "Database-backed asynchronous priority queue system -- Extracted from Shopify"
+    s.email    = "tobi@leetsoft.com"
+    s.homepage = "http://github.com/tobi/delayed_job/tree/master"
+    s.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."
+    s.authors  = ["Tobias Lütke"]
+    
+    s.has_rdoc = true
+    s.rdoc_options = ["--main", "README.textile", "--inline-source", "--line-numbers"]
+    s.extra_rdoc_files = ["README.textile"]
+    
+    s.test_files = Dir['spec/**/*']
+  end
+
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+  exit 1
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+ 
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+ 
+ 
+task :default => :spec

data/delayed_job.gemspec

@@ -1,41 +1,57 @@
-#version = File.read('README.textile').scan(/^\*\s+([\d\.]+)/).flatten
+# -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
-  s.name     = "delayed_job"
-  s.version  = "1.7.0"
-  s.date     = "2008-11-28"
-  s.summary  = "Database-backed asynchronous priority queue system -- Extracted from Shopify"
-  s.email    = "tobi@leetsoft.com"
-  s.homepage = "http://github.com/tobi/delayed_job/tree/master"
-  s.description = "Delated_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."
-  s.authors  = ["Tobias Lütke"]
+  s.name = %q{delayed_job}
+  s.version = "1.7.99"
 
-  # s.bindir = "bin"
-  # s.executables = ["delayed_job"]
-  # s.default_executable = "delayed_job"
-
-  s.has_rdoc = false
-  s.rdoc_options = ["--main", "README.textile"]
-  s.extra_rdoc_files = ["README.textile"]
-
-  # run git ls-files to get an updated list
-  s.files = %w[
-    MIT-LICENSE
-    README.textile
-    delayed_job.gemspec
-    init.rb
-    lib/delayed/job.rb
-    lib/delayed/message_sending.rb
-    lib/delayed/performable_method.rb
-    lib/delayed/worker.rb
-    lib/delayed_job.rb
-    tasks/jobs.rake
-    tasks/tasks.rb
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Tobias L\303\274tke"]
+  s.date = %q{2009-08-06}
+  s.description = %q{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.}
+  s.email = %q{tobi@leetsoft.com}
+  s.extra_rdoc_files = [
+    "README.textile"
+  ]
+  s.files = [
+    ".gitignore",
+     "MIT-LICENSE",
+     "README.textile",
+     "Rakefile",
+     "delayed_job.gemspec",
+     "generators/delayed_job/delayed_job_generator.rb",
+     "generators/delayed_job/templates/migration.rb",
+     "init.rb",
+     "lib/delayed/job.rb",
+     "lib/delayed/message_sending.rb",
+     "lib/delayed/performable_method.rb",
+     "lib/delayed/worker.rb",
+     "lib/delayed_job.rb",
+     "spec/database.rb",
+     "spec/delayed_method_spec.rb",
+     "spec/job_spec.rb",
+     "spec/story_spec.rb",
+     "tasks/jobs.rake",
+     "tasks/tasks.rb"
   ]
-  s.test_files = %w[
-    spec/database.rb
-    spec/delayed_method_spec.rb
-    spec/job_spec.rb
-    spec/story_spec.rb
+  s.homepage = %q{http://github.com/tobi/delayed_job/tree/master}
+  s.rdoc_options = ["--main", "README.textile", "--inline-source", "--line-numbers"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.3}
+  s.summary = %q{Database-backed asynchronous priority queue system -- Extracted from Shopify}
+  s.test_files = [
+    "spec/delayed_method_spec.rb",
+     "spec/story_spec.rb",
+     "spec/database.rb",
+     "spec/job_spec.rb"
   ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
 end

data/generators/delayed_job/delayed_job_generator.rb

@@ -0,0 +1,11 @@
+class DelayedJobGenerator < Rails::Generator::Base
+  def manifest
+    record do |m|
+      m.migration_template 'migration.rb', 'db/migrate',
+        :assigns => { :migration_name => 'CreateDelayedJobs' },
+        :migration_file_name => "create_delayed_jobs"
+    end
+  end
+
+end
+

data/generators/delayed_job/templates/migration.rb

@@ -0,0 +1,21 @@
+class CreateDelayedJobs < ActiveRecord::Migration
+  def self.up
+    create_table :delayed_jobs do |t|
+      t.integer  :priority, :default => 0
+      t.integer  :attempts, :default => 0
+      t.text     :handler
+      t.string   :job_type
+      t.string   :last_error
+      t.datetime :run_at
+      t.datetime :locked_at
+      t.datetime :failed_at
+      t.string   :locked_by
+      t.datetime :finished_at
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :delayed_jobs
+  end
+end

data/lib/delayed/job.rb

@@ -1,3 +1,5 @@
+require 'timeout'
+
 module Delayed
 
   class DeserializationError < StandardError
@@ -16,20 +18,27 @@ module Delayed
     cattr_accessor :destroy_failed_jobs
     self.destroy_failed_jobs = true
 
+    # By default successful jobs are destroyed after finished.
+    # If you want to keep them around (for statistics/monitoring),
+    # set this to false.
+    cattr_accessor :destroy_successful_jobs
+    self.destroy_successful_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.
     cattr_accessor :worker_name
     self.worker_name = "host:#{Socket.gethostname} pid:#{Process.pid}" rescue "pid:#{Process.pid}"
 
-    NextTaskSQL         = '(run_at <= ? AND (locked_at IS NULL OR locked_at < ?) OR (locked_by = ?)) AND failed_at IS NULL'
+    NextTaskSQL         = '(run_at <= ? AND (locked_at IS NULL OR locked_at < ?) OR (locked_by = ?)) AND failed_at IS NULL AND finished_at IS NULL'
     NextTaskOrder       = 'priority DESC, run_at ASC'
 
     ParseObjectFromYaml = /\!ruby\/\w+\:([^\s]+)/
 
-    cattr_accessor :min_priority, :max_priority
+    cattr_accessor :min_priority, :max_priority, :job_types
     self.min_priority = nil
     self.max_priority = nil
+    self.job_types    = nil
 
     # When a worker is exiting, make sure we don't have any locked jobs.
     def self.clear_locks!
@@ -57,13 +66,14 @@ module Delayed
     end
 
     def payload_object=(object)
-      self['handler'] = object.to_yaml
+      self['job_type'] = object.class.to_s
+      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)
-      if self.attempts < MAX_ATTEMPTS
+      if self.attempts < (payload_object.send(:max_attempts) rescue MAX_ATTEMPTS)
         time ||= Job.db_time_now + (attempts ** 4) + 5
 
         self.attempts    += 1
@@ -89,11 +99,11 @@ module Delayed
 
       begin
         runtime =  Benchmark.realtime do
-          invoke_job # TODO: raise error if takes longer than max_run_time
-          destroy
+          Timeout.timeout(max_run_time.to_i) { invoke_job }
         end
-        # TODO: warn if runtime > max_run_time ?
-        Delayed::Worker.logger.info "* [JOB] #{name} completed after %.4f" % runtime
+        destroy_successful_jobs ? destroy :
+          update_attribute(:finished_at, Time.now)
+        Delayed::Worker.logger.info "* [JOB] #{name} completed after %.4f" % runtime        
         return true  # did work
       rescue Exception => e
         reschedule e.message, e.backtrace
@@ -136,6 +146,11 @@ module Delayed
         conditions << max_priority
       end
 
+      if self.job_types
+        sql << ' AND (job_type IN (?))'
+        conditions << job_types
+      end
+
       conditions.unshift(sql)
 
       records = ActiveRecord::Base.silence do

data/lib/delayed/worker.rb

@@ -13,6 +13,7 @@ module Delayed
       @quiet = options[:quiet]
       Delayed::Job.min_priority = options[:min_priority] if options.has_key?(:min_priority)
       Delayed::Job.max_priority = options[:max_priority] if options.has_key?(:max_priority)
+      Delayed::Job.job_types    = options[:job_types]    if options.has_key?(:job_types)
     end
 
     def start

data/spec/database.rb

@@ -3,13 +3,17 @@ $:.unshift(File.dirname(__FILE__) + '/../../rspec/lib')
 
 require 'rubygems'
 require 'active_record'
-gem 'sqlite3-ruby'
 
 require File.dirname(__FILE__) + '/../init'
 require 'spec'
-  
-ActiveRecord::Base.logger = Logger.new('/tmp/dj.log')
-ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => '/tmp/jobs.sqlite')
+
+logger = Logger.new('/tmp/dj.log')
+ActiveRecord::Base.logger = logger
+Delayed::Worker.logger = logger
+ActiveRecord::Base.establish_connection(
+  :adapter  => (PLATFORM =~ /java/ ? 'jdbcsqlite3' : 'sqlite3'),
+  :database => '/tmp/jobs.sqlite'
+)
 ActiveRecord::Migration.verbose = false
 
 ActiveRecord::Schema.define do
@@ -18,11 +22,13 @@ ActiveRecord::Schema.define do
     table.integer  :priority, :default => 0
     table.integer  :attempts, :default => 0
     table.text     :handler
+    table.string   :job_type
     table.string   :last_error
     table.datetime :run_at
     table.datetime :locked_at
     table.string   :locked_by
     table.datetime :failed_at
+    table.datetime :finished_at
     table.timestamps
   end
 
@@ -35,8 +41,8 @@ end
 
 # Purely useful for test cases...
 class Story < ActiveRecord::Base
-  def tell; text; end       
+  def tell; text; end
   def whatever(n, _); tell*n; end
-  
+
   handle_asynchronously :whatever
 end

data/spec/job_spec.rb

@@ -5,11 +5,19 @@ class SimpleJob
   def perform; @@runs += 1; end
 end
 
+class CustomJob < SimpleJob
+  def max_attempts; 3; 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
@@ -69,8 +77,43 @@ describe Delayed::Job do
 
     SimpleJob.runs.should == 1
   end
-                     
-                     
+
+  it "should work on specified job types" do
+    SimpleJob.runs.should == 0
+
+    Delayed::Job.job_types = "SimpleJob"
+    Delayed::Job.enqueue SimpleJob.new
+    Delayed::Job.work_off
+
+    SimpleJob.runs.should == 1
+
+    Delayed::Job.job_types = nil
+  end
+
+  it "should not work on unspecified job types" do
+    SimpleJob.runs.should == 0
+
+    Delayed::Job.job_types = "AnotherJob"
+    Delayed::Job.enqueue SimpleJob.new
+    Delayed::Job.work_off
+
+    SimpleJob.runs.should == 0
+
+    Delayed::Job.job_types = nil
+  end
+
+  it "should work on specified job types even when it's a list" do
+    SimpleJob.runs.should == 0
+
+    Delayed::Job.job_types = %w( Whatever SimpleJob )
+    Delayed::Job.enqueue SimpleJob.new
+    Delayed::Job.work_off
+
+    SimpleJob.runs.should == 1
+
+    Delayed::Job.job_types = nil
+  end
+
   it "should work with eval jobs" do
     $eval_job_ran = false
 
@@ -92,7 +135,49 @@ describe Delayed::Job do
 
     M::ModuleJob.runs.should == 1
   end
-                   
+
+  it "should be destroyed if it succeeded and we want to destroy jobs" do
+    default = Delayed::Job.destroy_successful_jobs
+    Delayed::Job.destroy_successful_jobs = true
+
+    Delayed::Job.enqueue SimpleJob.new
+    Delayed::Job.work_off
+
+    Delayed::Job.count.should == 0
+
+    Delayed::Job.destroy_successful_jobs = default
+  end
+
+  it "should be kept if it succeeded and we don't want to destroy jobs" do
+    default = Delayed::Job.destroy_successful_jobs
+    Delayed::Job.destroy_successful_jobs = false
+
+    Delayed::Job.enqueue SimpleJob.new
+    Delayed::Job.work_off
+
+    Delayed::Job.count.should == 1
+
+    Delayed::Job.destroy_successful_jobs = default
+  end
+
+  it "should be finished if it succeeded and we don't want to destroy jobs" do
+    default = Delayed::Job.destroy_successful_jobs
+    Delayed::Job.destroy_successful_jobs = false
+    @job = Delayed::Job.create :payload_object => SimpleJob.new
+
+    @job.reload.finished_at.should == nil
+    Delayed::Job.work_off
+    @job.reload.finished_at.should_not == nil
+
+    Delayed::Job.destroy_successful_jobs = default
+  end
+
+  it "should never find finished jobs" do
+    @job = Delayed::Job.create :payload_object => SimpleJob.new,
+      :finished_at => Time.now
+    Delayed::Job.find_available(1).length.should == 0
+  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)
@@ -100,7 +185,7 @@ describe Delayed::Job do
     job = Delayed::Job.find(:first)
 
     job.last_error.should =~ /did not work/
-    job.last_error.should =~ /job_spec.rb:10:in `perform'/
+    job.last_error.should =~ /job_spec.rb:14:in `perform'/
     job.attempts.should == 1
 
     job.run_at.should > Delayed::Job.db_time_now - 10.minutes
@@ -171,6 +256,24 @@ describe Delayed::Job do
     Delayed::Job.destroy_failed_jobs = default
   end
 
+  it "should allow jobs to override max_attemps and behave appropriately" do
+    default = Delayed::Job.destroy_failed_jobs
+    Delayed::Job.destroy_failed_jobs = true
+
+    @job = Delayed::Job.create :payload_object => CustomJob.new, :attempts => 5
+    @job.should_receive(:destroy)
+    @job.reschedule 'FAIL'
+
+    Delayed::Job.destroy_failed_jobs = default
+  end
+
+  it "should fail after 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 => Time.now
     Delayed::Job.find_available(1).length.should == 0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: blaxter-delayed_job
 version: !ruby/object:Gem::Version 
-  version: 1.7.0
+  version: 1.7.99
 platform: ruby
 authors: 
 - "Tobias L\xC3\xBCtke"
@@ -9,11 +9,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-11-28 00:00:00 -08:00
+date: 2009-08-06 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
-description: Delated_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.
+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.
 email: tobi@leetsoft.com
 executables: []
 
@@ -22,15 +22,23 @@ extensions: []
 extra_rdoc_files: 
 - README.textile
 files: 
+- .gitignore
 - MIT-LICENSE
 - README.textile
+- Rakefile
 - delayed_job.gemspec
+- generators/delayed_job/delayed_job_generator.rb
+- generators/delayed_job/templates/migration.rb
 - init.rb
 - lib/delayed/job.rb
 - lib/delayed/message_sending.rb
 - lib/delayed/performable_method.rb
 - lib/delayed/worker.rb
 - lib/delayed_job.rb
+- spec/database.rb
+- spec/delayed_method_spec.rb
+- spec/job_spec.rb
+- spec/story_spec.rb
 - tasks/jobs.rake
 - tasks/tasks.rb
 has_rdoc: false
@@ -40,6 +48,8 @@ post_install_message:
 rdoc_options: 
 - --main
 - README.textile
+- --inline-source
+- --line-numbers
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -59,10 +69,10 @@ requirements: []
 rubyforge_project: 
 rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Database-backed asynchronous priority queue system -- Extracted from Shopify
 test_files: 
-- spec/database.rb
 - spec/delayed_method_spec.rb
-- spec/job_spec.rb
 - spec/story_spec.rb
+- spec/database.rb
+- spec/job_spec.rb