ActiveJob Integration Tests

22 files changed, 627 insertions, 5 deletions

diff --git a/.travis.yml b/.travis.yml
index 6e43023365..985956363a 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -21,6 +21,7 @@ env:
     - "GEM=ar:mysql2"
     - "GEM=ar:sqlite3"
     - "GEM=ar:postgresql"
+    - "GEM=aj:integration"
 matrix:
   allow_failures:
     - rvm: 1.9.3
@@ -46,3 +47,8 @@ notifications:
 bundler_args: --path vendor/bundle --without test
 services:
   - memcached
+  - redis
+  - rabbitmq
+addons:
+  postgresql: "9.3"
+
diff --git a/Gemfile b/Gemfile
index 61711a2339..eb7bdc2bdb 100644
--- a/Gemfile
+++ b/Gemfile
@@ -45,12 +45,14 @@ group :job do
   gem 'sidekiq', require: false
   gem 'sucker_punch', require: false
   gem 'delayed_job', require: false
-  gem 'queue_classic', require: false, platforms: :ruby
+  gem 'queue_classic', "< 3.0.0", require: false, platforms: :ruby
   gem 'sneakers', '0.1.1.pre', require: false
   gem 'que', require: false
   gem 'backburner', require: false
   gem 'qu-rails', github: "bkeepers/qu", branch: "master", require: false
   gem 'qu-redis', require: false
+  gem 'delayed_job_active_record', require: false
+  gem 'sequel', require: false
 end
 
 # Add your own local bundler stuff
diff --git a/activejob/.gitignore b/activejob/.gitignore
new file mode 100644
index 0000000000..b3aaf55871
--- /dev/null
+++ b/activejob/.gitignore
@@ -0,0 +1 @@
+test/dummy
diff --git a/activejob/Rakefile b/activejob/Rakefile
index 484cd1d0b8..e918428459 100644
--- a/activejob/Rakefile
+++ b/activejob/Rakefile
@@ -34,6 +34,12 @@ namespace :test do
     tasks = ACTIVEJOB_ADAPTERS.map{|a| "isolated_test_#{a}" }
     run_without_aborting(*tasks)
   end
+
+  desc 'Run all adapter integration tests'
+  task :integration do
+    tasks = ACTIVEJOB_ADAPTERS.map{|a| "integration_test_#{a}" }
+    run_without_aborting(*tasks)
+  end
 end
 
 
@@ -53,6 +59,15 @@ ACTIVEJOB_ADAPTERS.each do |adapter|
         end or raise 'Failures'
       end
     end
+
+    namespace :integration do
+      Rake::TestTask.new(adapter => "#{adapter}:env") do |t|
+        t.description = ""
+        t.libs << 'test'
+        t.test_files = FileList['test/integration/**/*_test.rb']
+        t.verbose = true
+      end
+    end
   end
 
   namespace adapter do
@@ -60,6 +75,17 @@ ACTIVEJOB_ADAPTERS.each do |adapter|
     task isolated_test: "isolated_test_#{adapter}"
 
     task(:env) { ENV['AJADAPTER'] = adapter }
+
+    namespace :isolated do
+      task(:env) { ENV['AJADAPTER'] = adapter }
+    end
+
+    namespace :integration do
+      task(:env) do
+        ENV['AJADAPTER'] = adapter
+        ENV['AJ_INTEGRATION_TESTS'] = "1"
+      end
+    end
   end
 
 
@@ -67,7 +93,10 @@ ACTIVEJOB_ADAPTERS.each do |adapter|
   task "test_#{adapter}" => ["#{adapter}:env", "test:#{adapter}"]
 
   desc "Run #{adapter} tests in isolation"
-  task "isolated_test_#{adapter}" => ["#{adapter}:env", "test:isolated:#{adapter}"]
+  task "isolated_test_#{adapter}" => ["#{adapter}:isolated:env", "test:isolated:#{adapter}"]
+
+  desc "Run #{adapter} integration tests"
+  task "integration_test_#{adapter}" => ["#{adapter}:integration:env", "test:integration:#{adapter}"]
 end
 
 
diff --git a/activejob/lib/active_job/queue_adapters/sneakers_adapter.rb b/activejob/lib/active_job/queue_adapters/sneakers_adapter.rb
index 60633639f4..1ab0a87485 100644
--- a/activejob/lib/active_job/queue_adapters/sneakers_adapter.rb
+++ b/activejob/lib/active_job/queue_adapters/sneakers_adapter.rb
@@ -21,7 +21,7 @@ module ActiveJob
 
       class JobWrapper
         include Sneakers::Worker
-        from_queue 'active_jobs_default'
+        from_queue 'default'
 
         def work(msg)
           job_data = ActiveSupport::JSON.decode(msg)
diff --git a/activejob/test/helper.rb b/activejob/test/helper.rb
index 85094387ef..3386cef6f3 100644
--- a/activejob/test/helper.rb
+++ b/activejob/test/helper.rb
@@ -1,6 +1,7 @@
 require File.expand_path('../../../load_paths', __FILE__)
 
 require 'active_job'
+require 'support/job_buffer'
 
 GlobalID.app = 'aj'
 
@@ -17,8 +18,13 @@ end
 # Sidekiq doesn't work with MRI 1.9.3
 exit if sidekiq? && ruby_193?
 
-require "adapters/#{@adapter}"
+if ENV['AJ_INTEGRATION_TESTS']
+  require 'support/integration/helper'
+else
+  require "adapters/#{@adapter}"
+end
 
 require 'active_support/testing/autorun'
 
 ActiveJob::Base.logger.level = Logger::DEBUG
+
diff --git a/activejob/test/integration/queuing_test.rb b/activejob/test/integration/queuing_test.rb
new file mode 100644
index 0000000000..779dedb53f
--- /dev/null
+++ b/activejob/test/integration/queuing_test.rb
@@ -0,0 +1,46 @@
+require 'helper'
+require 'jobs/logging_job'
+require 'active_support/core_ext/numeric/time'
+
+class QueuingTest < ActiveSupport::TestCase
+  test 'should run jobs enqueued on a listenting queue' do
+    TestJob.perform_later @id
+    wait_for_jobs_to_finish_for(5.seconds)
+    assert job_executed
+  end
+
+  test 'should not run jobs queued on a non-listenting queue' do
+    begin
+      skip if adapter_is?(:inline) || adapter_is?(:sucker_punch)
+      old_queue = TestJob.queue_name
+      TestJob.queue_as :some_other_queue
+      TestJob.perform_later @id
+      wait_for_jobs_to_finish_for(2.seconds)
+      assert_not job_executed
+    ensure
+      TestJob.queue_name = old_queue
+    end
+  end
+
+  test 'should not run job enqueued in the future' do
+    begin
+      TestJob.set(wait: 10.minutes).perform_later @id
+      wait_for_jobs_to_finish_for(5.seconds)
+      assert_not job_executed
+    rescue NotImplementedError
+      skip
+    end
+  end
+
+  test 'should run job enqueued in the future at the specified time' do
+    begin
+      TestJob.set(wait: 3.seconds).perform_later @id
+      wait_for_jobs_to_finish_for(2.seconds)
+      assert_not job_executed
+      wait_for_jobs_to_finish_for(10.seconds)
+      assert job_executed
+    rescue NotImplementedError
+      skip
+    end
+  end
+end
diff --git a/activejob/test/support/integration/adapters/backburner.rb b/activejob/test/support/integration/adapters/backburner.rb
new file mode 100644
index 0000000000..0cda36a273
--- /dev/null
+++ b/activejob/test/support/integration/adapters/backburner.rb
@@ -0,0 +1,38 @@
+module BackburnerJobsManager
+  def setup
+    ActiveJob::Base.queue_adapter = :backburner
+    Backburner.configure do |config|
+      config.logger = Rails.logger
+    end
+    unless can_run?
+      puts "Cannot run integration tests for backburner. To be able to run integration tests for backburner you need to install and start beanstalkd.\n"
+      exit
+    end
+  end
+
+  def clear_jobs
+    tube.clear
+  end
+
+  def start_workers
+    @thread = Thread.new { Backburner.work "integration-tests" } # backburner dasherizes the queue name
+  end
+
+  def stop_workers
+    @thread.kill
+  end
+
+  def tube
+    @tube ||= Beaneater::Tube.new(Backburner::Worker.connection, "backburner.worker.queue.integration-tests") # backburner dasherizes the queue name
+  end
+
+  def can_run?
+    begin
+      Backburner::Worker.connection.send :connect!
+    rescue => e
+      return false
+    end
+    true
+  end
+end
+
diff --git a/activejob/test/support/integration/adapters/delayed_job.rb b/activejob/test/support/integration/adapters/delayed_job.rb
new file mode 100644
index 0000000000..dbd0d1a4db
--- /dev/null
+++ b/activejob/test/support/integration/adapters/delayed_job.rb
@@ -0,0 +1,20 @@
+require 'delayed_job'
+require 'delayed_job_active_record'
+
+module DelayedJobJobsManager
+  def setup
+    ActiveJob::Base.queue_adapter = :delayed_job
+  end
+  def clear_jobs
+    Delayed::Job.delete_all
+  end
+
+  def start_workers
+    @worker = Delayed::Worker.new(quiet: false, sleep_delay: 0.5, queues: %w(integration_tests))
+    @thread = Thread.new { @worker.start }
+  end
+
+  def stop_workers
+    @worker.stop
+  end
+end
diff --git a/activejob/test/support/integration/adapters/inline.rb b/activejob/test/support/integration/adapters/inline.rb
new file mode 100644
index 0000000000..83c38f706f
--- /dev/null
+++ b/activejob/test/support/integration/adapters/inline.rb
@@ -0,0 +1,15 @@
+module InlineJobsManager
+  def setup
+    ActiveJob::Base.queue_adapter = :inline
+  end
+
+  def clear_jobs
+  end
+
+  def start_workers
+  end
+
+  def stop_workers
+  end
+end
+
diff --git a/activejob/test/support/integration/adapters/qu.rb b/activejob/test/support/integration/adapters/qu.rb
new file mode 100644
index 0000000000..e913f04a24
--- /dev/null
+++ b/activejob/test/support/integration/adapters/qu.rb
@@ -0,0 +1,38 @@
+module QuJobsManager
+  def setup
+    require 'qu-rails'
+    require 'qu-redis'
+    ActiveJob::Base.queue_adapter = :qu
+    ENV['REDISTOGO_URL'] = "tcp://127.0.0.1:6379/12"
+    backend = Qu::Backend::Redis.new
+    backend.namespace = "active_jobs_int_test"
+    Qu.backend  = backend
+    Qu.logger   = Rails.logger
+    Qu.interval = 0.5
+    unless can_run?
+      puts "Cannot run integration tests for qu. To be able to run integration tests for qu you need to install and start redis.\n"
+      exit
+    end
+  end
+
+  def clear_jobs
+    Qu.clear "integration_tests"
+  end
+
+  def start_workers
+    @thread = Thread.new { Qu::Worker.new("integration_tests").start }
+  end
+
+  def stop_workers
+    @thread.kill
+  end
+
+  def can_run?
+    begin
+      Qu.backend.connection.client.connect
+    rescue => e
+      return false
+    end
+    true
+  end
+end
diff --git a/activejob/test/support/integration/adapters/que.rb b/activejob/test/support/integration/adapters/que.rb
new file mode 100644
index 0000000000..a5b9b3ec0a
--- /dev/null
+++ b/activejob/test/support/integration/adapters/que.rb
@@ -0,0 +1,37 @@
+module QueJobsManager
+  def setup
+    require 'sequel'
+    ActiveJob::Base.queue_adapter = :que
+    que_url = ENV['QUE_DATABASE_URL'] || 'postgres://localhost/active_jobs_que_int_test'
+    uri = URI.parse(que_url)
+    user = uri.user||ENV['USER']
+    pass = uri.password
+    db   = uri.path[1..-1]
+    %x{#{"PGPASSWORD=\"#{pass}\"" if pass} psql -c 'drop database "#{db}"' -U #{user} -t template1}
+    %x{#{"PGPASSWORD=\"#{pass}\"" if pass} psql -c 'create database "#{db}"' -U #{user} -t template1}
+    Que.connection = Sequel.connect(que_url)
+    Que.migrate!
+    Que.mode = :off
+    Que.worker_count = 1
+  rescue Sequel::DatabaseConnectionError
+    puts "Cannot run integration tests for que. To be able to run integration tests for que you need to install and start postgresql.\n"
+    exit
+  end
+
+  def clear_jobs
+    Que.clear!
+  end
+
+  def start_workers
+    @thread = Thread.new do
+      loop do
+        Que::Job.work("integration_tests")
+        sleep 0.5
+      end
+    end
+  end
+
+  def stop_workers
+    @thread.kill
+  end
+end
diff --git a/activejob/test/support/integration/adapters/queue_classic.rb b/activejob/test/support/integration/adapters/queue_classic.rb
new file mode 100644
index 0000000000..81d1935132
--- /dev/null
+++ b/activejob/test/support/integration/adapters/queue_classic.rb
@@ -0,0 +1,45 @@
+module QueueClassicJobsManager
+  def setup
+    ENV['QC_DATABASE_URL'] ||= 'postgres://localhost/active_jobs_qc_int_test'
+    ENV['QC_LISTEN_TIME']    = "0.5"
+    uri = URI.parse(ENV['QC_DATABASE_URL'])
+    user = uri.user||ENV['USER']
+    pass = uri.password
+    db   = uri.path[1..-1]
+    %x{#{"PGPASSWORD=\"#{pass}\"" if pass} psql -c 'drop database "#{db}"' -U #{user} -t template1}
+    %x{#{"PGPASSWORD=\"#{pass}\"" if pass} psql -c 'create database "#{db}"' -U #{user} -t template1}
+    ActiveJob::Base.queue_adapter = :queue_classic
+    QC::Setup.create
+  rescue PG::ConnectionBad
+    puts "Cannot run integration tests for queue_classic. To be able to run integration tests for queue_classic you need to install and start postgresql.\n"
+    exit
+  end
+
+  def clear_jobs
+    QC::Queue.new("integration_tests").delete_all
+    retried = false
+  rescue => e
+    puts "Got exception while trying to clear jobs: #{e.inspect}"
+    if retried
+      puts "Already retried. Raising exception"
+      raise e
+    else
+      puts "Retrying"
+      retried = true
+      QC::Conn.connection = QC::Conn.connect
+      retry
+    end
+  end
+
+  def start_workers
+    @pid = fork do
+      QC::Conn.connection = QC::Conn.connect
+      worker = QC::Worker.new(q_name: 'integration_tests')
+      worker.start
+    end
+  end
+
+  def stop_workers
+    Process.kill 'HUP', @pid
+  end
+end
diff --git a/activejob/test/support/integration/adapters/resque.rb b/activejob/test/support/integration/adapters/resque.rb
new file mode 100644
index 0000000000..03ffd3fd62
--- /dev/null
+++ b/activejob/test/support/integration/adapters/resque.rb
@@ -0,0 +1,47 @@
+module ResqueJobsManager
+  def setup
+    ActiveJob::Base.queue_adapter = :resque
+    Resque.redis = Redis::Namespace.new 'active_jobs_int_test', redis: Redis.connect(url: "tcp://127.0.0.1:6379/12", :thread_safe => true)
+    Resque.logger = Rails.logger
+    unless can_run?
+      puts "Cannot run integration tests for resque. To be able to run integration tests for resque you need to install and start redis.\n"
+      exit
+    end
+  end
+
+  def clear_jobs
+    Resque.queues.each { |queue_name| Resque.redis.del "queue:#{queue_name}" }
+    Resque.redis.keys("delayed:*").each  { |key| Resque.redis.del "#{key}" }
+    Resque.redis.del "delayed_queue_schedule"
+  end
+
+  def start_workers
+    @resque_thread = Thread.new do
+      Resque::Worker.new("integration_tests").work(0.5)
+    end
+    @scheduler_thread = Thread.new do
+      Resque::Scheduler.configure do |c|
+        c.poll_sleep_amount = 0.5
+        c.dynamic = true
+        c.verbose = true
+        c.logfile = nil
+      end
+      Resque::Scheduler.master_lock.release!
+      Resque::Scheduler.run
+    end
+  end
+
+  def stop_workers
+    @resque_thread.kill
+    @scheduler_thread.kill
+  end
+
+  def can_run?
+    begin
+      Resque.redis.client.connect
+    rescue => e
+      return false
+    end
+    true
+  end
+end
diff --git a/activejob/test/support/integration/adapters/sidekiq.rb b/activejob/test/support/integration/adapters/sidekiq.rb
new file mode 100644
index 0000000000..b3c3dcff22
--- /dev/null
+++ b/activejob/test/support/integration/adapters/sidekiq.rb
@@ -0,0 +1,58 @@
+require 'sidekiq/cli'
+require 'sidekiq/api'
+
+module SidekiqJobsManager
+
+  def setup
+    ActiveJob::Base.queue_adapter = :sidekiq
+    unless can_run?
+      puts "Cannot run integration tests for sidekiq. To be able to run integration tests for sidekiq you need to install and start redis.\n"
+      exit
+    end
+  end
+
+  def clear_jobs
+    Sidekiq::ScheduledSet.new.clear
+    Sidekiq::Queue.new("integration_tests").clear
+  end
+
+  def start_workers
+    fork do
+      sidekiq = Sidekiq::CLI.instance
+      logfile = Rails.root.join("log/sidekiq.log").to_s
+      pidfile = Rails.root.join("tmp/sidekiq.pid").to_s
+      sidekiq.parse([ "--require", Rails.root.to_s,
+                      "--queue",   "integration_tests",
+                      "--logfile", logfile,
+                      "--pidfile", pidfile,
+                      "--environment", "test",
+                      "--concurrency", "1",
+                      "--timeout", "1",
+                      "--daemon",
+                      "--verbose"
+                      ])
+      require 'celluloid'
+      require 'sidekiq/scheduled'
+      Sidekiq.poll_interval = 0.5
+      Sidekiq::Scheduled.const_set :INITIAL_WAIT, 1
+      sidekiq.run
+    end
+    sleep 1
+  end
+
+  def stop_workers
+    pidfile = Rails.root.join("tmp/sidekiq.pid").to_s
+    Process.kill 'TERM', File.open(pidfile).read.to_i
+    FileUtils.rm_f pidfile
+  rescue
+  end
+
+  def can_run?
+    begin
+      Sidekiq.redis { |conn| conn.connect }
+    rescue => e
+      return false
+    end
+    true
+  end
+end
diff --git a/activejob/test/support/integration/adapters/sneakers.rb b/activejob/test/support/integration/adapters/sneakers.rb
new file mode 100644
index 0000000000..f21bb38a32
--- /dev/null
+++ b/activejob/test/support/integration/adapters/sneakers.rb
@@ -0,0 +1,90 @@
+require 'sneakers/runner'
+require 'sneakers/publisher'
+require 'timeout'
+
+module Sneakers
+  class Publisher
+    def safe_ensure_connected
+      @mutex.synchronize do
+        ensure_connection! unless connected?
+      end
+    end
+  end
+end
+
+
+module SneakersJobsManager
+  def setup
+    ActiveJob::Base.queue_adapter = :sneakers
+    Sneakers.configure  :heartbeat => 2,
+                        :amqp => 'amqp://guest:guest@localhost:5672',
+                        :vhost => '/',
+                        :exchange => 'active_jobs_sneakers_int_test',
+                        :exchange_type => :direct,
+                        :daemonize => true,
+                        :threads => 1,
+                        :workers => 1,
+                        :pid_path => Rails.root.join("tmp/sneakers.pid").to_s,
+                        :log => Rails.root.join("log/sneakers.log").to_s
+    unless can_run?
+      puts "Cannot run integration tests for sneakers. To be able to run integration tests for sneakers you need to install and start rabbitmq.\n"
+      exit
+    end
+  end
+
+  def clear_jobs
+    bunny_queue.purge
+  end
+
+  def start_workers
+    @pid = fork do
+      queues = %w(integration_tests)
+      workers = queues.map do |q|
+        worker_klass = "ActiveJobWorker"+Digest::MD5.hexdigest(q)
+        Sneakers.const_set(worker_klass, Class.new(ActiveJob::QueueAdapters::SneakersAdapter::JobWrapper) do
+          from_queue q
+        end)
+      end
+      Sneakers::Runner.new(workers).run
+    end
+    begin
+      Timeout.timeout(10) do
+        while bunny_queue.status[:consumer_count] == 0
+          sleep 0.5
+        end
+      end
+    rescue Timeout::Error
+      stop_workers
+      raise "Failed to start sneakers worker"
+    end
+  end
+
+  def stop_workers
+    Process.kill 'TERM', @pid
+    Process.kill 'TERM', File.open(Rails.root.join("tmp/sneakers.pid").to_s).read.to_i
+  rescue
+  end
+
+  def can_run?
+    begin
+      bunny_publisher
+    rescue => e
+      return false
+    end
+    true
+  end
+
+  protected
+    def bunny_publisher
+      @bunny_publisher ||= begin
+        p = ActiveJob::QueueAdapters::SneakersAdapter::JobWrapper.send(:publisher)
+        p.safe_ensure_connected
+        p
+      end
+    end
+
+    def bunny_queue
+      @queue ||= bunny_publisher.exchange.channel.queue "integration_tests", durable: true
+    end
+
+end
diff --git a/activejob/test/support/integration/adapters/sucker_punch.rb b/activejob/test/support/integration/adapters/sucker_punch.rb
new file mode 100644
index 0000000000..691ba35c90
--- /dev/null
+++ b/activejob/test/support/integration/adapters/sucker_punch.rb
@@ -0,0 +1,5 @@
+module SuckerPunchJobsManager
+  def setup
+    ActiveJob::Base.queue_adapter = :sucker_punch
+  end
+end
diff --git a/activejob/test/support/integration/dummy_app_template.rb b/activejob/test/support/integration/dummy_app_template.rb
new file mode 100644
index 0000000000..28aae0f884
--- /dev/null
+++ b/activejob/test/support/integration/dummy_app_template.rb
@@ -0,0 +1,21 @@
+if ENV['AJADAPTER'] == 'delayed_job'
+  generate "delayed_job:active_record"
+  rake("db:migrate")
+end
+
+initializer 'activejob.rb', <<-CODE
+require "#{File.expand_path("../jobs_manager.rb",  __FILE__)}"
+JobsManager.current_manager.setup
+CODE
+
+file 'app/jobs/test_job.rb', <<-CODE
+class TestJob < ActiveJob::Base
+  queue_as :integration_tests
+
+  def perform(x)
+    File.open(Rails.root.join("tmp/\#{x}"), "w+") do |f|
+      f.write x
+    end
+  end
+end
+CODE
diff --git a/activejob/test/support/integration/helper.rb b/activejob/test/support/integration/helper.rb
new file mode 100644
index 0000000000..ccd5036b36
--- /dev/null
+++ b/activejob/test/support/integration/helper.rb
@@ -0,0 +1,32 @@
+puts "\n\n"
+puts "*** Running integration tests for #{ENV['AJADAPTER']} ***"
+puts "\n\n"
+
+ENV["RAILS_ENV"] = "test"
+ActiveJob::Base.queue_name_prefix = nil
+
+require 'rails/generators/rails/app/app_generator'
+
+dummy_app_path     = Dir.mktmpdir + "/dummy"
+dummy_app_template = File.expand_path("../dummy_app_template.rb",  __FILE__)
+args = Rails::Generators::ARGVScrubber.new(["new", dummy_app_path, "--skip-gemfile", "--skip-bundle",
+  "--skip-git", "--skip-spring", "-d", "sqlite3", "--skip-javascript", "--force", "--quite",
+  "--template", dummy_app_template]).prepare!
+Rails::Generators::AppGenerator.start args
+
+require "#{dummy_app_path}/config/environment.rb"
+
+ActiveRecord::Migrator.migrations_paths = [ Rails.root.join('db/migrate').to_s ]
+require 'rails/test_help'
+
+Rails.backtrace_cleaner.remove_silencers!
+
+require_relative 'test_case_helpers'
+ActiveSupport::TestCase.send(:include, TestCaseHelpers)
+
+JobsManager.current_manager.start_workers
+
+Minitest.after_run do
+  JobsManager.current_manager.stop_workers
+  JobsManager.current_manager.clear_jobs
+end
diff --git a/activejob/test/support/integration/jobs_manager.rb b/activejob/test/support/integration/jobs_manager.rb
new file mode 100644
index 0000000000..4df34aaeb1
--- /dev/null
+++ b/activejob/test/support/integration/jobs_manager.rb
@@ -0,0 +1,27 @@
+class JobsManager
+  @@managers = {}
+  attr :adapter_name
+
+  def self.current_manager
+    @@managers[ENV['AJADAPTER']] ||= new(ENV['AJADAPTER'])
+  end
+
+  def initialize(adapter_name)
+    @adapter_name = adapter_name
+    require_relative "adapters/#{adapter_name}"
+    extend "#{adapter_name.camelize}JobsManager".constantize
+  end
+
+  def setup
+    ActiveJob::Base.queue_adapter = nil
+  end
+
+  def clear_jobs
+  end
+
+  def start_workers
+  end
+
+  def stop_workers
+  end
+end
diff --git a/activejob/test/support/integration/test_case_helpers.rb b/activejob/test/support/integration/test_case_helpers.rb
new file mode 100644
index 0000000000..ee2f6aebea
--- /dev/null
+++ b/activejob/test/support/integration/test_case_helpers.rb
@@ -0,0 +1,48 @@
+require 'active_support/concern'
+require 'support/integration/jobs_manager'
+
+module TestCaseHelpers
+  extend ActiveSupport::Concern
+
+  included do
+    self.use_transactional_fixtures = false
+
+    setup do
+      clear_jobs
+      @id = "AJ-#{SecureRandom.uuid}"
+    end
+
+    teardown do
+      clear_jobs
+    end
+  end
+
+  protected
+
+    def jobs_manager
+      JobsManager.current_manager
+    end
+
+    def clear_jobs
+      jobs_manager.clear_jobs
+    end
+
+    def adapter_is?(adapter)
+      ActiveJob::Base.queue_adapter.name.split("::").last.gsub(/Adapter$/, '').underscore==adapter.to_s
+    end
+
+    def wait_for_jobs_to_finish_for(seconds=60)
+      begin
+        Timeout.timeout(seconds) do
+          while !job_executed do
+            sleep 0.25
+          end
+        end
+      rescue Timeout::Error
+      end
+    end
+
+    def job_executed
+      Dummy::Application.root.join("tmp/#{@id}").exist?
+    end
+end
diff --git a/ci/travis.rb b/ci/travis.rb
index db6e41ecfa..3ccbd1dad4 100755
--- a/ci/travis.rb
+++ b/ci/travis.rb
@@ -48,6 +48,7 @@ class Build
     heading = [gem]
     heading << "with #{adapter}" if activerecord?
     heading << "in isolation" if isolated?
+    heading << "integration" if integration?
     heading.join(' ')
   end
 
@@ -55,7 +56,7 @@ class Build
     if activerecord?
       ['db:mysql:rebuild', "#{adapter}:#{'isolated_' if isolated?}test"]
     else
-      ["test#{':isolated' if isolated?}"]
+      ["test", ('isolated' if isolated?), ('integration' if integration?)].compact.join(":")
     end
   end
 
@@ -74,6 +75,10 @@ class Build
     options[:isolated]
   end
 
+  def integration?
+    component.split(':').last == 'integration'
+  end
+
   def gem
     MAP[component.split(':').first]
   end
@@ -93,11 +98,17 @@ class Build
   end
 end
 
+if ENV['GEM']=='aj:integration'
+   ENV['QC_DATABASE_URL']  = 'postgres://postgres@localhost/active_jobs_qc_int_test'
+   ENV['QUE_DATABASE_URL'] = 'postgres://postgres@localhost/active_jobs_que_int_test'
+end
+
 results = {}
 
 ENV['GEM'].split(',').each do |gem|
   [false, true].each do |isolated|
     next if gem == 'railties' && isolated
+    next if gem == 'aj:integration' && isolated
 
     build = Build.new(gem, :isolated => isolated)
     results[build.key] = build.run!