que 0.14.3 → 1.0.0.beta

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