que 0.14.3 → 1.0.0.beta

data/spec/adapters/connection_pool_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'connection_pool'
-
-Que.connection = QUE_SPEC_CONNECTION_POOL = ConnectionPool.new &NEW_PG_CONNECTION
-QUE_ADAPTERS[:connection_pool] = Que.adapter
-
-describe "Que using the ConnectionPool adapter" do
-  before { Que.adapter = QUE_ADAPTERS[:connection_pool] }
-
-  it_behaves_like "a multi-threaded Que adapter"
-
-  it "should be able to tell when it's already in a transaction" do
-    Que.adapter.should_not be_in_transaction
-    QUE_SPEC_CONNECTION_POOL.with do |conn|
-      conn.async_exec "BEGIN"
-      Que.adapter.should be_in_transaction
-      conn.async_exec "COMMIT"
-    end
-  end
-end

data/spec/adapters/pg_spec.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe "Que using a bare PG connection" do
-  it_behaves_like "a Que adapter"
-
-  it "should synchronize access to that connection" do
-    lock   = Que.adapter.lock
-    q1, q2 = Queue.new, Queue.new
-
-    thread1 = Thread.new do
-      Que.adapter.checkout do
-        q1.push nil
-        q2.pop
-      end
-    end
-
-    q1.pop
-
-    thread2 = Thread.new do
-      Que.adapter.checkout do
-        q1.push nil
-        q2.pop
-      end
-    end
-
-    sleep_until { thread2.status == 'sleep' }
-
-    thread1.should be_alive
-    thread2.should be_alive
-
-    lock.send(:instance_variable_get, :@mon_owner).should == thread1
-    q2.push nil
-    q1.pop
-    lock.send(:instance_variable_get, :@mon_owner).should == thread2
-    q2.push nil
-    thread1.join
-    thread2.join
-  end
-end

data/spec/adapters/pond_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'pond'
-
-Que.connection = QUE_SPEC_POND = Pond.new &NEW_PG_CONNECTION
-QUE_ADAPTERS[:pond] = Que.adapter
-
-describe "Que using the Pond adapter" do
-  before { Que.adapter = QUE_ADAPTERS[:pond] }
-
-  it_behaves_like "a multi-threaded Que adapter"
-
-  it "should be able to tell when it's already in a transaction" do
-    Que.adapter.should_not be_in_transaction
-    QUE_SPEC_POND.checkout do |conn|
-      conn.async_exec "BEGIN"
-      Que.adapter.should be_in_transaction
-      conn.async_exec "COMMIT"
-    end
-  end
-end

data/spec/adapters/sequel_spec.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-Que.connection = SEQUEL_ADAPTER_DB = Sequel.connect(QUE_URL)
-QUE_ADAPTERS[:sequel] = Que.adapter
-
-describe "Que using the Sequel adapter" do
-  before { Que.adapter = QUE_ADAPTERS[:sequel] }
-
-  it_behaves_like "a multi-threaded Que adapter"
-
-  it "should use the same connection that Sequel does" do
-    begin
-      class SequelJob < Que::Job
-        def run
-          $pid1 = Integer(Que.execute("select pg_backend_pid()").first['pg_backend_pid'])
-          $pid2 = Integer(SEQUEL_ADAPTER_DB['select pg_backend_pid()'].get)
-        end
-      end
-
-      SequelJob.enqueue
-      Que::Job.work
-
-      $pid1.should == $pid2
-    ensure
-      $pid1 = $pid2 = nil
-    end
-  end
-
-  it "should wake up a Worker after queueing a job in async mode, waiting for a transaction to commit if necessary" do
-    Que.mode = :async
-    Que.worker_count = 4
-    sleep_until { Que::Worker.workers.all? &:sleeping? }
-
-    # Wakes a worker immediately when not in a transaction.
-    Que::Job.enqueue
-    sleep_until { Que::Worker.workers.all?(&:sleeping?) && DB[:que_jobs].empty? }
-
-    SEQUEL_ADAPTER_DB.transaction do
-      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.enqueue :run_at => Time.now
-    Que::Worker.workers.each { |worker| worker.should be_sleeping }
-  end
-
-  it "should be able to tell when it's in a Sequel transaction" do
-    Que.adapter.should_not be_in_transaction
-    SEQUEL_ADAPTER_DB.transaction do
-      Que.adapter.should be_in_transaction
-    end
-  end
-end

data/spec/gemfiles/Gemfile.current

@@ -1,19 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'que', path: '../..'
-
-group :development, :test do
-  gem 'rake', '< 11.0'
-
-  gem 'activerecord',    :require => nil
-  gem 'sequel',          :require => nil
-  gem 'connection_pool', :require => nil
-  gem 'pond',            :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/Gemfile.old

@@ -1,19 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'que', path: '../..'
-
-group :development, :test do
-  gem 'rake', '< 11.0'
-
-  gem 'activerecord',    '~> 4.2.0', :require => nil
-  gem 'sequel',          '~> 3.0', :require => nil
-  gem 'connection_pool', :require => nil
-  gem 'pond',            :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/Gemfile.older

@@ -1,19 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'que', path: '../..'
-
-group :development, :test do
-  gem 'rake', '< 11.0'
-
-  gem 'activerecord',    '~> 4.1.0', :require => nil
-  gem 'sequel',          :require => nil
-  gem 'connection_pool', :require => nil
-  gem 'pond',            :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/Gemfile.oldest

@@ -1,19 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'que', path: '../..'
-
-group :development, :test do
-  gem 'rake', '< 11.0'
-
-  gem 'activerecord',    '~> 4.0.0', :require => nil
-  gem 'sequel',          :require => nil
-  gem 'connection_pool', :require => nil
-  gem 'pond',            :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/spec_helper.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-require 'que'
-require 'uri'
-require 'pg'
-require 'logger'
-require 'json'
-require 'pry'
-
-Dir['./spec/support/**/*.rb'].sort.each &method(:require)
-
-
-
-# Handy constants for initializing PG connections:
-QUE_URL = ENV['DATABASE_URL'] || 'postgres://postgres:@localhost/que-test'
-
-NEW_PG_CONNECTION = proc do
-  uri = URI.parse(QUE_URL)
-  pg = PG::Connection.open :host     => uri.host,
-                           :user     => uri.user,
-                           :password => uri.password,
-                           :port     => uri.port || 5432,
-                           :dbname   => uri.path[1..-1]
-
-  # Avoid annoying NOTICE messages in specs.
-  pg.async_exec "SET client_min_messages TO 'warning'"
-  pg
-end
-
-
-
-# Adapters track which statements have been prepared for their connections,
-# and if Que.connection= is called before each spec, we're constantly creating
-# new adapters and losing that information, which is bad. So instead, we hang
-# onto a few adapters and assign them using Que.adapter= as needed. The plain
-# pg adapter is the default.
-
-# Also, let Que initialize the adapter itself, to make sure that the
-# recognition logic works. Similar code can be found in the adapter specs.
-Que.connection = NEW_PG_CONNECTION.call
-QUE_ADAPTERS = {:pg => Que.adapter}
-
-
-
-# We use Sequel to examine the database in specs.
-require 'sequel'
-DB = Sequel.connect(QUE_URL)
-
-
-
-if ENV['CI']
-  DB.synchronize do |conn|
-    puts "Ruby #{RUBY_VERSION}"
-    puts "Sequel #{Sequel::VERSION}"
-    puts conn.async_exec("SELECT version()").to_a.first['version']
-  end
-end
-
-
-
-# Reset the table to the most up-to-date version.
-DB.drop_table? :que_jobs
-Que::Migrations.migrate!
-
-
-
-# Set up a dummy logger.
-Que.logger = $logger = Object.new
-$logger_mutex = Mutex.new # Protect against rare errors on Rubinius/JRuby.
-
-def $logger.messages
-  @messages ||= []
-end
-
-def $logger.method_missing(m, message)
-  $logger_mutex.synchronize { messages << message }
-end
-
-# Object includes Kernel#warn which is not what we expect, so remove:
-def $logger.warn(message)
-  method_missing(:warn, message)
-end
-
-
-
-# Helper to display spec descriptions.
-description_builder = -> hash do
-  if g = hash[:example_group]
-    "#{description_builder.call(g)} #{hash[:description_args].first}"
-  else
-    hash[:description_args].first
-  end
-end
-
-stdout = Logger.new(STDOUT)
-
-RSpec.configure do |config|
-  config.around do |spec|
-    # Figure out which spec is about to run, for logging purposes.
-    data = example.metadata
-    desc = description_builder.call(data)
-    line = "rspec #{data[:file_path]}:#{data[:line_number]}"
-
-    # Optionally log to STDOUT which spec is about to run. This is noisy, but
-    # helpful in identifying hanging specs.
-    stdout.info "Running spec: #{desc} @ #{line}" if ENV['LOG_SPEC']
-
-    Que.adapter = QUE_ADAPTERS[:pg]
-
-    Que.worker_count = 0
-    Que.mode = :async
-    Que.wake_interval = nil
-
-    $logger.messages.clear
-
-    spec.run
-
-    Que.worker_count = 0
-    Que.mode = :off
-    Que.wake_interval = nil
-
-    DB[:que_jobs].delete
-
-    # A bit of lint: make sure that no advisory locks are left open.
-    unless DB[:pg_locks].where(:locktype => 'advisory').empty?
-      stdout.info "Advisory lock left open: #{desc} @ #{line}"
-    end
-  end
-end

data/spec/support/helpers.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-# Travis seems to freeze the VM the tests run in sometimes, so bump up the limit
-# when running in CI.
-QUE_SLEEP_UNTIL_TIMEOUT = ENV['CI'] ? 10 : 2
-
-# Helper for testing threaded code.
-def sleep_until(timeout = QUE_SLEEP_UNTIL_TIMEOUT)
-  deadline = Time.now + timeout
-  loop do
-    break if yield
-    if Time.now > deadline
-      puts "sleep_until timeout reached!"
-      raise "sleep_until timeout reached!"
-    end
-    sleep 0.01
-  end
-end
-
-def suppress_warnings
-  original_verbosity, $VERBOSE = $VERBOSE, nil
-  yield
-ensure
-  $VERBOSE = original_verbosity
-end

data/spec/support/jobs.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-# Common Job classes for use in specs.
-
-# Handy for blocking in the middle of processing a job.
-class BlockJob < Que::Job
-  def run
-    $q1.push nil
-    $q2.pop
-  end
-end
-
-RSpec.configure do |config|
-  config.before { $q1, $q2 = Queue.new, Queue.new }
-end
-
-
-
-class ErrorJob < Que::Job
-  def run
-    raise "ErrorJob!"
-  end
-end
-
-
-
-class ArgsJob < Que::Job
-  def run(*args)
-    $passed_args = args
-  end
-end
-
-RSpec.configure do |config|
-  config.before { $passed_args = nil }
-end

data/spec/support/shared_examples/adapter.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-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
-  end
-
-  it "should be able to cast boolean results properly" do
-    r = Que.execute("SELECT true AS true_value, false AS false_value")
-    r.should == [{'true_value' => true, 'false_value' => false}]
-  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.enqueue
-    result = Que::Job.work
-    result[:event].should == :job_worked
-    result[:job][:job_class].should == 'Que::Job'
-  end
-
-  it "should yield the same Postgres connection for the duration of the block" do
-    Que.adapter.checkout do |conn|
-      conn.should be_a PG::Connection
-      pid1 = Que.execute "SELECT pg_backend_pid()"
-      pid2 = Que.execute "SELECT pg_backend_pid()"
-      pid1.should == pid2
-    end
-  end
-
-  it "should allow nested checkouts" do
-    Que.adapter.checkout do |a|
-      Que.adapter.checkout do |b|
-        a.object_id.should == b.object_id
-      end
-    end
-  end
-end