queue_classic 3.1.0.RC1 → 4.0.0.pre.beta1

data/test/queue_test.rb

@@ -1,8 +1,10 @@
-require File.expand_path("../helper.rb", __FILE__)
+# frozen_string_literal: true
+
+require_relative 'helper'
 
 class QueueTest < QCTest
 
-  ResetError = Class.new(PGError)
+  ResetError = Class.new(PG::Error)
 
   def test_enqueue
     QC.enqueue("Klass.method")
@@ -28,12 +30,14 @@ class QueueTest < QCTest
   end
 
   def test_lock_with_future_job_with_enqueue_in
+    now = Time.now
     QC.enqueue_in(2, "Klass.method")
     assert_nil QC.lock
     sleep 2
     job = QC.lock
     assert_equal("Klass.method", job[:method])
     assert_equal([], job[:args])
+    assert_equal((now + 2).to_i, job[:scheduled_at].to_i)
   end
 
   def test_lock_with_future_job_with_enqueue_at_with_a_time_object
@@ -44,6 +48,7 @@ class QueueTest < QCTest
     job = QC.lock
     assert_equal("Klass.method", job[:method])
     assert_equal([], job[:args])
+    assert_equal(future.to_i, job[:scheduled_at].to_i)
   end
 
   def test_lock_with_future_job_with_enqueue_at_with_a_float_timestamp
@@ -59,6 +64,20 @@ class QueueTest < QCTest
   def test_count
     QC.enqueue("Klass.method")
     assert_equal(1, QC.count)
+
+    QC.enqueue("Klass.method")
+    assert_equal(2, QC.count)
+    assert_equal(2, QC.count_ready)
+    assert_equal(0, QC.count_scheduled)
+
+    QC.enqueue_in(60, "Klass.method")
+    assert_equal(3, QC.count)
+    assert_equal(2, QC.count_ready)
+    assert_equal(1, QC.count_scheduled)
+
+    assert_raises(ArgumentError) do
+      QC.count(:potatoes)
+    end
   end
 
   def test_delete
@@ -102,13 +121,57 @@ class QueueTest < QCTest
     queue.enqueue("Klass.method")
     assert_equal(1, queue.count)
     conn = queue.conn_adapter.connection
-    def conn.exec(*args); raise(PGError); end
+    def conn.exec(*args); raise(PG::Error); end
     def conn.reset(*args); raise(ResetError)  end
     # We ensure that the reset method is called on the connection.
     assert_raises(PG::Error, ResetError) {queue.enqueue("Klass.other_method")}
     queue.conn_adapter.disconnect
   end
 
+  def test_enqueue_retry
+    queue = QC::Queue.new("queue_classic_jobs")
+    queue.conn_adapter = QC::ConnAdapter.new
+    conn = queue.conn_adapter.connection
+    conn.exec('select pg_terminate_backend(pg_backend_pid())') rescue nil
+    queue.enqueue("Klass.method")
+    assert_equal(1, queue.count)
+    queue.conn_adapter.disconnect
+  end
+
+  def test_enqueue_stops_retrying_on_permanent_error
+    queue = QC::Queue.new("queue_classic_jobs")
+    queue.conn_adapter = QC::ConnAdapter.new
+    conn = queue.conn_adapter.connection
+    conn.exec('select pg_terminate_backend(pg_backend_pid())') rescue nil
+    # Simulate permanent connection error
+    def conn.exec(*args); raise(PG::Error); end
+    # Ensure that the error is reraised on second time
+    assert_raises(PG::Error) {queue.enqueue("Klass.other_method")}
+    queue.conn_adapter.disconnect
+  end
+
+  def test_enqueue_in_retry
+    queue = QC::Queue.new("queue_classic_jobs")
+    queue.conn_adapter = QC::ConnAdapter.new
+    conn = queue.conn_adapter.connection
+    conn.exec('select pg_terminate_backend(pg_backend_pid())') rescue nil
+    queue.enqueue_in(10,"Klass.method")
+    assert_equal(1, queue.count)
+    queue.conn_adapter.disconnect
+  end
+
+  def test_enqueue_in_stops_retrying_on_permanent_error
+    queue = QC::Queue.new("queue_classic_jobs")
+    queue.conn_adapter = QC::ConnAdapter.new
+    conn = queue.conn_adapter.connection
+    conn.exec('select pg_terminate_backend(pg_backend_pid())') rescue nil
+    # Simulate permanent connection error
+    def conn.exec(*args); raise(PG::Error); end
+    # Ensure that the error is reraised on second time
+    assert_raises(PG::Error) {queue.enqueue_in(10,"Klass.method")}
+    queue.conn_adapter.disconnect
+  end
+
   def test_custom_default_queue
     queue_class = Class.new do
       attr_accessor :jobs
@@ -129,9 +192,50 @@ class QueueTest < QCTest
     QC.default_queue = nil
   end
 
+  def test_multi_threaded_server_can_specified_connection
+    adapter1 = QC::ConnAdapter.new
+    adapter2 = QC::ConnAdapter.new
+    q1 = q2 = nil
+
+    QC.default_conn_adapter = adapter1
+
+    t1 = Thread.new do
+      QC.default_conn_adapter = adapter1
+      q1 = QC::Queue.new('queue1').conn_adapter
+    end
+
+    t2 = Thread.new do
+      QC.default_conn_adapter = adapter2
+      q2 = QC::Queue.new('queue2').conn_adapter
+    end
+
+    t1.join
+    t2.join
+
+    assert_equal adapter1, q1
+    assert_equal adapter2, q2
+  end
+
+  def test_multi_threaded_server_each_thread_acquires_unique_connection
+    q1 = q2 = nil
+
+    t1 = Thread.new do
+      q1 = QC::Queue.new('queue1').conn_adapter
+    end
+
+    t2 = Thread.new do
+      q2 = QC::Queue.new('queue2').conn_adapter
+    end
+
+    t1.join
+    t2.join
+
+    refute_equal q1, q2
+  end
+
   def test_enqueue_triggers_notify
     adapter = QC.default_conn_adapter
-    adapter.execute('LISTEN "' + QC::QUEUE + '"')
+    adapter.execute('LISTEN "' + QC.queue + '"')
     adapter.send(:drain_notify)
 
     msgs = adapter.send(:wait_for_notify, 0.25)
@@ -142,4 +246,23 @@ class QueueTest < QCTest
     assert_equal(1, msgs.length)
   end
 
+  def test_enqueue_returns_job_id
+    enqueued_job = QC.enqueue("Klass.method")
+    locked_job = QC.lock
+    assert_equal enqueued_job, "id" => locked_job[:id]
+  end
+
+  def test_enqueue_in_returns_job_id
+    enqueued_job = QC.enqueue_in(1, "Klass.method")
+    sleep 1
+    locked_job = QC.lock
+    assert_equal enqueued_job, "id" => locked_job[:id]
+  end
+
+  def test_enqueue_at_returns_job_id
+    enqueued_job = QC.enqueue_at(Time.now + 1, "Klass.method")
+    sleep 1
+    locked_job = QC.lock
+    assert_equal enqueued_job, "id" => locked_job[:id]
+  end
 end

data/test/rails-tests/.gitignore

@@ -0,0 +1,2 @@
+vendor/
+qctest*/

data/test/rails-tests/rails523.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+set -e
+
+# remove any old folder, should only matter locally
+rm -rf qctest523
+
+# install rails but not with much stuff
+gem install rails -v 5.2.3
+rails new qctest523 --api --database=postgresql --skip-test-unit --skip-keeps --skip-spring --skip-sprockets --skip-javascript --skip-turbolinks
+cd qctest523
+
+# get the db setup, run any default migrations
+bundle install
+bundle exec rails db:drop:all
+bundle exec rails db:create
+bundle exec rails db:migrate
+bundle exec rails db:setup
+
+# install qc --> gem file, bundle, add ourselves and migrate.
+echo "gem 'queue_classic', path: '../../../'" >> Gemfile
+bundle install
+bundle exec rails generate queue_classic:install
+bundle exec rails db:migrate

data/test/worker_test.rb

@@ -1,4 +1,6 @@
-require File.expand_path("../helper.rb", __FILE__)
+# frozen_string_literal: true
+
+require_relative 'helper'
 
 module TestObject
   extend self
@@ -27,7 +29,6 @@ class TestWorker < QC::Worker
 end
 
 class WorkerTest < QCTest
-
   def test_work
     QC.enqueue("TestObject.no_args")
     worker = TestWorker.new
@@ -40,7 +41,7 @@ class WorkerTest < QCTest
   def test_failed_job
     QC.enqueue("TestObject.not_a_method")
     worker = TestWorker.new
-    worker.work
+    capture_stderr_output { worker.work }
     assert_equal(1, worker.failed_count)
   end
 
@@ -122,14 +123,16 @@ class WorkerTest < QCTest
     t.join
   end
 
-  def test_worker_ueses_one_conn
+  def test_worker_reuses_conn
     QC.enqueue("TestObject.no_args")
+    count = QC.default_conn_adapter.execute("SELECT count(*) from pg_stat_activity where datname = current_database()")["count"].to_i;
     worker = TestWorker.new
     worker.work
-    assert_equal(
-      1,
-      QC.default_conn_adapter.execute("SELECT count(*) from pg_stat_activity where datname = current_database()")["count"].to_i,
-      "Multiple connections found -- are there open connections to #{ QC.default_conn_adapter.send(:db_url) } in other terminals?"
+
+    new_count = QC.default_conn_adapter.execute("SELECT count(*) from pg_stat_activity where datname = current_database()")["count"].to_i;
+    assert(
+      new_count == count,
+      "Worker should not initialize new connections to #{ QC.default_conn_adapter.send(:db_url) }."
     )
   end
 
@@ -175,48 +178,163 @@ class WorkerTest < QCTest
     assert_equal(0, worker.failed_count)
   end
 
-  def test_init_worker_with_arg
-    set_database 'postgres:///invalid'
+  def test_init_worker_with_database_url
+    with_database ENV['DATABASE_URL'] || ENV['QC_DATABASE_URL'] do
+      worker = QC::Worker.new
+      QC.enqueue("TestObject.no_args")
+      worker.lock_job
 
-    conn = PG::Connection.connect(dbname: 'queue_classic_test')
-    QC::Worker.new connection: conn
+      QC.default_conn_adapter.disconnect
+    end
+  end
 
-    conn.close
-    reset_database
+  def test_init_worker_without_conn
+    with_database nil do
+      assert_raises(ArgumentError) do
+        worker = QC::Worker.new
+        QC.enqueue("TestObject.no_args")
+        worker.lock_job
+      end
+    end
   end
 
-  def test_init_worker_with_database_url
-    set_database ENV['DATABASE_URL'] || ENV['QC_DATABASE_URL']
+  def test_worker_unlocks_job_on_signal_exception
+    job_details = QC.enqueue("Kernel.eval", "raise SignalException.new('INT')")
+    worker = TestWorker.new
 
-    worker = QC::Worker.new
-    QC.enqueue("TestObject.no_args")
-    worker.lock_job
+    unlocked = nil
 
-    QC.default_conn_adapter.disconnect
-    reset_database
+    fake_unlock = Proc.new do |job_id|
+      if job_id == job_details['id']
+        unlocked = true
+      end
+      original_unlock(job_id)
+    end
+
+    stub_any_instance(QC::Queue, :unlock, fake_unlock) do
+      begin
+        worker.work
+      rescue SignalException
+      ensure
+        assert unlocked, "SignalException failed to unlock the job in the queue."
+      end
+    end
   end
 
-  def test_init_worker_without_conn
-    set_database nil
+  def test_worker_unlocks_job_on_system_exit
+    job_details = QC.enqueue("Kernel.eval", "raise SystemExit.new")
+    worker = TestWorker.new
+
+    unlocked = nil
+
+    fake_unlock = Proc.new do |job_id|
+      if job_id == job_details['id']
+        unlocked = true
+      end
+      original_unlock(job_id)
+    end
+
+    stub_any_instance(QC::Queue, :unlock, fake_unlock) do
+      begin
+        worker.work
+      rescue SystemExit
+      ensure
+        assert unlocked, "SystemExit failed to unlock the job in the queue."
+      end
+    end
+  end
+
+  def test_worker_does_not_unlock_jobs_on_syntax_error
+    job_details = QC.enqueue("Kernel.eval", "bad syntax")
+    worker = TestWorker.new
+
+    unlocked = nil
 
-    assert_raises(ArgumentError) { QC::Worker.new }
+    fake_unlock = Proc.new do |job_id|
+      if job_id == job_details['id']
+        unlocked = true
+      end
+      original_unlock(job_id)
+    end
 
-    reset_database
+    stub_any_instance(QC::Queue, :unlock, fake_unlock) do
+      begin
+        errors = capture_stderr_output do
+          worker.work
+        end
+      ensure
+        message = ["SyntaxError unexpectedly unlocked the job in the queue."]
+        message << "Errors:\n#{errors}" unless errors.empty?
+        refute unlocked, message.join("\n")
+      end
+    end
+  end
+
+  def test_worker_does_not_unlock_jobs_on_load_error
+    job_details = QC.enqueue("Kernel.eval", "require 'not_a_real_file'")
+    worker = TestWorker.new
+
+    unlocked = nil
+
+    fake_unlock = Proc.new do |job_id|
+      if job_id == job_details['id']
+        unlocked = true
+      end
+      original_unlock(job_id)
+    end
+
+    stub_any_instance(QC::Queue, :unlock, fake_unlock) do
+      begin
+        errors = capture_stderr_output do
+          worker.work
+        end
+      ensure
+        message = ["LoadError unexpectedly unlocked the job in the queue."]
+        message << "Errors:\n#{errors}" unless errors.empty?
+        refute unlocked, message.join("\n")
+      end
+    end
+  end
+
+  def test_worker_does_not_unlock_jobs_on_no_memory_error
+    job_details = QC.enqueue("Kernel.eval", "raise NoMemoryError.new")
+    worker = TestWorker.new
+
+    unlocked = nil
+
+    fake_unlock = Proc.new do |job_id|
+      if job_id == job_details['id']
+        unlocked = true
+      end
+      original_unlock(job_id)
+    end
+
+    stub_any_instance(QC::Queue, :unlock, fake_unlock) do
+      begin
+        errors = capture_stderr_output do
+          worker.work
+        end
+      ensure
+        message = ["NoMemoryError unexpectedly unlocked the job in the queue."]
+        message << "Errors:\n#{errors}" unless errors.empty?
+        refute unlocked, message.join("\n")
+      end
+    end
   end
 
   private
 
-  def set_database(url)
-    @database_url = ENV['DATABASE_URL']
-    @qc_database_url = ENV['QC_DATABASE_URL']
+  def with_database(url)
+    original_conn_adapter = QC.default_conn_adapter
+    original_database_url = ENV['DATABASE_URL']
+    original_qc_database_url = ENV['QC_DATABASE_URL']
+
     ENV['DATABASE_URL'] = ENV['QC_DATABASE_URL'] = url
-    @conn_adapter = QC.default_conn_adapter
     QC.default_conn_adapter = nil
-  end
-
-  def reset_database
-    ENV['DATABASE_URL'] = @database_url
-    ENV['QC_DATABASE_URL'] = @qc_database_url
-    QC.default_conn_adapter = @conn_adapter
+    yield
+  ensure
+    ENV['DATABASE_URL'] = original_database_url
+    ENV['QC_DATABASE_URL'] = original_qc_database_url
+    QC.default_conn_adapter = original_conn_adapter
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: queue_classic
 version: !ruby/object:Gem::Version
-  version: 3.1.0.RC1
+  version: 4.0.0.pre.beta1
 platform: ruby
 authors:
 - Ryan Smith (♠ ace hacker)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-07 00:00:00.000000000 Z
+date: 2021-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -19,7 +19,7 @@ dependencies:
         version: '0.17'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.19'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,7 +29,27 @@ dependencies:
         version: '0.17'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.19'
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.1'
 description: queue_classic is a queueing library for Ruby apps. (Rails, Sinatra, Etc...)
   queue_classic features asynchronous job polling, database maintained locks and no
   ridiculous dependencies. As a matter of fact, queue_classic only requires pg.
@@ -38,31 +58,50 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".circleci/config.yml"
+- ".gitignore"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- CONTRIBUTING.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
 - lib/generators/queue_classic/install_generator.rb
 - lib/generators/queue_classic/templates/add_queue_classic.rb
 - lib/generators/queue_classic/templates/update_queue_classic_3_0_0.rb
 - lib/generators/queue_classic/templates/update_queue_classic_3_0_2.rb
 - lib/generators/queue_classic/templates/update_queue_classic_3_1_0.rb
+- lib/generators/queue_classic/templates/update_queue_classic_4_0_0.rb
 - lib/queue_classic.rb
+- lib/queue_classic/config.rb
 - lib/queue_classic/conn_adapter.rb
 - lib/queue_classic/queue.rb
 - lib/queue_classic/railtie.rb
 - lib/queue_classic/setup.rb
 - lib/queue_classic/tasks.rb
+- lib/queue_classic/version.rb
 - lib/queue_classic/worker.rb
-- readme.md
+- queue_classic.gemspec
 - sql/create_table.sql
 - sql/ddl.sql
 - sql/downgrade_from_3_0_0.sql
 - sql/downgrade_from_3_1_0.sql
+- sql/downgrade_from_4_0_0.sql
 - sql/drop_ddl.sql
 - sql/update_to_3_0_0.sql
 - sql/update_to_3_1_0.sql
+- sql/update_to_4_0_0.sql
 - test/benchmark_test.rb
+- test/config_test.rb
 - test/helper.rb
+- test/helper.sql
 - test/lib/queue_classic_rails_connection_test.rb
 - test/lib/queue_classic_test.rb
+- test/lib/queue_classic_test_with_activerecord_typecast.rb
 - test/queue_test.rb
+- test/rails-tests/.gitignore
+- test/rails-tests/rails523.sh
 - test/worker_test.rb
 homepage: http://github.com/QueueClassic/queue_classic
 licenses:
@@ -83,14 +122,19 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Simple, efficient worker queue for Ruby & PostgreSQL.
 test_files:
 - test/benchmark_test.rb
+- test/config_test.rb
+- test/helper.rb
+- test/helper.sql
 - test/lib/queue_classic_rails_connection_test.rb
 - test/lib/queue_classic_test.rb
+- test/lib/queue_classic_test_with_activerecord_typecast.rb
 - test/queue_test.rb
+- test/rails-tests/.gitignore
+- test/rails-tests/rails523.sh
 - test/worker_test.rb