delayed 0.1.0

data/spec/performable_mailer_spec.rb

@@ -0,0 +1,68 @@
+require 'helper'
+
+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 {
+        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'])
+      }.to change { Delayed::Job.count }.by(1)
+    end
+  end
+
+  describe 'delay on a mail object' do
+    it 'raises an exception' do
+      expect {
+        MyMailer.signup('john@example.com').delay
+      }.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 = described_class.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
+
+if defined?(ActionMailer::Parameterized::Mailer)
+  describe ActionMailer::Parameterized::Mailer do
+    describe 'delay' do
+      it 'enqueues a PerformableEmail job' do
+        expect {
+          job = MyMailer.with(foo: 1, bar: 2).delay.signup('john@example.com')
+          expect(job.payload_object.class).to eq(Delayed::PerformableMailer)
+          expect(job.payload_object.object.class).to eq(described_class)
+          expect(job.payload_object.object.instance_variable_get('@mailer')).to eq(MyMailer)
+          expect(job.payload_object.object.instance_variable_get('@params')).to eq(foo: 1, bar: 2)
+          expect(job.payload_object.method_name).to eq(:signup)
+          expect(job.payload_object.args).to eq(['john@example.com'])
+        }.to change { Delayed::Job.count }.by(1)
+      end
+    end
+
+    describe 'delay on a mail object' do
+      it 'raises an exception' do
+        expect {
+          MyMailer.with(foo: 1, bar: 2).signup('john@example.com').delay
+        }.to raise_error(RuntimeError)
+      end
+    end
+  end
+end

data/spec/performable_method_spec.rb

@@ -0,0 +1,123 @@
+require 'helper'
+
+describe Delayed::PerformableMethod do
+  describe 'perform' do
+    before do
+      @method = described_class.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 {
+      described_class.new(Object, :method_that_does_not_exist, [])
+    }.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 { described_class.new(clazz.new, :private_method, []) }.not_to raise_error
+  end
+
+  context 'when it receives an object that is not persisted' do
+    let(:object) { double(persisted?: false, expensive_operation: true) }
+
+    it 'raises an ArgumentError' do
+      expect { described_class.new(object, :expensive_operation, []) }.to raise_error ArgumentError
+    end
+
+    it 'does not raise ArgumentError if the object acts like a Her model' do
+      allow(object.class).to receive(:save_existing).and_return(true)
+      expect { described_class.new(object, :expensive_operation, []) }.not_to raise_error
+    end
+  end
+
+  describe 'display_name' do
+    it 'returns class_name#method_name for instance methods' do
+      expect(described_class.new('foo', :count, ['o']).display_name).to eq('String#count')
+    end
+
+    it 'returns class_name.method_name for class methods' do
+      expect(described_class.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(RuntimeError)
+    end
+
+    it 'delegates failure hook to object' do
+      method = described_class.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(RuntimeError)
+      end
+
+      it 'delegates failure hook to object' do
+        method = described_class.new('object', :size, [])
+        expect(method.object).to receive(:failure)
+        method.failure
+      end
+    end
+  end
+end

data/spec/psych_ext_spec.rb

@@ -0,0 +1,94 @@
+require 'helper'
+require 'active_support/core_ext/string/strip'
+
+describe 'Psych::Visitors::ToRuby', if: defined?(Psych::Visitors::ToRuby) do
+  context BigDecimal do
+    it 'deserializes correctly' do
+      deserialized = YAML.load_dj("--- !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
+
+  context ActiveRecord::Base do
+    it 'serializes and deserializes in a version-independent way' do
+      Story.create.tap do |story|
+        serialized = YAML.dump_dj(story)
+        expect(serialized).to eq <<-YAML.strip_heredoc
+          --- !ruby/ActiveRecord:Story
+          attributes:
+            story_id: #{story.id}
+        YAML
+
+        deserialized = YAML.load_dj(serialized)
+        expect(deserialized).to be_an_instance_of(Story)
+        expect(deserialized).to eq Story.find(story.id)
+      end
+    end
+
+    it 'ignores garbage when deserializing' do
+      Story.create.tap do |story|
+        serialized = <<-YML.strip_heredoc
+          --- !ruby/ActiveRecord:Story
+          attributes:
+            story_id: #{story.id}
+            other_stuff: 'boo'
+            asdf: { fish: true }
+        YML
+
+        deserialized = YAML.load_dj(serialized)
+        expect(deserialized).to be_an_instance_of(Story)
+        expect(deserialized).to eq Story.find(story.id)
+      end
+    end
+  end
+
+  context Singleton do
+    it 'serializes and deserializes generic singleton classes' do
+      serialized = <<-YML.strip_heredoc
+        - !ruby/object:SingletonClass {}
+        - !ruby/object:SingletonClass {}
+      YML
+      deserialized = YAML.load_dj(
+        YAML.load_dj(serialized).to_yaml,
+      )
+
+      expect(deserialized).to contain_exactly(SingletonClass.instance, SingletonClass.instance)
+    end
+
+    it 'deserializes ActiveModel::NullMutationTracker' do
+      serialized = <<-YML.strip_heredoc
+        - !ruby/object:ActiveModel::NullMutationTracker {}
+        - !ruby/object:ActiveModel::NullMutationTracker {}
+      YML
+      deserialized = YAML.load_dj(
+        YAML.load_dj(serialized).to_yaml,
+      )
+
+      expect(deserialized).to contain_exactly(ActiveModel::NullMutationTracker.instance, ActiveModel::NullMutationTracker.instance)
+    end
+  end
+
+  context 'load_tag handling' do
+    # This only broadly works in ruby 2.0 but will cleanly work through load_dj
+    # here because this class is so simple it only touches our extention
+    YAML.load_tags['!ruby/object:RenamedClass'] = SimpleJob
+    # This is how ruby 2.1 and newer works throughout the yaml handling
+    YAML.load_tags['!ruby/object:RenamedString'] = 'SimpleJob'
+
+    it 'deserializes class tag' do
+      deserialized = YAML.load_dj("--- !ruby/object:RenamedClass\ncheck: 12\n")
+
+      expect(deserialized).to be_an_instance_of(SimpleJob)
+      expect(deserialized.instance_variable_get(:@check)).to eq(12)
+    end
+
+    it 'deserializes string tag' do
+      deserialized = YAML.load_dj("--- !ruby/object:RenamedString\ncheck: 12\n")
+
+      expect(deserialized).to be_an_instance_of(SimpleJob)
+      expect(deserialized.instance_variable_get(:@check)).to eq(12)
+    end
+  end
+end

data/spec/sample_jobs.rb

@@ -0,0 +1,117 @@
+NamedJob = Struct.new(:perform)
+class NamedJob
+  def display_name
+    'named_job'
+  end
+end
+
+class SimpleJob
+  cattr_accessor(: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) { 0 }
+  def perform
+    raise StandardError, 'did not work'
+  end
+end
+
+class FailureJob < ErrorJob
+  def max_attempts
+    1
+  end
+end
+
+CustomRescheduleJob = Struct.new(:offset)
+class CustomRescheduleJob
+  cattr_accessor(: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) { 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
+
+class ActiveJobJob < ActiveJob::Base # rubocop:disable Rails/ApplicationJob
+  def perform; end
+end

data/spec/worker_spec.rb

@@ -0,0 +1,235 @@
+require 'helper'
+
+describe Delayed::Worker do
+  before do
+    described_class.sleep_delay = 0
+  end
+
+  describe 'start' do
+    it 'runs the :execute lifecycle hook' do
+      performances = []
+      plugin = Class.new(Delayed::Plugin) do
+        callbacks do |lifecycle|
+          lifecycle.before(:execute) { performances << true }
+          lifecycle.after(:execute) { |arg| performances << arg }
+          lifecycle.around(:execute) { |arg, &block| performances << block.call(arg) }
+        end
+      end
+      Delayed.plugins << plugin
+
+      subject.send(:stop) # prevent start from running more than one loop
+      allow(Delayed::Job).to receive(:reserve).and_return([])
+      subject.start
+      expect(performances).to eq [true, nil, nil]
+      expect(Delayed::Job).to have_received(:reserve)
+    end
+  end
+
+  # rubocop:disable RSpec/SubjectStub
+  describe '#run!' do
+    before do
+      allow(Delayed.logger).to receive(:info).and_call_original
+      allow(subject).to receive(:interruptable_sleep).and_call_original
+    end
+
+    context 'when there are no jobs' do
+      before do
+        allow(Delayed::Job).to receive(:reserve).and_return([])
+      end
+
+      it 'does not log and then sleeps' do
+        subject.run!
+        expect(Delayed.logger).not_to have_received(:info)
+        expect(subject).to have_received(:interruptable_sleep)
+      end
+    end
+
+    context 'when there is a job worked off' do
+      around do |example|
+        max_claims_was = described_class.max_claims
+        described_class.max_claims = max_claims
+        example.run
+      ensure
+        described_class.max_claims = max_claims_was
+      end
+
+      before do
+        allow(Delayed::Job).to receive(:reserve).and_return([job], [])
+      end
+
+      let(:max_claims) { 1 }
+      let(:job) do
+        instance_double(
+          Delayed::Job,
+          id: 123,
+          max_run_time: 10,
+          name: 'MyJob',
+          run_at: Delayed::Job.db_time_now,
+          created_at: Delayed::Job.db_time_now,
+          priority: Delayed::Priority.interactive,
+          queue: 'testqueue',
+          attempts: 0,
+          invoke_job: true,
+          destroy: true,
+        )
+      end
+
+      it 'logs the count and does not sleep' do
+        subject.run!
+        expect(Delayed.logger).to have_received(:info).with(/1 jobs processed/)
+        expect(subject).not_to have_received(:interruptable_sleep)
+      end
+
+      context 'when max_claims is 2' do
+        let(:max_claims) { 2 }
+
+        it 'logs the count and sleeps' do
+          subject.run!
+          expect(Delayed.logger).to have_received(:info).with(/1 jobs processed/)
+          expect(subject).to have_received(:interruptable_sleep)
+        end
+      end
+    end
+  end
+  # rubocop:enable RSpec/SubjectStub
+
+  describe 'job_say' do
+    before do
+      @worker = described_class.new
+      @job = double('job', id: 123, name: 'ExampleJob', queue: nil)
+    end
+
+    it 'logs with job name and id' do
+      expect(@job).to receive(:queue)
+      expect(@worker).to receive(:say)
+        .with('Job ExampleJob (id=123) message', 'info')
+      @worker.job_say(@job, 'message')
+    end
+
+    it 'logs with job name, queue and id' do
+      expect(@job).to receive(:queue).and_return('test')
+      expect(@worker).to receive(:say)
+        .with('Job ExampleJob (id=123) (queue=test) message', 'info')
+      @worker.job_say(@job, 'message')
+    end
+
+    it 'has a configurable default log level' do
+      described_class.default_log_level = 'error'
+
+      expect(@worker).to receive(:say)
+        .with('Job ExampleJob (id=123) message', 'error')
+      @worker.job_say(@job, 'message')
+    ensure
+      described_class.default_log_level = 'info'
+    end
+  end
+
+  context 'worker read-ahead' do
+    before do
+      @read_ahead = described_class.read_ahead
+    end
+
+    after do
+      described_class.read_ahead = @read_ahead
+    end
+
+    it 'reads five jobs' do
+      expect(described_class.new.read_ahead).to eq(5)
+    end
+
+    it 'reads a configurable number of jobs' do
+      described_class.read_ahead = 15
+      expect(described_class.new.read_ahead).to eq(15)
+    end
+  end
+
+  context 'worker job reservation' do
+    it 'handles error during job reservation' do
+      expect(Delayed::Job).to receive(:reserve).and_raise(Exception)
+      described_class.new.work_off
+    end
+
+    it 'gives up after 10 backend failures' do
+      expect(Delayed::Job).to receive(:reserve).exactly(10).times.and_raise(Exception)
+      worker = described_class.new
+      9.times { worker.work_off }
+      expect(lambda { worker.work_off }).to raise_exception Delayed::FatalBackendError
+    end
+
+    it 'allows the backend to attempt recovery from reservation errors' do
+      expect(Delayed::Job).to receive(:reserve).and_raise(Exception)
+      expect(Delayed::Job).to receive(:recover_from).with(instance_of(Exception))
+      described_class.new.work_off
+    end
+  end
+
+  describe '#say' do
+    before(:each) do
+      @worker = described_class.new
+      @worker.name = 'ExampleJob'
+      time = Time.now
+      allow(Time).to receive(:now).and_return(time)
+      @text = 'Job executed'
+      @worker_name = '[Worker(ExampleJob)]'
+      @expected_time = time.strftime('%FT%T%z')
+    end
+
+    around do |example|
+      logger = Delayed.logger
+      Delayed.logger = double('job')
+      example.run
+    ensure
+      Delayed.logger = logger
+    end
+
+    it 'logs a message on the default log level' do
+      expect(Delayed.logger).to receive(:send)
+        .with('info', "#{@expected_time}: #{@worker_name} #{@text}")
+      @worker.say(@text)
+    end
+
+    it 'logs a message on a custom log level' do
+      expect(Delayed.logger).to receive(:send)
+        .with('error', "#{@expected_time}: #{@worker_name} #{@text}")
+      @worker.say(@text, 'error')
+    end
+  end
+
+  describe 'plugin registration' do
+    it 'does not double-register plugins on worker instantiation' do
+      performances = 0
+      plugin = Class.new(Delayed::Plugin) do
+        callbacks do |lifecycle|
+          lifecycle.before(:enqueue) { performances += 1 }
+        end
+      end
+      Delayed.plugins << plugin
+
+      described_class.new
+      described_class.new
+      Delayed::Job.enqueue SimpleJob.new
+
+      expect(performances).to eq(1)
+    end
+  end
+
+  describe 'thread callback' do
+    it 'wraps code after thread is checked out' do
+      performances = Concurrent::AtomicFixnum.new(0)
+      plugin = Class.new(Delayed::Plugin) do
+        callbacks do |lifecycle|
+          lifecycle.before(:thread) { performances.increment }
+        end
+      end
+      Delayed.plugins << plugin
+
+      Delayed::Job.delete_all
+      Delayed::Job.enqueue SimpleJob.new
+      worker = described_class.new
+
+      worker.work_off
+
+      expect(performances.value).to eq(1)
+    end
+  end
+end