que 0.11.3 → 2.2.0

data/spec/unit/work_spec.rb

@@ -1,407 +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 =~ /\AErrorJob!\n/
-      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 =~ /\AErrorJob!\n/
-      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 =~ /\AErrorJob!\n/
-      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 =~ /\AErrorJob!\n/
-      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 =~ /\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.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_handler = nil
-      end
-    end
-
-    it "should pass job to an error handler, if one is defined" do
-      begin
-        jobs = []
-        Que.error_handler = 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_handler = nil
-      end
-    end
-
-    it "should not do anything if the error handler itelf throws an error" do
-      begin
-        Que.error_handler = 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_handler = 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
-  end
-end

data/spec/unit/worker_spec.rb

@@ -1,167 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Que::Worker do
-  it "should work jobs when started until there are none available" do
-    begin
-      Que::Job.enqueue
-      Que::Job.enqueue
-      DB[:que_jobs].count.should be 2
-
-      @worker = Que::Worker.new
-      sleep_until { @worker.sleeping? }
-      DB[:que_jobs].count.should be 0
-
-      $logger.messages.map{|m| JSON.load(m)['event']}.should == %w(job_worked job_worked job_unavailable)
-
-      json = JSON.load($logger.messages[0])
-      json['job']['job_class'].should == 'Que::Job'
-    ensure
-      if @worker
-        @worker.stop
-        @worker.wait_until_stopped
-      end
-    end
-  end
-
-  it "should work jobs without a named queue by default" do
-    begin
-      Que::Job.enqueue 1
-      Que::Job.enqueue 2, :queue => 'my_queue'
-
-      @worker = Que::Worker.new
-      sleep_until { @worker.sleeping? }
-      DB[:que_jobs].count.should be 1
-
-      $logger.messages.map{|m| JSON.load(m)['event']}.should == %w(job_worked job_unavailable)
-
-      json = JSON.load($logger.messages[0])
-      json['job']['queue'].should == ''
-      json['job']['job_class'].should == 'Que::Job'
-      json['job']['args'].should == [1]
-    ensure
-      if @worker
-        @worker.stop
-        @worker.wait_until_stopped
-      end
-    end
-  end
-
-  it "should accept the name of a single queue to work jobs from" do
-    begin
-      Que::Job.enqueue 1
-      Que::Job.enqueue 2, :queue => 'my_queue'
-
-      @worker = Que::Worker.new(:my_queue)
-      sleep_until { @worker.sleeping? }
-      DB[:que_jobs].count.should be 1
-
-      $logger.messages.map{|m| JSON.load(m)['event']}.should == %w(job_worked job_unavailable)
-
-      json = JSON.load($logger.messages[0])
-      json['job']['queue'].should == 'my_queue'
-      json['job']['job_class'].should == 'Que::Job'
-      json['job']['args'].should == [2]
-    ensure
-      if @worker
-        @worker.stop
-        @worker.wait_until_stopped
-      end
-    end
-  end
-
-  it "#wake! should return truthy if the worker was asleep and is woken up, at which point it should work until no jobs are available" do
-    begin
-      @worker = Que::Worker.new
-      sleep_until { @worker.sleeping? }
-
-      Que::Job.enqueue
-      Que::Job.enqueue
-      DB[:que_jobs].count.should be 2
-
-      @worker.wake!.should be true
-      sleep_until { @worker.sleeping? }
-      DB[:que_jobs].count.should be 0
-    ensure
-      if @worker
-        @worker.stop
-        @worker.wait_until_stopped
-      end
-    end
-  end
-
-  it "#wake! should return falsy if the worker was already working" do
-    begin
-      BlockJob.enqueue
-      @worker = Que::Worker.new
-
-      $q1.pop
-      DB[:que_jobs].count.should be 1
-      @worker.wake!.should be nil
-      $q2.push nil
-    ensure
-      if @worker
-        @worker.stop
-        @worker.wait_until_stopped
-      end
-    end
-  end
-
-  it "should not be deterred by a job that raises an error" do
-    begin
-      ErrorJob.enqueue :priority => 1
-      Que::Job.enqueue :priority => 5
-
-      @worker = Que::Worker.new
-
-      sleep_until { @worker.sleeping? }
-
-      DB[:que_jobs].count.should be 1
-      job = DB[:que_jobs].first
-      job[:job_class].should == 'ErrorJob'
-      job[:run_at].should be_within(3).of Time.now + 4
-
-      log = JSON.load($logger.messages[0])
-      log['event'].should == 'job_errored'
-      log['error']['class'].should == 'RuntimeError'
-      log['error']['message'].should == "ErrorJob!"
-      log['job']['job_class'].should == 'ErrorJob'
-    ensure
-      if @worker
-        @worker.stop
-        @worker.wait_until_stopped
-      end
-    end
-  end
-
-  it "should receive and respect a notification to stop down when it is working, after its current job completes" do
-    begin
-      BlockJob.enqueue :priority => 1
-      Que::Job.enqueue :priority => 5
-      DB[:que_jobs].count.should be 2
-
-      @worker = Que::Worker.new
-
-      $q1.pop
-      @worker.stop
-      $q2.push nil
-
-      @worker.wait_until_stopped
-
-      DB[:que_jobs].count.should be 1
-      job = DB[:que_jobs].first
-      job[:job_class].should == 'Que::Job'
-    end
-  end
-
-  it "should receive and respect a notification to stop when it is currently asleep" do
-    begin
-      @worker = Que::Worker.new
-      sleep_until { @worker.sleeping? }
-
-      @worker.stop
-      @worker.wait_until_stopped
-    end
-  end
-end

data/tasks/benchmark.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-# The benchmarking tasks have been merged together and now live at github.com/chanks/queue-shootout.

data/tasks/rspec.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require 'rspec/core/rake_task'
-
-RSpec::Core::RakeTask.new :default do |spec|
-  spec.pattern = './spec/**/*_spec.rb'
-end
-
-# Shortcut to skip the adapter specs, and run only with the basic PG
-# connection. I use this occasionally to make sure ActiveRecord isn't loaded,
-# so any accidental Rails-isms are caught.
-RSpec::Core::RakeTask.new :pg do |spec|
-  spec.pattern = './spec/unit/*_spec.rb'
-end

data/tasks/safe_shutdown.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-# This task is used to test Que's behavior when its process is shut down.
-
-# The situation we're trying to avoid occurs when the process dies while a job
-# is in the middle of a transaction - ideally, the transaction would be rolled
-# back and the job could just be reattempted later, but if we're not careful,
-# the transaction could be committed prematurely. For specifics, see here:
-
-# http://coderrr.wordpress.com/2011/05/03/beware-of-threadkill-or-your-activerecord-transactions-are-in-danger-of-being-partially-committed/
-
-# So, this task opens a transaction within a job, makes a write, then prompts
-# you to kill it with one of a few signals. You can then run it again to make
-# sure that the write was rolled back (if it wasn't, Que isn't functioning
-# like it should). This task only explicitly tests Sequel, but the behavior
-# for ActiveRecord is very similar.
-
-task :safe_shutdown do
-  require 'sequel'
-  require 'que'
-
-  url = ENV['DATABASE_URL'] || 'postgres://postgres:@localhost/que-test'
-  DB = Sequel.connect(url)
-
-  if DB.table_exists?(:que_jobs)
-    puts "Uh-oh! Previous shutdown wasn't clean!" if DB[:que_jobs].where(:job_id => 0).count > 0
-    DB.drop_table :que_jobs
-  end
-
-  Que.connection = DB
-  Que.create!
-
-  $queue = Queue.new
-
-  class SafeJob < Que::Job
-    def run
-      DB.transaction do
-        DB[:que_jobs].insert(:job_id => 0, :job_class => 'Que::Job')
-        $queue.push nil
-        sleep
-      end
-    end
-  end
-
-  SafeJob.enqueue
-  Que.mode = :async
-  $queue.pop
-
-  puts "From a different terminal window, run one of the following:"
-  %w(SIGINT SIGTERM SIGKILL).each do |signal|
-    puts "kill -#{signal} #{Process.pid}"
-  end
-
-  stop = false
-  trap('INT'){stop = true}
-
-  at_exit do
-    $stdout.puts "Finishing Que's current jobs before exiting..."
-    Que.mode = :off
-    $stdout.puts "Que's jobs finished, exiting..."
-  end
-
-  loop do
-    sleep 0.01
-    break if stop
-  end
-end