tresque 0.0.2

data/lib/tresque/registry.rb

@@ -0,0 +1,94 @@
+require 'resque-bus'
+
+module TResque
+  class Registry
+    class << self
+      def default_weight
+        100
+      end
+      
+      def class_hash
+        @class_hash ||= {}
+      end
+      
+      def queue_hash
+        @queue_hash ||= {}
+      end
+      
+      def class_list
+        class_hash.keys
+      end
+      
+      def worker(klass)
+        klass = klass.name if klass.is_a?(Class)
+        klass = klass.to_s
+        class_hash[klass] = 1
+      end
+      
+      def queue(queue_name, weight=nil)
+        queue_name = queue_name.to_s
+        if weight
+          # take higher weight
+          if !queue_hash[queue_name] || weight > queue_hash[queue_name]
+            queue_hash[queue_name] = weight
+          end
+        else
+          queue_hash[queue_name] ||= false
+        end
+      end
+
+      def weight(key)
+        if !self.queue_hash[key]
+          self.default_weight
+        else
+          self.queue_hash[key]
+        end
+      end
+      
+      # called to know what queues to set
+      def queues
+        register_classes
+        register_bus
+        sorted_queues
+      end
+      
+      protected
+      
+      def register_classes
+        class_list.each do |klass_name|
+          klass = klass_name.constantize
+          queue(klass.queue)
+        end
+      end
+      
+      def register_bus
+        manager = QueueBus::TaskManager.new(false)
+        manager.queue_names.each do |name|
+          queue(name)
+        end
+        queue("bus_incoming", 1)
+      end
+      
+      def sorted_queues
+        array = queue_hash.keys.clone.shuffle
+        hash = {}
+        array.each do |key|
+          hash[key] = self.weight(key)
+        end
+        # sorted with highest weight first
+        array.sort!{ |x,y| hash[y] <=> hash[x] }
+        array
+      end
+    end
+    
+    attr_reader :app_key
+    def initialize(app_key)
+      @app_key = Util.normalize(app_key)
+    end
+    
+    def queue(name, weight=nil)
+      queue_name = "#{app_key}_#{name}"
+      ::TResque::Registry.queue(queue_name, weight)
+    end
+  end
+end

data/lib/tresque/resque_spec/ext.rb

@@ -0,0 +1,92 @@
+require 'resque'
+
+module Resque
+  class Job
+    class << self
+      alias :create_without_resque_spec :create
+      alias :destroy_without_resque_spec :destroy
+    end
+
+    def self.create(queue, klass, *args)
+      return create_without_resque_spec(queue, klass, *args) if ResqueSpec.disable_ext
+
+      raise ::Resque::NoQueueError.new("Jobs must be placed onto a queue.") if !queue
+      raise ::Resque::NoClassError.new("Jobs must be given a class.") if klass.to_s.empty?
+      ResqueSpec.enqueue(queue, klass, *args)
+    end
+
+    def self.destroy(queue, klass, *args)
+      return destroy_without_resque_spec(queue, klass, *args) if ResqueSpec.disable_ext
+
+      raise ::Resque::NoQueueError.new("Jobs must have been placed onto a queue.") if !queue
+      raise ::Resque::NoClassError.new("Jobs must have been given a class.") if klass.to_s.empty?
+
+      old_count = ResqueSpec.queue_by_name(queue).size
+
+      ResqueSpec.dequeue(queue, klass, *args)
+
+      old_count - ResqueSpec.queue_by_name(queue).size
+    end
+  end
+
+  alias :enqueue_without_resque_spec :enqueue
+  alias :enqueue_to_without_resque_spec :enqueue_to if Resque.respond_to? :enqueue_to
+  alias :reserve_without_resque_spec :reserve
+  alias :peek_without_resque_spec :peek
+  alias :size_without_resque_spec :size
+
+  def enqueue(klass, *args)
+    return enqueue_without_resque_spec(klass, *args) if ResqueSpec.disable_ext
+
+    enqueue_to(queue_from_class(klass), klass, *args)
+  end
+
+  def enqueue_to(queue, klass, *args)
+    return enqueue_to_without_resque_spec(queue, klass, *args) if ResqueSpec.disable_ext
+
+    if ResqueSpec.inline
+      return if run_before_enqueue(klass, *args)
+      run_after_enqueue(klass, *args)
+      Job.create(queue, klass, *args)
+    else
+      return if run_before_enqueue(klass, *args)
+      Job.create(queue, klass, *args)
+      run_after_enqueue(klass, *args)
+      true
+    end
+  end
+
+  def peek(queue, start = 0, count = 1)
+    return peek_without_resque_spec(queue, start, count) if ResqueSpec.disable_ext
+    ResqueSpec.peek(queue, start, count).map do |job|
+      job.inject({}) { |a, (k, v)| a[k.to_s] = v; a }
+    end
+  end
+
+  def reserve(queue_name)
+    return reserve_without_resque_spec(queue_name) if ResqueSpec.disable_ext
+
+    ResqueSpec.pop(queue_name)
+  end
+
+  def size(queue_name)
+    return size_without_resque_spec(queue_name) if ResqueSpec.disable_ext
+
+    ResqueSpec.queue_by_name(queue_name).count
+  end
+
+  private
+
+  def run_after_enqueue(klass, *args)
+    Plugin.after_enqueue_hooks(klass).each do |hook|
+      klass.send(hook, *args)
+    end
+  end
+
+  def run_before_enqueue(klass, *args)
+    before_hooks = Plugin.before_enqueue_hooks(klass).collect do |hook|
+      klass.send(hook, *args)
+    end
+    before_hooks.any? { |result| result == false }
+  end
+end

data/lib/tresque/resque_spec/helpers.rb

@@ -0,0 +1,25 @@
+module ResqueSpec
+  module Helpers
+
+    def with_resque
+      original = ResqueSpec.inline
+      begin
+        ResqueSpec.inline = true
+        yield
+      ensure
+        ResqueSpec.inline = original
+      end
+    end
+
+    def without_resque_spec
+      original = ResqueSpec.disable_ext
+      begin
+        ResqueSpec.disable_ext = true
+        yield
+      ensure
+        ResqueSpec.disable_ext = original
+      end
+    end
+
+  end
+end

data/lib/tresque/resque_spec/matchers.rb

@@ -0,0 +1,318 @@
+require 'rspec/core'
+require 'rspec/expectations'
+require 'rspec/mocks'
+
+module InQueueHelper
+  def self.extended(klass)
+    klass.instance_eval do
+      self.queue_name = nil
+      chain :in do |queue_name|
+        self.queue_name = queue_name
+      end
+    end
+  end
+
+  private
+
+  attr_accessor :queue_name
+
+  def queue(actual)
+    if @queue_name
+      ResqueSpec.queue_by_name(@queue_name)
+    else
+      ResqueSpec.queue_for(actual)
+    end
+  end
+
+end
+
+RSpec::Matchers.define :have_queued do |*expected_args|
+  extend InQueueHelper
+  include InQueueHelper
+  chain :times do |num_times_queued|
+    @times = num_times_queued
+    @times_info = @times == 1 ? ' once' : " #{@times} times"
+  end
+
+  chain :once do |num_times_queued|
+    @times = 1
+    @times_info = ' once'
+  end
+
+  match do |actual|
+    matched = queue(actual).select do |entry|
+      klass = entry.fetch(:class)
+      args = entry.fetch(:args)
+
+      if expected_args.length == 0
+        klass.to_s == actual.to_s
+      elsif expected_args.length == 1 && expected_args[0].is_a?(Hash) && !expected_args[0].has_key?('tz') && !expected_args[0].has_key?('locale')
+        klass.to_s == actual.to_s && args[0].except('locale', 'tz') == expected_args[0]
+      else
+        klass.to_s == actual.to_s && expected_args == args
+      end
+    end
+
+    if @times
+      matched.size == @times
+    else
+      matched.size > 0
+    end
+  end
+
+  failure_message do |actual|
+    "expected that #{actual} would have [#{expected_args.join(', ')}] queued#{@times_info}"
+  end
+
+  failure_message_when_negated do |actual|
+    "expected that #{actual} would not have [#{expected_args.join(', ')}] queued#{@times_info}"
+  end
+
+  description do
+    "have queued arguments of [#{expected_args.join(', ')}]#{@times_info}"
+  end
+end
+
+RSpec::Matchers.define :have_queue_size_of do |size|
+  extend InQueueHelper
+  include InQueueHelper
+
+  match do |actual|
+    queue(actual).size == size
+  end
+
+  failure_message do |actual|
+    "expected that #{actual} would have #{size} entries queued, but got #{queue(actual).size} instead"
+  end
+
+  failure_message_when_negated do |actual|
+    "expected that #{actual} would not have #{size} entries queued, but got #{queue(actual).size} instead"
+  end
+
+  description do
+    "have a queue size of #{size}"
+  end
+end
+
+RSpec::Matchers.define :have_queue_size_of_at_least do |size|
+  extend InQueueHelper
+  include InQueueHelper
+  match do |actual|
+    queue(actual).size >= size
+  end
+
+  failure_message do |actual|
+    "expected that #{actual} would have at least #{size} entries queued, but got #{queue(actual).size} instead"
+  end
+
+  failure_message_when_negated do |actual|
+    "expected that #{actual} would not have at least #{size} entries queued, but got #{queue(actual).size} instead"
+  end
+
+  description do
+    "have a queue size of at least #{size}"
+  end
+end
+
+module ScheduleQueueHelper
+  def self.extended(klass)
+    klass.instance_eval do
+      self.queue_name = nil
+      chain :queue do |queue_name|
+        self.queue_name = queue_name
+      end
+    end
+  end
+
+  attr_accessor :queue_name
+
+  def schedule_queue_for(actual)
+    if @queue_name
+      ResqueSpec.queue_by_name(@queue_name)
+    else
+      ResqueSpec.schedule_for(actual)
+    end
+  end
+
+end
+
+RSpec::Matchers.define :have_scheduled do |*expected_args|
+  extend ScheduleQueueHelper
+  include ScheduleQueueHelper
+  chain :at do |timestamp|
+    @interval = nil
+    @time = timestamp
+    @time_info = "at #{@time}"
+  end
+
+  chain :in do |interval|
+    @time = nil
+    @interval = interval
+    @time_info = "in #{@interval} seconds"
+  end
+
+  match do |actual|
+    schedule_queue_for(actual).any? do |entry|
+      class_matches = entry[:class].to_s == actual.to_s
+      args_match = begin
+        if expected_args.length == 1 && expected_args[0].is_a?(Hash) && !expected_args[0].has_key?('tz') && !expected_args[0].has_key?('locale')
+          entry[:args][0].except('tz', 'locale') == expected_args[0]
+        else
+          entry[:args] == expected_args
+        end
+      end
+
+      time_matches = if @time
+        entry[:time] == @time
+      elsif @interval
+        entry[:time].to_i == (entry[:stored_at] + @interval).to_i
+      else
+        true
+      end
+
+      class_matches && args_match && time_matches
+    end
+  end
+
+  failure_message do |actual|
+    ["expected that #{actual} would have [#{expected_args.join(', ')}] scheduled", @time_info].join(' ')
+  end
+
+  failure_message_when_negated do |actual|
+    ["expected that #{actual} would not have [#{expected_args.join(', ')}] scheduled", @time_info].join(' ')
+  end
+
+  description do
+    "have scheduled arguments"
+  end
+end
+
+RSpec::Matchers.define :have_scheduled_at do |*expected_args|
+  extend ScheduleQueueHelper
+  warn "DEPRECATION WARNING: have_scheduled_at(time, *args) is deprecated and will be removed in future. Please use have_scheduled(*args).at(time) instead."
+
+  match do |actual|
+    time = expected_args.first
+    other_args = expected_args[1..-1]
+    schedule_queue_for(actual).any? { |entry| entry[:class].to_s == actual.to_s && entry[:time] == time && other_args == entry[:args] }
+  end
+
+  failure_message do |actual|
+    "expected that #{actual} would have [#{expected_args.join(', ')}] scheduled"
+  end
+
+  failure_message_when_negated do |actual|
+    "expected that #{actual} would not have [#{expected_args.join(', ')}] scheduled"
+  end
+
+  description do
+    "have scheduled at the given time the arguments"
+  end
+end
+
+RSpec::Matchers.define :have_schedule_size_of do |size|
+  extend ScheduleQueueHelper
+
+  match do |actual|
+    schedule_queue_for(actual).size == size
+  end
+
+  failure_message do |actual|
+    "expected that #{actual} would have #{size} scheduled entries, but got #{schedule_queue_for(actual).size} instead"
+  end
+
+  failure_message_when_negated do |actual|
+    "expected that #{actual} would have #{size} scheduled entries."
+  end
+
+  description do
+    "have schedule size of #{size}"
+  end
+end
+
+RSpec::Matchers.define :have_schedule_size_of_at_least do |size|
+  extend ScheduleQueueHelper
+
+  match do |actual|
+    schedule_queue_for(actual).size >= size
+  end
+
+  failure_message do |actual|
+    "expected that #{actual} would have at least #{size} scheduled entries, but got #{schedule_queue_for(actual).size} instead"
+  end
+
+  failure_message_when_negated do |actual|
+    "expected that #{actual} would have at least #{size} scheduled entries."
+  end
+
+  description do
+    "have schedule size of #{size}"
+  end
+end
+
+
+RSpec::Matchers.define :have_delayed do |method_name|
+  extend InQueueHelper
+  include InQueueHelper
+
+  chain :until do |timestamp|
+    @when = timestamp.to_i
+  end
+
+  chain :with do |*args|
+    @args = args
+  end
+
+  chain :in_lock_namespace do |ns|
+    @lock_namespace = ns.to_s
+  end
+
+  chain :with_queue_lock do |lock|
+    @queue_lock = lock.to_s
+  end
+
+  chain :with_worker_lock do |lock|
+    @worker_lock = lock.to_s
+  end
+
+  match do |class_name|
+
+    class_name = case class_name
+    when Class
+      class_name.name
+    when String, Symbol
+      class_name
+    else # instances of objects
+      class_name.class.name
+    end
+
+    [@queue_name || ResqueSpec.queues].flatten.compact.each do |queue|
+      ResqueSpec.queue_by_name(queue).detect do |entry|
+        klass = entry[:class]
+        args  = entry[:args]
+        data  = args.first if args.is_a?(Array)
+
+        matched =   data['class_name'] == class_name.to_s
+        matched &&= data['method_name'] == method_name.to_s
+        matched &&= data['run_at'] == @when                   if @when
+        matched &&= data['args'] == @args                     if @args
+        matched &&= data['lock_namespace'] == @lock_namespace if @lock_namespace
+        matched &&= data['queue_lock'] == @queue_lock         if @queue_lock
+        matched &&= data['worker_lock'] == @worker_lock       if @worker_lock
+        matched
+      end
+    end
+  end
+
+  failure_message do |actual|
+    "expected that #{method_name} would have been a delayed invocation"
+  end
+
+  failure_message_when_negated do |actual|
+    "expected that #{method_name} would not have been delayed"
+  end
+
+  description do
+    "#{method_name} should be deplayed"
+  end
+end