resque_unit 0.4.8 → 1.0.0.beta.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1aad0f765a2b78da6d5f17cdbf2f5646066d8b8d
-  data.tar.gz: c694a2f46b3ec5892f7a83ebfae9d734dd0371ec
+  metadata.gz: c7f97661c4942301890a017728285e1ab9d65b3f
+  data.tar.gz: 260b78240c5893fd2a63f555699d46643f4d0d1f
 SHA512:
-  metadata.gz: 812552beeb3b8c3de00be72b6c13b8dfc4fd2808df1114f308c3eb5aaba2635108d58d9583c5a8c879248b91b716c0bf21c38fad6b2d1453a0405c272daa3f3b
-  data.tar.gz: 97110758541b5c3335906743fdd0dbfd2f1514106ec90ea98dbb9149bef0f86b0932974cc2ed2455d9ea119fffae551aaf9764302ab64101195f4ae3977dec8a
+  metadata.gz: bb7c292dff03229418161eab51a16f8e9f3415df0d5ed24b58dbf8bca94453c0962bf792de19c0669b080c3ed12642f2a1b07ea381003aefb8024847b74950ea
+  data.tar.gz: e6b67c8fbd8b9409981b409836d9613a20a8b7fc1732b98beaee8b353ccbf18c3977b8af464bd368165c9021b0e47dceec1bbd4ac8d2f3db514aaa696973b776

data/README.md

@@ -3,7 +3,7 @@ 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:
+either a gem:
 
     gem install resque_unit
 
@@ -11,12 +11,6 @@ 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
 ========
 
@@ -103,10 +97,6 @@ Caveats
 
 * You should make sure that you call `Resque.reset!` in your test's
   setup method to clear all of the test queues.
-* Hooks support is optional. Just because you probably don't want to call
-  them during unit tests if they play with a DB. Call `Resque.enable_hooks!`
-  in your tests's setup method to enable hooks. To disable hooks, call
-  `Resque.disable_hooks!`.
 
 Resque-Scheduler Support
 ========================

data/lib/resque_unit/assertions.rb

@@ -1,7 +1,6 @@
 # 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
@@ -9,14 +8,14 @@ module ResqueUnit::Assertions
   # want to assert that klass has been queued without arguments. Pass a block
   # if you want to assert something was queued within its execution.
   def assert_queued(klass, args = nil, message = nil, &block)
-    queue_name = Resque.queue_for(klass)
+    queue_name = Resque.queue_from_class(klass)
     assert_job_created(queue_name, klass, args, message, &block)
   end
   alias assert_queues assert_queued
 
   # The opposite of +assert_queued+.
   def assert_not_queued(klass = nil, args = nil, message = nil, &block)
-    queue_name = Resque.queue_for(klass)
+    queue_name = Resque.queue_from_class(klass)
 
     queue = if block_given?
       snapshot = Resque.size(queue_name)
@@ -32,9 +31,9 @@ module ResqueUnit::Assertions
 
   # Asserts no jobs were queued within the block passed.
   def assert_nothing_queued(message = nil, &block)
-    snapshot = Resque.size
+    snapshot = total_job_count
     yield
-    present = Resque.size
+    present = total_job_count
     assert_equal snapshot, present, message || "No jobs should have been queued"
   end
 
@@ -54,6 +53,11 @@ module ResqueUnit::Assertions
 
   private
 
+  # The total count of all the jobs in Resque.
+  def total_job_count
+    Resque.queues.inject(0) { |acc, queue| acc + Resque.size(queue) }
+  end
+
   # In Test::Unit, +assert_block+ displays only the message on a test
   # failure and +assert+ always appends a message to the end of the
   # passed-in assertion message. In MiniTest, it's the other way

data/lib/resque_unit/resque/test_extensions.rb

@@ -0,0 +1,66 @@
+module Resque
+  module TestExtensions
+    # A redis connection that always uses fakeredis.
+    def fake_redis
+      @fake_redis ||= Redis.new(driver: :memory)
+    end
+
+    # Always return the fake redis.
+    def redis
+      fake_redis
+    end
+
+    # 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.
+    #
+    # If <tt>queue_name</tt> is given, then resets only that queue.
+    def reset!(queue = nil)
+      if queue
+        remove_queue(queue)
+      else
+        redis.flushall
+      end
+    end
+
+    # Return an array of all jobs' payloads for queue
+    # Elements are decoded
+    def all(queue_name)
+      jobs = peek(queue_name, 0, size(queue_name))
+      jobs.kind_of?(Array) ? jobs : [jobs]
+    end
+    alias queue all
+
+    # Executes all jobs in all queues in an undefined order.
+    def run!
+      payloads = []
+      queues.each do |queue|
+        size(queue).times { payloads << pop(queue) }
+      end
+      exec_payloads payloads.shuffle
+    end
+
+    def run_for!(queue, limit = Float::INFINITY)
+      job_count = [limit, size(queue)].min
+      payloads = []
+
+      job_count.times { payloads << pop(queue) }
+      exec_payloads payloads.shuffle
+    end
+
+    def exec_payloads(raw_payloads)
+      raw_payloads.each do |raw_payload|
+        Resque::Job.new(:inline, raw_payload).perform
+      end
+    end
+
+    private :exec_payloads
+
+    # 1. Execute all jobs in all queues in an undefined order,
+    # 2. Check if new jobs were announced, and execute them.
+    # 3. Repeat 3
+    def full_run!
+      run! until queues.all? { |queue| size(queue) == 0 }
+    end
+  end
+end

data/lib/resque_unit/resque.rb

@@ -1,224 +1,15 @@
-# The fake Resque class. This needs to be loaded after the real Resque
-# for the assertions in +ResqueUnit::Assertions+ to work.
-module Resque
-  include ResqueUnit::Helpers
-  extend self
-
-  # 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.
-  #
-  # If <tt>queue_name</tt> is given, then resets only that queue.
-  def reset!(queue_name = nil)
-    if @queue && queue_name
-      @queue[queue_name] = []
-    else
-      @queue = Hash.new { |h, k| h[k] = [] }
-    end
-  end
-
-  # Returns a hash of all the queue names and jobs that have been queued. The
-  # format is <tt>{queue_name => [job, ..]}</tt>.
-  def self.queues
-    @queue || reset!
-  end
-
-  # Returns an array of all the jobs that have been queued. Each
-  # element is of the form +{"class" => klass, "args" => args}+ where
-  # +klass+ is the job's class and +args+ is an array of the arguments
-  # passed to the job.
-  def queue(queue_name)
-    queues[queue_name]
-  end
-
-  # Return an array of all jobs' payloads for queue
-  # Elements are decoded
-  def all(queue_name)
-    result = list_range(queue_name, 0, size(queue_name))
-    result.is_a?(Array) ? result : [ result ]
-  end
-
-  # Returns an array of jobs' payloads for queue.
-  #
-  # start and count should be integer and can be used for pagination.
-  # start is the item to begin, count is how many items to return.
-  #
-  # To get the 3rd page of a 30 item, paginatied list one would use:
-  #   Resque.peek('my_list', 59, 30)
-  def peek(queue_name, start = 0, count = 1)
-    list_range(queue_name, start, count)
-  end
-
-  # Gets a range of jobs' payloads from queue.
-  # Returns single element if count equal 1
-  # Elements are decoded
-  def list_range(key, start = 0, count = 1)
-    data = if count == 1
-      decode(queues[key][start])
-    else
-      (queues[key][start...start + count] || []).map { |entry| decode(entry) }
-    end
-  end
-
-  # Yes, all Resque hooks!
-  def enable_hooks!
-    @hooks_enabled = true
-  end
-
-  def disable_hooks!
-    @hooks_enabled = nil
-  end
-
-  # Executes all jobs in all queues in an undefined order.
-  def run!
-    payloads = []
-    @queue.each do |queue_name, queue|
-      payloads.concat queue.slice!(0, queue.size)
-    end
-    exec_payloads payloads.shuffle
-  end
-
-  def run_for!(queue_name, limit=false)
-    queue = @queue[queue_name]
-    exec_payloads queue.slice!(0, ( limit ? limit : queue.size) ).shuffle
-  end
-
-  def exec_payloads(raw_payloads)
-    raw_payloads.each do |raw_payload|
-      job_payload = decode(raw_payload)
-      @hooks_enabled ? perform_with_hooks(job_payload) : perform_without_hooks(job_payload)
-    end
-  end
-  private :exec_payloads
-
-  # 1. Execute all jobs in all queues in an undefined order,
-  # 2. Check if new jobs were announced, and execute them.
-  # 3. Repeat 3
-  def full_run!
-    run! until empty_queues?
-  end
-
-  # Returns the size of the given queue
-  def size(queue_name = nil)
-    if queue_name
-      queues[queue_name].length
-    else
-      queues.values.flatten.length
-    end
-  end
-
-  # :nodoc: 
-  def enqueue(klass, *args)
-    enqueue_to( queue_for(klass), klass, *args)
-  end
-
-  # :nodoc:
-  def enqueue_to( queue_name, klass, *args )
-    # Behaves like Resque, raise if no queue was specifed
-    raise NoQueueError.new("Jobs must be placed onto a queue.") unless queue_name
-    enqueue_unit(queue_name, {"class" => klass.to_s, "args" => args })
-  end
-
-  # :nodoc: 
-  def queue_for(klass)
-    klass.instance_variable_get(:@queue) || (klass.respond_to?(:queue) && klass.queue)
-  end
-  alias :queue_from_class :queue_for
-
-  # :nodoc:
-  def empty_queues?
-    queues.all? do |k, v|
-      v.empty?
-    end
-  end
-
-  def enqueue_unit(queue_name, hash)
-    klass = constantize(hash["class"])
-    if @hooks_enabled
-      before_hooks = Plugin.before_enqueue_hooks(klass).map do |hook|
-        klass.send(hook, *hash["args"])
-      end
-      return nil if before_hooks.any? { |result| result == false }
-    end
-    queue(queue_name) << encode(hash)
-    if @hooks_enabled
-      Plugin.after_enqueue_hooks(klass).each do |hook|
-        klass.send(hook, *hash["args"])
-      end
-    end
-    queue(queue_name).size
-  end
-
-  # Call perform on the job class
-  def perform_without_hooks(job_payload)
-    constantize(job_payload["class"]).perform(*job_payload["args"])
-  end
-
-  # Call perform on the job class, and adds support for Resque hooks.
-  def perform_with_hooks(job_payload)
-    job_class = constantize(job_payload["class"])
-    before_hooks  = Resque::Plugin.before_hooks(job_class)
-    around_hooks  = Resque::Plugin.around_hooks(job_class)
-    after_hooks   = Resque::Plugin.after_hooks(job_class)
-    failure_hooks = Resque::Plugin.failure_hooks(job_class)
-    
-    begin
-      # Execute before_perform hook. Abort the job gracefully if
-      # Resque::DontPerform is raised.
-      begin
-        before_hooks.each do |hook|
-          job_class.send(hook, *job_payload["args"])
-        end
-      rescue Resque::Job::DontPerform
-        return false
-      end
-      
-      # Execute the job. Do it in an around_perform hook if available.
-      if around_hooks.empty?
-        perform_without_hooks(job_payload)
-        job_was_performed = true
-      else
-        # We want to nest all around_perform plugins, with the last one
-        # finally calling perform
-        stack = around_hooks.reverse.inject(nil) do |last_hook, hook|
-          if last_hook
-            lambda do
-              job_class.send(hook, *job_payload["args"]) { last_hook.call }
-            end
-          else
-            lambda do
-              job_class.send(hook, *job_payload["args"]) do
-                result = perform_without_hooks(job_payload)
-                job_was_performed = true
-                result
-              end
-            end
-          end
-        end
-        stack.call
-      end
-      
-      # Execute after_perform hook
-      after_hooks.each do |hook|
-        job_class.send(hook, *job_payload["args"])
-      end
-      
-      # Return true if the job was performed
-      return job_was_performed
-      
-    # If an exception occurs during the job execution, look for an
-    # on_failure hook then re-raise.
-    rescue Object => e
-      failure_hooks.each { |hook| job_class.send(hook, e, *job_payload["args"]) }
-      raise e
-    end
-  end
-
-  class Job
-    extend ResqueUnit::Helpers
-    def self.create(queue, klass_name, *args)
-      Resque.enqueue_unit(queue, {"class" => constantize(klass_name).to_s, "args" => args})
-    end
-  end
-
-end
+require 'resque'
+require 'resque_unit/resque/test_extensions'
+
+# This is a little weird. Fakeredis registers itself as the default
+# redis driver after you load it. This might not be what you want,
+# though -- resque_unit needs fakeredis, but you may have a reason to
+# use a different redis driver for the rest of your test code. So
+# we'll store the old default here, and restore it afer we're done
+# loading fakeredis. Then, we'll point resque at fakeredis
+# specifically.
+default_redis_driver = Redis::Connection.drivers.pop
+require 'fakeredis'
+Redis::Connection.drivers << default_redis_driver if default_redis_driver
+
+Resque.extend Resque::TestExtensions

data/lib/resque_unit/scheduler_assertions.rb

@@ -3,7 +3,7 @@
 require 'time'
 
 module ResqueUnit::SchedulerAssertions
-  
+
   # Asserts that +klass+ has been queued into its appropriate queue at
   # least once, with a +timestamp+ less than or equal to
   # +expected_timestamp+. If the job wasn't queued with a timestamp,
@@ -13,7 +13,7 @@ module ResqueUnit::SchedulerAssertions
   # +args+ if you want to assert that klass has been queued without
   # arguments.
   def assert_queued_at(expected_timestamp, klass, args = nil, message = nil)
-    queue = Resque.queue_for(klass)
+    queue = Resque.queue_from_class(klass)
     assert in_timestamped_queue?(queue, expected_timestamp, klass, args),
       (message || "#{klass} should have been queued in #{queue} before #{expected_timestamp}: #{Resque.queue(queue).inspect}.")
   end
@@ -23,10 +23,10 @@ module ResqueUnit::SchedulerAssertions
   def assert_queued_in(expected_time_difference, klass, args = nil, message = nil)
     assert_queued_at(Time.now + expected_time_difference, klass, args, message)
   end
-  
+
   # opposite of +assert_queued_at+
   def assert_not_queued_at(expected_timestamp, klass, args = nil, message = nil)
-    queue = Resque.queue_for(klass)
+    queue = Resque.queue_from_class(klass)
     assert !in_timestamped_queue?(queue, expected_timestamp, klass, args),
       (message || "#{klass} should not have been queued in #{queue} before #{expected_timestamp}.")
   end
@@ -38,10 +38,24 @@ module ResqueUnit::SchedulerAssertions
 
   private
 
-  def in_timestamped_queue?(queue_name, expected_timestamp, klass, args = nil)
+  def in_queue?(queue, klass, args = nil)
+    super(queue, klass, args) || !matching_jobs(all_jobs_scheduled_before_or_at(:forever), klass, args).empty?
+  end
+
+  def in_timestamped_queue?(queue_name, max_timestamp, klass, args = nil)
     # check if we have any matching jobs with a timestamp less than
     # expected_timestamp
-    !matching_jobs(Resque.all(queue_name), klass, args).select {|e| e["timestamp"] && Time.parse(e["timestamp"]) <= expected_timestamp}.empty?
+    !matching_jobs(all_jobs_scheduled_before_or_at(max_timestamp), klass, args).empty?
   end
-  
+
+  def all_jobs_scheduled_before_or_at(max_timestamp = :forever)
+    timestamps = Resque.delayed_queue_peek(0, Resque.delayed_queue_schedule_size).map(&:to_i)
+
+    if max_timestamp != :forever
+      timestamps.select! { |timestamp| Time.at(timestamp) <= Time.at(max_timestamp) }
+    end
+
+    timestamps.flat_map { |timestamp| Resque.delayed_timestamp_peek(timestamp, 0, Resque.delayed_timestamp_size(timestamp)) }
+  end
+
 end

data/lib/resque_unit.rb

@@ -6,14 +6,11 @@ begin
 rescue LoadError
   require 'json'
 end
-
-require 'resque_unit/helpers'
+require 'resque'
 require 'resque_unit/resque'
-require 'resque_unit/errors'
 require 'resque_unit/assertions'
-require 'resque_unit/plugin'
 
-if defined?(Test::Unit)
+if defined?(Test::Unit::TestCase)
   Test::Unit::TestCase.send(:include, ResqueUnit::Assertions)
 end
 

data/lib/resque_unit_scheduler.rb

@@ -1,7 +1,8 @@
-require 'resque_unit/scheduler'
+require 'resque_unit'
+require 'resque-scheduler'
 require 'resque_unit/scheduler_assertions'
 
-if defined?(Test::Unit)
+if defined?(Test::Unit::TestCase)
   Test::Unit::TestCase.send(:include, ResqueUnit::SchedulerAssertions)
 end
 

data/test/redis_test.rb

@@ -0,0 +1,11 @@
+require 'test_helper'
+
+describe Redis do
+  it "uses a real Redis connection by default" do
+    redis = Redis.current
+    refute_equal Redis::Connection::Memory, redis.client.driver
+
+    redis = Redis.new
+    refute_equal Redis::Connection::Memory, redis.client.driver
+  end
+end

data/test/resque_test.rb

@@ -1,60 +1,60 @@
 require 'test_helper'
+describe Resque do
 
-class ResqueTest < Test::Unit::TestCase
-
-  def setup
+  before do
     Resque.reset!
   end
 
-  context "with one queued job" do
-    setup do
+  describe "with one queued job" do
+    before do
       Resque.enqueue(MediumPriorityJob, "some args")
       @job_payload = {"args"=>["some args"], "class"=>"MediumPriorityJob"}
     end
 
-    should "return job payload when peek method called with count equal 1" do
+    it "returns the job payload when peek method called with count equal 1" do
       assert_equal @job_payload, Resque.peek(MediumPriorityJob.queue, 0, 1)
     end
 
-    should "return array of jobs' payloads when peek method called with count different than 1" do
+    it "returns an array of jobs' payloads when peek method called with count different than 1" do
       assert_equal [@job_payload], Resque.peek(MediumPriorityJob.queue, 0, 5)
     end
   end
 
-  context "with few queued jobs" do
-    setup do
+  describe "with few queued jobs" do
+    before do
       Resque.enqueue(MediumPriorityJob, "1")
       Resque.enqueue(MediumPriorityJob, "2")
       Resque.enqueue(MediumPriorityJob, "3")
     end
 
-    should "return jobs' payloads 2 and 3 when peek method called with start equal 1 and count equal 2" do
+    it "returns jobs' payloads 2 and 3 when peek method called with start equal 1 and count equal 2" do
       assert_equal [["2"], ["3"]], Resque.peek(MediumPriorityJob.queue, 1, 2).map{|h| h["args"]}
     end
 
-    should "return empty array when peek method called with start higher than queue size" do
+    it "returns an empty array when peek method called with start higher than queue size" do
       assert_equal [], Resque.peek(MediumPriorityJob.queue, 4, 2)
     end
 
-    should "return empty array when peek method called with count equal 0" do
-      assert_equal [], Resque.peek(MediumPriorityJob.queue, 0, 0)
+    it "returns all jobs' payloads when peek method called with count equal 0" do
+      # This is the way Resque.peek works, so it's now the way resque-unit works!
+      assert_equal Resque.all(MediumPriorityJob.queue), Resque.peek(MediumPriorityJob.queue, 0, 0)
     end
 
-    should "return all jobs' payloads when all method called" do
+    it "returns all jobs' payloads when all method called" do
       assert Resque.all(MediumPriorityJob.queue).length == 3, "should return all 3 elements"
     end
   end
 
-  context "without queued jobs" do
-    should "return nil when peek method called with count equal 1" do
+  describe "without queued jobs" do
+    it "returns nil when peek method called with count equal 1" do
       assert_equal nil, Resque.peek(MediumPriorityJob.queue, 0, 1)
     end
 
-    should "return empty array when peek method called with count not equal 1" do
+    it "returns an empty array when peek method called with count not equal 1" do
       assert_equal [], Resque.peek(MediumPriorityJob.queue, 0, 999)
     end
 
-    should "return empty array when all method called" do
+    it "returns an empty array when `all` is called" do
       assert_equal [], Resque.all(MediumPriorityJob.queue)
     end
   end