drewda_delayed_job 3.0.3

data/spec/autoloaded/instance_struct.rb

@@ -0,0 +1,6 @@
+module Autoloaded
+  class InstanceStruct < ::Struct.new(nil)
+    def perform
+    end
+  end
+end

data/spec/autoloaded/struct.rb

@@ -0,0 +1,7 @@
+# Make sure this file does not get required manually
+module Autoloaded
+  class Struct < ::Struct.new(nil)
+    def perform
+    end
+  end
+end

data/spec/delayed/backend/test.rb

@@ -0,0 +1,113 @@
+require 'ostruct'
+
+# An in-memory backend suitable only for testing. Tries to behave as if it were an ORM.
+module Delayed
+  module Backend
+    module Test
+      class Job
+        attr_accessor :id
+        attr_accessor :priority
+        attr_accessor :attempts
+        attr_accessor :handler
+        attr_accessor :last_error
+        attr_accessor :run_at
+        attr_accessor :locked_at
+        attr_accessor :locked_by
+        attr_accessor :failed_at
+        attr_accessor :queue
+
+        include Delayed::Backend::Base
+
+        cattr_accessor :id
+        self.id = 0
+
+        def initialize(hash = {})
+          self.attempts = 0
+          self.priority = 0
+          self.id = (self.class.id += 1)
+          hash.each{|k,v| send(:"#{k}=", v)}
+        end
+
+        @jobs = []
+        def self.all
+          @jobs
+        end
+
+        def self.count
+          all.size
+        end
+
+        def self.delete_all
+          all.clear
+        end
+
+        def self.create(attrs = {})
+          new(attrs).tap do |o|
+            o.save
+          end
+        end
+
+        def self.create!(*args); create(*args); end
+
+        def self.clear_locks!(worker_name)
+          all.select{|j| j.locked_by == worker_name}.each {|j| j.locked_by = nil; j.locked_at = nil; j.is_locked = false}
+        end
+
+        # Find a few candidate jobs to run (in case some immediately get locked by others).
+        def self.find_available(worker_name, limit = 5, max_run_time = Worker.max_run_time)
+          jobs = all.select do |j|
+            j.run_at <= db_time_now &&
+            (j.locked_at.nil? || j.locked_at < db_time_now - max_run_time || j.locked_by == worker_name) &&
+            !j.failed?
+          end
+
+          jobs = jobs.select{|j| Worker.queues.include?(j.queue)}   if Worker.queues.any?
+          jobs = jobs.select{|j| j.priority >= Worker.min_priority} if Worker.min_priority
+          jobs = jobs.select{|j| j.priority <= Worker.max_priority} if Worker.max_priority
+          jobs.sort_by{|j| [j.priority, j.run_at]}[0..limit-1]
+        end
+
+        # Lock this job for this worker.
+        # Returns true if we have the lock, false otherwise.
+        def lock_exclusively!(max_run_time, worker)
+          now = self.class.db_time_now
+          if locked_by != worker
+            # We don't own this job so we will update the locked_by name and the locked_at
+            self.locked_at = now
+            self.locked_by = worker
+            self.is_locked = true
+          end
+
+          return true
+        end
+
+        def self.db_time_now
+          Time.current
+        end
+
+        def update_attributes(attrs = {})
+          attrs.each{|k,v| send(:"#{k}=", v)}
+          save
+        end
+
+        def destroy
+          self.class.all.delete(self)
+        end
+
+        def save
+          self.run_at ||= Time.current
+
+          self.class.all << self unless self.class.all.include?(self)
+          true
+        end
+
+        def save!; save; end
+
+        def reload
+          reset
+          self
+        end
+      end
+    end
+  end
+end

data/spec/fixtures/bad_alias.yml

@@ -0,0 +1 @@
+foo: *bar

data/spec/lifecycle_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Delayed::Lifecycle do
+  let(:lifecycle) { Delayed::Lifecycle.new }
+  let(:callback) { lambda {|*args|} }
+  let(:arguments) { [1] }
+  let(:behavior) { mock(Object, :before! => nil, :after! => nil, :inside! => nil) }
+  let(:wrapped_block) { Proc.new { behavior.inside! } }
+
+  describe "before callbacks" do
+    before(:each) do
+      lifecycle.before(:execute, &callback)
+    end
+
+    it 'should execute before wrapped block' do
+      callback.should_receive(:call).with(*arguments).ordered
+      behavior.should_receive(:inside!).ordered
+      lifecycle.run_callbacks :execute, *arguments, &wrapped_block
+    end
+  end
+
+  describe "after callbacks" do
+    before(:each) do
+      lifecycle.after(:execute, &callback)
+    end
+
+    it 'should execute after wrapped block' do
+      behavior.should_receive(:inside!).ordered
+      callback.should_receive(:call).with(*arguments).ordered
+      lifecycle.run_callbacks :execute, *arguments, &wrapped_block
+    end
+  end
+
+  describe "around callbacks" do
+    before(:each) do
+      lifecycle.around(:execute) do |*args, &block|
+        behavior.before!
+        block.call(*args)
+        behavior.after!
+      end
+    end
+
+    it 'should before and after wrapped block' do
+      behavior.should_receive(:before!).ordered
+      behavior.should_receive(:inside!).ordered
+      behavior.should_receive(:after!).ordered
+      lifecycle.run_callbacks :execute, *arguments, &wrapped_block
+    end
+
+    it "should execute multiple callbacks in order" do
+      behavior.should_receive(:one).ordered
+      behavior.should_receive(:two).ordered
+      behavior.should_receive(:three).ordered
+
+      lifecycle.around(:execute) { |*args, &block| behavior.one; block.call(*args) }
+      lifecycle.around(:execute) { |*args, &block| behavior.two; block.call(*args) }
+      lifecycle.around(:execute) { |*args, &block| behavior.three; block.call(*args) }
+
+      lifecycle.run_callbacks(:execute, *arguments, &wrapped_block)
+    end
+  end
+
+  it "should raise if callback is executed with wrong number of parameters" do
+    lifecycle.before(:execute, &callback)
+    expect { lifecycle.run_callbacks(:execute, 1,2,3) {} }.to raise_error(ArgumentError, /1 parameter/)
+  end
+end

data/spec/message_sending_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+describe Delayed::MessageSending do
+  describe "handle_asynchronously" do
+    class Story
+      def tell!(arg);end
+      handle_asynchronously :tell!
+    end
+
+    it "should alias original method" do
+      Story.new.should respond_to(:tell_without_delay!)
+      Story.new.should respond_to(:tell_with_delay!)
+    end
+
+    it "should create a PerformableMethod" do
+      story = Story.create
+      lambda {
+        job = story.tell!(1)
+        job.payload_object.class.should == Delayed::PerformableMethod
+        job.payload_object.method_name.should == :tell_without_delay!
+        job.payload_object.args.should == [1]
+      }.should change { Delayed::Job.count }
+    end
+
+    describe 'with options' do
+      class Fable
+        cattr_accessor :importance
+        def tell;end
+        handle_asynchronously :tell, :priority => Proc.new { self.importance }
+      end
+
+      it 'should set the priority based on the Fable importance' do
+        Fable.importance = 10
+        job = Fable.new.tell
+        job.priority.should == 10
+
+        Fable.importance = 20
+        job = Fable.new.tell
+        job.priority.should == 20
+      end
+
+      describe 'using a proc with parameters' do
+        class Yarn
+          attr_accessor :importance
+          def spin
+          end
+          handle_asynchronously :spin, :priority => Proc.new {|y| y.importance }
+        end
+
+        it 'should set the priority based on the Fable importance' do
+          job = Yarn.new.tap {|y| y.importance = 10 }.spin
+          job.priority.should == 10
+
+          job = Yarn.new.tap {|y| y.importance = 20 }.spin
+          job.priority.should == 20
+        end
+      end
+    end
+  end
+
+  context "delay" do
+    class FairyTail
+      attr_accessor :happy_ending
+      def self.princesses;end
+      def tell
+        @happy_ending = true
+      end
+    end
+
+    it "should create a new PerformableMethod job" do
+      lambda {
+        job = "hello".delay.count('l')
+        job.payload_object.class.should == Delayed::PerformableMethod
+        job.payload_object.method_name.should == :count
+        job.payload_object.args.should == ['l']
+      }.should change { Delayed::Job.count }.by(1)
+    end
+
+    it "should set default priority" do
+      Delayed::Worker.default_priority = 99
+      job = FairyTail.delay.to_s
+      job.priority.should == 99
+      Delayed::Worker.default_priority = 0
+    end
+
+    it "should set job options" do
+      run_at = Time.parse('2010-05-03 12:55 AM')
+      job = FairyTail.delay(:priority => 20, :run_at => run_at).to_s
+      job.run_at.should == run_at
+      job.priority.should == 20
+    end
+
+    it "should not delay the job when delay_jobs is false" do
+      Delayed::Worker.delay_jobs = false
+      fairy_tail = FairyTail.new
+      lambda {
+        lambda {
+          fairy_tail.delay.tell
+        }.should change(fairy_tail, :happy_ending).from(nil).to(true)
+      }.should_not change { Delayed::Job.count }
+    end
+
+    it "should delay the job when delay_jobs is true" do
+      Delayed::Worker.delay_jobs = true
+      fairy_tail = FairyTail.new
+      lambda {
+        lambda {
+          fairy_tail.delay.tell
+        }.should_not change(fairy_tail, :happy_ending)
+      }.should change { Delayed::Job.count }.by(1)
+    end
+  end
+end

data/spec/performable_mailer_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+require 'action_mailer'
+class MyMailer < ActionMailer::Base
+  def signup(email)
+    mail :to => email, :subject => "Delaying Emails", :from => "delayedjob@example.com"
+  end
+end
+
+describe ActionMailer::Base do
+  describe "delay" do
+    it "should enqueue a PerformableEmail job" do
+      lambda {
+        job = MyMailer.delay.signup('john@example.com')
+        job.payload_object.class.should == Delayed::PerformableMailer
+        job.payload_object.method_name.should == :signup
+        job.payload_object.args.should == ['john@example.com']
+      }.should change { Delayed::Job.count }.by(1)
+    end
+  end
+
+  describe "delay on a mail object" do
+    it "should raise an exception" do
+      lambda {
+        MyMailer.signup('john@example.com').delay
+      }.should raise_error(RuntimeError)
+    end
+  end
+
+  describe Delayed::PerformableMailer do
+    describe "perform" do
+      it "should call the method and #deliver on the mailer" do
+        email = mock('email', :deliver => true)
+        mailer_class = mock('MailerClass', :signup => email)
+        mailer = Delayed::PerformableMailer.new(mailer_class, :signup, ['john@example.com'])
+
+        mailer_class.should_receive(:signup).with('john@example.com')
+        email.should_receive(:deliver)
+        mailer.perform
+      end
+    end
+  end
+
+end

data/spec/performable_method_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+describe Delayed::PerformableMethod do
+  describe "perform" do
+    before do
+      @method = Delayed::PerformableMethod.new("foo", :count, ['o'])
+    end
+
+    context "with the persisted record cannot be found" do
+      before do
+        @method.object = nil
+      end
+
+      it "should be a no-op if object is nil" do
+        lambda { @method.perform }.should_not raise_error
+      end
+    end
+
+    it "should call the method on the object" do
+      @method.object.should_receive(:count).with('o')
+      @method.perform
+    end
+  end
+
+  it "should raise a NoMethodError if target method doesn't exist" do
+    lambda {
+      Delayed::PerformableMethod.new(Object, :method_that_does_not_exist, [])
+    }.should raise_error(NoMethodError)
+  end
+
+  it "should not raise NoMethodError if target method is private" do
+    clazz = Class.new do
+      def private_method
+      end
+      private :private_method
+    end
+    lambda {
+      Delayed::PerformableMethod.new(clazz.new, :private_method, [])
+    }.should_not raise_error(NoMethodError)
+  end
+
+  describe "hooks" do
+    %w(enqueue before after success).each do |hook|
+      it "should delegate #{hook} hook to object" do
+        story = Story.create
+        story.should_receive(hook).with(an_instance_of(Delayed::Job))
+        story.delay.tell.invoke_job
+      end
+    end
+
+    %w(before after success).each do |hook|
+      it "should delegate #{hook} hook to object when delay_jobs = false" do
+        Delayed::Worker.delay_jobs = false
+        story = Story.create
+        story.should_receive(hook).with(an_instance_of(Delayed::Job))
+        story.delay.tell
+      end
+    end
+
+    it "should delegate error hook to object" do
+      story = Story.create
+      story.should_receive(:error).with(an_instance_of(Delayed::Job), an_instance_of(RuntimeError))
+      story.should_receive(:tell).and_raise(RuntimeError)
+      lambda { story.delay.tell.invoke_job }.should raise_error
+    end
+
+    it "should delegate error hook to object when delay_jobs = false" do
+      Delayed::Worker.delay_jobs = false
+      story = Story.create
+      story.should_receive(:error).with(an_instance_of(Delayed::Job), an_instance_of(RuntimeError))
+      story.should_receive(:tell).and_raise(RuntimeError)
+      lambda { story.delay.tell }.should raise_error
+    end
+
+    it "should delegate failure hook to object" do
+      method = Delayed::PerformableMethod.new("object", :size, [])
+      method.object.should_receive(:failure)
+      method.failure
+    end
+
+    it "should delegate failure hook to object when delay_jobs = false" do
+      Delayed::Worker.delay_jobs = false
+      method = Delayed::PerformableMethod.new("object", :size, [])
+      method.object.should_receive(:failure)
+      method.failure
+    end
+
+  end
+end