que 0.11.3 → 2.2.0

data/spec/unit/migrations_spec.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Que::Migrations do
-  it "should be able to perform migrations up and down" do
-    # Migration #1 creates the table with a priority default of 1, migration
-    # #2 ups that to 100.
-
-    default = proc do
-      result = Que.execute <<-SQL
-        select adsrc::integer
-        from pg_attribute a
-        join pg_class c on c.oid = a.attrelid
-        join pg_attrdef on adrelid = attrelid AND adnum = attnum
-        where relname = 'que_jobs'
-        and attname = 'priority'
-      SQL
-
-      result.first[:adsrc]
-    end
-
-    default.call.should == 100
-    Que::Migrations.migrate! :version => 1
-    default.call.should == 1
-    Que::Migrations.migrate! :version => 2
-    default.call.should == 100
-
-    # Clean up.
-    Que.migrate!
-  end
-
-  it "should be able to get and set the current schema version" do
-    Que::Migrations.db_version.should == Que::Migrations::CURRENT_VERSION
-    Que::Migrations.set_db_version(59328)
-    Que::Migrations.db_version.should == 59328
-    Que::Migrations.set_db_version(Que::Migrations::CURRENT_VERSION)
-    Que::Migrations.db_version.should == Que::Migrations::CURRENT_VERSION
-  end
-
-  it "should be able to cycle the jobs table all the way between nonexistent and current without error" do
-    Que::Migrations.db_version.should == Que::Migrations::CURRENT_VERSION
-    Que::Migrations.migrate! :version => 0
-    Que::Migrations.db_version.should == 0
-    Que.db_version.should == 0
-    Que::Migrations.migrate!
-    Que::Migrations.db_version.should == Que::Migrations::CURRENT_VERSION
-
-    # The helper on the Que module does the same thing.
-    Que.migrate! :version => 0
-    Que::Migrations.db_version.should == 0
-    Que.migrate!
-    Que::Migrations.db_version.should == Que::Migrations::CURRENT_VERSION
-  end
-
-  it "should be able to honor the initial behavior of Que.drop!" do
-    DB.table_exists?(:que_jobs).should be true
-    Que.drop!
-    DB.table_exists?(:que_jobs).should be false
-
-    # Clean up.
-    Que::Migrations.migrate!
-    DB.table_exists?(:que_jobs).should be true
-  end
-
-  it "should be able to recognize a que_jobs table created before the versioning system" do
-    DB.drop_table :que_jobs
-    DB.create_table(:que_jobs){serial :id} # Dummy Table.
-    Que::Migrations.db_version.should == 1
-    DB.drop_table(:que_jobs)
-    Que::Migrations.migrate!
-  end
-
-  it "should be able to honor the initial behavior of Que.create!" do
-    DB.drop_table :que_jobs
-    Que.create!
-    DB.table_exists?(:que_jobs).should be true
-    Que::Migrations.db_version.should == 1
-
-    # Clean up.
-    Que::Migrations.migrate!
-    DB.table_exists?(:que_jobs).should be true
-  end
-end

data/spec/unit/pool_spec.rb

@@ -1,365 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe "Managing the Worker pool" do
-  it "should log mode changes" do
-    Que.mode = :sync
-    Que.mode = :off
-    Que.mode = :off
-
-    $logger.messages.count.should be 3
-    m1, m2, m3 = $logger.messages.map { |m| JSON.load(m) }
-
-    m1['event'].should == 'mode_change'
-    m1['value'].should == 'sync'
-
-    m2['event'].should == 'mode_change'
-    m2['value'].should == 'off'
-
-    m3['event'].should == 'mode_change'
-    m3['value'].should == 'off'
-  end
-
-  describe "Que.mode=" do
-    describe ":off" do
-      it "with worker_count 0 should not instantiate workers or hit the db" do
-        Que.connection = nil
-        Que.worker_count = 0
-        Que.mode = :off
-        Que::Worker.workers.should == []
-      end
-
-      it "with worker_count > 0 should not instantiate workers or hit the db" do
-        Que.connection = nil
-        Que.mode = :off
-        Que.worker_count = 5
-        Que.mode = :off
-        Que::Worker.workers.should == []
-      end
-    end
-
-    describe ":sync" do
-      it "with worker_count 0 should not instantiate workers or hit the db" do
-        Que.connection = nil
-        Que.worker_count = 0
-        Que.mode = :sync
-        Que::Worker.workers.should == []
-      end
-
-      it "with worker_count > 0 should not instantiate workers or hit the db" do
-        Que.connection = nil
-        Que.mode = :sync
-        Que.worker_count = 5
-        Que.mode = :sync
-        Que::Worker.workers.should == []
-      end
-
-      it "should make jobs run in the same thread as they are queued" do
-        Que.mode = :sync
-
-        ArgsJob.enqueue(5, :testing => "synchronous").should be_an_instance_of ArgsJob
-        $passed_args.should == [5, {:testing => "synchronous"}]
-        DB[:que_jobs].count.should be 0
-      end
-
-      it "should work fine with enqueuing jobs without a DB connection" do
-        Que.connection = nil
-        Que.mode = :sync
-
-        ArgsJob.enqueue(5, :testing => "synchronous").should be_an_instance_of ArgsJob
-        $passed_args.should == [5, {:testing => "synchronous"}]
-      end
-
-      it "should not affect jobs that are queued with specific run_ats" do
-        Que.mode = :sync
-
-        ArgsJob.enqueue(5, :testing => "synchronous", :run_at => Time.now + 60)
-        DB[:que_jobs].select_map(:job_class).should == ["ArgsJob"]
-      end
-    end
-
-    describe ":async" do
-      it "with worker_count 0 should not instantiate workers or hit the db" do
-        Que.connection = nil
-        Que.worker_count = 0
-        Que.mode = :async
-        Que::Worker.workers.map{|w| [w.state, w.thread.status]}.should == []
-      end
-
-      it "with worker_count > 0 should instantiate workers and hit the db" do
-        Que::Job.enqueue
-        Que.worker_count = 5
-        Que.mode = :async
-        sleep_until { Que::Worker.workers.all? &:sleeping? }
-        DB[:que_jobs].count.should == 0
-        Que::Worker.workers.map{|w| [w.state, w.thread.status]}.should == [[:sleeping, 'sleep']] * 5
-      end
-
-      it "should wake a worker every Que.wake_interval seconds" do
-        Que.worker_count = 4
-        Que.mode = :async
-        sleep_until { Que::Worker.workers.all? &:sleeping? }
-        Que.wake_interval = 0.01 # 10 ms
-        Que::Job.enqueue
-        sleep_until { DB[:que_jobs].count == 0 }
-      end
-
-      it "should work jobs in the queue defined by the Que.queue_name config option" do
-        begin
-          Que::Job.enqueue 1
-          Que::Job.enqueue 2, :queue => 'my_queue'
-
-          Que.queue_name = 'my_queue'
-
-          Que.mode = :async
-          Que.worker_count = 2
-
-          sleep_until { Que::Worker.workers.all? &:sleeping? }
-          DB[:que_jobs].count.should be 1
-
-          job = DB[:que_jobs].first
-          job[:queue].should == ''
-          job[:args].should == '[1]'
-        ensure
-          Que.queue_name = nil
-        end
-      end
-    end
-  end
-
-  describe "Que.worker_count=" do
-    describe "when the mode is :off" do
-      it "should record the setting but not instantiate any workers" do
-        Que.worker_count.should == 0
-        Que.connection = nil
-        Que.mode = :off
-        Que::Worker.workers.should == []
-
-        Que.worker_count = 4
-        Que.worker_count.should == 4
-        Que::Worker.workers.should == []
-
-        Que.worker_count = 6
-        Que.worker_count.should == 6
-        Que::Worker.workers.should == []
-
-        Que.worker_count = 2
-        Que.worker_count.should == 2
-        Que::Worker.workers.should == []
-
-        Que.worker_count = 0
-        Que.worker_count.should == 0
-        Que::Worker.workers.should == []
-      end
-    end
-
-    describe "when the mode is :sync" do
-      it "should record the setting but not instantiate any workers" do
-        Que.worker_count.should == 0
-        Que.connection = nil
-        Que.mode = :sync
-        Que::Worker.workers.should == []
-
-        Que.worker_count = 4
-        Que.worker_count.should == 4
-        Que::Worker.workers.should == []
-
-        Que.worker_count = 6
-        Que.worker_count.should == 6
-        Que::Worker.workers.should == []
-
-        Que.worker_count = 2
-        Que.worker_count.should == 2
-        Que::Worker.workers.should == []
-
-        Que.worker_count = 0
-        Que.worker_count.should == 0
-        Que::Worker.workers.should == []
-      end
-    end
-
-    describe "when the mode is :async" do
-      it "should start hitting the DB when transitioning to a non-zero value" do
-        Que.mode = :async
-        Que::Job.enqueue
-        Que.worker_count = 4
-        sleep_until { Que::Worker.workers.all?(&:sleeping?) }
-        Que::Worker.workers.map{|w| [w.state, w.thread.status]}.should == [[:sleeping, 'sleep']] * 4
-        DB[:que_jobs].count.should == 0
-      end
-
-      it "should stop hitting the DB when transitioning to zero" do
-        Que.mode = :async
-        Que.worker_count = 4
-        sleep_until { Que::Worker.workers.all?(&:sleeping?) }
-        Que.connection = nil
-        Que.worker_count = 0
-        $logger.messages.map{|m| JSON.load(m).values_at('event', 'value')}.should ==
-          [['mode_change', 'async'], ['worker_count_change', '4']] + [['job_unavailable', nil]] * 4 + [['worker_count_change', '0']]
-      end
-
-      it "should be able to scale down the number of workers gracefully" do
-        Que.mode = :async
-        Que.worker_count = 4
-
-        workers = Que::Worker.workers.dup
-        workers.count.should be 4
-        sleep_until { Que::Worker.workers.all?(&:sleeping?) }
-
-        Que.worker_count = 2
-        Que::Worker.workers.count.should be 2
-        sleep_until { Que::Worker.workers.all?(&:sleeping?) }
-
-        workers[0..1].should == Que::Worker.workers
-        workers[2..3].each do |worker|
-          worker.should be_an_instance_of Que::Worker
-          worker.thread.status.should == false
-        end
-
-        $logger.messages.map{|m| JSON.load(m).values_at('event', 'value')}.should ==
-          [['mode_change', 'async'], ['worker_count_change', '4']] + [['job_unavailable', nil]] * 4 + [['worker_count_change', '2']]
-      end
-
-      it "should be able to scale up the number of workers gracefully" do
-        Que.mode = :async
-        Que.worker_count = 4
-        workers = Que::Worker.workers.dup
-        workers.count.should be 4
-
-        sleep_until { Que::Worker.workers.all?(&:sleeping?) }
-        Que.worker_count = 6
-        Que::Worker.workers.count.should be 6
-        sleep_until { Que::Worker.workers.all?(&:sleeping?) }
-
-        workers.should == Que::Worker.workers[0..3]
-
-        $logger.messages.map{|m| JSON.load(m).values_at('event', 'value')}.should ==
-          [['mode_change', 'async'], ['worker_count_change', '4']] + [['job_unavailable', nil]] * 4 + [['worker_count_change', '6']] + [['job_unavailable', nil]] * 2
-      end
-    end
-  end
-
-  describe "Que.wake!" do
-    it "when mode = :off should do nothing" do
-      Que.connection = nil
-      Que.mode = :off
-      Que.worker_count = 4
-      sleep_until { Que::Worker.workers.all? &:sleeping? }
-      Que.wake!
-      sleep_until { Que::Worker.workers.all? &:sleeping? }
-      $logger.messages.map{|m| JSON.load(m).values_at('event', 'value')}.should ==
-        [['mode_change', 'off'], ['worker_count_change', '4']]
-    end
-
-    it "when mode = :sync should do nothing" do
-      Que.connection = nil
-      Que.mode = :sync
-      Que.worker_count = 4
-      sleep_until { Que::Worker.workers.all? &:sleeping? }
-      Que.wake!
-      sleep_until { Que::Worker.workers.all? &:sleeping? }
-      $logger.messages.map{|m| JSON.load(m).values_at('event', 'value')}.should ==
-        [['mode_change', 'sync'], ['worker_count_change', '4']]
-    end
-
-    it "when mode = :async and worker_count = 0 should do nothing" do
-      Que.connection = nil
-      Que.mode = :async
-      Que.worker_count = 0
-      sleep_until { Que::Worker.workers.all? &:sleeping? }
-      Que.wake!
-      sleep_until { Que::Worker.workers.all? &:sleeping? }
-      $logger.messages.map{|m| JSON.load(m).values_at('event', 'value')}.should ==
-        [['mode_change', 'async'], ['worker_count_change', '0']]
-    end
-
-    it "when mode = :async and worker_count > 0 should wake up a single worker" do
-      Que.mode = :async
-      Que.worker_count = 4
-      sleep_until { Que::Worker.workers.all? &:sleeping? }
-
-      BlockJob.enqueue
-      Que.wake!
-
-      $q1.pop
-      Que::Worker.workers.first.should be_working
-      Que::Worker.workers[1..3].each { |w| w.should be_sleeping }
-      DB[:que_jobs].count.should be 1
-      $q2.push nil
-
-      sleep_until { Que::Worker.workers.all? &:sleeping? }
-      DB[:que_jobs].count.should be 0
-    end
-
-    it "when mode = :async and worker_count > 0 should be thread-safe" do
-      Que.mode = :async
-      Que.worker_count = 4
-      sleep_until { Que::Worker.workers.all? &:sleeping? }
-      threads = 4.times.map { Thread.new { 100.times { Que.wake! } } }
-      threads.each(&:join)
-    end
-  end
-
-  describe "Que.wake_all!" do
-    it "when mode = :off should do nothing" do
-      Que.connection = nil
-      Que.mode = :off
-      Que.worker_count = 4
-      sleep_until { Que::Worker.workers.all? &:sleeping? }
-      Que.wake_all!
-      sleep_until { Que::Worker.workers.all? &:sleeping? }
-      $logger.messages.map{|m| JSON.load(m).values_at('event', 'value')}.should ==
-        [['mode_change', 'off'], ['worker_count_change', '4']]
-    end
-
-    it "when mode = :sync should do nothing" do
-      Que.connection = nil
-      Que.mode = :sync
-      Que.worker_count = 4
-      sleep_until { Que::Worker.workers.all? &:sleeping? }
-      Que.wake_all!
-      sleep_until { Que::Worker.workers.all? &:sleeping? }
-      $logger.messages.map{|m| JSON.load(m).values_at('event', 'value')}.should ==
-        [['mode_change', 'sync'], ['worker_count_change', '4']]
-    end
-
-    it "when mode = :async and worker_count = 0 should do nothing" do
-      Que.connection = nil
-      Que.mode = :async
-      Que.worker_count = 0
-      sleep_until { Que::Worker.workers.all? &:sleeping? }
-      Que.wake_all!
-      sleep_until { Que::Worker.workers.all? &:sleeping? }
-      $logger.messages.map{|m| JSON.load(m).values_at('event', 'value')}.should ==
-        [['mode_change', 'async'], ['worker_count_change', '0']]
-    end
-
-    # This spec requires at least four connections.
-    it "when mode = :async and worker_count > 0 should wake up all workers" do
-      Que.adapter = QUE_ADAPTERS[:pond]
-
-      Que.mode = :async
-      Que.worker_count = 4
-      sleep_until { Que::Worker.workers.all? &:sleeping? }
-
-      4.times { BlockJob.enqueue }
-      Que.wake_all!
-      4.times { $q1.pop }
-
-      Que::Worker.workers.each{ |worker| worker.should be_working }
-      4.times { $q2.push nil }
-
-      sleep_until { Que::Worker.workers.all? &:sleeping? }
-      DB[:que_jobs].count.should be 0
-    end if QUE_ADAPTERS[:pond]
-
-    it "when mode = :async and worker_count > 0 should be thread-safe" do
-      Que.mode = :async
-      Que.worker_count = 4
-      sleep_until { Que::Worker.workers.all? &:sleeping? }
-      threads = 4.times.map { Thread.new { 100.times { Que.wake_all! } } }
-      threads.each(&:join)
-    end
-  end
-end

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{}}
-    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