que 0.14.3 → 1.0.0.beta

data/spec/unit/helper_spec.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Que, 'helpers' do
-  it "should be able to clear the jobs table" do
-    DB[:que_jobs].insert :job_class => "Que::Job"
-    DB[:que_jobs].count.should be 1
-    Que.clear!
-    DB[:que_jobs].count.should be 0
-  end
-end

data/spec/unit/logging_spec.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe "Logging" do
-  it "by default should record the library and hostname and thread id in JSON" do
-    Que.log :event => "blah", :source => 4
-    $logger.messages.count.should be 1
-
-    message = JSON.load($logger.messages.first)
-    message['lib'].should == 'que'
-    message['hostname'].should == Socket.gethostname
-    message['pid'].should == Process.pid
-    message['event'].should == 'blah'
-    message['source'].should == 4
-    message['thread'].should == Thread.current.object_id
-  end
-
-  it "should allow a callable to be set as the logger" do
-    begin
-      # Make sure we can get through a work cycle without a logger.
-      Que.logger = proc { $logger }
-
-      Que::Job.enqueue
-      worker = Que::Worker.new
-      sleep_until { worker.sleeping? }
-
-      DB[:que_jobs].should be_empty
-
-      worker.stop
-      worker.wait_until_stopped
-
-      $logger.messages.count.should be 2
-      $logger.messages.map{|m| JSON.load(m)['event']}.should == ['job_worked', 'job_unavailable']
-    ensure
-      Que.logger = $logger
-    end
-  end
-
-  it "should not raise an error when no logger is present" do
-    begin
-      # Make sure we can get through a work cycle without a logger.
-      Que.logger = nil
-
-      Que::Job.enqueue
-      worker = Que::Worker.new
-      sleep_until { worker.sleeping? }
-
-      DB[:que_jobs].should be_empty
-
-      worker.stop
-      worker.wait_until_stopped
-    ensure
-      Que.logger = $logger
-    end
-  end
-
-  it "should allow the use of a custom log formatter" do
-    begin
-      Que.log_formatter = proc { |data| "Logged event is #{data[:event]}" }
-      Que.log :event => 'my_event'
-      $logger.messages.count.should be 1
-      $logger.messages.first.should == "Logged event is my_event"
-    ensure
-      Que.log_formatter = nil
-    end
-  end
-
-  it "should not log anything if the logging formatter returns falsey" do
-    begin
-      Que.log_formatter = proc { |data| false }
-
-      Que.log :event => "blah"
-      $logger.messages.should be_empty
-    ensure
-      Que.log_formatter = nil
-    end
-  end
-
-  it "should use a :level option to set the log level if one exists, or default to info" do
-    begin
-      Que.logger = o = Object.new
-
-      def o.method_missing(level, message)
-        $level = level
-        $message = message
-      end
-
-      Que.log :message => 'one'
-      $level.should == :info
-      JSON.load($message)['message'].should == 'one'
-
-      Que.log :message => 'two', :level => 'debug'
-      $level.should == :debug
-      JSON.load($message)['message'].should == 'two'
-    ensure
-      Que.logger = $logger
-      $level = $message = nil
-    end
-  end
-end

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