que 0.14.3 → 1.0.0.beta

data/spec/support/shared_examples/multi_threaded_adapter.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-shared_examples "a multi-threaded Que adapter" do
-  it_behaves_like "a Que adapter"
-
-  it "should allow multiple threads to check out their own connections" do
-    one = nil
-    two = nil
-
-    q1, q2 = Queue.new, Queue.new
-
-    thread = Thread.new do
-      Que.adapter.checkout do |conn|
-        q1.push nil
-        q2.pop
-        one = conn.object_id
-      end
-    end
-
-    Que.adapter.checkout do |conn|
-      q1.pop
-      q2.push nil
-      two = conn.object_id
-    end
-
-    thread.join
-    one.should_not == two
-  end
-
-  it "should allow multiple workers to complete jobs simultaneously" do
-    BlockJob.enqueue
-    worker_1 = Que::Worker.new
-    $q1.pop
-
-    Que::Job.enqueue
-    DB[:que_jobs].count.should be 2
-
-    worker_2 = Que::Worker.new
-    sleep_until { worker_2.sleeping? }
-    DB[:que_jobs].count.should be 1
-
-    $q2.push nil
-    sleep_until { worker_1.sleeping? }
-    DB[:que_jobs].count.should be 0
-  end
-end

data/spec/unit/configuration_spec.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Que do
-  it ".use_prepared_statements should be the opposite of disable_prepared_statements" do
-    original_verbose = $VERBOSE
-    $VERBOSE = nil
-
-    Que.use_prepared_statements.should == true
-    Que.disable_prepared_statements.should == false
-
-    Que.disable_prepared_statements = true
-    Que.use_prepared_statements.should == false
-    Que.disable_prepared_statements.should == true
-
-    Que.disable_prepared_statements = nil
-    Que.use_prepared_statements.should == true
-    Que.disable_prepared_statements.should == false
-
-    Que.use_prepared_statements = false
-    Que.use_prepared_statements.should == false
-    Que.disable_prepared_statements.should == true
-
-    Que.use_prepared_statements = true
-    Que.use_prepared_statements.should == true
-    Que.disable_prepared_statements.should == false
-
-    $VERBOSE = original_verbose
-  end
-end

data/spec/unit/connection_spec.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Que do
-  it ".connection= with an unsupported connection should raise an error" do
-    proc{Que.connection = "ferret"}.should raise_error RuntimeError, /Que connection not recognized: "ferret"/
-  end
-
-  it ".adapter when no connection has been established should raise an error" do
-    Que.connection = nil
-    proc{Que.adapter}.should raise_error RuntimeError, /Que connection not established!/
-  end
-end

data/spec/unit/customization_spec.rb

@@ -1,251 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-# A few specs to ensure that the ideas given in the customizing_que document
-# stay functional.
-describe "Customizing Que" do
-  it "Cron should allow for easy recurring jobs" do
-    begin
-      class CronJob < Que::Job
-        # Default repetition interval in seconds. Can be overridden in
-        # subclasses. Can use 1.minute if using Rails.
-        INTERVAL = 60
-
-        attr_reader :start_at, :end_at, :run_again_at, :time_range
-
-        def _run
-          args = attrs[:args].first
-          @start_at, @end_at = Time.at(args.delete('start_at')), Time.at(args.delete('end_at'))
-          @run_again_at = @end_at + self.class::INTERVAL
-          @time_range = @start_at...@end_at
-
-          super
-
-          args['start_at'] = @end_at.to_f
-          args['end_at']   = @run_again_at.to_f
-          self.class.enqueue(args, run_at: @run_again_at)
-        end
-      end
-
-      class MyCronJob < CronJob
-        INTERVAL = 1.5
-
-        def run(args)
-          $args       = args.dup
-          $time_range = time_range
-        end
-      end
-
-      t = (Time.now - 1000).to_f.round(6)
-      MyCronJob.enqueue :start_at => t, :end_at => t + 1.5, :arg => 4
-
-      $args.should be nil
-      $time_range.should be nil
-
-      Que::Job.work
-
-      $args.should == {'arg' => 4}
-      $time_range.begin.to_f.round(6).should be_within(0.000001).of t
-      $time_range.end.to_f.round(6).should be_within(0.000001).of t + 1.5
-      $time_range.exclude_end?.should be true
-
-      DB[:que_jobs].get(:run_at).to_f.round(6).should be_within(0.000001).of(t + 3.0)
-      args = JSON.parse(DB[:que_jobs].get(:args)).first
-      args.keys.should == ['arg', 'start_at', 'end_at']
-      args['arg'].should == 4
-      args['start_at'].should be_within(0.000001).of(t + 1.5)
-      args['end_at'].should be_within(0.000001).of(t + 3.0)
-    ensure
-      $args       = nil
-      $time_range = nil
-    end
-  end
-
-  it "Object#delay should allow for simpler job enqueueing" do
-    begin
-      class Delayed < Que::Job
-        def run(receiver, method, args)
-          Marshal.load(receiver).send method, *Marshal.load(args)
-        end
-      end
-
-      class DelayedAction
-        def initialize(receiver)
-          @receiver = receiver
-        end
-
-        def method_missing(method, *args)
-          Delayed.enqueue Marshal.dump(@receiver), method, Marshal.dump(args)
-        end
-      end
-
-      class Object
-        def delay
-          DelayedAction.new(self)
-        end
-      end
-
-      module MyModule
-        class << self
-          def blah
-            $run = true
-          end
-        end
-      end
-
-      MyModule.delay.blah
-      Que::Job.work
-
-      $run.should be true
-    ensure
-      $run = nil
-    end
-  end
-
-  it "QueueClassic-style jobs should be easy" do
-    begin
-      class Command < Que::Job
-        def run(method, *args)
-          receiver, message = method.split('.')
-          Object.const_get(receiver).send(message, *args)
-        end
-      end
-
-      module MyModule
-        class << self
-          def blah(arg)
-            $value = arg
-          end
-        end
-      end
-
-      Command.enqueue "MyModule.blah", "hello world"
-      Que::Job.work
-
-      $value.should == "hello world"
-    ensure
-      $value = nil
-    end
-  end
-
-  describe "retaining deleted jobs" do
-    before do
-      Que.execute "CREATE TABLE finished_jobs AS SELECT * FROM que_jobs LIMIT 0"
-    end
-
-    after do
-      DB.drop_table? :finished_jobs
-    end
-
-    it "with a Ruby override" do
-      class MyJobClass < Que::Job
-        def destroy
-          Que.execute "INSERT INTO finished_jobs SELECT * FROM que_jobs WHERE queue = $1::text AND priority = $2::integer AND run_at = $3::timestamptz AND job_id = $4::bigint", @attrs.values_at(:queue, :priority, :run_at, :job_id)
-          super
-        end
-      end
-
-      class MyJob < MyJobClass
-      end
-
-      MyJob.enqueue 1, 'arg1', :priority => 89
-      Que::Job.work
-
-      DB[:finished_jobs].count.should == 1
-      job = DB[:finished_jobs].first
-      job[:priority].should == 89
-      JSON.load(job[:args]).should == [1, 'arg1']
-    end
-
-    it "with a trigger" do
-      begin
-        Que.execute <<-SQL
-          CREATE FUNCTION please_save_my_job()
-          RETURNS trigger
-          LANGUAGE plpgsql
-          AS $$
-            BEGIN
-              INSERT INTO finished_jobs SELECT (OLD).*;
-              RETURN OLD;
-            END;
-          $$;
-        SQL
-
-        Que.execute "CREATE TRIGGER keep_all_my_old_jobs BEFORE DELETE ON que_jobs FOR EACH ROW EXECUTE PROCEDURE please_save_my_job();"
-
-        Que::Job.enqueue 2, 'arg2', :priority => 45
-        Que::Job.work
-
-        DB[:finished_jobs].count.should == 1
-        job = DB[:finished_jobs].first
-        job[:priority].should == 45
-        JSON.load(job[:args]).should == [2, 'arg2']
-      ensure
-        DB.drop_trigger :que_jobs, :keep_all_my_old_jobs, :if_exists => true
-        DB.drop_function :please_save_my_job, :if_exists => true
-      end
-    end
-  end
-
-  describe "not retrying specific failed jobs" do
-    before do
-      Que.execute "CREATE TABLE failed_jobs AS SELECT * FROM que_jobs LIMIT 0"
-    end
-
-    after do
-      DB.drop_table? :failed_jobs
-    end
-
-    it "should be easily achievable with a module" do
-      begin
-        module SkipRetries
-          def run(*args)
-            super
-          rescue
-            sql = <<-SQL
-              WITH failed AS (
-                DELETE
-                FROM   que_jobs
-                WHERE  queue    = $1::text
-                AND    priority = $2::smallint
-                AND    run_at   = $3::timestamptz
-                AND    job_id   = $4::bigint
-                RETURNING *
-              )
-              INSERT INTO failed_jobs
-                SELECT * FROM failed;
-            SQL
-
-            Que.execute sql, @attrs.values_at(:queue, :priority, :run_at, :job_id)
-
-            raise
-          end
-        end
-
-        class SkipRetryJob < Que::Job
-          prepend SkipRetries
-
-          def run(*args)
-            $retry_job_args = args
-            raise "Fail!"
-          end
-        end
-
-        SkipRetryJob.enqueue 1, 'arg1', :other_arg => 'blah'
-        Que::Job.work
-
-        $retry_job_args.should == [1, 'arg1', {'other_arg' => 'blah'}]
-
-        DB[:que_jobs].count.should == 0
-        DB[:failed_jobs].count.should == 1
-
-        job = DB[:failed_jobs].first
-        JSON.parse(job[:args]).should == [1, 'arg1', {'other_arg' => 'blah'}]
-        job[:job_class].should == 'SkipRetryJob'
-      ensure
-        $retry_job_args = nil
-      end
-    end
-  end
-end

data/spec/unit/enqueue_spec.rb

@@ -1,245 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Que::Job, '.enqueue' do
-  it "should be able to queue a job" do
-    DB[:que_jobs].count.should be 0
-    result = Que::Job.enqueue
-    DB[:que_jobs].count.should be 1
-
-    result.should be_an_instance_of Que::Job
-    result.attrs[:queue].should == ''
-    result.attrs[:priority].should == 100
-    result.attrs[:args].should == []
-
-    job = DB[:que_jobs].first
-    job[:queue].should == ''
-    job[:priority].should be 100
-    job[:run_at].should be_within(3).of Time.now
-    job[:job_class].should == "Que::Job"
-    JSON.load(job[:args]).should == []
-  end
-
-  it "should be aliased to .queue" do
-    DB[:que_jobs].count.should be 0
-    suppress_warnings { Que::Job.queue }
-    DB[:que_jobs].count.should be 1
-  end
-
-  it "should be able to queue a job with arguments" do
-    DB[:que_jobs].count.should be 0
-    Que::Job.enqueue 1, 'two'
-    DB[:que_jobs].count.should be 1
-
-    job = DB[:que_jobs].first
-    job[:queue].should == ''
-    job[:priority].should be 100
-    job[:run_at].should be_within(3).of Time.now
-    job[:job_class].should == "Que::Job"
-    JSON.load(job[:args]).should == [1, 'two']
-  end
-
-  it "should be able to queue a job with complex arguments" do
-    DB[:que_jobs].count.should be 0
-    Que::Job.enqueue 1, 'two', :string => "string",
-                             :integer => 5,
-                             :array => [1, "two", {:three => 3}],
-                             :hash => {:one => 1, :two => 'two', :three => [3]}
-
-    DB[:que_jobs].count.should be 1
-
-    job = DB[:que_jobs].first
-    job[:queue].should == ''
-    job[:priority].should be 100
-    job[:run_at].should be_within(3).of Time.now
-    job[:job_class].should == "Que::Job"
-    JSON.load(job[:args]).should == [
-      1,
-      'two',
-      {
-        'string' => 'string',
-        'integer' => 5,
-        'array' => [1, "two", {"three" => 3}],
-        'hash' => {'one' => 1, 'two' => 'two', 'three' => [3]}
-      }
-    ]
-  end
-
-  it "should be able to queue a job with a specific time to run" do
-    DB[:que_jobs].count.should be 0
-    Que::Job.enqueue 1, :run_at => Time.now + 60
-    DB[:que_jobs].count.should be 1
-
-    job = DB[:que_jobs].first
-    job[:queue].should == ''
-    job[:priority].should be 100
-    job[:run_at].should be_within(3).of Time.now + 60
-    job[:job_class].should == "Que::Job"
-    JSON.load(job[:args]).should == [1]
-  end
-
-  it "should be able to queue a job with a specific priority" do
-    DB[:que_jobs].count.should be 0
-    Que::Job.enqueue 1, :priority => 4
-    DB[:que_jobs].count.should be 1
-
-    job = DB[:que_jobs].first
-    job[:queue].should == ''
-    job[:priority].should be 4
-    job[:run_at].should be_within(3).of Time.now
-    job[:job_class].should == "Que::Job"
-    JSON.load(job[:args]).should == [1]
-  end
-
-  it "should be able to queue a job with queueing options in addition to argument options" do
-    DB[:que_jobs].count.should be 0
-    Que::Job.enqueue 1, :string => "string", :run_at => Time.now + 60, :priority => 4
-    DB[:que_jobs].count.should be 1
-
-    job = DB[:que_jobs].first
-    job[:queue].should == ''
-    job[:priority].should be 4
-    job[:run_at].should be_within(3).of Time.now + 60
-    job[:job_class].should == "Que::Job"
-    JSON.load(job[:args]).should == [1, {'string' => 'string'}]
-  end
-
-  it "should respect a job class defined as a string" do
-    Que.enqueue 'argument', :queue => 'my_queue', :other_arg => 'other_arg', :job_class => 'MyJobClass'
-    Que::Job.enqueue 'argument', :queue => 'my_queue', :other_arg => 'other_arg', :job_class => 'MyJobClass'
-
-    DB[:que_jobs].count.should be 2
-    DB[:que_jobs].all.each do |job|
-      job[:job_class].should == 'MyJobClass'
-      job[:queue].should == 'my_queue'
-      JSON.load(job[:args]).should == ['argument', {'other_arg' => 'other_arg'}]
-    end
-  end
-
-  it "should respect a default (but overridable) priority for the job class" do
-    class DefaultPriorityJob < Que::Job
-      @priority = 3
-    end
-
-    DB[:que_jobs].count.should be 0
-    DefaultPriorityJob.enqueue 1
-    DefaultPriorityJob.enqueue 1, :priority => 4
-    DB[:que_jobs].count.should be 2
-
-    first, second = DB[:que_jobs].order(:job_id).all
-
-    first[:queue].should == ''
-    first[:priority].should be 3
-    first[:run_at].should be_within(3).of Time.now
-    first[:job_class].should == "DefaultPriorityJob"
-    JSON.load(first[:args]).should == [1]
-
-    second[:queue].should == ''
-    second[:priority].should be 4
-    second[:run_at].should be_within(3).of Time.now
-    second[:job_class].should == "DefaultPriorityJob"
-    JSON.load(second[:args]).should == [1]
-  end
-
-  it "should respect the old @default_priority setting" do
-    class OldDefaultPriorityJob < Que::Job
-      @default_priority = 3
-    end
-
-    DB[:que_jobs].count.should be 0
-    suppress_warnings do
-      OldDefaultPriorityJob.enqueue 1
-      OldDefaultPriorityJob.enqueue 1, :priority => 4
-    end
-    DB[:que_jobs].count.should be 2
-
-    first, second = DB[:que_jobs].order(:job_id).all
-
-    first[:queue].should == ''
-    first[:priority].should be 3
-    first[:run_at].should be_within(3).of Time.now
-    first[:job_class].should == "OldDefaultPriorityJob"
-    JSON.load(first[:args]).should == [1]
-
-    second[:queue].should == ''
-    second[:priority].should be 4
-    second[:run_at].should be_within(3).of Time.now
-    second[:job_class].should == "OldDefaultPriorityJob"
-    JSON.load(second[:args]).should == [1]
-  end
-
-  it "should respect a default (but overridable) run_at for the job class" do
-    class DefaultRunAtJob < Que::Job
-      @run_at = -> { Time.now + 60 }
-    end
-
-    DB[:que_jobs].count.should be 0
-    DefaultRunAtJob.enqueue 1
-    DefaultRunAtJob.enqueue 1, :run_at => Time.now + 30
-    DB[:que_jobs].count.should be 2
-
-    first, second = DB[:que_jobs].order(:job_id).all
-
-    first[:queue].should == ''
-    first[:priority].should be 100
-    first[:run_at].should be_within(3).of Time.now + 60
-    first[:job_class].should == "DefaultRunAtJob"
-    JSON.load(first[:args]).should == [1]
-
-    second[:queue].should == ''
-    second[:priority].should be 100
-    second[:run_at].should be_within(3).of Time.now + 30
-    second[:job_class].should == "DefaultRunAtJob"
-    JSON.load(second[:args]).should == [1]
-  end
-
-  it "should respect the old @default_run_at setting" do
-    class OldDefaultRunAtJob < Que::Job
-      @default_run_at = -> { Time.now + 60 }
-    end
-
-    DB[:que_jobs].count.should be 0
-    suppress_warnings do
-      OldDefaultRunAtJob.enqueue 1
-      OldDefaultRunAtJob.enqueue 1, :run_at => Time.now + 30
-    end
-    DB[:que_jobs].count.should be 2
-
-    first, second = DB[:que_jobs].order(:job_id).all
-
-    first[:queue].should == ''
-    first[:priority].should be 100
-    first[:run_at].should be_within(3).of Time.now + 60
-    first[:job_class].should == "OldDefaultRunAtJob"
-    JSON.load(first[:args]).should == [1]
-
-    second[:queue].should == ''
-    second[:priority].should be 100
-    second[:run_at].should be_within(3).of Time.now + 30
-    second[:job_class].should == "OldDefaultRunAtJob"
-    JSON.load(second[:args]).should == [1]
-  end
-
-  it "should respect a default (but overridable) queue for the job class" do
-    class NamedQueueJob < Que::Job
-      @queue = :my_queue
-    end
-
-    DB[:que_jobs].count.should be 0
-    NamedQueueJob.enqueue 1
-    NamedQueueJob.enqueue 1, :queue => 'my_queue_2'
-    NamedQueueJob.enqueue 1, :queue => :my_queue_2
-    NamedQueueJob.enqueue 1, :queue => ''
-    NamedQueueJob.enqueue 1, :queue => nil
-    DB[:que_jobs].count.should be 5
-
-    first, second, third, fourth, fifth = DB[:que_jobs].order(:job_id).select_map(:queue)
-
-    first.should  == 'my_queue'
-    second.should == 'my_queue_2'
-    third.should  == 'my_queue_2'
-    fourth.should == ''
-    fifth.should  == ''
-  end
-end