rails-queue 1.0.0

data/lib/rails/queue/version.rb

@@ -0,0 +1,5 @@
+module Rails
+  module Queue
+    VERSION = "1.0.0"
+  end
+end

data/test/ci/before_script.sh

@@ -0,0 +1,4 @@
+# clone Rails 3.2 one directory up from our library
+git clone git://github.com/rails/rails.git ../rails
+cd ../rails
+git checkout v$RAILS_VERSION

data/test/fixtures/async_mailer/welcome.erb

@@ -0,0 +1 @@
+Welcome

data/test/rails-queue_test.rb

@@ -0,0 +1,7 @@
+require File.expand_path("../../lib/rails-queue", __FILE__)
+
+class Rails::QueueTest < ActiveSupport::TestCase
+  test "module definition" do
+    assert_kind_of Module, Rails::Queue
+  end
+end

data/test/rails/frameworks_test.rb

@@ -0,0 +1,35 @@
+require "support/isolation_abstract_unit"
+require 'set'
+
+module ApplicationTests
+  class FrameworksTest < ActiveSupport::TestCase
+    include ActiveSupport::Testing::Isolation
+
+    def setup
+      build_app
+      boot_rails
+      FileUtils.rm_rf "#{app_path}/config/environments"
+    end
+
+    def teardown
+      teardown_app
+    end
+
+    test "uses the default queue for ActionMailer" do
+      require "#{app_path}/config/environment"
+      assert_kind_of Rails::Queue::Queue, ActionMailer::Base.queue
+    end
+
+    test "allows me to configure queue for ActionMailer" do
+      app_file "config/environments/development.rb", <<-RUBY
+        AppTemplate::Application.configure do
+          config.action_mailer.queue = Rails::Queue::TestQueue.new
+        end
+      RUBY
+
+      require "#{app_path}/config/environment"
+      assert_kind_of Rails::Queue::TestQueue, ActionMailer::Base.queue
+    end
+
+  end
+end

data/test/rails/queue/actionmailer/base_test.rb

@@ -0,0 +1,22 @@
+# Original File: RAILS_ROOT/actionmailer/test/base_test.rb
+require "support/action_mailer_abstract_unit"
+require "rails-queue"
+require "support/mailers"
+
+class BaseTest < ActiveSupport::TestCase
+  def teardown
+    ActionMailer::Base.asset_host = nil
+    ActionMailer::Base.assets_dir = nil
+  end
+
+  test "delivering message asynchronously" do
+    AsyncMailer.delivery_method = :test
+    AsyncMailer.deliveries.clear
+
+    AsyncMailer.welcome.deliver
+    assert_equal 0, AsyncMailer.deliveries.length
+
+    AsyncMailer.queue.drain
+    assert_equal 1, AsyncMailer.deliveries.length
+  end
+end

data/test/rails/queue/synchronous_queue_test.rb

@@ -0,0 +1,28 @@
+# Original File: RAILS_ROOT/activesupport/test/queueing/synchronous_queue_test.rb
+require "support/active_support_abstract_unit"
+require "rails-queue"
+
+class SynchronousQueueTest < ActiveSupport::TestCase
+  class Job
+    attr_reader :ran
+    def run; @ran = true end
+  end
+
+  class ExceptionRaisingJob
+    def run; raise end
+  end
+
+  def setup
+    @queue = Rails::Queue::SynchronousQueue.new
+  end
+
+  def test_runs_jobs_immediately
+    job = Job.new
+    @queue.push job
+    assert job.ran
+
+    assert_raises RuntimeError do
+      @queue.push ExceptionRaisingJob.new
+    end
+  end
+end

data/test/rails/queue/test_queue_test.rb

@@ -0,0 +1,147 @@
+# Original File: RAILS_ROOT/activesupport/test/queueing/test_queue_test.rb
+require "support/active_support_abstract_unit"
+require "rails-queue"
+
+class TestQueueTest < ActiveSupport::TestCase
+  def setup
+    @queue = Rails::Queue::TestQueue.new
+  end
+
+  class ExceptionRaisingJob
+    def run
+      raise
+    end
+  end
+
+  def test_drain_raises_exceptions_from_running_jobs
+    @queue.push ExceptionRaisingJob.new
+    assert_raises(RuntimeError) { @queue.drain }
+  end
+
+  def test_jobs
+    @queue.push 1
+    @queue.push 2
+    assert_equal [1,2], @queue.jobs
+  end
+
+  class EquivalentJob
+    def initialize
+      @initial_id = self.object_id
+    end
+
+    def run
+    end
+
+    def ==(other)
+      other.same_initial_id?(@initial_id)
+    end
+
+    def same_initial_id?(other_id)
+      other_id == @initial_id
+    end
+  end
+
+  def test_contents
+    job = EquivalentJob.new
+    assert @queue.empty?
+    @queue.push job
+    refute @queue.empty?
+    assert_equal job, @queue.pop
+  end
+
+  class ProcessingJob
+    def self.clear_processed
+      @processed = []
+    end
+
+    def self.processed
+      @processed
+    end
+
+    def initialize(object)
+      @object = object
+    end
+
+    def run
+      self.class.processed << @object
+    end
+  end
+
+  def test_order
+    ProcessingJob.clear_processed
+    job1 = ProcessingJob.new(1)
+    job2 = ProcessingJob.new(2)
+
+    @queue.push job1
+    @queue.push job2
+    @queue.drain
+
+    assert_equal [1,2], ProcessingJob.processed
+  end
+
+  class ThreadTrackingJob
+    attr_reader :thread_id
+
+    def run
+      @thread_id = Thread.current.object_id
+    end
+
+    def ran?
+      @thread_id
+    end
+  end
+
+  def test_drain
+    @queue.push ThreadTrackingJob.new
+    job = @queue.jobs.last
+    @queue.drain
+
+    assert @queue.empty?
+    assert job.ran?, "The job runs synchronously when the queue is drained"
+    assert_equal job.thread_id, Thread.current.object_id
+  end
+
+  class IdentifiableJob
+    def initialize(id)
+      @id = id
+    end
+
+    def ==(other)
+      other.same_id?(@id)
+    end
+
+    def same_id?(other_id)
+      other_id == @id
+    end
+
+    def run
+    end
+  end
+
+  def test_queue_can_be_observed
+    jobs = (1..10).map do |id|
+      IdentifiableJob.new(id)
+    end
+
+    jobs.each do |job|
+      @queue.push job
+    end
+
+    assert_equal jobs, @queue.jobs
+  end
+
+  def test_adding_an_unmarshallable_job
+    anonymous_class_instance = Struct.new(:run).new
+
+    assert_raises TypeError do
+      @queue.push anonymous_class_instance
+    end
+  end
+
+  def test_attempting_to_add_a_reference_to_itself
+    job = {reference: @queue}
+    assert_raises TypeError do
+      @queue.push job
+    end
+  end
+end

data/test/rails/queue/threaded_consumer_test.rb

@@ -0,0 +1,111 @@
+# Original File: RAILS_ROOT/activesupport/test/queueing/threaded_consumer_test.rb
+require "support/active_support_abstract_unit"
+require "rails-queue"
+require "active_support/log_subscriber/test_helper"
+
+class TestThreadConsumer < ActiveSupport::TestCase
+  class Job
+    attr_reader :id
+    def initialize(id = 1, &block)
+      @id = id
+      @block = block
+    end
+
+    def run
+      @block.call if @block
+    end
+  end
+
+  def setup
+    @logger = ActiveSupport::LogSubscriber::TestHelper::MockLogger.new
+    @queue = Rails::Queue::Queue.new(logger: @logger)
+  end
+
+  def teardown
+    @queue.drain
+  end
+
+  test "the jobs are executed" do
+    ran = false
+    job = Job.new { ran = true }
+
+    @queue.push job
+    @queue.drain
+
+    assert_equal true, ran
+  end
+
+  test "the jobs are not executed synchronously" do
+    run, ran = Queue.new, Queue.new
+    job = Job.new { ran.push run.pop }
+
+    @queue.consumer.start
+    @queue.push job
+    assert ran.empty?
+
+    run.push true
+    assert_equal true, ran.pop
+  end
+
+  test "shutting down the queue synchronously drains the jobs" do
+    ran = false
+    job = Job.new do
+      sleep 0.1
+      ran = true
+    end
+
+    @queue.consumer.start
+    @queue.push job
+    assert_equal false, ran
+
+    @queue.consumer.shutdown
+    assert_equal true, ran
+  end
+
+  test "log job that raises an exception" do
+    job = Job.new { raise "RuntimeError: Error!" }
+
+    @queue.push job
+    consume_queue @queue
+
+    assert_equal 1, @logger.logged(:error).size
+    assert_match "Job Error: #{job.inspect}\nRuntimeError: Error!", @logger.logged(:error).last
+  end
+
+  test "logger defaults to stderr" do
+    begin
+      $stderr, old_stderr = StringIO.new, $stderr
+      queue = Rails::Queue::Queue.new
+      queue.push Job.new { raise "RuntimeError: Error!" }
+      consume_queue queue
+      assert_match 'Job Error', $stderr.string
+    ensure
+      $stderr = old_stderr
+    end
+  end
+
+  test "test overriding exception handling" do
+    @queue.consumer.instance_eval do
+      def handle_exception(job, exception)
+        @last_error = exception.message
+      end
+
+      def last_error
+        @last_error
+      end
+    end
+
+    job = Job.new { raise "RuntimeError: Error!" }
+
+    @queue.push job
+    consume_queue @queue
+
+    assert_equal "RuntimeError: Error!", @queue.consumer.last_error
+  end
+
+  private
+    def consume_queue(queue)
+      queue.push nil
+      queue.consumer.consume
+    end
+end

data/test/rails/queue_test.rb

@@ -0,0 +1,152 @@
+require "support/isolation_abstract_unit"
+
+class QueueTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::Isolation
+
+  def setup
+    build_app
+    boot_rails
+  end
+
+  def teardown
+    teardown_app
+  end
+
+  def app_const
+    @app_const ||= Class.new(Rails::Application)
+  end
+
+  test "the queue is a SynchronousQueue in test mode" do
+    app("test")
+    assert_kind_of Rails::Queue::SynchronousQueue, Rails.application.queue
+    assert_kind_of Rails::Queue::SynchronousQueue, Rails.queue
+  end
+
+  test "the queue is a SynchronousQueue in development mode" do
+    app("development")
+    assert_kind_of Rails::Queue::SynchronousQueue, Rails.application.queue
+    assert_kind_of Rails::Queue::SynchronousQueue, Rails.queue
+  end
+
+  class ThreadTrackingJob
+    def initialize
+      @origin = Thread.current.object_id
+    end
+
+    def run
+      @target = Thread.current.object_id
+    end
+
+    def ran_in_different_thread?
+      @origin != @target
+    end
+
+    def ran?
+      @target
+    end
+  end
+
+  test "in development mode, an enqueued job will be processed in the same thread" do
+    app("development")
+
+    job = ThreadTrackingJob.new
+    Rails.queue.push job
+    sleep 0.1
+
+    assert job.ran?, "Expected job to be run"
+    refute job.ran_in_different_thread?, "Expected job to run in the same thread"
+  end
+
+  test "in test mode, an enqueued job will be processed in the same thread" do
+    app("test")
+
+    job = ThreadTrackingJob.new
+    Rails.queue.push job
+    sleep 0.1
+
+    assert job.ran?, "Expected job to be run"
+    refute job.ran_in_different_thread?, "Expected job to run in the same thread"
+  end
+
+  test "in production, automatically spawn a queue consumer in a background thread" do
+    add_to_env_config "production", <<-RUBY
+      config.queue = Rails::Queue::Queue.new
+    RUBY
+
+    app("production")
+
+    assert_nil Rails.application.config.queue_consumer
+    assert_kind_of Rails::Queue::ThreadedQueueConsumer, Rails.application.queue_consumer
+    assert_equal Rails.logger, Rails.application.queue_consumer.logger
+  end
+
+  test "attempting to marshal a queue will raise an exception" do
+    app("test")
+    assert_raises TypeError do
+      Marshal.dump Rails.queue
+    end
+  end
+
+  def setup_custom_queue
+    add_to_env_config "production", <<-RUBY
+      require "my_queue"
+      config.queue = MyQueue.new
+    RUBY
+
+    app_file "lib/my_queue.rb", <<-RUBY
+      class MyQueue
+        def push(job)
+          job.run
+        end
+      end
+    RUBY
+
+    app("production")
+  end
+
+  test "a custom queue implementation can be provided" do
+    setup_custom_queue
+
+    assert_kind_of MyQueue, Rails.queue
+
+    job = Struct.new(:id, :ran) do
+      def run
+        self.ran = true
+      end
+    end
+
+    job1 = job.new(1)
+    Rails.queue.push job1
+
+    assert_equal true, job1.ran
+  end
+
+  test "a custom consumer implementation can be provided" do
+    add_to_env_config "production", <<-RUBY
+      require "my_queue_consumer"
+      config.queue = Rails::Queue::Queue.new
+      config.queue_consumer = MyQueueConsumer.new
+    RUBY
+
+    app_file "lib/my_queue_consumer.rb", <<-RUBY
+      class MyQueueConsumer
+        attr_reader :started
+
+        def start
+          @started = true
+        end
+      end
+    RUBY
+
+    app("production")
+
+    assert_kind_of MyQueueConsumer, Rails.application.queue_consumer
+    assert Rails.application.queue_consumer.started
+  end
+
+  test "default consumer is not used with custom queue implementation" do
+    setup_custom_queue
+
+    assert_nil Rails.application.queue_consumer
+  end
+end