delayed_job_tgmerritt 4.0.7

data/spec/lifecycle_spec.rb

@@ -0,0 +1,75 @@
+require 'helper'
+
+describe Delayed::Lifecycle do
+  let(:lifecycle) { Delayed::Lifecycle.new }
+  let(:callback) { lambda { |*_args| } }
+  let(:arguments) { [1] }
+  let(:behavior) { double(Object, :before! => nil, :after! => nil, :inside! => nil) }
+  let(:wrapped_block) { proc { behavior.inside! } }
+
+  describe 'before callbacks' do
+    before(:each) do
+      lifecycle.before(:execute, &callback)
+    end
+
+    it 'executes before wrapped block' do
+      expect(callback).to receive(:call).with(*arguments).ordered
+      expect(behavior).to 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 'executes after wrapped block' do
+      expect(behavior).to receive(:inside!).ordered
+      expect(callback).to 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 'wraps a block' do
+      expect(behavior).to receive(:before!).ordered
+      expect(behavior).to receive(:inside!).ordered
+      expect(behavior).to receive(:after!).ordered
+      lifecycle.run_callbacks :execute, *arguments, &wrapped_block
+    end
+
+    it 'executes multiple callbacks in order' do
+      expect(behavior).to receive(:one).ordered
+      expect(behavior).to receive(:two).ordered
+      expect(behavior).to receive(:three).ordered
+
+      lifecycle.around(:execute) do |*args, &block|
+        behavior.one
+        block.call(*args)
+      end
+      lifecycle.around(:execute) do |*args, &block|
+        behavior.two
+        block.call(*args)
+      end
+      lifecycle.around(:execute) do |*args, &block|
+        behavior.three
+        block.call(*args)
+      end
+      lifecycle.run_callbacks(:execute, *arguments, &wrapped_block)
+    end
+  end
+
+  it 'raises 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,122 @@
+require 'helper'
+
+describe Delayed::MessageSending do
+  describe 'handle_asynchronously' do
+    class Story
+      def tell!(_arg); end
+      handle_asynchronously :tell!
+    end
+
+    it 'aliases original method' do
+      expect(Story.new).to respond_to(:tell_without_delay!)
+      expect(Story.new).to respond_to(:tell_with_delay!)
+    end
+
+    it 'creates a PerformableMethod' do
+      story = Story.create
+      expect do
+        job = story.tell!(1)
+        expect(job.payload_object.class).to eq(Delayed::PerformableMethod)
+        expect(job.payload_object.method_name).to eq(:tell_without_delay!)
+        expect(job.payload_object.args).to eq([1])
+      end.to change { Delayed::Job.count }
+    end
+
+    describe 'with options' do
+      class Fable
+        cattr_accessor :importance
+        def tell; end
+        handle_asynchronously :tell, :priority => proc { importance }
+      end
+
+      it 'sets the priority based on the Fable importance' do
+        Fable.importance = 10
+        job = Fable.new.tell
+        expect(job.priority).to eq(10)
+
+        Fable.importance = 20
+        job = Fable.new.tell
+        expect(job.priority).to eq(20)
+      end
+
+      describe 'using a proc with parameters' do
+        class Yarn
+          attr_accessor :importance
+          def spin
+          end
+          handle_asynchronously :spin, :priority => proc { |y| y.importance }
+        end
+
+        it 'sets the priority based on the Fable importance' do
+          job = Yarn.new.tap { |y| y.importance = 10 }.spin
+          expect(job.priority).to eq(10)
+
+          job = Yarn.new.tap { |y| y.importance = 20 }.spin
+          expect(job.priority).to eq(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
+
+    after do
+      Delayed::Worker.default_queue_name = nil
+    end
+
+    it 'creates a new PerformableMethod job' do
+      expect do
+        job = 'hello'.delay.count('l')
+        expect(job.payload_object.class).to eq(Delayed::PerformableMethod)
+        expect(job.payload_object.method_name).to eq(:count)
+        expect(job.payload_object.args).to eq(['l'])
+      end.to change { Delayed::Job.count }.by(1)
+    end
+
+    it 'sets default priority' do
+      Delayed::Worker.default_priority = 99
+      job = FairyTail.delay.to_s
+      expect(job.priority).to eq(99)
+    end
+
+    it 'sets default queue name' do
+      Delayed::Worker.default_queue_name = 'abbazabba'
+      job = FairyTail.delay.to_s
+      expect(job.queue).to eq('abbazabba')
+    end
+
+    it 'sets job options' do
+      run_at = Time.parse('2010-05-03 12:55 AM')
+      job = FairyTail.delay(:priority => 20, :run_at => run_at).to_s
+      expect(job.run_at).to eq(run_at)
+      expect(job.priority).to eq(20)
+    end
+
+    it 'does not delay the job when delay_jobs is false' do
+      Delayed::Worker.delay_jobs = false
+      fairy_tail = FairyTail.new
+      expect do
+        expect do
+          fairy_tail.delay.tell
+        end.to change(fairy_tail, :happy_ending).from(nil).to(true)
+      end.not_to change { Delayed::Job.count }
+    end
+
+    it 'does delay the job when delay_jobs is true' do
+      Delayed::Worker.delay_jobs = true
+      fairy_tail = FairyTail.new
+      expect do
+        expect do
+          fairy_tail.delay.tell
+        end.not_to change(fairy_tail, :happy_ending)
+      end.to change { Delayed::Job.count }.by(1)
+    end
+  end
+end

data/spec/performable_mailer_spec.rb

@@ -0,0 +1,43 @@
+require 'helper'
+
+require 'action_mailer'
+class MyMailer < ActionMailer::Base
+  def signup(email)
+    mail :to => email, :subject => 'Delaying Emails', :from => 'delayedjob@example.com', :body => 'Delaying Emails Body'
+  end
+end
+
+describe ActionMailer::Base do
+  describe 'delay' do
+    it 'enqueues a PerformableEmail job' do
+      expect do
+        job = MyMailer.delay.signup('john@example.com')
+        expect(job.payload_object.class).to eq(Delayed::PerformableMailer)
+        expect(job.payload_object.method_name).to eq(:signup)
+        expect(job.payload_object.args).to eq(['john@example.com'])
+      end.to change { Delayed::Job.count }.by(1)
+    end
+  end
+
+  describe 'delay on a mail object' do
+    it 'raises an exception' do
+      expect do
+        MyMailer.signup('john@example.com').delay
+      end.to raise_error(RuntimeError)
+    end
+  end
+
+  describe Delayed::PerformableMailer do
+    describe 'perform' do
+      it 'calls the method and #deliver on the mailer' do
+        email = double('email', :deliver => true)
+        mailer_class = double('MailerClass', :signup => email)
+        mailer = Delayed::PerformableMailer.new(mailer_class, :signup, ['john@example.com'])
+
+        expect(mailer_class).to receive(:signup).with('john@example.com')
+        expect(email).to receive(:deliver)
+        mailer.perform
+      end
+    end
+  end
+end

data/spec/performable_method_spec.rb

@@ -0,0 +1,111 @@
+require '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 'does nothing if object is nil' do
+        expect { @method.perform }.not_to raise_error
+      end
+    end
+
+    it 'calls the method on the object' do
+      expect(@method.object).to receive(:count).with('o')
+      @method.perform
+    end
+  end
+
+  it "raises a NoMethodError if target method doesn't exist" do
+    expect do
+      Delayed::PerformableMethod.new(Object, :method_that_does_not_exist, [])
+    end.to raise_error(NoMethodError)
+  end
+
+  it 'does not raise NoMethodError if target method is private' do
+    clazz = Class.new do
+      def private_method
+      end
+      private :private_method
+    end
+    expect { Delayed::PerformableMethod.new(clazz.new, :private_method, []) }.not_to raise_error
+  end
+
+  describe 'display_name' do
+    it 'returns class_name#method_name for instance methods' do
+      expect(Delayed::PerformableMethod.new('foo', :count, ['o']).display_name).to eq('String#count')
+    end
+
+    it 'returns class_name.method_name for class methods' do
+      expect(Delayed::PerformableMethod.new(Class, :inspect, []).display_name).to eq('Class.inspect')
+    end
+  end
+
+  describe 'hooks' do
+    %w[before after success].each do |hook|
+      it "delegates #{hook} hook to object" do
+        story = Story.create
+        job = story.delay.tell
+
+        expect(story).to receive(hook).with(job)
+        job.invoke_job
+      end
+    end
+
+    it 'delegates enqueue hook to object' do
+      story = Story.create
+      expect(story).to receive(:enqueue).with(an_instance_of(Delayed::Job))
+      story.delay.tell
+    end
+
+    it 'delegates error hook to object' do
+      story = Story.create
+      expect(story).to receive(:error).with(an_instance_of(Delayed::Job), an_instance_of(RuntimeError))
+      expect(story).to receive(:tell).and_raise(RuntimeError)
+      expect { story.delay.tell.invoke_job }.to raise_error
+    end
+
+    it 'delegates failure hook to object' do
+      method = Delayed::PerformableMethod.new('object', :size, [])
+      expect(method.object).to receive(:failure)
+      method.failure
+    end
+
+    context 'with delay_job == false' do
+      before do
+        Delayed::Worker.delay_jobs = false
+      end
+
+      after do
+        Delayed::Worker.delay_jobs = true
+      end
+
+      %w[before after success].each do |hook|
+        it "delegates #{hook} hook to object" do
+          story = Story.create
+          expect(story).to receive(hook).with(an_instance_of(Delayed::Job))
+          story.delay.tell
+        end
+      end
+
+      it 'delegates error hook to object' do
+        story = Story.create
+        expect(story).to receive(:error).with(an_instance_of(Delayed::Job), an_instance_of(RuntimeError))
+        expect(story).to receive(:tell).and_raise(RuntimeError)
+        expect { story.delay.tell }.to raise_error
+      end
+
+      it 'delegates failure hook to object' do
+        method = Delayed::PerformableMethod.new('object', :size, [])
+        expect(method.object).to receive(:failure)
+        method.failure
+      end
+    end
+  end
+end

data/spec/psych_ext_spec.rb

@@ -0,0 +1,12 @@
+require 'helper'
+
+describe 'Psych::Visitors::ToRuby', :if => defined?(Psych::Visitors::ToRuby) do
+  context BigDecimal do
+    it 'deserializes correctly' do
+      deserialized = YAML.load("--- !ruby/object:BigDecimal 18:0.1337E2\n...\n")
+
+      expect(deserialized).to be_an_instance_of(BigDecimal)
+      expect(deserialized).to eq(BigDecimal('13.37'))
+    end
+  end
+end

data/spec/sample_jobs.rb

@@ -0,0 +1,111 @@
+NamedJob = Struct.new(:perform)
+class NamedJob
+  def display_name
+    'named_job'
+  end
+end
+
+class SimpleJob
+  cattr_accessor :runs
+  @runs = 0
+  def perform
+    self.class.runs += 1
+  end
+end
+
+class NamedQueueJob < SimpleJob
+  def queue_name
+    'job_tracking'
+  end
+end
+
+class ErrorJob
+  cattr_accessor :runs
+  @runs = 0
+  def perform
+    raise 'did not work'
+  end
+end
+
+CustomRescheduleJob = Struct.new(:offset)
+class CustomRescheduleJob
+  cattr_accessor :runs
+  @runs = 0
+  def perform
+    raise 'did not work'
+  end
+
+  def reschedule_at(time, _attempts)
+    time + offset
+  end
+end
+
+class LongRunningJob
+  def perform
+    sleep 250
+  end
+end
+
+class OnPermanentFailureJob < SimpleJob
+  attr_writer :raise_error
+
+  def initialize
+    @raise_error = false
+  end
+
+  def failure
+    raise 'did not work' if @raise_error
+  end
+
+  def max_attempts
+    1
+  end
+end
+
+module M
+  class ModuleJob
+    cattr_accessor :runs
+    @runs = 0
+    def perform
+      self.class.runs += 1
+    end
+  end
+end
+
+class CallbackJob
+  cattr_accessor :messages
+
+  def enqueue(_job)
+    self.class.messages << 'enqueue'
+  end
+
+  def before(_job)
+    self.class.messages << 'before'
+  end
+
+  def perform
+    self.class.messages << 'perform'
+  end
+
+  def after(_job)
+    self.class.messages << 'after'
+  end
+
+  def success(_job)
+    self.class.messages << 'success'
+  end
+
+  def error(_job, error)
+    self.class.messages << "error: #{error.class}"
+  end
+
+  def failure(_job)
+    self.class.messages << 'failure'
+  end
+end
+
+class EnqueueJobMod < SimpleJob
+  def enqueue(job)
+    job.run_at = 20.minutes.from_now
+  end
+end