queue_classic_pg2 3.2.0.RC1

data/test/queue_test.rb

@@ -0,0 +1,208 @@
+require_relative 'helper'
+
+class QueueTest < QCTest
+
+  ResetError = Class.new(PG::Error)
+
+  def test_enqueue
+    QC.enqueue("Klass.method")
+  end
+
+  def test_respond_to
+    assert_equal(true, QC.respond_to?(:enqueue))
+  end
+
+  def test_lock
+    queue = QC::Queue.new("queue_classic_jobs")
+    queue.enqueue("Klass.method")
+    job = queue.lock
+    # See helper.rb for more information about the large initial id number.
+    assert_equal((2**34).to_s, job[:id])
+    assert_equal("queue_classic_jobs", job[:q_name])
+    assert_equal("Klass.method", job[:method])
+    assert_equal([], job[:args])
+  end
+
+  def test_lock_when_empty
+    assert_nil(QC.lock)
+  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
+    future = Time.now + 2
+    QC.enqueue_at(future, "Klass.method")
+    assert_nil QC.lock
+    until Time.now >= future do sleep 0.1 end
+    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
+    offset = (Time.now + 2).to_f
+    QC.enqueue_at(offset, "Klass.method")
+    assert_nil QC.lock
+    sleep 2
+    job = QC.lock
+    assert_equal("Klass.method", job[:method])
+    assert_equal([], job[:args])
+  end
+
+  def test_count
+    QC.enqueue("Klass.method")
+    assert_equal(1, QC.count)
+  end
+
+  def test_delete
+    QC.enqueue("Klass.method")
+    assert_equal(1, QC.count)
+    QC.delete(QC.lock[:id])
+    assert_equal(0, QC.count)
+  end
+
+  def test_delete_all
+    QC.enqueue("Klass.method")
+    QC.enqueue("Klass.method")
+    assert_equal(2, QC.count)
+    QC.delete_all
+    assert_equal(0, QC.count)
+  end
+
+  def test_delete_all_by_queue_name
+    p_queue = QC::Queue.new("priority_queue")
+    s_queue = QC::Queue.new("secondary_queue")
+    p_queue.enqueue("Klass.method")
+    s_queue.enqueue("Klass.method")
+    assert_equal(1, p_queue.count)
+    assert_equal(1, s_queue.count)
+    p_queue.delete_all
+    assert_equal(0, p_queue.count)
+    assert_equal(1, s_queue.count)
+  end
+
+  def test_queue_instance
+    queue = QC::Queue.new("queue_classic_jobs")
+    queue.enqueue("Klass.method")
+    assert_equal(1, queue.count)
+    queue.delete(queue.lock[:id])
+    assert_equal(0, queue.count)
+  end
+
+  def test_repair_after_error
+    queue = QC::Queue.new("queue_classic_jobs")
+    queue.conn_adapter = QC::ConnAdapter.new
+    queue.enqueue("Klass.method")
+    assert_equal(1, queue.count)
+    conn = queue.conn_adapter.connection
+    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_custom_default_queue
+    queue_class = Class.new do
+      attr_accessor :jobs
+      def enqueue(method, *args)
+        @jobs ||= []
+        @jobs << method
+      end
+    end
+
+    queue_instance = queue_class.new
+    QC.default_queue = queue_instance
+
+    QC.enqueue("Klass.method1")
+    QC.enqueue("Klass.method2")
+
+    assert_equal ["Klass.method1", "Klass.method2"], queue_instance.jobs
+  ensure
+    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.send(:drain_notify)
+
+    msgs = adapter.send(:wait_for_notify, 0.25)
+    assert_equal(0, msgs.length)
+
+    QC.enqueue("Klass.method")
+    msgs = adapter.send(:wait_for_notify, 0.25)
+    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/worker_test.rb

@@ -0,0 +1,219 @@
+require_relative 'helper'
+
+module TestObject
+  extend self
+  def no_args; return nil; end
+  def one_arg(a); return a; end
+  def two_args(a,b); return [a,b]; end
+  def forty_two; OpenStruct.new(number: 42); end
+end
+
+# This not only allows me to test what happens
+# when a failure occurs but it also demonstrates
+# how to override the worker to handle failures the way
+# you want.
+class TestWorker < QC::Worker
+  attr_accessor :failed_count
+
+  def initialize(args={})
+    super(args.merge(:connection => QC.default_conn_adapter.connection))
+    @failed_count = 0
+  end
+
+  def handle_failure(job,e)
+    @failed_count += 1
+    super
+  end
+end
+
+class WorkerTest < QCTest
+  def test_work
+    QC.enqueue("TestObject.no_args")
+    worker = TestWorker.new
+    assert_equal(1, QC.count)
+    worker.work
+    assert_equal(0, QC.count)
+    assert_equal(0, worker.failed_count)
+  end
+
+  def test_failed_job
+    QC.enqueue("TestObject.not_a_method")
+    worker = TestWorker.new
+    capture_stderr_output { worker.work }
+    assert_equal(1, worker.failed_count)
+  end
+
+  def test_failed_job_is_logged
+    output = capture_stderr_output do
+      QC.enqueue("TestObject.not_a_method")
+      TestWorker.new.work
+    end
+    assert(output.include?("#<NoMethodError: undefined method `not_a_method'"))
+  end
+
+  def test_log_yield
+    output = capture_debug_output do
+      QC.log_yield(:action => "test") do
+        0 == 1
+      end
+    end
+    expected_output = /lib=queue-classic action=test elapsed=\d*/
+    assert_match(expected_output, output, "=== debug output ===\n #{output}")
+  end
+
+  def test_log
+    output = capture_debug_output do
+      QC.log(:action => "test")
+    end
+    expected_output = /lib=queue-classic action=test/
+    assert_match(expected_output, output, "=== debug output ===\n #{output}")
+  end
+
+  def test_work_with_no_args
+    QC.enqueue("TestObject.no_args")
+    worker = TestWorker.new
+    r = worker.work
+    assert_nil(r)
+    assert_equal(0, worker.failed_count)
+  end
+
+  def test_work_with_one_arg
+    QC.enqueue("TestObject.one_arg", "1")
+    worker = TestWorker.new
+    r = worker.work
+    assert_equal("1", r)
+    assert_equal(0, worker.failed_count)
+  end
+
+  def test_work_with_two_args
+    QC.enqueue("TestObject.two_args", "1", 2)
+    worker = TestWorker.new
+    r = worker.work
+    assert_equal(["1", 2], r)
+    assert_equal(0, worker.failed_count)
+  end
+
+  def test_work_custom_queue
+    p_queue = QC::Queue.new("priority_queue")
+    p_queue.enqueue("TestObject.two_args", "1", 2)
+    worker = TestWorker.new(q_name: "priority_queue")
+    r = worker.work
+    assert_equal(["1", 2], r)
+    assert_equal(0, worker.failed_count)
+  end
+
+  def test_worker_listens_on_chan
+    p_queue = QC::Queue.new("priority_queue")
+    # Use a new connection because the default connection
+    # will be locked by the sleeping worker.
+    p_queue.conn_adapter = QC::ConnAdapter.new
+    # The wait interval is extreme to demonstrate
+    # that the worker is in fact being activated by a NOTIFY.
+    worker = TestWorker.new(:q_name => "priority_queue", :wait_interval => 100)
+    t = Thread.new do
+      r = worker.work
+      assert_equal(["1", 2], r)
+      assert_equal(0, worker.failed_count)
+    end
+    sleep(0.5) #Give the thread some time to start the worker.
+    p_queue.enqueue("TestObject.two_args", "1", 2)
+    p_queue.conn_adapter.disconnect
+    t.join
+  end
+
+  def test_worker_uses_one_conn
+    skip "This test is broken and needs to be fixed."
+
+    QC.enqueue("TestObject.no_args")
+    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?"
+    )
+  end
+
+  def test_worker_can_work_multiple_queues
+    p_queue = QC::Queue.new("priority_queue")
+    p_queue.enqueue("TestObject.two_args", "1", 2)
+
+    s_queue = QC::Queue.new("secondary_queue")
+    s_queue.enqueue("TestObject.two_args", "1", 2)
+
+    worker = TestWorker.new(:q_names => ["priority_queue", "secondary_queue"])
+
+    2.times do
+      r = worker.work
+      assert_equal(["1", 2], r)
+      assert_equal(0, worker.failed_count)
+    end
+  end
+
+  def test_worker_works_multiple_queue_left_to_right
+    l_queue = QC::Queue.new("left_queue")
+    r_queue = QC::Queue.new("right_queue")
+
+    3.times { l_queue.enqueue("TestObject.two_args", "1", 2) }
+    3.times { r_queue.enqueue("TestObject.two_args", "1", 2) }
+
+    worker = TestWorker.new(:q_names => ["left_queue", "right_queue"])
+
+    worker.work
+    assert_equal(2, l_queue.count)
+    assert_equal(3, r_queue.count)
+
+    worker.work
+    assert_equal(1, l_queue.count)
+    assert_equal(3, r_queue.count)
+  end
+
+  def test_work_with_more_complex_construct
+    QC.enqueue("TestObject.forty_two.number")
+    worker = TestWorker.new
+    r = worker.work
+    assert_equal(42, r)
+    assert_equal(0, worker.failed_count)
+  end
+
+  def test_init_worker_with_arg
+    with_database 'postgres:///invalid' do
+      conn = PG.connect(dbname: 'queue_classic_test')
+      QC::Worker.new connection: conn
+
+      conn.close
+    end
+  end
+
+  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
+
+      QC.default_conn_adapter.disconnect
+    end
+  end
+
+  def test_init_worker_without_conn
+    with_database nil do
+      assert_raises(ArgumentError) { QC::Worker.new }
+    end
+  end
+
+  private
+
+  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
+    QC.default_conn_adapter = nil
+    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

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: queue_classic_pg2
+version: !ruby/object:Gem::Version
+  version: 3.2.0.RC1
+platform: ruby
+authors:
+- Ryan Smith (♠ ace hacker)
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-01-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.17'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.17'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: 'Support for Postgres2 : 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.'
+email: r@32k.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CONTRIBUTING.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- changelog
+- 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/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
+- 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/drop_ddl.sql
+- sql/update_to_3_0_0.sql
+- sql/update_to_3_1_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/queue_test.rb
+- test/worker_test.rb
+homepage: https://github.com/PatrickLef/queue_classic
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.7
+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/queue_test.rb
+- test/worker_test.rb