que 0.5.0 → 0.6.0

data/spec/adapters/sequel_spec.rb

@@ -17,7 +17,7 @@ describe "Que using the Sequel adapter" do
         end
       end
 
-      SequelJob.queue
+      SequelJob.enqueue
       Que::Job.work
 
       $pid1.should == $pid2
@@ -31,17 +31,17 @@ describe "Que using the Sequel adapter" do
     sleep_until { Que::Worker.workers.all? &:sleeping? }
 
     # Wakes a worker immediately when not in a transaction.
-    Que::Job.queue
+    Que::Job.enqueue
     sleep_until { Que::Worker.workers.all?(&:sleeping?) && DB[:que_jobs].empty? }
 
     SEQUEL_ADAPTER_DB.transaction do
-      Que::Job.queue
+      Que::Job.enqueue
       Que::Worker.workers.each { |worker| worker.should be_sleeping }
     end
     sleep_until { Que::Worker.workers.all?(&:sleeping?) && DB[:que_jobs].empty? }
 
     # Do nothing when queueing with a specific :run_at.
-    BlockJob.queue :run_at => Time.now
+    BlockJob.enqueue :run_at => Time.now
     Que::Worker.workers.each { |worker| worker.should be_sleeping }
   end
 

data/spec/gemfiles/Gemfile1

@@ -0,0 +1,18 @@
+source 'https://rubygems.org'
+
+gem 'que', path: '../..'
+
+group :development, :test do
+  gem 'rake'
+
+  gem 'activerecord',    '~> 3.2', :require => nil
+  gem 'sequel',          '~> 3', :require => nil
+  gem 'connection_pool', :require => nil
+  gem 'pg',              :require => nil, :platform => :ruby
+  gem 'pg_jruby',        :require => nil, :platform => :jruby
+end
+
+group :test do
+  gem 'rspec', '~> 2.14.1'
+  gem 'pry'
+end

data/spec/gemfiles/Gemfile2

@@ -0,0 +1,18 @@
+source 'https://rubygems.org'
+
+gem 'que', path: "../.."
+
+group :development, :test do
+  gem 'rake'
+
+  gem 'activerecord',    '~> 4.0', :require => nil
+  gem 'sequel',          '~> 4', :require => nil
+  gem 'connection_pool', :require => nil
+  gem 'pg',              :require => nil, :platform => :ruby
+  gem 'pg_jruby',        :require => nil, :platform => :jruby
+end
+
+group :test do
+  gem 'rspec', '~> 2.14.1'
+  gem 'pry'
+end

data/spec/support/helpers.rb

@@ -1,5 +1,6 @@
 # Helper for testing threaded code.
-def sleep_until(timeout = 2)
+QUE_TEST_TIMEOUT ||= 2
+def sleep_until(timeout = QUE_TEST_TIMEOUT)
   deadline = Time.now + timeout
   loop do
     break if yield

data/spec/support/shared_examples/adapter.rb

@@ -1,12 +1,16 @@
 shared_examples "a Que adapter" do
   it "should be able to execute arbitrary SQL and return indifferent hashes" do
     result = Que.execute("SELECT 1 AS one")
-    result.should == [{'one'=>'1'}]
-    result.first[:one].should == '1'
+    result.should == [{'one'=>1}]
+    result.first[:one].should == 1
+  end
+
+  it "should be able to execute multiple SQL statements in one string" do
+    Que.execute("SELECT 1 AS one; SELECT 1 AS one")
   end
 
   it "should be able to queue and work a job" do
-    Que::Job.queue
+    Que::Job.enqueue
     result = Que::Job.work
     result[:event].should == :job_worked
     result[:job][:job_class].should == 'Que::Job'

data/spec/support/shared_examples/multi_threaded_adapter.rb

@@ -26,11 +26,11 @@ shared_examples "a multi-threaded Que adapter" do
   end
 
   it "should allow multiple workers to complete jobs simultaneously" do
-    BlockJob.queue
+    BlockJob.enqueue
     worker_1 = Que::Worker.new
     $q1.pop
 
-    Que::Job.queue
+    Que::Job.enqueue
     DB[:que_jobs].count.should be 2
 
     worker_2 = Que::Worker.new

data/spec/travis.rb

@@ -4,10 +4,18 @@
 test_runs = if ENV['TESTS']
               Integer(ENV['TESTS'])
             else
-              50
+              25
             end
 
-1.upto(test_runs) do |i|
-  puts "Test Run #{i}"
-  exit(-1) if !system("bundle exec rake")
+
+# I think travis might be pausing jobs, let's try a higher timeout
+QUE_TEST_TIMEOUT = 10
+
+%w( Gemfile spec/gemfiles/Gemfile1 spec/gemfiles/Gemfile2 ).each do |gemfile|
+  # Install the particular gemfile
+  system("BUNDLE_GEMFILE=#{gemfile} bundle")
+  1.upto(test_runs) do |i|
+    puts "Test Run #{i}"
+    exit(-1) if !system("bundle exec rake")
+  end
 end

data/spec/unit/customization_spec.rb

@@ -0,0 +1,148 @@
+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
+    class Cron < Que::Job
+      def run
+        destroy
+        self.class.enqueue :run_at => @attrs[:run_at] + 3600
+      end
+    end
+
+    Cron.enqueue
+
+    run_at = DB[:que_jobs].get(:run_at).to_f
+
+    Que::Job.work
+
+    DB[:que_jobs].get(:run_at).to_f.should be_within(0.000001).of(run_at + 3600)
+  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.queue 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
+end

data/spec/unit/{queue_spec.rb → enqueue_spec.rb}

@@ -1,28 +1,37 @@
 require 'spec_helper'
 
-describe Que::Job, '.queue' do
+describe Que::Job, '.enqueue' do
   it "should be able to queue a job" do
     DB[:que_jobs].count.should be 0
-    result = Que::Job.queue
+    result = Que::Job.enqueue
     DB[:que_jobs].count.should be 1
 
     result.should be_an_instance_of Que::Job
-    result.attrs[:priority].should == '100'
+    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
+    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.queue 1, 'two'
+    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"
@@ -31,7 +40,7 @@ describe Que::Job, '.queue' do
 
   it "should be able to queue a job with complex arguments" do
     DB[:que_jobs].count.should be 0
-    Que::Job.queue 1, 'two', :string => "string",
+    Que::Job.enqueue 1, 'two', :string => "string",
                              :integer => 5,
                              :array => [1, "two", {:three => 3}],
                              :hash => {:one => 1, :two => 'two', :three => [3]}
@@ -39,6 +48,7 @@ describe Que::Job, '.queue' do
     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"
@@ -56,10 +66,11 @@ describe Que::Job, '.queue' do
 
   it "should be able to queue a job with a specific time to run" do
     DB[:que_jobs].count.should be 0
-    Que::Job.queue 1, :run_at => Time.now + 60
+    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"
@@ -68,10 +79,11 @@ describe Que::Job, '.queue' do
 
   it "should be able to queue a job with a specific priority" do
     DB[:que_jobs].count.should be 0
-    Que::Job.queue 1, :priority => 4
+    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"
@@ -80,59 +92,148 @@ describe Que::Job, '.queue' do
 
   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.queue 1, :string => "string", :run_at => Time.now + 60, :priority => 4
+    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
-      @default_priority = 3
+      @priority = 3
     end
 
     DB[:que_jobs].count.should be 0
-    DefaultPriorityJob.queue 1
-    DefaultPriorityJob.queue 1, :priority => 4
+    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
+    OldDefaultPriorityJob.enqueue 1
+    OldDefaultPriorityJob.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 == "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
-      @default_run_at = -> { Time.now + 60 }
+      @run_at = -> { Time.now + 60 }
     end
 
     DB[:que_jobs].count.should be 0
-    DefaultRunAtJob.queue 1
-    DefaultRunAtJob.queue 1, :run_at => Time.now + 30
+    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
+    OldDefaultRunAtJob.enqueue 1
+    OldDefaultRunAtJob.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 == "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