activejob_backport 0.0.1

data/lib/active_job/queue_adapters/resque_adapter.rb

@@ -0,0 +1,41 @@
+require 'resque'
+require 'active_support/core_ext/enumerable'
+require 'active_support/core_ext/array/access'
+
+begin
+  require 'resque-scheduler'
+rescue LoadError
+  begin
+    require 'resque_scheduler'
+  rescue LoadError
+    false
+  end
+end
+
+module ActiveJob
+  module QueueAdapters
+    class ResqueAdapter
+      class << self
+        def enqueue(job)
+          Resque.enqueue_to job.queue_name, JobWrapper, job.serialize
+        end
+
+        def enqueue_at(job, timestamp)
+          unless Resque.respond_to?(:enqueue_at_with_queue)
+            raise NotImplementedError, "To be able to schedule jobs with Resque you need the " \
+              "resque-scheduler gem. Please add it to your Gemfile and run bundle install"
+          end
+          Resque.enqueue_at_with_queue job.queue_name, timestamp, JobWrapper, job.serialize
+        end
+      end
+
+      class JobWrapper
+        class << self
+          def perform(job_data)
+            Base.execute job_data
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_job/queue_adapters/sidekiq_adapter.rb

@@ -0,0 +1,35 @@
+require 'sidekiq'
+
+module ActiveJob
+  module QueueAdapters
+    class SidekiqAdapter
+      class << self
+        def enqueue(job)
+          #Sidekiq::Client does not support symbols as keys
+          Sidekiq::Client.push \
+            'class' => JobWrapper,
+            'queue' => job.queue_name,
+            'args'  => [ job.serialize ],
+            'retry' => true
+        end
+
+        def enqueue_at(job, timestamp)
+          Sidekiq::Client.push \
+            'class' => JobWrapper,
+            'queue' => job.queue_name,
+            'args'  => [ job.serialize ],
+            'retry' => true,
+            'at'    => timestamp
+        end
+      end
+
+      class JobWrapper
+        include Sidekiq::Worker
+
+        def perform(job_data)
+          Base.execute job_data
+        end
+      end
+    end
+  end
+end

data/lib/active_job/queue_adapters/sneakers_adapter.rb

@@ -0,0 +1,34 @@
+require 'sneakers'
+require 'thread'
+
+module ActiveJob
+  module QueueAdapters
+    class SneakersAdapter
+      @monitor = Monitor.new
+
+      class << self
+        def enqueue(job)
+          @monitor.synchronize do
+            JobWrapper.from_queue job.queue_name
+            JobWrapper.enqueue ActiveSupport::JSON.encode(job.serialize)
+          end
+        end
+
+        def enqueue_at(job, timestamp)
+          raise NotImplementedError
+        end
+      end
+
+      class JobWrapper
+        include Sneakers::Worker
+        from_queue 'default'
+
+        def work(msg)
+          job_data = ActiveSupport::JSON.decode(msg)
+          Base.execute job_data
+          ack!
+        end
+      end
+    end
+  end
+end

data/lib/active_job/queue_adapters/sucker_punch_adapter.rb

@@ -0,0 +1,25 @@
+require 'sucker_punch'
+
+module ActiveJob
+  module QueueAdapters
+    class SuckerPunchAdapter
+      class << self
+        def enqueue(job)
+          JobWrapper.new.async.perform job.serialize
+        end
+
+        def enqueue_at(job, timestamp)
+          raise NotImplementedError
+        end
+      end
+
+      class JobWrapper
+        include SuckerPunch::Job
+
+        def perform(job_data)
+          Base.execute job_data
+        end
+      end
+    end
+  end
+end

data/lib/active_job/queue_adapters/test_adapter.rb

@@ -0,0 +1,37 @@
+module ActiveJob
+  module QueueAdapters
+    class TestAdapter
+      delegate :name, to: :class
+      attr_accessor(:perform_enqueued_jobs, :perform_enqueued_at_jobs)
+      attr_writer(:enqueued_jobs, :performed_jobs)
+
+      # Provides a store of all the enqueued jobs with the TestAdapter so you can check them.
+      def enqueued_jobs
+        @enqueued_jobs ||= []
+      end
+
+      # Provides a store of all the performed jobs with the TestAdapter so you can check them.
+      def performed_jobs
+        @performed_jobs ||= []
+      end
+
+      def enqueue(job)
+        if perform_enqueued_jobs
+          performed_jobs << {job: job.class, args: job.arguments, queue: job.queue_name}
+          job.perform_now
+        else
+          enqueued_jobs << {job: job.class, args: job.arguments, queue: job.queue_name}
+        end
+      end
+
+      def enqueue_at(job, timestamp)
+        if perform_enqueued_at_jobs
+          performed_jobs << {job: job.class, args: job.arguments, queue: job.queue_name, at: timestamp}
+          job.perform_now
+        else
+          enqueued_jobs << {job: job.class, args: job.arguments, queue: job.queue_name, at: timestamp}
+        end
+      end
+    end
+  end
+end

data/lib/active_job/queue_name.rb

@@ -0,0 +1,39 @@
+module ActiveJob
+  module QueueName
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      mattr_accessor(:queue_name_prefix)
+      mattr_accessor(:default_queue_name)
+
+      def queue_as(part_name=nil, &block)
+        if block_given?
+          self.queue_name = block
+        else
+          self.queue_name = queue_name_from_part(part_name)
+        end
+      end
+
+      def queue_name_from_part(part_name) #:nodoc:
+        queue_name = part_name.to_s.presence || default_queue_name
+        name_parts = [queue_name_prefix.presence, queue_name]
+        name_parts.compact.join('_')
+      end
+    end
+
+    included do
+      class_attribute :queue_name, instance_accessor: false
+      self.default_queue_name = "default"
+      self.queue_name = default_queue_name
+    end
+
+    # Returns the name of the queue the job will be run on
+    def queue_name
+      if @queue_name.is_a?(Proc)
+        @queue_name = self.class.queue_name_from_part(instance_exec(&@queue_name))
+      end
+      @queue_name
+    end
+
+  end
+end

data/lib/active_job/railtie.rb

@@ -0,0 +1,23 @@
+# require 'global_id/railtie'
+require 'active_job'
+
+module ActiveJob
+  # = Active Job Railtie
+  class Railtie < Rails::Railtie # :nodoc:
+    config.active_job = ActiveSupport::OrderedOptions.new
+
+    initializer 'active_job.logger' do
+      ActiveSupport.on_load(:active_job) { self.logger = ::Rails.logger }
+    end
+
+    initializer "active_job.set_configs" do |app|
+      options = app.config.active_job
+      options.queue_adapter ||= :inline
+
+      ActiveSupport.on_load(:active_job) do
+        options.each { |k,v| send("#{k}=", v) }
+      end
+    end
+
+  end
+end

data/lib/active_job/test_case.rb

@@ -0,0 +1,7 @@
+require 'active_support/test_case'
+
+module ActiveJob
+  class TestCase < ActiveSupport::TestCase
+    include ActiveJob::TestHelper
+  end
+end

data/lib/active_job/test_helper.rb

@@ -0,0 +1,196 @@
+module ActiveJob
+  # Provides helper methods for testing Active Job
+  module TestHelper
+    extend ActiveSupport::Concern
+
+    included do
+      def before_setup
+        @old_queue_adapter  = queue_adapter
+        ActiveJob::Base.queue_adapter = :test
+        clear_enqueued_jobs
+        clear_performed_jobs
+        super
+      end
+
+      def after_teardown
+        super
+        ActiveJob::Base.queue_adapter = @old_queue_adapter
+      end
+
+      # Asserts that the number of enqueued jobs matches the given number.
+      #
+      #   def test_jobs
+      #     assert_enqueued_jobs 0
+      #     HelloJob.perform_later('david')
+      #     assert_enqueued_jobs 1
+      #     HelloJob.perform_later('abdelkader')
+      #     assert_enqueued_jobs 2
+      #   end
+      #
+      # If a block is passed, that block should cause the specified number of
+      # jobs to be enqueued.
+      #
+      #   def test_jobs_again
+      #     assert_enqueued_jobs 1 do
+      #       HelloJob.perform_later('cristian')
+      #     end
+      #
+      #     assert_enqueued_jobs 2 do
+      #       HelloJob.perform_later('aaron')
+      #       HelloJob.perform_later('rafael')
+      #     end
+      #   end
+      def assert_enqueued_jobs(number)
+        if block_given?
+          original_count = enqueued_jobs.size
+          yield
+          new_count = enqueued_jobs.size
+          assert_equal original_count + number, new_count,
+                       "#{number} jobs expected, but #{new_count - original_count} were enqueued"
+        else
+          enqueued_jobs_size = enqueued_jobs.size
+          assert_equal number, enqueued_jobs_size, "#{number} jobs expected, but #{enqueued_jobs_size} were enqueued"
+        end
+      end
+
+      # Assert that no job have been enqueued.
+      #
+      #   def test_jobs
+      #     assert_no_enqueued_jobs
+      #     HelloJob.perform_later('jeremy')
+      #     assert_enqueued_jobs 1
+      #   end
+      #
+      # If a block is passed, that block should not cause any job to be enqueued.
+      #
+      #   def test_jobs_again
+      #     assert_no_enqueued_jobs do
+      #       # No job should be enqueued from this block
+      #     end
+      #   end
+      #
+      # Note: This assertion is simply a shortcut for:
+      #
+      #   assert_enqueued_jobs 0
+      def assert_no_enqueued_jobs(&block)
+        assert_enqueued_jobs 0, &block
+      end
+
+      # Asserts that the number of performed jobs matches the given number.
+      #
+      #   def test_jobs
+      #     assert_performed_jobs 0
+      #     HelloJob.perform_later('xavier')
+      #     assert_performed_jobs 1
+      #     HelloJob.perform_later('yves')
+      #     assert_performed_jobs 2
+      #   end
+      #
+      # If a block is passed, that block should cause the specified number of
+      # jobs to be performed.
+      #
+      #   def test_jobs_again
+      #     assert_performed_jobs 1 do
+      #       HelloJob.perform_later('robin')
+      #     end
+      #
+      #     assert_performed_jobs 2 do
+      #       HelloJob.perform_later('carlos')
+      #       HelloJob.perform_later('sean')
+      #     end
+      #   end
+      def assert_performed_jobs(number)
+        if block_given?
+          original_count = performed_jobs.size
+          yield
+          new_count = performed_jobs.size
+          assert_equal original_count + number, new_count,
+                       "#{number} jobs expected, but #{new_count - original_count} were performed"
+        else
+          performed_jobs_size = performed_jobs.size
+          assert_equal number, performed_jobs_size, "#{number} jobs expected, but #{performed_jobs_size} were performed"
+        end
+      end
+
+      # Asserts that no jobs have been performed.
+      #
+      #   def test_jobs
+      #     assert_no_performed_jobs
+      #     HelloJob.perform_later('matthew')
+      #     assert_performed_jobs 1
+      #   end
+      #
+      # If a block is passed, that block should not cause any job to be performed.
+      #
+      #   def test_jobs_again
+      #     assert_no_performed_jobs do
+      #       # No job should be performed from this block
+      #     end
+      #   end
+      #
+      # Note: This assertion is simply a shortcut for:
+      #
+      #   assert_performed_jobs 0
+      def assert_no_performed_jobs(&block)
+        assert_performed_jobs 0, &block
+      end
+
+      # Asserts that the job passed in the block has been enqueued with the given arguments.
+      #
+      #   def assert_enqueued_job
+      #     assert_enqueued_with(job: MyJob, args: [1,2,3], queue: 'low') do
+      #       MyJob.perform_later(1,2,3)
+      #     end
+      #   end
+      def assert_enqueued_with(args = {}, &_block)
+        original_enqueued_jobs = enqueued_jobs.dup
+        clear_enqueued_jobs
+        args.assert_valid_keys(:job, :args, :at, :queue)
+        yield
+        matching_job = enqueued_jobs.any? do |job|
+          args.all? { |key, value| value == job[key] }
+        end
+        assert matching_job
+      ensure
+        queue_adapter.enqueued_jobs = original_enqueued_jobs + enqueued_jobs
+      end
+
+      # Asserts that the job passed in the block has been performed with the given arguments.
+      #
+      #   def test_assert_performed_with
+      #     assert_performed_with(job: MyJob, args: [1,2,3], queue: 'high') do
+      #       MyJob.perform_later(1,2,3)
+      #     end
+      #   end
+      def assert_performed_with(args = {}, &_block)
+        original_performed_jobs = performed_jobs.dup
+        clear_performed_jobs
+        args.assert_valid_keys(:job, :args, :at, :queue)
+        yield
+        matching_job = performed_jobs.any? do |job|
+          args.all? { |key, value| value == job[key] }
+        end
+        assert matching_job, "No performed job found with #{args}"
+      ensure
+        queue_adapter.performed_jobs = original_performed_jobs + performed_jobs
+      end
+
+      def queue_adapter
+        ActiveJob::Base.queue_adapter
+      end
+
+      delegate :enqueued_jobs, :enqueued_jobs=,
+               :performed_jobs, :performed_jobs=,
+               to: :queue_adapter
+
+      private
+        def clear_enqueued_jobs
+          enqueued_jobs.clear
+        end
+
+        def clear_performed_jobs
+          performed_jobs.clear
+        end
+    end
+  end
+end