delayed 0.1.0

data/spec/delayed/serialization/active_record_spec.rb

@@ -0,0 +1,15 @@
+require "helper"
+
+describe ActiveRecord do
+  it "loads classes with non-default primary key" do
+    expect {
+      YAML.load(Story.create.to_yaml)
+    }.not_to raise_error
+  end
+
+  it "loads classes even if not in default scope" do
+    expect {
+      YAML.load(Story.create(scoped: false).to_yaml)
+    }.not_to raise_error
+  end
+end

data/spec/delayed/tasks_spec.rb

@@ -0,0 +1,116 @@
+require 'helper'
+
+describe 'rake' do
+  let(:runnable) { instance_double(Delayed::Runnable, start: true) }
+
+  before do
+    Rake::Task.clear
+    Rake::Task.define_task(:environment)
+    load 'lib/delayed/tasks.rb'
+
+    allow(ENV).to receive(:[]).and_call_original
+    allow(ENV).to receive(:key?).and_call_original
+  end
+
+  def stub_env(key, value)
+    allow(ENV).to receive(:[]).with(key).and_return(value)
+    allow(ENV).to receive(:key?).with(key).and_return(true)
+  end
+
+  describe 'delayed:work' do
+    before do
+      allow(Delayed::Worker).to receive(:new).and_return(runnable)
+    end
+
+    it 'starts a worker' do
+      Rake.application.invoke_task 'delayed:work'
+      expect(runnable).to have_received(:start)
+    end
+
+    context 'when configurations are set manually' do
+      before do
+        Delayed::Worker.min_priority = 99
+        Delayed::Worker.max_priority = 101
+        Delayed::Worker.queues = %w(a b c)
+        Delayed::Worker.sleep_delay = 1.5
+        Delayed::Worker.read_ahead = 100
+        Delayed::Worker.max_claims = 10
+      end
+
+      it 'does not override them' do
+        Rake.application.invoke_task('delayed:work')
+
+        expect(Delayed::Worker.min_priority).to eq 99
+        expect(Delayed::Worker.max_priority).to eq 101
+        expect(Delayed::Worker.queues).to eq %w(a b c)
+        expect(Delayed::Worker.sleep_delay).to eq 1.5
+        expect(Delayed::Worker.read_ahead).to eq 100
+        expect(Delayed::Worker.max_claims).to eq 10
+      end
+    end
+
+    context 'when environment variables are set' do
+      before do
+        stub_env('MIN_PRIORITY', '6')
+        stub_env('MAX_PRIORITY', '8')
+        stub_env('QUEUES', 'foo,bar')
+        stub_env('SLEEP_DELAY', '1')
+        stub_env('READ_AHEAD', '3')
+        stub_env('MAX_CLAIMS', '3')
+      end
+
+      it 'sets the worker config' do
+        expect { Rake.application.invoke_task('delayed:work') }
+          .to change { Delayed::Worker.min_priority }.from(nil).to(6)
+          .and change { Delayed::Worker.max_priority }.from(nil).to(8)
+          .and change { Delayed::Worker.queues }.from([]).to(%w(foo bar))
+          .and change { Delayed::Worker.sleep_delay }.from(5).to(1)
+          .and change { Delayed::Worker.read_ahead }.from(5).to(3)
+          .and change { Delayed::Worker.max_claims }.from(5).to(3)
+      end
+    end
+  end
+
+  describe 'delayed:monitor' do
+    before do
+      allow(Delayed::Monitor).to receive(:new).and_return(runnable)
+    end
+
+    it 'starts a monitor' do
+      Rake.application.invoke_task 'delayed:monitor'
+      expect(runnable).to have_received(:start)
+    end
+
+    context 'when environment variables are set' do
+      before do
+        stub_env('MIN_PRIORITY', '6')
+        stub_env('MAX_PRIORITY', '8')
+        stub_env('QUEUE', 'foo')
+        stub_env('SLEEP_DELAY', '1')
+        stub_env('READ_AHEAD', '3')
+        stub_env('MAX_CLAIMS', '3')
+      end
+
+      it 'sets the worker config' do
+        expect { Rake.application.invoke_task('delayed:monitor') }
+          .to change { Delayed::Worker.min_priority }.from(nil).to(6)
+          .and change { Delayed::Worker.max_priority }.from(nil).to(8)
+          .and change { Delayed::Worker.queues }.from([]).to(%w(foo))
+          .and change { Delayed::Worker.sleep_delay }.from(5).to(1)
+          .and change { Delayed::Worker.read_ahead }.from(5).to(3)
+          .and change { Delayed::Worker.max_claims }.from(5).to(3)
+      end
+    end
+  end
+
+  describe 'jobs:work' do
+    before do
+      allow(Delayed::Worker).to receive(:new).and_return(runnable)
+    end
+
+    it 'starts a worker' do
+      Rake.application.invoke_task 'jobs:work'
+      expect(runnable).to have_received(:start)
+    end
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,196 @@
+require 'rspec'
+require 'timecop'
+
+require 'action_mailer'
+require 'active_job'
+require 'active_record'
+
+require 'delayed'
+require 'sample_jobs'
+
+require 'rake'
+
+if ENV['DEBUG_LOGS']
+  Delayed.logger = Logger.new($stdout)
+else
+  require 'tempfile'
+
+  tf = Tempfile.new('dj.log')
+  Delayed.logger = Logger.new(tf.path)
+  tf.unlink
+end
+ENV['RAILS_ENV'] = 'test'
+
+db_adapter = ENV["ADAPTER"]
+gemfile = ENV["BUNDLE_GEMFILE"]
+db_adapter ||= gemfile && gemfile[%r{gemfiles/(.*?)/}] && $1 # rubocop:disable Style/PerlBackrefs
+db_adapter ||= "sqlite3"
+
+config = YAML.load(ERB.new(File.read("spec/database.yml")).result)
+ActiveRecord::Base.establish_connection config[db_adapter]
+ActiveRecord::Base.logger = Delayed.logger
+ActiveRecord::Migration.verbose = false
+
+# MySQL 5.7 no longer supports null default values for the primary key
+# Override the default primary key type in Rails <= 4.0
+# https://stackoverflow.com/a/34555109
+if db_adapter == "mysql2"
+  types = if defined?(ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter)
+            # ActiveRecord 3.2+
+            ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter::NATIVE_DATABASE_TYPES
+          else
+            # ActiveRecord < 3.2
+            ActiveRecord::ConnectionAdapters::Mysql2Adapter::NATIVE_DATABASE_TYPES
+          end
+  types[:primary_key] = types[:primary_key].sub(" DEFAULT NULL", "")
+end
+
+migration_template = File.open("lib/generators/delayed/templates/migration.rb")
+
+# need to eval the template with the migration_version intact
+migration_context =
+  Class.new do
+    def my_binding
+      binding
+    end
+
+    private
+
+    def migration_version
+      "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]" if ActiveRecord::VERSION::MAJOR >= 5
+    end
+  end
+
+migration_ruby = ERB.new(migration_template.read).result(migration_context.new.my_binding)
+eval(migration_ruby) # rubocop:disable Security/Eval
+
+ActiveRecord::Schema.define do
+  if table_exists?(:delayed_jobs)
+    # `if_exists: true` was only added in Rails 5
+    drop_table :delayed_jobs
+  end
+
+  CreateDelayedJobs.up
+
+  create_table :stories, primary_key: :story_id, force: true do |table|
+    table.string :text
+    table.boolean :scoped, default: true
+  end
+end
+
+class Story < ActiveRecord::Base
+  self.primary_key = :story_id
+
+  def tell
+    text
+  end
+
+  def whatever(number)
+    tell * number
+  end
+  default_scope { where(scoped: true) }
+
+  handle_asynchronously :whatever
+end
+
+class SingletonClass
+  include Singleton
+end
+
+RSpec.configure do |config|
+  config.around(:each) do |example|
+    aj_priority_was = ActiveJob::Base.priority
+    aj_queue_name_was = ActiveJob::Base.queue_name
+    default_priority_was = Delayed::Worker.default_priority
+    default_queue_name_was = Delayed::Worker.default_queue_name
+    delay_jobs_was = Delayed::Worker.delay_jobs
+    destroy_failed_jobs_was = Delayed::Worker.destroy_failed_jobs
+    max_attempts_was = Delayed::Worker.max_attempts
+    max_claims_was = Delayed::Worker.max_claims
+    max_priority_was = Delayed::Worker.max_priority
+    max_run_time_was = Delayed::Worker.max_run_time
+    min_priority_was = Delayed::Worker.min_priority
+    queues_was = Delayed::Worker.queues
+    read_ahead_was = Delayed::Worker.read_ahead
+    sleep_delay_was = Delayed::Worker.sleep_delay
+
+    example.run
+  ensure
+    ActiveJob::Base.priority = aj_priority_was
+    ActiveJob::Base.queue_name = aj_queue_name_was
+    Delayed::Worker.default_priority = default_priority_was
+    Delayed::Worker.default_queue_name = default_queue_name_was
+    Delayed::Worker.delay_jobs = delay_jobs_was
+    Delayed::Worker.destroy_failed_jobs = destroy_failed_jobs_was
+    Delayed::Worker.max_attempts = max_attempts_was
+    Delayed::Worker.max_claims = max_claims_was
+    Delayed::Worker.max_priority = max_priority_was
+    Delayed::Worker.max_run_time = max_run_time_was
+    Delayed::Worker.min_priority = min_priority_was
+    Delayed::Worker.queues = queues_was
+    Delayed::Worker.read_ahead = read_ahead_was
+    Delayed::Worker.sleep_delay = sleep_delay_was
+
+    Delayed::Job.delete_all
+  end
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end
+
+# Add this directory so the ActiveSupport autoloading works
+ActiveSupport::Dependencies.autoload_paths << File.dirname(__FILE__)
+
+RSpec::Matchers.define :emit_notification do |expected_event_name|
+  attr_reader :actual, :expected
+
+  def supports_block_expectations?
+    true
+  end
+
+  chain :with_payload, :expected_payload
+  chain :with_value, :expected_value
+  diffable
+
+  match do |block|
+    @expected = { event_name: expected_event_name, payload: expected_payload, value: expected_value }
+    @actuals = []
+    callback = ->(name, _started, _finished, _unique_id, payload) do
+      @actuals << { event_name: name, payload: payload.except(:value), value: payload[:value] }
+    end
+
+    ActiveSupport::Notifications.subscribed(callback, expected_event_name, &block)
+
+    unless expected_payload
+      @actuals.each { |a| a.delete(:payload) }
+      @expected.delete(:payload)
+    end
+
+    @actual = @actuals.select { |a| values_match?(@expected.except(:value), a.except(:value)) }
+    @expected = [@expected]
+    values_match?(@expected, @actual)
+  end
+
+  failure_message do
+    <<~MSG
+      Expected the code block to emit:
+        #{@expected.first.inspect}
+
+      But instead, the following were emitted:
+        #{(@actual.presence || @actuals).map(&:inspect).join("\n  ")}
+    MSG
+  end
+end
+
+def current_adapter
+  ENV.fetch('ADAPTER', 'sqlite3')
+end
+
+def current_database
+  if current_adapter == 'sqlite3'
+    a_string_ending_with('tmp/database.sqlite')
+  else
+    'delayed_job_test'
+  end
+end

data/spec/lifecycle_spec.rb

@@ -0,0 +1,77 @@
+require 'helper'
+
+describe Delayed::Lifecycle do
+  let(:lifecycle) { described_class.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(:enqueue, &callback)
+    end
+
+    it 'enqueues before wrapped block' do
+      expect(callback).to receive(:call).with(*arguments).ordered
+      expect(behavior).to receive(:inside!).ordered
+      lifecycle.run_callbacks :enqueue, *arguments, &wrapped_block
+    end
+  end
+
+  describe 'after callbacks' do
+    before(:each) do
+      lifecycle.after(:enqueue, &callback)
+    end
+
+    it 'enqueues after wrapped block' do
+      expect(behavior).to receive(:inside!).ordered
+      expect(callback).to receive(:call).with(*arguments).ordered
+      lifecycle.run_callbacks :enqueue, *arguments, &wrapped_block
+    end
+  end
+
+  describe 'around callbacks' do
+    before(:each) do
+      lifecycle.around(:enqueue) 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 :enqueue, *arguments, &wrapped_block
+    end
+
+    it 'enqueues 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(:enqueue) do |*args, &block|
+        behavior.one
+        block.call(*args)
+      end
+      lifecycle.around(:enqueue) do |*args, &block|
+        behavior.two
+        block.call(*args)
+      end
+      lifecycle.around(:enqueue) do |*args, &block|
+        behavior.three
+        block.call(*args)
+      end
+      lifecycle.run_callbacks(:enqueue, *arguments, &wrapped_block)
+    end
+  end
+
+  it 'raises if callback is enqueued with wrong number of parameters' do
+    lifecycle.before(:enqueue, &callback)
+    expect {
+      lifecycle.run_callbacks(:enqueue, 1, 2, 3) {} # no-op
+    }.to raise_error(ArgumentError, /1 parameter/)
+  end
+end

data/spec/message_sending_spec.rb

@@ -0,0 +1,149 @@
+require 'helper'
+
+describe Delayed::MessageSending do
+  it 'does not include ClassMethods along with MessageSending' do
+    expect { ClassMethods }.to raise_error(NameError)
+    expect(defined?(String::ClassMethods)).to eq(nil)
+  end
+
+  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 {
+        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])
+      }.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 {
+        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'])
+      }.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 {
+        expect {
+          fairy_tail.delay.tell
+        }.to change { fairy_tail.happy_ending }.from(nil).to(true)
+      }.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 {
+        expect {
+          fairy_tail.delay.tell
+        }.not_to change { fairy_tail.happy_ending }
+      }.to change { Delayed::Job.count }.by(1)
+    end
+
+    it 'does delay when delay_jobs is a proc returning true' do
+      Delayed::Worker.delay_jobs = ->(_job) { true }
+      fairy_tail = FairyTail.new
+      expect {
+        expect {
+          fairy_tail.delay.tell
+        }.not_to change { fairy_tail.happy_ending }
+      }.to change { Delayed::Job.count }.by(1)
+    end
+
+    it 'does not delay the job when delay_jobs is a proc returning false' do
+      Delayed::Worker.delay_jobs = ->(_job) { false }
+      fairy_tail = FairyTail.new
+      expect {
+        expect {
+          fairy_tail.delay.tell
+        }.to change { fairy_tail.happy_ending }.from(nil).to(true)
+      }.not_to(change { Delayed::Job.count })
+    end
+  end
+end