que 0.5.0 → 0.6.0

data/spec/unit/logging_spec.rb

@@ -1,12 +1,13 @@
 require 'spec_helper'
 
 describe "Logging" do
-  it "by default should record the library and thread id in JSON" do
+  it "by default should record the library and hostname and thread id in JSON" do
     Que.log :event => "blah", :source => 4
     $logger.messages.count.should be 1
 
     message = JSON.load($logger.messages.first)
     message['lib'].should == 'que'
+    message['hostname'].should == Socket.gethostname
     message['event'].should == 'blah'
     message['source'].should == 4
     message['thread'].should == Thread.current.object_id
@@ -16,7 +17,7 @@ describe "Logging" do
     begin
       Que.logger = nil
 
-      Que::Job.queue
+      Que::Job.enqueue
       worker = Que::Worker.new
       sleep_until { worker.sleeping? }
 

data/spec/unit/migrations_spec.rb

@@ -7,7 +7,7 @@ describe Que::Migrations do
 
     default = proc do
       result = Que.execute <<-SQL
-        select adsrc
+        select adsrc::integer
         from pg_attribute a
         join pg_class c on c.oid = a.attrelid
         join pg_attrdef on adrelid = attrelid AND adnum = attnum
@@ -15,7 +15,7 @@ describe Que::Migrations do
         and attname = 'priority'
       SQL
 
-      result.first['adsrc'].to_i
+      result.first[:adsrc]
     end
 
     default.call.should == 100
@@ -40,6 +40,7 @@ describe Que::Migrations do
     Que::Migrations.db_version.should == Que::Migrations::CURRENT_VERSION
     Que::Migrations.migrate! :version => 0
     Que::Migrations.db_version.should == 0
+    Que.db_version.should == 0
     Que::Migrations.migrate!
     Que::Migrations.db_version.should == Que::Migrations::CURRENT_VERSION
 

data/spec/unit/pool_spec.rb

@@ -19,15 +19,15 @@ describe "Managing the Worker pool" do
     it "should make jobs run in the same thread as they are queued" do
       Que.mode = :sync
 
-      ArgsJob.queue(5, :testing => "synchronous").should be_an_instance_of ArgsJob
-      $passed_args.should == [5, {'testing' => "synchronous"}]
+      ArgsJob.enqueue(5, :testing => "synchronous").should be_an_instance_of ArgsJob
+      $passed_args.should == [5, {:testing => "synchronous"}]
       DB[:que_jobs].count.should be 0
     end
 
     it "should not affect jobs that are queued with specific run_ats" do
       Que.mode = :sync
 
-      ArgsJob.queue(5, :testing => "synchronous", :run_at => Time.now + 60)
+      ArgsJob.enqueue(5, :testing => "synchronous", :run_at => Time.now + 60)
       DB[:que_jobs].select_map(:job_class).should == ["ArgsJob"]
     end
   end
@@ -132,7 +132,7 @@ describe "Managing the Worker pool" do
       Que.mode = :async
       sleep_until { Que::Worker.workers.all? &:sleeping? }
 
-      BlockJob.queue
+      BlockJob.enqueue
       Que.wake!
 
       $q1.pop
@@ -158,7 +158,7 @@ describe "Managing the Worker pool" do
       Que.mode = :async
       sleep_until { Que::Worker.workers.all? &:sleeping? }
 
-      4.times { BlockJob.queue }
+      4.times { BlockJob.enqueue }
       Que.wake_all!
       4.times { $q1.pop }
 
@@ -179,8 +179,32 @@ describe "Managing the Worker pool" do
       Que.mode = :async
       sleep_until { Que::Worker.workers.all? &:sleeping? }
       Que.wake_interval = 0.01 # 10 ms
-      Que::Job.queue
+      Que::Job.enqueue
       sleep_until { DB[:que_jobs].count == 0 }
     end
+
+    it "should work jobs in the queue defined by QUE_QUEUE" do
+      begin
+        Que::Job.enqueue 1
+        Que::Job.enqueue 2, :queue => 'my_queue'
+
+        ENV['QUE_QUEUE'] = 'my_queue'
+
+        Que.mode = :async
+        sleep_until { Que::Worker.workers.all? &:sleeping? }
+        DB[:que_jobs].count.should be 1
+
+        job = DB[:que_jobs].first
+        job[:queue].should == ''
+        job[:args].should == '[1]'
+      ensure
+        ENV.delete('QUE_QUEUE')
+
+        if @worker
+          @worker.stop
+          @worker.wait_until_stopped
+        end
+      end
+    end
   end
 end

data/spec/unit/run_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Que::Job, '.run' do
+  it "should immediately process the job with the arguments given to it" do
+    result = ArgsJob.run 1, 'two', {:three => 3}
+    result.should be_an_instance_of ArgsJob
+    result.attrs[:args].should == [1, 'two', {:three => 3}]
+
+    DB[:que_jobs].count.should be 0
+    $passed_args.should == [1, 'two', {:three => 3}]
+  end
+end

data/spec/unit/states_spec.rb

@@ -6,45 +6,43 @@ describe Que, '.worker_states' do
 
     class WorkerStateJob < BlockJob
       def run
-        $pid = Que.execute("select pg_backend_pid()").first['pg_backend_pid']
+        $pid = Que.execute("select pg_backend_pid()").first[:pg_backend_pid]
         super
       end
     end
 
-    WorkerStateJob.queue :priority => 2
+    WorkerStateJob.enqueue :priority => 2
 
     # Ensure that the portion of the SQL query that accounts for bigint
     # job_ids functions correctly.
     DB[:que_jobs].update(:job_id => 2**33)
 
-    begin
-      t = Thread.new { Que::Job.work }
-      $q1.pop
-
-      states = Que.worker_states
-      states.length.should be 1
-
-      $q2.push nil
-      t.join
-
-      state = states.first
-      state.keys.should == %w(priority run_at job_id job_class args error_count last_error pg_backend_pid pg_state pg_state_changed_at pg_last_query pg_last_query_started_at pg_transaction_started_at pg_waiting_on_lock)
-
-      state[:priority].should == '2'
-      Time.parse(state[:run_at]).should be_within(3).of Time.now
-      state[:job_id].should == (2**33).to_s
-      state[:job_class].should == 'WorkerStateJob'
-      state[:args].should == '[]'
-      state[:error_count].should == '0'
-      state[:last_error].should be nil
-
-      state[:pg_backend_pid].should == $pid.to_s
-      state[:pg_state].should == 'idle'
-      Time.parse(state[:pg_state_changed_at]).should be_within(3).of Time.now
-      state[:pg_last_query].should == 'select pg_backend_pid()'
-      Time.parse(state[:pg_last_query_started_at]).should be_within(3).of Time.now
-      state[:pg_transaction_started_at].should == nil
-      state[:pg_waiting_on_lock].should == 'f'
-    end
+    t = Thread.new { Que::Job.work }
+    $q1.pop
+
+    states = Que.worker_states
+    states.length.should be 1
+
+    $q2.push nil
+    t.join
+
+    state = states.first
+    state.keys.should == %w(priority run_at job_id job_class args error_count last_error queue pg_backend_pid pg_state pg_state_changed_at pg_last_query pg_last_query_started_at pg_transaction_started_at pg_waiting_on_lock)
+
+    state[:priority].should == 2
+    state[:run_at].should be_within(3).of Time.now
+    state[:job_id].should == 2**33
+    state[:job_class].should == 'WorkerStateJob'
+    state[:args].should == []
+    state[:error_count].should == 0
+    state[:last_error].should be nil
+
+    state[:pg_backend_pid].should == $pid
+    state[:pg_state].should == 'idle'
+    state[:pg_state_changed_at].should be_within(3).of Time.now
+    state[:pg_last_query].should == 'select pg_backend_pid()'
+    state[:pg_last_query_started_at].should be_within(3).of Time.now
+    state[:pg_transaction_started_at].should == nil
+    state[:pg_waiting_on_lock].should == false
   end if QUE_ADAPTERS[:connection_pool]
 end

data/spec/unit/stats_spec.rb

@@ -2,15 +2,15 @@ require 'spec_helper'
 
 describe Que, '.job_stats' do
   it "should return a list of the job types in the queue, their counts and the number of each currently running" do
-    BlockJob.queue
-    Que::Job.queue
+    BlockJob.enqueue
+    Que::Job.enqueue
 
     # Have to tweak the job_id to ensure that the portion of the SQL query
     # that accounts for bigint job_ids functions correctly.
     old = Time.now - 3600
     DB[:que_jobs].where(:job_class => "Que::Job").update(:job_id => 2**33, :error_count => 5, :run_at => old)
 
-    Que::Job.queue
+    Que::Job.enqueue
 
     begin
       DB.get{pg_advisory_lock(2**33)}
@@ -20,21 +20,23 @@ describe Que, '.job_stats' do
 
       qj, bj = stats
 
-      qj.keys.should == %w(job_class count count_working count_errored highest_error_count oldest_run_at)
+      qj.keys.should == %w(queue job_class count count_working count_errored highest_error_count oldest_run_at)
 
+      qj[:queue].should == ''
       qj[:job_class].should == 'Que::Job'
-      qj[:count].should == '2'
-      qj[:count_working].should == '1'
-      qj[:count_errored].should == '1'
-      qj[:highest_error_count].should == '5'
-      Time.parse(qj[:oldest_run_at]).should be_within(3).of old
+      qj[:count].should == 2
+      qj[:count_working].should == 1
+      qj[:count_errored].should == 1
+      qj[:highest_error_count].should == 5
+      qj[:oldest_run_at].should be_within(3).of old
 
+      bj[:queue].should == ''
       bj[:job_class].should == 'BlockJob'
-      bj[:count].should == '1'
-      bj[:count_working].should == '0'
-      bj[:count_errored].should == '0'
-      bj[:highest_error_count].should == '0'
-      Time.parse(bj[:oldest_run_at]).should be_within(3).of Time.now
+      bj[:count].should == 1
+      bj[:count_working].should == 0
+      bj[:count_errored].should == 0
+      bj[:highest_error_count].should == 0
+      bj[:oldest_run_at].should be_within(3).of Time.now
     ensure
       DB.get{pg_advisory_unlock_all{}}
     end

data/spec/unit/work_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Que::Job, '.work' do
   it "should pass a job's arguments to the run method and delete it from the database" do
-    ArgsJob.queue 1, 'two', {'three' => 3}
+    ArgsJob.enqueue 1, 'two', {'three' => 3}
     DB[:que_jobs].count.should be 1
 
     result = Que::Job.work
@@ -13,9 +13,38 @@ describe Que::Job, '.work' do
     $passed_args.should == [1, 'two', {'three' => 3}]
   end
 
+  it "should default to only working jobs without a named queue" do
+    Que::Job.enqueue 1, :queue => 'other_queue'
+    Que::Job.enqueue 2
+
+    result = Que::Job.work
+    result[:event].should == :job_worked
+    result[:job][:args].should == [2]
+
+    result = Que::Job.work
+    result[:event].should == :job_unavailable
+  end
+
+  it "should accept the name of a single queue to pull jobs from" do
+    Que::Job.enqueue 1, :queue => 'other_queue'
+    Que::Job.enqueue 2, :queue => 'other_queue'
+    Que::Job.enqueue 3
+
+    result = Que::Job.work(:other_queue)
+    result[:event].should == :job_worked
+    result[:job][:args].should == [1]
+
+    result = Que::Job.work('other_queue')
+    result[:event].should == :job_worked
+    result[:job][:args].should == [2]
+
+    result = Que::Job.work(:other_queue)
+    result[:event].should == :job_unavailable
+  end
+
   it "should make a job's argument hashes indifferently accessible" do
     DB[:que_jobs].count.should be 0
-    ArgsJob.queue 1, 'two', {'array' => [{'number' => 3}]}
+    ArgsJob.enqueue 1, 'two', {'array' => [{'number' => 3}]}
     DB[:que_jobs].count.should be 1
 
     result = Que::Job.work
@@ -33,7 +62,7 @@ describe Que::Job, '.work' do
 
   it "should prefer a job with a higher priority" do
     # 1 is highest priority.
-    [5, 4, 3, 2, 1, 2, 3, 4, 5].map{|p| Que::Job.queue :priority => p}
+    [5, 4, 3, 2, 1, 2, 3, 4, 5].map{|p| Que::Job.enqueue :priority => p}
     DB[:que_jobs].order(:job_id).select_map(:priority).should == [5, 4, 3, 2, 1, 2, 3, 4, 5]
 
     result = Que::Job.work
@@ -43,9 +72,9 @@ describe Que::Job, '.work' do
   end
 
   it "should prefer a job that was scheduled to run longer ago when priorities are equal" do
-    Que::Job.queue :run_at => Time.now - 30
-    Que::Job.queue :run_at => Time.now - 60
-    Que::Job.queue :run_at => Time.now - 30
+    Que::Job.enqueue :run_at => Time.now - 30
+    Que::Job.enqueue :run_at => Time.now - 60
+    Que::Job.enqueue :run_at => Time.now - 30
 
     recent1, old, recent2 = DB[:que_jobs].order(:job_id).select_map(:run_at)
 
@@ -57,9 +86,9 @@ describe Que::Job, '.work' do
 
   it "should prefer a job that was queued earlier when priorities and run_ats are equal" do
     run_at = Time.now - 30
-    Que::Job.queue :run_at => run_at
-    Que::Job.queue :run_at => run_at
-    Que::Job.queue :run_at => run_at
+    Que::Job.enqueue :run_at => run_at
+    Que::Job.enqueue :run_at => run_at
+    Que::Job.enqueue :run_at => run_at
 
     first, second, third = DB[:que_jobs].select_order_map(:job_id)
 
@@ -70,9 +99,9 @@ describe Que::Job, '.work' do
   end
 
   it "should only work a job whose scheduled time to run has passed" do
-    Que::Job.queue :run_at => Time.now + 30
-    Que::Job.queue :run_at => Time.now - 30
-    Que::Job.queue :run_at => Time.now + 30
+    Que::Job.enqueue :run_at => Time.now + 30
+    Que::Job.enqueue :run_at => Time.now - 30
+    Que::Job.enqueue :run_at => Time.now + 30
 
     future1, past, future2 = DB[:que_jobs].order(:job_id).select_map(:run_at)
 
@@ -84,7 +113,7 @@ describe Que::Job, '.work' do
   end
 
   it "should lock the job it selects" do
-    BlockJob.queue
+    BlockJob.enqueue
     id = DB[:que_jobs].get(:job_id)
     thread = Thread.new { Que::Job.work }
 
@@ -96,9 +125,9 @@ describe Que::Job, '.work' do
   end
 
   it "should skip jobs that are advisory-locked" do
-    Que::Job.queue :priority => 2
-    Que::Job.queue :priority => 1
-    Que::Job.queue :priority => 3
+    Que::Job.enqueue :priority => 2
+    Que::Job.enqueue :priority => 1
+    Que::Job.enqueue :priority => 3
     id = DB[:que_jobs].where(:priority => 1).get(:job_id)
 
     begin
@@ -116,7 +145,7 @@ describe Que::Job, '.work' do
 
   it "should handle subclasses of other jobs" do
     class SubClassJob < Que::Job
-      @default_priority = 2
+      @priority = 2
 
       def run
         $job_spec_result << :sub
@@ -124,7 +153,7 @@ describe Que::Job, '.work' do
     end
 
     class SubSubClassJob < SubClassJob
-      @default_priority = 4
+      @priority = 4
 
       def run
         super
@@ -133,7 +162,7 @@ describe Que::Job, '.work' do
     end
 
     $job_spec_result = []
-    SubClassJob.queue
+    SubClassJob.enqueue
     DB[:que_jobs].select_map(:priority).should == [2]
     result = Que::Job.work
     result[:event].should == :job_worked
@@ -141,7 +170,7 @@ describe Que::Job, '.work' do
     $job_spec_result.should == [:sub]
 
     $job_spec_result = []
-    SubSubClassJob.queue
+    SubSubClassJob.enqueue
     DB[:que_jobs].select_map(:priority).should == [4]
     result = Que::Job.work
     result[:event].should == :job_worked
@@ -155,7 +184,7 @@ describe Que::Job, '.work' do
       end
     end
 
-    ModuleJobModule::ModuleJob.queue
+    ModuleJobModule::ModuleJob.enqueue
     DB[:que_jobs].get(:job_class).should == "ModuleJobModule::ModuleJob"
 
     result = Que::Job.work
@@ -170,7 +199,7 @@ describe Que::Job, '.work' do
       end
     end
 
-    DestroyJob.queue
+    DestroyJob.enqueue
     DB[:que_jobs].count.should be 1
     Que::Job.work
     DB[:que_jobs].count.should be 0
@@ -178,7 +207,7 @@ describe Que::Job, '.work' do
 
   describe "when encountering an error" do
     it "should exponentially back off the job" do
-      ErrorJob.queue
+      ErrorJob.enqueue
 
       result = Que::Job.work
       result[:event].should == :job_errored
@@ -206,12 +235,78 @@ describe Que::Job, '.work' do
       job[:run_at].should be_within(3).of Time.now + 1299
     end
 
+    it "should respect a custom retry interval" do
+      class RetryIntervalJob < ErrorJob
+        @retry_interval = 5
+      end
+
+      RetryIntervalJob.enqueue
+
+      result = Que::Job.work
+      result[:event].should == :job_errored
+      result[:error].should be_an_instance_of RuntimeError
+      result[:job][:job_class].should == 'RetryIntervalJob'
+
+      DB[:que_jobs].count.should be 1
+      job = DB[:que_jobs].first
+      job[:error_count].should be 1
+      job[:last_error].should =~ /\AErrorJob!\n/
+      job[:run_at].should be_within(3).of Time.now + 5
+
+      DB[:que_jobs].update :error_count => 5,
+                           :run_at => Time.now - 60
+
+      result = Que::Job.work
+      result[:event].should == :job_errored
+      result[:error].should be_an_instance_of RuntimeError
+      result[:job][:job_class].should == 'RetryIntervalJob'
+
+      DB[:que_jobs].count.should be 1
+      job = DB[:que_jobs].first
+      job[:error_count].should be 6
+      job[:last_error].should =~ /\AErrorJob!\n/
+      job[:run_at].should be_within(3).of Time.now + 5
+    end
+
+    it "should respect a custom retry interval formula" do
+      class RetryIntervalFormulaJob < ErrorJob
+        @retry_interval = proc { |count| count * 10 }
+      end
+
+      RetryIntervalFormulaJob.enqueue
+
+      result = Que::Job.work
+      result[:event].should == :job_errored
+      result[:error].should be_an_instance_of RuntimeError
+      result[:job][:job_class].should == 'RetryIntervalFormulaJob'
+
+      DB[:que_jobs].count.should be 1
+      job = DB[:que_jobs].first
+      job[:error_count].should be 1
+      job[:last_error].should =~ /\AErrorJob!\n/
+      job[:run_at].should be_within(3).of Time.now + 10
+
+      DB[:que_jobs].update :error_count => 5,
+                           :run_at => Time.now - 60
+
+      result = Que::Job.work
+      result[:event].should == :job_errored
+      result[:error].should be_an_instance_of RuntimeError
+      result[:job][:job_class].should == 'RetryIntervalFormulaJob'
+
+      DB[:que_jobs].count.should be 1
+      job = DB[:que_jobs].first
+      job[:error_count].should be 6
+      job[:last_error].should =~ /\AErrorJob!\n/
+      job[:run_at].should be_within(3).of Time.now + 60
+    end
+
     it "should pass it to an error handler, if one is defined" do
       begin
         errors = []
         Que.error_handler = proc { |error| errors << error }
 
-        ErrorJob.queue
+        ErrorJob.enqueue
 
         result = Que::Job.work
         result[:event].should == :job_errored
@@ -230,7 +325,7 @@ describe Que::Job, '.work' do
     it "should not do anything if the error handler itelf throws an error" do
       begin
         Que.error_handler = proc { |error| raise "Another error!" }
-        ErrorJob.queue
+        ErrorJob.enqueue
 
         result = Que::Job.work
         result[:event].should == :job_errored