queue_classic 3.2.0.RC1 → 4.0.0

data/lib/queue_classic/queue.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'conn_adapter'
 require 'json'
 require 'time'
@@ -5,8 +7,8 @@ require 'time'
 module QC
   # The queue class maps a queue abstraction onto a database table.
   class Queue
-
     attr_reader :name, :top_bound
+
     def initialize(name, top_bound=nil)
       @name = name
       @top_bound = top_bound || QC.top_bound
@@ -38,7 +40,16 @@ module QC
     def enqueue(method, *args)
       QC.log_yield(:measure => 'queue.enqueue') do
         s = "INSERT INTO #{QC.table_name} (q_name, method, args) VALUES ($1, $2, $3) RETURNING id"
-        conn_adapter.execute(s, name, method, JSON.dump(args))
+        begin
+          retries ||= 0
+          conn_adapter.execute(s, name, method, JSON.dump(args))
+        rescue PG::Error
+          if (retries += 1) < 2
+            retry
+          else
+            raise
+          end
+        end
       end
     end
 
@@ -64,21 +75,49 @@ module QC
         s = "INSERT INTO #{QC.table_name} (q_name, method, args, scheduled_at)
              VALUES ($1, $2, $3, now() + interval '#{seconds.to_i} seconds')
              RETURNING id"
-        conn_adapter.execute(s, name, method, JSON.dump(args))
+        begin
+          retries ||= 0
+          conn_adapter.execute(s, name, method, JSON.dump(args))
+        rescue PG::Error
+          if (retries += 1) < 2
+            retry
+          else
+            raise
+          end
+        end
       end
     end
 
     def lock
       QC.log_yield(:measure => 'queue.lock') do
-        s = "SELECT * FROM lock_head($1, $2)"
-        if r = conn_adapter.execute(s, name, top_bound)
+        s = <<~SQL
+          WITH selected_job AS (
+            SELECT id
+            FROM queue_classic_jobs
+            WHERE
+              locked_at IS NULL AND
+              q_name = $1 AND
+              scheduled_at <= now()
+            LIMIT 1
+            FOR NO KEY UPDATE SKIP LOCKED
+          )
+          UPDATE queue_classic_jobs
+          SET
+            locked_at = now(),
+            locked_by = pg_backend_pid()
+          FROM selected_job
+          WHERE queue_classic_jobs.id = selected_job.id
+          RETURNING *
+        SQL
+
+        if r = conn_adapter.execute(s, name)
           {}.tap do |job|
             job[:id] = r["id"]
             job[:q_name] = r["q_name"]
             job[:method] = r["method"]
             job[:args] = JSON.parse(r["args"])
             if r["scheduled_at"]
-              job[:scheduled_at] = Time.parse(r["scheduled_at"])
+              job[:scheduled_at] = r["scheduled_at"].kind_of?(Time) ? r["scheduled_at"] : Time.parse(r["scheduled_at"])
               ttl = Integer((Time.now - job[:scheduled_at]) * 1000)
               QC.measure("time-to-lock=#{ttl}ms source=#{name}")
             end
@@ -89,14 +128,14 @@ module QC
 
     def unlock(id)
       QC.log_yield(:measure => 'queue.unlock') do
-        s = "UPDATE #{QC.table_name} set locked_at = null where id = $1"
+        s = "UPDATE #{QC.table_name} SET locked_at = NULL WHERE id = $1"
         conn_adapter.execute(s, id)
       end
     end
 
     def delete(id)
       QC.log_yield(:measure => 'queue.delete') do
-        conn_adapter.execute("DELETE FROM #{QC.table_name} where id = $1", id)
+        conn_adapter.execute("DELETE FROM #{QC.table_name} WHERE id = $1", id)
       end
     end
 
@@ -107,13 +146,28 @@ module QC
       end
     end
 
+    # Count the number of jobs in a specific queue. This returns all
+    # jobs, including ones that are scheduled in the future.
     def count
-      QC.log_yield(:measure => 'queue.count') do
-        s = "SELECT COUNT(*) FROM #{QC.table_name} WHERE q_name = $1"
-        r = conn_adapter.execute(s, name)
+      _count('queue.count', "SELECT COUNT(*) FROM #{QC.table_name} WHERE q_name = $1")
+    end
+
+    # Count the number of jobs in a specific queue, except ones scheduled in the future
+    def count_ready
+      _count('queue.count_scheduled', "SELECT COUNT(*) FROM #{QC.table_name} WHERE q_name = $1 AND scheduled_at <= now()")
+    end
+
+    # Count the number of jobs in a specific queue scheduled in the future
+    def count_scheduled
+      _count('queue.count_scheduled', "SELECT COUNT(*) FROM #{QC.table_name} WHERE q_name = $1 AND scheduled_at > now()")
+    end
+
+    private
+    def _count(metric_name, sql)
+      QC.log_yield(measure: metric_name) do
+        r = conn_adapter.execute(sql, name)
         r["count"].to_i
       end
     end
-
   end
 end

data/lib/queue_classic/railtie.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rails/railtie'
 
 module QC

data/lib/queue_classic/setup.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module QC
   module Setup
     Root = File.expand_path("../..", File.dirname(__FILE__))
@@ -8,51 +10,66 @@ module QC
     DowngradeFrom_3_0_0 = File.join(Root, "/sql/downgrade_from_3_0_0.sql")
     UpgradeTo_3_1_0 = File.join(Root, "/sql/update_to_3_1_0.sql")
     DowngradeFrom_3_1_0 = File.join(Root, "/sql/downgrade_from_3_1_0.sql")
+    UpgradeTo_4_0_0 = File.join(Root, "/sql/update_to_4_0_0.sql")
+    DowngradeFrom_4_0_0 = File.join(Root, "/sql/downgrade_from_4_0_0.sql")
 
     def self.create(c = QC::default_conn_adapter.connection)
-      conn = QC::ConnAdapter.new(c)
+      conn = QC::ConnAdapter.new(connection: c)
       conn.execute(File.read(CreateTable))
       conn.execute(File.read(SqlFunctions))
       conn.disconnect if c.nil? #Don't close a conn we didn't create.
     end
 
     def self.drop(c = QC::default_conn_adapter.connection)
-      conn = QC::ConnAdapter.new(c)
+      conn = QC::ConnAdapter.new(connection: c)
       conn.execute("DROP TABLE IF EXISTS queue_classic_jobs CASCADE")
       conn.execute(File.read(DropSqlFunctions))
       conn.disconnect if c.nil? #Don't close a conn we didn't create.
     end
 
     def self.update(c = QC::default_conn_adapter.connection)
-      conn = QC::ConnAdapter.new(c)
+      conn = QC::ConnAdapter.new(connection: c)
       conn.execute(File.read(UpgradeTo_3_0_0))
       conn.execute(File.read(UpgradeTo_3_1_0))
+      conn.execute(File.read(UpgradeTo_4_0_0))
       conn.execute(File.read(DropSqlFunctions))
       conn.execute(File.read(SqlFunctions))
     end
 
     def self.update_to_3_0_0(c = QC::default_conn_adapter.connection)
-      conn = QC::ConnAdapter.new(c)
+      conn = QC::ConnAdapter.new(connection: c)
       conn.execute(File.read(UpgradeTo_3_0_0))
       conn.execute(File.read(DropSqlFunctions))
       conn.execute(File.read(SqlFunctions))
     end
 
     def self.downgrade_from_3_0_0(c = QC::default_conn_adapter.connection)
-      conn = QC::ConnAdapter.new(c)
+      conn = QC::ConnAdapter.new(connection: c)
       conn.execute(File.read(DowngradeFrom_3_0_0))
     end
 
     def self.update_to_3_1_0(c = QC::default_conn_adapter.connection)
-      conn = QC::ConnAdapter.new(c)
+      conn = QC::ConnAdapter.new(connection: c)
       conn.execute(File.read(UpgradeTo_3_1_0))
       conn.execute(File.read(DropSqlFunctions))
       conn.execute(File.read(SqlFunctions))
     end
 
     def self.downgrade_from_3_1_0(c = QC::default_conn_adapter.connection)
-      conn = QC::ConnAdapter.new(c)
+      conn = QC::ConnAdapter.new(connection: c)
       conn.execute(File.read(DowngradeFrom_3_1_0))
     end
+
+    def self.update_to_4_0_0(c = QC::default_conn_adapter.connection)
+      conn = QC::ConnAdapter.new(connection: c)
+      conn.execute(File.read(UpgradeTo_4_0_0))
+      conn.execute(File.read(DropSqlFunctions))
+      conn.execute(File.read(SqlFunctions))
+    end
+
+    def self.downgrade_from_4_0_0(c = QC::default_conn_adapter.connection)
+      conn = QC::ConnAdapter.new(connection: c)
+      conn.execute(File.read(DowngradeFrom_4_0_0))
+    end
   end
 end

data/lib/queue_classic/tasks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 task :environment
 
 namespace :jobs do
@@ -11,11 +13,8 @@ namespace :qc do
     @worker = QC.default_worker_class.new
 
     trap('INT') do
-      $stderr.puts("Received INT. Shutting down.")
-      if !@worker.running
-        $stderr.puts("Worker has stopped running. Exit.")
-        exit(1)
-      end
+      $stderr.puts("Received INT. Shutting down.")      
+      abort("Worker has stopped running. Exit.") unless @worker.running
       @worker.stop
     end
 

data/lib/queue_classic/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module QC
-  VERSION = "3.2.0.RC1"
+  VERSION = "4.0.0"
 end

data/lib/queue_classic/worker.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -*- coding: utf-8 -*-
 require_relative 'queue'
 require_relative 'conn_adapter'
@@ -12,7 +14,7 @@ module QC
     # This method takes a single hash argument. The following keys are read:
     # fork_worker:: Worker forks each job execution.
     # wait_interval:: Time to wait between failed lock attempts
-    # connection:: PGConn object.
+    # connection:: PG::Connection object.
     # q_name:: Name of a single queue to process.
     # q_names:: Names of queues to process. Will process left to right.
     # top_bound:: Offset to the head of the queue. 1 == strict FIFO.
@@ -21,7 +23,7 @@ module QC
       @wait_interval = args[:wait_interval] || QC.wait_time
 
       if args[:connection]
-        @conn_adapter = ConnAdapter.new(args[:connection])
+        @conn_adapter = ConnAdapter.new(connection: args[:connection])
       else
         @conn_adapter = QC.default_conn_adapter
       end
@@ -109,10 +111,13 @@ module QC
       finished = false
       begin
         call(job).tap do
-          queue.delete(job[:id])
+          handle_success(queue, job)
           finished = true
         end
-      rescue => e
+      rescue StandardError, ScriptError, NoMemoryError => e
+        # We really only want to unlock the job for signal and system exit
+        # exceptions. If we encounter a ScriptError or a NoMemoryError any
+        # future run will likely encounter the same error.
         handle_failure(job, e)
         finished = true
       ensure
@@ -134,8 +139,12 @@ module QC
       receiver.send(message, *args)
     end
 
-    # This method will be called when an exception
-    # is raised during the execution of the job.
+    def handle_success(queue, job)
+      queue.delete(job[:id])
+    end
+
+    # This method will be called when a StandardError, ScriptError or
+    # NoMemoryError is raised during the execution of the job.
     def handle_failure(job,e)
       $stderr.puts("count#qc.job-error=1 job=#{job} error=#{e.inspect} at=#{e.backtrace.first}")
     end

data/lib/queue_classic.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "queue_classic/config"
 
 module QC
@@ -49,15 +51,7 @@ Please use the method QC.#{config_method} instead.
   end
 
   def self.default_conn_adapter
-    t = Thread.current
-    return t[:qc_conn_adapter] if t[:qc_conn_adapter]
-    adapter = if rails_connection_sharing_enabled?
-      ConnAdapter.new(ActiveRecord::Base.connection.raw_connection)
-    else
-      ConnAdapter.new
-    end
-
-    t[:qc_conn_adapter] = adapter
+    Thread.current[:qc_conn_adapter] ||= ConnAdapter.new(active_record_connection_share: rails_connection_sharing_enabled?)
   end
 
   def self.default_conn_adapter=(conn)
@@ -100,8 +94,7 @@ Please use the method QC.#{config_method} instead.
   # This will unlock all jobs any postgres' PID that is not existing anymore
   # to prevent any infinitely locked jobs
   def self.unlock_jobs_of_dead_workers
-    pid_column = default_conn_adapter.server_version < 90200 ? "procpid" : "pid"
-    default_conn_adapter.execute("UPDATE #{QC.table_name} SET locked_at = NULL, locked_by = NULL WHERE locked_by NOT IN (SELECT #{pid_column} FROM pg_stat_activity);")
+    default_conn_adapter.execute("UPDATE #{QC.table_name} SET locked_at = NULL, locked_by = NULL WHERE locked_by NOT IN (SELECT pid FROM pg_stat_activity);")
   end
 
   # private class methods

data/queue_classic.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.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."
   spec.summary       = "Simple, efficient worker queue for Ruby & PostgreSQL."
   spec.authors       = ["Ryan Smith (♠ ace hacker)"]
-  spec.homepage      = "http://github.com/QueueClassic/queue_classic"
+  spec.homepage      = "https://github.com/QueueClassic/queue_classic"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0")
@@ -20,5 +20,6 @@ Gem::Specification.new do |spec|
 
   spec.require_paths = %w[lib]
 
-  spec.add_dependency "pg", ">= 0.17", "< 0.19"
+  spec.add_dependency "pg", ">= 1.1", "< 2.0"
+  spec.add_development_dependency "activerecord", ">= 5.0.0", "< 6.1"
 end

data/sql/create_table.sql

@@ -1,26 +1,17 @@
-do $$ begin
+DO $$ BEGIN
 
 CREATE TABLE queue_classic_jobs (
   id bigserial PRIMARY KEY,
-  q_name text not null check (length(q_name) > 0),
-  method text not null check (length(method) > 0),
-  args   text not null,
+  q_name text NOT NULL CHECK (length(q_name) > 0),
+  method text NOT NULL CHECK (length(method) > 0),
+  args   jsonb NOT NULL,
   locked_at timestamptz,
   locked_by integer,
-  created_at timestamptz default now(),
-  scheduled_at timestamptz default now()
+  created_at timestamptz DEFAULT now(),
+  scheduled_at timestamptz DEFAULT now()
 );
 
--- If jsonb type is available, use it for the args column
-if exists (select 1 from pg_type where typname = 'jsonb') then
-  alter table queue_classic_jobs alter column args type jsonb using args::jsonb;
--- Otherwise, use json type for the args column if available
-elsif exists (select 1 from pg_type where typname = 'json') then
-  alter table queue_classic_jobs alter column args type json using args::json;
-end if;
-
-end $$ language plpgsql;
+END $$ LANGUAGE plpgsql;
 
 CREATE INDEX idx_qc_on_name_only_unlocked ON queue_classic_jobs (q_name, id) WHERE locked_at IS NULL;
 CREATE INDEX idx_qc_on_scheduled_at_only_unlocked ON queue_classic_jobs (scheduled_at, id) WHERE locked_at IS NULL;
-

data/sql/ddl.sql

@@ -1,84 +1,8 @@
--- We are declaring the return type to be queue_classic_jobs.
--- This is ok since I am assuming that all of the users added queues will
--- have identical columns to queue_classic_jobs.
--- When QC supports queues with columns other than the default, we will have to change this.
-
-CREATE OR REPLACE FUNCTION lock_head(q_name varchar, top_boundary integer)
-RETURNS SETOF queue_classic_jobs AS $$
-DECLARE
-  unlocked bigint;
-  relative_top integer;
-  job_count integer;
-BEGIN
-  -- The purpose is to release contention for the first spot in the table.
-  -- The select count(*) is going to slow down dequeue performance but allow
-  -- for more workers. Would love to see some optimization here...
-
-  EXECUTE 'SELECT count(*) FROM '
-    || '(SELECT * FROM queue_classic_jobs '
-    || ' WHERE locked_at IS NULL'
-    || ' AND q_name = '
-    || quote_literal(q_name)
-    || ' AND scheduled_at <= '
-    || quote_literal(now())
-    || ' LIMIT '
-    || quote_literal(top_boundary)
-    || ') limited'
-  INTO job_count;
-
-  SELECT TRUNC(random() * (top_boundary - 1))
-  INTO relative_top;
-
-  IF job_count < top_boundary THEN
-    relative_top = 0;
-  END IF;
-
-  LOOP
-    BEGIN
-      EXECUTE 'SELECT id FROM queue_classic_jobs '
-        || ' WHERE locked_at IS NULL'
-        || ' AND q_name = '
-        || quote_literal(q_name)
-        || ' AND scheduled_at <= '
-        || quote_literal(now())
-        || ' ORDER BY id ASC'
-        || ' LIMIT 1'
-        || ' OFFSET ' || quote_literal(relative_top)
-        || ' FOR UPDATE NOWAIT'
-      INTO unlocked;
-      EXIT;
-    EXCEPTION
-      WHEN lock_not_available THEN
-        -- do nothing. loop again and hope we get a lock
-    END;
-  END LOOP;
-
-  RETURN QUERY EXECUTE 'UPDATE queue_classic_jobs '
-    || ' SET locked_at = (CURRENT_TIMESTAMP),'
-    || ' locked_by = (select pg_backend_pid())'
-    || ' WHERE id = $1'
-    || ' AND locked_at is NULL'
-    || ' RETURNING *'
-  USING unlocked;
-
-  RETURN;
-END;
-$$ LANGUAGE plpgsql;
-
-CREATE OR REPLACE FUNCTION lock_head(tname varchar)
-RETURNS SETOF queue_classic_jobs AS $$
-BEGIN
-  RETURN QUERY EXECUTE 'SELECT * FROM lock_head($1,10)' USING tname;
-END;
-$$ LANGUAGE plpgsql;
-
 -- queue_classic_notify function and trigger
-create function queue_classic_notify() returns trigger as $$ begin
-  perform pg_notify(new.q_name, '');
-  return null;
-end $$ language plpgsql;
+CREATE FUNCTION queue_classic_notify() RETURNS TRIGGER AS $$ BEGIN
+  perform pg_notify(new.q_name, ''); RETURN NULL;
+END $$ LANGUAGE plpgsql;
 
-create trigger queue_classic_notify
-after insert on queue_classic_jobs
-for each row
-execute procedure queue_classic_notify();
+CREATE TRIGGER queue_classic_notify
+AFTER INSERT ON queue_classic_jobs FOR EACH ROW
+EXECUTE PROCEDURE queue_classic_notify();

data/sql/downgrade_from_4_0_0.sql

@@ -0,0 +1,88 @@
+DO $$DECLARE r record;
+BEGIN
+  -- If jsonb type is available, do nothing as we're downgrading from 4.0.0
+  IF EXISTS (SELECT 1 FROM pg_type WHERE typname = 'jsonb') THEN
+   -- do nothing - it should already be already jsonb
+  -- Otherwise, use json type for the args column if available
+  ELSIF EXISTS (SELECT 1 FROM pg_type WHERE typname = 'json') THEN
+    -- this should only happen if someone downgrades QC and their database < pg 9.4
+    ALTER TABLE queue_classic_jobs ALTER COLUMN args TYPE json USING args::json;
+  END IF;
+
+
+END$$;
+
+
+--
+-- Re install the lock_head function
+--
+
+-- We are declaring the return type to be queue_classic_jobs.
+-- This is ok since I am assuming that all of the users added queues will
+-- have identical columns to queue_classic_jobs.
+-- When QC supports queues with columns other than the default, we will have to change this.
+
+CREATE OR REPLACE FUNCTION lock_head(q_name varchar, top_boundary integer)
+RETURNS SETOF queue_classic_jobs AS $$
+DECLARE
+  unlocked bigint;
+  relative_top integer;
+  job_count integer;
+BEGIN
+  -- The purpose is to release contention for the first spot in the table.
+  -- The select count(*) is going to slow down dequeue performance but allow
+  -- for more workers. Would love to see some optimization here...
+
+  EXECUTE 'SELECT count(*) FROM '
+    || '(SELECT * FROM queue_classic_jobs '
+    || ' WHERE locked_at IS NULL'
+    || ' AND q_name = '
+    || quote_literal(q_name)
+    || ' AND scheduled_at <= '
+    || quote_literal(now())
+    || ' LIMIT '
+    || quote_literal(top_boundary)
+    || ') limited'
+  INTO job_count;
+
+  SELECT TRUNC(random() * (top_boundary - 1))
+  INTO relative_top;
+
+  IF job_count < top_boundary THEN
+    relative_top = 0;
+  END IF;
+
+  LOOP
+    BEGIN
+      EXECUTE 'SELECT id FROM queue_classic_jobs '
+        || ' WHERE locked_at IS NULL'
+        || ' AND q_name = '
+        || quote_literal(q_name)
+        || ' AND scheduled_at <= '
+        || quote_literal(now())
+        || ' ORDER BY id ASC'
+        || ' LIMIT 1'
+        || ' OFFSET ' || quote_literal(relative_top)
+        || ' FOR UPDATE NOWAIT'
+      INTO unlocked;
+      EXIT;
+    EXCEPTION
+      WHEN lock_not_available THEN
+        -- do nothing. loop again and hope we get a lock
+    END;
+  END LOOP;
+
+  RETURN QUERY EXECUTE 'UPDATE queue_classic_jobs '
+    || ' SET locked_at = (CURRENT_TIMESTAMP),'
+    || ' locked_by = (select pg_backend_pid())'
+    || ' WHERE id = $1'
+    || ' AND locked_at is NULL'
+    || ' RETURNING *'
+  USING unlocked;
+
+  RETURN;
+END $$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE FUNCTION lock_head(tname varchar) RETURNS SETOF queue_classic_jobs AS $$ BEGIN
+  RETURN QUERY EXECUTE 'SELECT * FROM lock_head($1,10)' USING tname;
+END $$ LANGUAGE plpgsql;

data/sql/update_to_3_0_0.sql

@@ -1,10 +1,10 @@
 DO $$DECLARE r record;
 BEGIN
-	BEGIN
-		ALTER TABLE queue_classic_jobs ADD COLUMN created_at timestamptz default now();
-	EXCEPTION
-		WHEN duplicate_column THEN RAISE NOTICE 'column created_at already exists in queue_classic_jobs.';
-	END;
+  BEGIN
+    ALTER TABLE queue_classic_jobs ADD COLUMN created_at timestamptz DEFAULT now();
+  EXCEPTION
+    WHEN duplicate_column THEN RAISE NOTICE 'column created_at already exists in queue_classic_jobs.';
+  END;
 END$$;
 
 DO $$DECLARE r record;

data/sql/update_to_3_1_0.sql

@@ -1,9 +1,9 @@
 DO $$DECLARE r record;
 BEGIN
-	BEGIN
-		ALTER TABLE queue_classic_jobs ADD COLUMN scheduled_at timestamptz default now();
-		CREATE INDEX idx_qc_on_scheduled_at_only_unlocked ON queue_classic_jobs (scheduled_at, id) WHERE locked_at IS NULL;
-	EXCEPTION
-		WHEN duplicate_column THEN RAISE NOTICE 'column scheduled_at already exists in queue_classic_jobs.';
-	END;
+  BEGIN
+    ALTER TABLE queue_classic_jobs ADD COLUMN scheduled_at timestamptz DEFAULT now();
+    CREATE INDEX idx_qc_on_scheduled_at_only_unlocked ON queue_classic_jobs (scheduled_at, id) WHERE locked_at IS NULL;
+  EXCEPTION
+    WHEN duplicate_column THEN RAISE NOTICE 'column scheduled_at already exists in queue_classic_jobs.';
+  END;
 END$$;

data/sql/update_to_4_0_0.sql

@@ -0,0 +1,6 @@
+DO $$DECLARE r record;
+BEGIN
+  ALTER TABLE queue_classic_jobs ALTER COLUMN args TYPE jsonb USING args::jsonb;
+  DROP FUNCTION IF EXISTS lock_head(tname varchar);
+  DROP FUNCTION IF EXISTS lock_head(q_name varchar, top_boundary integer);
+END$$;

data/test/benchmark_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'helper'
 
 if ENV["QC_BENCHMARK"]

data/test/config_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'helper'
 
 class ConfigTest < QCTest

data/test/helper.rb

@@ -1,6 +1,16 @@
+# frozen_string_literal: true
+
 require "bundler"
+require "minitest/reporters"
+
 Bundler.setup :default, :test
 
+if ENV['CIRCLECI'] == "true"
+  Minitest::Reporters.use! Minitest::Reporters::JUnitReporter.new
+else
+  Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+end
+
 ENV["DATABASE_URL"] ||= "postgres:///queue_classic_test"
 
 require_relative '../lib/queue_classic'
@@ -58,4 +68,28 @@ class QCTest < Minitest::Test
   ensure
     original_environment.each { |name, value| ENV[name] = value }
   end
+
+  def stub_any_instance(class_name, method_name, definition)
+    new_method_name = "new_#{method_name}"
+    original_method_name = "original_#{method_name}"
+
+    method_present = class_name.instance_methods(false).include? method_name
+
+    if method_present
+      class_name.send(:alias_method, original_method_name, method_name)
+      class_name.send(:define_method, new_method_name, definition)
+      class_name.send(:alias_method, method_name, new_method_name)
+
+      yield
+    else
+      message = "#{class_name} does not have method #{method_name}."
+      message << "\nAvailable methods: #{class_name.instance_methods(false)}"
+      raise ArgumentError.new message
+    end
+  ensure
+    if method_present
+      class_name.send(:alias_method, method_name, original_method_name)
+      class_name.send(:undef_method, new_method_name)
+    end
+  end
 end