que 0.14.3 → 1.0.0.beta

data/spec/unit/run_spec.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Que, '.worker_states' do
-  it "should return a list of the job types in the queue, their counts and the number of each currently running" do
-    Que.adapter = QUE_ADAPTERS[:connection_pool]
-
-    class WorkerStateJob < BlockJob
-      def run
-        $pid = Que.execute("select pg_backend_pid()").first[:pg_backend_pid]
-        super
-      end
-    end
-
-    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)
-
-    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

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-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.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.enqueue
-
-    begin
-      DB.get{pg_advisory_lock(2**33)}
-
-      stats = Que.job_stats
-      stats.length.should == 2
-
-      qj, bj = stats
-
-      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
-      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
-      bj[:oldest_run_at].should be_within(3).of Time.now
-    ensure
-      DB.get{pg_advisory_unlock_all.function}
-    end
-  end
-end

data/spec/unit/transaction_spec.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Que, '.transaction' do
-  it "should use a transaction to rollback changes in the event of an error" do
-    proc do
-      Que.transaction do
-        Que.execute "DROP TABLE que_jobs"
-        Que.execute "invalid SQL syntax"
-      end
-    end.should raise_error(PG::Error)
-
-    DB.table_exists?(:que_jobs).should be true
-  end
-
-  unless RUBY_VERSION.start_with?('1.9')
-    it "should rollback correctly in the event of a killed thread" do
-      q = Queue.new
-
-      t = Thread.new do
-        Que.transaction do
-          Que.execute "DROP TABLE que_jobs"
-          q.push :go!
-          sleep
-        end
-      end
-
-      q.pop
-      t.kill
-      t.join
-
-      DB.table_exists?(:que_jobs).should be true
-    end
-  end
-end

data/spec/unit/work_spec.rb

@@ -1,596 +0,0 @@
-# frozen_string_literal: true
-
-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.enqueue 1, 'two', {'three' => 3}
-    DB[:que_jobs].count.should be 1
-
-    result = Que::Job.work
-    result[:event].should == :job_worked
-    result[:job][:job_class].should == 'ArgsJob'
-
-    DB[:que_jobs].count.should be 0
-    $passed_args.should == [1, 'two', {'three' => 3}]
-  end
-
-  it "should respect a custom json converter when processing the job's arguments" do
-    ArgsJob.enqueue 1, 'two', {'three' => 3}
-    DB[:que_jobs].count.should be 1
-
-    begin
-      Que.json_converter = Que::SYMBOLIZER
-
-      result = Que::Job.work
-      result[:event].should == :job_worked
-      result[:job][:job_class].should == 'ArgsJob'
-
-      DB[:que_jobs].count.should be 0
-      $passed_args.should == [1, 'two', {:three => 3}]
-    ensure
-      Que.json_converter = Que::INDIFFERENTIATOR
-    end
-  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.enqueue 1, 'two', {'array' => [{'number' => 3}]}
-    DB[:que_jobs].count.should be 1
-
-    result = Que::Job.work
-    result[:event].should == :job_worked
-    result[:job][:job_class].should == 'ArgsJob'
-
-    DB[:que_jobs].count.should be 0
-
-    $passed_args.last[:array].first[:number].should == 3
-  end
-
-  it "should not fail if there are no jobs to work" do
-    Que::Job.work[:event].should be :job_unavailable
-  end
-
-  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.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
-    result[:event].should == :job_worked
-    result[:job][:job_class].should == 'Que::Job'
-    DB[:que_jobs].select_map(:priority).should == [5, 4, 3, 2, 2, 3, 4, 5]
-  end
-
-  it "should prefer a job that was scheduled to run longer ago when priorities are equal" do
-    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)
-
-    result = Que::Job.work
-    result[:event].should == :job_worked
-    result[:job][:job_class].should == 'Que::Job'
-    DB[:que_jobs].order_by(:job_id).select_map(:run_at).should == [recent1, recent2]
-  end
-
-  it "should prefer a job that was queued earlier when priorities and run_ats are equal" do
-    run_at = Time.now - 30
-    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)
-
-    result = Que::Job.work
-    result[:event].should == :job_worked
-    result[:job][:job_class].should == 'Que::Job'
-    DB[:que_jobs].select_order_map(:job_id).should == [second, third]
-  end
-
-  it "should only work a job whose scheduled time to run has passed" do
-    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)
-
-    result = Que::Job.work
-    result[:event].should == :job_worked
-    result[:job][:job_class].should == 'Que::Job'
-    Que::Job.work[:event].should be :job_unavailable
-    DB[:que_jobs].order_by(:job_id).select_map(:run_at).should == [future1, future2]
-  end
-
-  it "should lock the job it selects" do
-    BlockJob.enqueue
-    id = DB[:que_jobs].get(:job_id)
-    thread = Thread.new { Que::Job.work }
-
-    $q1.pop
-    DB[:pg_locks].where(:locktype => 'advisory').select_map(:objid).should == [id]
-    $q2.push nil
-
-    thread.join
-  end
-
-  it "should skip jobs that are advisory-locked" do
-    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
-      DB.select{pg_advisory_lock(id)}.single_value
-
-      result = Que::Job.work
-      result[:event].should == :job_worked
-      result[:job][:job_class].should == 'Que::Job'
-
-      DB[:que_jobs].order_by(:job_id).select_map(:priority).should == [1, 3]
-    ensure
-      DB.select{pg_advisory_unlock(id)}.single_value
-    end
-  end
-
-  it "should handle subclasses of other jobs" do
-    class SubClassJob < Que::Job
-      @priority = 2
-
-      def run
-        $job_spec_result << :sub
-      end
-    end
-
-    class SubSubClassJob < SubClassJob
-      @priority = 4
-
-      def run
-        super
-        $job_spec_result << :subsub
-      end
-    end
-
-    $job_spec_result = []
-    SubClassJob.enqueue
-    DB[:que_jobs].select_map(:priority).should == [2]
-    result = Que::Job.work
-    result[:event].should == :job_worked
-    result[:job][:job_class].should == 'SubClassJob'
-    $job_spec_result.should == [:sub]
-
-    $job_spec_result = []
-    SubSubClassJob.enqueue
-    DB[:que_jobs].select_map(:priority).should == [4]
-    result = Que::Job.work
-    result[:event].should == :job_worked
-    result[:job][:job_class].should == 'SubSubClassJob'
-    $job_spec_result.should == [:sub, :subsub]
-  end
-
-  it "should handle namespaced subclasses" do
-    module ModuleJobModule
-      class ModuleJob < Que::Job
-      end
-    end
-
-    ModuleJobModule::ModuleJob.enqueue
-    DB[:que_jobs].get(:job_class).should == "ModuleJobModule::ModuleJob"
-
-    result = Que::Job.work
-    result[:event].should == :job_worked
-    result[:job][:job_class].should == 'ModuleJobModule::ModuleJob'
-  end
-
-  it "should make it easy to destroy the job within the same transaction as other changes" do
-    class DestroyJob < Que::Job
-      def run
-        destroy
-      end
-    end
-
-    DestroyJob.enqueue
-    DB[:que_jobs].count.should be 1
-    Que::Job.work
-    DB[:que_jobs].count.should be 0
-  end
-
-  describe "when encountering an error" do
-    it "should exponentially back off the job" do
-      ErrorJob.enqueue
-
-      result = Que::Job.work
-      result[:event].should == :job_errored
-      result[:error].should be_an_instance_of RuntimeError
-      result[:job][:job_class].should == 'ErrorJob'
-
-      DB[:que_jobs].count.should be 1
-      job = DB[:que_jobs].first
-      job[:error_count].should be 1
-      job[:last_error].should =~ /\ARuntimeError: ErrorJob!/
-      job[:run_at].should be_within(3).of Time.now + 4
-
-      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 == 'ErrorJob'
-
-      DB[:que_jobs].count.should be 1
-      job = DB[:que_jobs].first
-      job[:error_count].should be 6
-      job[:last_error].should =~ /\ARuntimeError: ErrorJob!/
-      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 = 3155760000000 # 100,000 years from now
-      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 =~ /\ARuntimeError: ErrorJob!/
-      job[:run_at].to_f.should be_within(3).of Time.now.to_f + RetryIntervalJob.retry_interval
-
-      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 =~ /\ARuntimeError: ErrorJob!/
-      job[:run_at].to_f.should be_within(3).of Time.now.to_f + RetryIntervalJob.retry_interval
-    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 =~ /\ARuntimeError: ErrorJob!/
-      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 =~ /\ARuntimeError: ErrorJob!/
-      job[:run_at].should be_within(3).of Time.now + 60
-    end
-
-    it "should pass it to an error notifier, if one is defined" do
-      begin
-        errors = []
-        Que.error_notifier = proc { |error| errors << error }
-
-        ErrorJob.enqueue
-
-        result = Que::Job.work
-        result[:event].should == :job_errored
-        result[:error].should be_an_instance_of RuntimeError
-        result[:job][:job_class].should == 'ErrorJob'
-
-        errors.count.should be 1
-        error = errors[0]
-        error.should be_an_instance_of RuntimeError
-        error.message.should == "ErrorJob!"
-      ensure
-        Que.error_notifier = nil
-      end
-    end
-
-    it "should pass job to an error notifier, if one is defined" do
-      begin
-        jobs = []
-        Que.error_notifier = proc { |error, job| jobs << job }
-
-        ErrorJob.enqueue
-        result = Que::Job.work
-
-        jobs.count.should be 1
-        job = jobs[0]
-        job.should be result[:job]
-      ensure
-        Que.error_notifier = nil
-      end
-    end
-
-    it "should not do anything if the error notifier itelf throws an error" do
-      begin
-        Que.error_notifier = proc { |error| raise "Another error!" }
-        ErrorJob.enqueue
-
-        result = Que::Job.work
-        result[:event].should == :job_errored
-        result[:error].should be_an_instance_of RuntimeError
-      ensure
-        Que.error_notifier = nil
-      end
-    end
-
-    it "should throw an error properly if there's no corresponding job class" do
-      DB[:que_jobs].insert :job_class => "NonexistentClass"
-
-      result = Que::Job.work
-      result[:event].should == :job_errored
-      result[:error].should be_an_instance_of NameError
-      result[:job][:job_class].should == 'NonexistentClass'
-
-      DB[:que_jobs].count.should be 1
-      job = DB[:que_jobs].first
-      job[:error_count].should be 1
-      job[:last_error].should =~ /uninitialized constant:? NonexistentClass/
-      job[:run_at].should be_within(3).of Time.now + 4
-    end
-
-    it "should throw an error properly if the corresponding job class doesn't descend from Que::Job" do
-      class J
-        def run(*args)
-        end
-      end
-
-      Que.enqueue :job_class => "J"
-
-      result = Que::Job.work
-      result[:event].should == :job_errored
-      result[:job][:job_class].should == 'J'
-
-      DB[:que_jobs].count.should be 1
-      job = DB[:que_jobs].first
-      job[:error_count].should be 1
-      job[:run_at].should be_within(3).of Time.now + 4
-    end
-
-    it "should use the class name of the exception if its message is blank when setting last_error" do
-      class BlankExceptionMessageJob < Que::Job
-        def self.error
-          @error ||= RuntimeError.new("")
-        end
-
-        def run
-          raise self.class.error
-        end
-      end
-
-      BlankExceptionMessageJob.enqueue
-      result = Que::Job.work
-      result[:event].should == :job_errored
-      job = DB[:que_jobs].first
-      job[:error_count].should be 1
-      last_error_lines = job[:last_error].split("\n")
-      last_error_lines.should == %w[RuntimeError] + BlankExceptionMessageJob.error.backtrace
-    end
-
-    it "should use the class name of the exception if its message is blank when setting last_error" do
-      class LongExceptionMessageJob < Que::Job
-        def self.error
-          @error ||= RuntimeError.new("a" * 500)
-        end
-
-        def run
-          raise self.class.error
-        end
-      end
-
-      LongExceptionMessageJob.enqueue
-      result = Que::Job.work
-      result[:event].should == :job_errored
-      job = DB[:que_jobs].first
-      job[:error_count].should be 1
-      last_error_lines = job[:last_error].split("\n")
-      last_error_lines.should == ["RuntimeError: #{'a' * 486}"] + LongExceptionMessageJob.error.backtrace
-    end
-
-    context "in a job class that has a custom error handler" do
-      it "should allow it to schedule a retry after a specific interval" do
-        begin
-          error = nil
-          Que.error_notifier = proc { |e| error = e }
-
-          class CustomRetryIntervalJob < Que::Job
-            def run(*args)
-              raise "Blah!"
-            end
-
-            private
-
-            def handle_error(error)
-              retry_in(42)
-            end
-          end
-
-          CustomRetryIntervalJob.enqueue
-
-          result = Que::Job.work
-          result[:event].should == :job_errored
-          result[:error].should be_an_instance_of RuntimeError
-          result[:job][:job_class].should == 'CustomRetryIntervalJob'
-
-          DB[:que_jobs].count.should be 1
-          job = DB[:que_jobs].first
-          job[:error_count].should be 1
-
-          lines = job[:last_error].split("\n")
-          lines[0].should == "RuntimeError: Blah!"
-          lines[1].should =~ /work_spec/
-          job[:run_at].should be_within(3).of Time.now + 42
-
-          error.should == result[:error]
-        ensure
-          Que.error_notifier = nil
-        end
-      end
-
-      it "should allow it to destroy the job" do
-        begin
-          error = nil
-          Que.error_notifier = proc { |e| error = e }
-
-          class CustomRetryIntervalJob < Que::Job
-            def run(*args)
-              raise "Blah!"
-            end
-
-            private
-
-            def handle_error(error)
-              destroy
-            end
-          end
-
-          CustomRetryIntervalJob.enqueue
-
-          result = Que::Job.work
-          result[:event].should == :job_errored
-          result[:error].should be_an_instance_of RuntimeError
-          result[:job][:job_class].should == 'CustomRetryIntervalJob'
-
-          DB[:que_jobs].count.should be 0
-
-          error.should == result[:error]
-        ensure
-          Que.error_notifier = nil
-        end
-      end
-
-      it "should allow it to return false to skip the error notification" do
-        begin
-          error = nil
-          Que.error_notifier = proc { |e| error = e }
-
-          class CustomRetryIntervalJob < Que::Job
-            def run(*args)
-              raise "Blah!"
-            end
-
-            private
-
-            def handle_error(error)
-              false
-            end
-          end
-
-          CustomRetryIntervalJob.enqueue
-
-          result = Que::Job.work
-          result[:event].should == :job_errored
-          result[:error].should be_an_instance_of RuntimeError
-          result[:job][:job_class].should == 'CustomRetryIntervalJob'
-
-          DB[:que_jobs].count.should be 0
-
-          error.should == nil
-        ensure
-          Que.error_notifier = nil
-        end
-      end
-
-      it "should allow it to call super to get the default behavior" do
-        begin
-          error = nil
-          Que.error_notifier = proc { |e| error = e }
-
-          class CustomRetryIntervalJob < Que::Job
-            def run(*args)
-              raise "Blah!"
-            end
-
-            private
-
-            def handle_error(error)
-              case error
-              when RuntimeError
-                super
-              else
-                $error_handler_failed = true
-                raise "Bad!"
-              end
-            end
-          end
-
-          CustomRetryIntervalJob.enqueue
-
-          result = Que::Job.work
-          result[:event].should == :job_errored
-          result[:error].should be_an_instance_of RuntimeError
-          result[:job][:job_class].should == 'CustomRetryIntervalJob'
-
-          $error_handler_failed.should == nil
-
-          DB[:que_jobs].count.should be 1
-          job = DB[:que_jobs].first
-          job[:error_count].should be 1
-          job[:last_error].should =~ /\ARuntimeError: Blah!/
-          job[:run_at].should be_within(3).of Time.now + 4
-
-          error.should == result[:error]
-        ensure
-          Que.error_notifier = nil
-        end
-      end
-    end
-  end
-end