resque_unit 0.1

data/README.md

@@ -0,0 +1,74 @@
+ResqueUnit
+==========
+
+ResqueUnit provides some extra assertions and a mock Resque for
+testing Rails code that depends on Resque. You can install it as
+either a gem or a plugin:
+
+    gem install resque_unit
+
+and in your test.rb: 
+
+    config.gem 'resque_unit'
+
+If you'd rather install it as a plugin, you should be able to run
+
+    script/plugin install git://github.com/justinweiss/resque_unit.git
+
+inside your Rails projects. 
+
+Examples
+========
+
+ResqueUnit provides some extra assertions for your unit tests. For
+example, if you have code that queues a resque job:
+
+    class MyJob
+      @queue = :low  
+    
+      def self.perform(x)
+        // do stuff
+      end
+    end
+    
+    def queue_job
+      Resque.enqueue(MyJob, 1)
+    end
+
+You can write a unit test for code that queues this job:
+
+    def test_job_queued
+      queue_job
+      assert_queued(MyJob) # assert that MyJob was queued in the :low queue
+    end
+
+You can also verify that a job was queued with arguments:
+
+    def test_job_queued_with_arguments
+      queue_job
+      assert_queued(MyJob, [1])
+    end
+
+And you can run all the jobs in the queue, so you can verify that they
+run correctly:
+
+    def test_job_runs 
+      queue_job 
+      Resque.run!
+      assert stuff_was_done, "Job didn't run"
+    end
+
+You can also access the queues directly:
+
+    def test_jobs_in_queue
+      queue_job 
+      assert_equal 1, Resque.queue(:low).length
+    end
+
+Caveats
+=======
+
+* You should make sure that you call `Resque.reset!` in your test's
+  setup method to clear all of the test queues.
+
+Copyright (c) 2010 Justin Weiss, released under the MIT license

data/lib/resque_unit.rb

@@ -0,0 +1,9 @@
+module ResqueUnit
+end
+
+require 'resque_unit/resque'
+require 'resque_unit/assertions'
+
+
+Test::Unit::TestCase.send(:include, ResqueUnit::Assertions)
+

data/lib/resque_unit/assertions.rb

@@ -0,0 +1,35 @@
+# These are a group of assertions you can use in your unit tests to
+# verify that your code is using Resque correctly.
+module ResqueUnit::Assertions
+  
+  # Asserts that +klass+ has been queued into its appropriate queue at
+  # least once. If +args+ is nil, it only asserts that the klass has
+  # been queued. Otherwise, it asserts that the klass has been queued
+  # with the correct arguments. Pass an empty array for +args+ if you
+  # want to assert that klass has been queued without arguments.
+  def assert_queued(klass, args = nil, message = nil)
+    queue = Resque.queue_for(klass)
+    assert_block (message || "#{klass} should have been queued in #{queue}: #{Resque.queue(queue).inspect}.") do 
+      in_queue?(queue, klass, args)
+    end
+  end
+
+  # The opposite of +assert_queued+.
+  def assert_not_queued(klass, args = nil, message = nil)
+    queue = Resque.queue_for(klass)
+    assert_block (message || "#{klass} should have been queued in #{queue}.") do 
+      !in_queue?(queue, klass, args)
+    end
+  end
+
+  private
+
+  def in_queue?(queue, klass, args = nil)
+    if args # verify the klass and args match some element in the queue
+      !Resque.queue(queue).select {|e| e[:klass] == klass && e[:args] == args}.empty?
+    else # if no args were passed, just verify the job is in the queue
+      !Resque.queue(queue).select {|e| e[:klass] == klass}.empty?
+    end
+  end
+  
+end

data/lib/resque_unit/resque.rb

@@ -0,0 +1,40 @@
+# The fake Resque class. This needs to be loaded after the real Resque
+# for the assertions in +ResqueUnit::Assertions+ to work.
+module Resque
+
+  # Resets all the queues to the empty state. This should be called in
+  # your test's +setup+ method until I can figure out a way for it to
+  # automatically be called.
+  def self.reset!
+    @queue = Hash.new { |h, k| h[k] = [] }
+  end
+
+  # Returns an array of all the jobs that have been queued. Each
+  # element is of the form +{:klass => klass, :args => args}+ where
+  # +klass+ is the job's class and +args+ is an array of the arguments
+  # passed to the job.
+  def self.queue(queue)
+    self.reset unless @queue
+    @queue[queue]
+  end
+
+  # Executes all jobs in all queues in an undefined order.
+  def self.run!
+    @queue.each do |k, v|
+      while job = v.shift
+        job[:klass].perform(*job[:args])
+      end
+    end
+  end
+
+  # :nodoc: 
+  def self.enqueue(klass, *args)
+    queue(queue_for(klass)) << {:klass => klass, :args => args}
+  end
+
+  # :nodoc: 
+  def self.queue_for(klass)
+    klass.instance_variable_get(:@queue)
+  end
+
+end

data/test/resque_unit_test.rb

@@ -0,0 +1,91 @@
+require 'test_helper'
+
+class ResqueUnitTest < ActiveSupport::TestCase
+
+  setup do
+    # should probably happen automatically, but I haven't thought of a
+    # good way to hook setup() yet.
+    Resque.reset!
+  end
+  
+  context "A task that schedules a resque job" do
+    setup do 
+      Resque.enqueue(LowPriorityJob)
+    end
+
+    should "pass the assert_queued(job) assertion" do 
+      assert_queued(LowPriorityJob)
+    end
+
+    should "fail the assert_not_queued(job) assertion" do 
+      assert_raise Test::Unit::AssertionFailedError do 
+        assert_not_queued(LowPriorityJob)
+      end
+    end
+
+    context ", when Resque.run! is called," do 
+      setup do 
+        assert !LowPriorityJob.run?, "The job should not have been run yet"
+        Resque.run!
+      end
+      
+      teardown do 
+        LowPriorityJob.run = false
+      end
+
+      should "run the job" do 
+        assert LowPriorityJob.run?, "The job should have run"
+      end
+
+      should "clear the job from the queue" do
+        assert_not_queued(LowPriorityJob)
+      end
+    end
+
+    # assert number of jobs?
+  end
+
+  context "An empty queue" do
+    should "pass the assert_not_queued(job) assertion" do 
+      assert_not_queued(LowPriorityJob)
+    end
+
+    should "fail the assert_queued(job) assertion" do
+      assert_raise Test::Unit::AssertionFailedError do 
+        assert_queued(LowPriorityJob)
+      end
+    end
+  end
+  
+  context "A task that schedules a resque job with arguments" do 
+    setup do 
+      Resque.enqueue(JobWithArguments, 1, "test")
+    end
+    
+    should "pass the assert_queued(job, *args) assertion if the args match" do
+      assert_queued(JobWithArguments, [1, "test"])
+    end
+    
+    should "pass the assert_queued(job) assertion with no args passed" do
+      assert_queued(JobWithArguments)
+    end
+
+    should "fail the assert_queued(job) assertion if the args don't match" do 
+      assert_raise Test::Unit::AssertionFailedError do 
+        assert_queued(JobWithArguments, [2, "test"])
+      end
+    end
+
+    should "pass the assert_not_queued(job) assertion if the args don't match" do
+      assert_not_queued(JobWithArguments, [2, "test"])
+    end
+
+    should "fail the assert_not_queued(job) assertion if the args match" do
+      assert_raise Test::Unit::AssertionFailedError do 
+        assert_not_queued(JobWithArguments, [1, "test"])
+      end
+    end
+
+  end
+
+end

data/test/sample_jobs.rb

@@ -0,0 +1,24 @@
+class LowPriorityJob
+  @queue = :low
+  @run = false
+  def self.perform
+    self.run = true
+  end
+
+  def self.run?
+    @run
+  end
+
+  def self.run=(value)
+    @run = value
+  end
+
+end
+
+class JobWithArguments
+  @queue = :medium
+
+  def self.perform(num, text)
+
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'active_support'
+require 'active_support/test_case'
+require 'shoulda'
+require 'resque_unit'
+require 'sample_jobs'

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: resque_unit
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Justin Weiss
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-04 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: justin@uberweiss.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- lib/resque_unit/assertions.rb
+- lib/resque_unit/resque.rb
+- lib/resque_unit.rb
+- test/resque_unit_test.rb
+- test/sample_jobs.rb
+- test/test_helper.rb
+- README.md
+has_rdoc: true
+homepage: http://github.com/justinweiss/resque_unit
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Test::Unit support for resque job queueing
+test_files: 
+- test/resque_unit_test.rb