delayed_job_unique_key 0.0.4 → 0.1.0

data/spec/fixtures/bad_alias.yml

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

data/spec/lifecycle_spec.rb

@@ -1,107 +0,0 @@
-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
-
-  # # This is a spectacularly crappy way to test callbacks. What's a better way?
-  # describe 'arguments callbacks' do
-  #   subject do
-  #     class Testarguments < Delayed::arguments
-  #       def before_execute; end
-  #       def before_loop; end
-  #       def before_perform; end
-  #
-  #       set_callback :execute, :before, :before_execute
-  #       set_callback :loop, :before, :before_loop
-  #       set_callback :perform, :before, :before_perform
-  #     end
-  #
-  #     Testarguments.new.tap { |w| w.stop }
-  #   end
-  #
-  #   it "should trigger for execute event" do
-  #     subject.should_receive(:before_execute).with()
-  #     subject.start
-  #   end
-  #
-  #   it "should trigger for loop event" do
-  #     subject.should_receive(:before_loop).with()
-  #     subject.start
-  #   end
-  #
-  #   it "should trigger for perform event" do
-  #     "foo".delay.length
-  #     subject.should_receive(:before_perform).with()
-  #     subject.start
-  #   end
-  # end
-  #
-  # describe 'job callbacks' do
-  #   it "should trigger for enqueue event" do
-  #     pending 'figure out how to test this'
-  #   end
-  # end
-
-end

data/spec/message_sending_spec.rb

@@ -1,116 +0,0 @@
-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.new
-      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
-        class << self
-          attr_accessor :importance
-        end
-        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 parament' 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
-    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 = Object.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 = Object.delay(:priority => 20, :run_at => run_at).to_s
-      job.run_at.should == run_at
-      job.priority.should == 20
-    end
-    
-    class FairyTail
-      attr_accessor :happy_ending
-      def tell
-        @happy_ending = true
-      end
-    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

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-require 'action_mailer'
-class MyMailer < ActionMailer::Base
-  def signup(email)
-    mail :to => email, :subject => "Delaying Emails"
-  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
-      before do
-        @email = mock('email', :deliver => true)
-        @mailer_class = mock('MailerClass', :signup => @email)
-        @mailer = Delayed::PerformableMailer.new(@mailer_class, :signup, ['john@example.com'])
-      end
-
-      it "should call the method and #deliver on the mailer" do
-        @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

@@ -1,89 +0,0 @@
-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.new
-        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.new
-        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.new
-      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.new
-      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

data/spec/sample_jobs.rb

@@ -1,75 +0,0 @@
-class NamedJob < Struct.new(:perform)
-  def display_name
-    'named_job'
-  end
-end
-
-class SimpleJob
-  cattr_accessor :runs; self.runs = 0
-  def perform; @@runs += 1; end
-end
-
-class ErrorJob
-  cattr_accessor :runs; self.runs = 0
-  def perform; raise 'did not work'; end
-end
-
-class CustomRescheduleJob < Struct.new(:offset)
-  cattr_accessor :runs; self.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
-  def failure; end
-  def max_attempts; 1; end
-end
-
-module M
-  class ModuleJob
-    cattr_accessor :runs; self.runs = 0
-    def perform; @@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

data/spec/spec_helper.rb

@@ -1,45 +0,0 @@
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-
-require 'bundler/setup'
-require 'logger'
-
-require 'rails'
-require 'action_mailer'
-require 'active_support/dependencies'
-require 'active_record'
-
-require 'delayed_job'
-require 'delayed/backend/shared_spec'
-
-Delayed::Worker.logger = Logger.new('/tmp/dj.log')
-ENV['RAILS_ENV'] = 'test'
-
-Delayed::Worker.backend = :test
-
-# Add this directory so the ActiveSupport autoloading works
-ActiveSupport::Dependencies.autoload_paths << File.dirname(__FILE__)
-
-# Add this to simulate Railtie initializer being executed
-ActionMailer::Base.send(:extend, Delayed::DelayMail)
-
-
-# Used to test interactions between DJ and an ORM
-ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => ':memory:'
-ActiveRecord::Base.logger = Delayed::Worker.logger
-ActiveRecord::Migration.verbose = false
-
-ActiveRecord::Schema.define do
-  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
-  set_primary_key :story_id
-  def tell; text; end
-  def whatever(n, _); tell*n; end
-  default_scope where(:scoped => true)
-
-  handle_asynchronously :whatever
-end