pipeline 0.0.8 → 0.0.9

data/spec/pipeline/api_methods_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require 'spec/spec_helper'
 
 module Pipeline
   describe ApiMethods do
@@ -48,6 +48,7 @@ module Pipeline
     describe "#resume" do
       before(:each) do
         @pipeline = Pipeline::Base.new
+        @pipeline.stub!(:resume)
         Pipeline::Base.stub!(:find).with('1').and_return(@pipeline)
         Delayed::Job.stub!(:enqueue)
       end
@@ -72,10 +73,10 @@ module Pipeline
         Pipeline.resume('1')
       end
       
-      it "should raise error is trying to resume in invalid state" do
-        @pipeline.send(:_setup)
+      it "should resume pipeline instance" do
+        @pipeline.should_receive(:resume)
 
-        lambda {Pipeline.resume('1')}.should raise_error(InvalidStatusError, "Status is already in progress")
+        Pipeline.resume('1')
       end
 
     end

data/spec/pipeline/base_spec.rb

@@ -1,53 +1,9 @@
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
-
-class FirstStage < Pipeline::Stage::Base
-  def run
-    @executed = true
-  end
-  
-  def executed?
-    !!@executed
-  end
-end
-
-class SecondStage < FirstStage; end # Ugly.. just so I don't have to write stub again
-
-class IrrecoverableStage < FirstStage
-  def run
-    super
-    raise Pipeline::IrrecoverableError.new
-  end
-end
-
-class RecoverableInputRequiredStage < FirstStage
-  def run
-    super
-    raise Pipeline::RecoverableError.new("message", true)
-  end
-end
-
-class RecoverableStage < FirstStage
-  def run
-    super
-    raise Pipeline::RecoverableError.new("message")
-  end
-end
-
-class GenericErrorStage < FirstStage
-  def run
-    super
-    raise Exception.new
-  end
-end
-
-class SamplePipeline < Pipeline::Base
-  define_stages FirstStage >> SecondStage
-end
+require 'spec/spec_helper'
 
 module Pipeline
   describe Base do
 
-    describe "- configuring" do
+    context "- configuring" do
       before(:each) do
         class ::SamplePipeline
           define_stages FirstStage >> SecondStage
@@ -70,7 +26,7 @@ module Pipeline
       end
     end
     
-    describe "- setup" do
+    context "- setup" do
       before(:each) do
         @pipeline = SamplePipeline.new
       end
@@ -88,15 +44,15 @@ module Pipeline
       end
     end
 
-    describe "- persistence" do
+    context "- persistence" do
       before(:each) do
         @pipeline = Base.new
       end
       
       it "should persist pipeline instance" do
-        @pipeline.id.should be_nil
+        @pipeline.should be_new_record
         lambda {@pipeline.save!}.should_not raise_error
-        @pipeline.id.should_not be_nil
+        @pipeline.should_not be_new_record
       end
       
       it "should allow retrieval by id" do
@@ -149,20 +105,15 @@ module Pipeline
       end
     end
     
-    describe "- execution (success)" do
+    context "- execution (success)" do
       before(:each) do
-        class ::SamplePipeline
-          define_stages FirstStage >> SecondStage
-        end
-        @pipeline = ::SamplePipeline.new
+        @pipeline = SamplePipeline.new
       end
 
       it "should increment attempts" do
-        pipeline = SamplePipeline.new
-        
-        pipeline.attempts.should == 0
-        pipeline.perform
-        pipeline.attempts.should == 1
+        @pipeline.attempts.should == 0
+        @pipeline.perform
+        @pipeline.attempts.should == 1
       end
       
       it "should perform each stage" do
@@ -183,7 +134,7 @@ module Pipeline
       end
     end
     
-    describe "- execution (in progress)" do
+    context "- execution (in progress)" do
       it "should set status to in_progress" do
         pipeline = SamplePipeline.new
         pipeline.send(:_setup)
@@ -193,7 +144,7 @@ module Pipeline
       end
     end
     
-    describe "- execution (irrecoverable error)" do
+    context "- execution (irrecoverable error)" do
       before(:each) do
         class ::SamplePipeline
           define_stages FirstStage >> IrrecoverableStage
@@ -217,7 +168,7 @@ module Pipeline
       end
     end
     
-    describe "- execution (recoverable error that doesn't require user input)" do
+    context "- execution (recoverable error that doesn't require user input)" do
       before(:each) do
         class ::SamplePipeline
           define_stages FirstStage >> RecoverableStage
@@ -241,7 +192,7 @@ module Pipeline
       end
     end
 
-    describe "- execution (recoverable error that requires user input)" do
+    context "- execution (recoverable error that requires user input)" do
       before(:each) do
         class ::SamplePipeline
           define_stages FirstStage >> RecoverableInputRequiredStage
@@ -265,7 +216,7 @@ module Pipeline
       end
     end
 
-    describe "- execution (other errors will use failure mode to pause/cancel pipeline)" do
+    context "- execution (other errors will use failure mode to pause/cancel pipeline)" do
       before(:each) do
         class ::SamplePipeline
           define_stages FirstStage >> GenericErrorStage
@@ -304,7 +255,7 @@ module Pipeline
       end
     end
 
-    describe "- execution (retrying)" do
+    context "- execution (retrying)" do
       before(:each) do
         class ::SamplePipeline
           define_stages FirstStage >> RecoverableInputRequiredStage
@@ -344,15 +295,14 @@ module Pipeline
         
         # Status gets updated to failed on the database (not on the current instance)
         same_pipeline = SamplePipeline.find(@pipeline.id)
-        same_pipeline.send(:status=, :failed)
-        same_pipeline.save!
+        same_pipeline.update_attribute(:status, :failed)
         
         # Retrying should fail because pipeline is now failed
         lambda {@pipeline.perform}.should raise_error(InvalidStatusError, "Status is already failed")
       end
     end
     
-    describe "- execution (state transitions)" do
+    context "- execution (state transitions)" do
       before(:each) do
         @pipeline = Base.new
       end
@@ -363,42 +313,42 @@ module Pipeline
       end
 
       it "should execute if status is :paused (for retrying)" do
-        @pipeline.send(:status=, :paused)
+        @pipeline.update_attribute(:status, :paused)
         
         @pipeline.should be_ok_to_resume
         lambda {@pipeline.perform}.should_not raise_error(InvalidStatusError)
       end
 
       it "should execute if status is :retry" do
-        @pipeline.send(:status=, :retry)
+        @pipeline.update_attribute(:status, :retry)
         
         @pipeline.should be_ok_to_resume
         lambda {@pipeline.perform}.should_not raise_error(InvalidStatusError)
       end
       
       it "should not execute if status is :in_progress" do
-        @pipeline.send(:status=, :in_progress)
+        @pipeline.update_attribute(:status, :in_progress)
         
         @pipeline.should_not be_ok_to_resume
         lambda {@pipeline.perform}.should raise_error(InvalidStatusError, "Status is already in progress")
       end
 
       it "should not execute if status is :completed" do
-        @pipeline.send(:status=, :completed)
+        @pipeline.update_attribute(:status, :completed)
         
         @pipeline.should_not be_ok_to_resume
         lambda {@pipeline.perform}.should raise_error(InvalidStatusError, "Status is already completed")
       end
 
       it "should not execute if status is :failed" do
-        @pipeline.send(:status=, :failed)
+        @pipeline.update_attribute(:status, :failed)
         
         @pipeline.should_not be_ok_to_resume
         lambda {@pipeline.perform}.should raise_error(InvalidStatusError, "Status is already failed")
       end
     end
     
-    describe "- cancelling" do
+    context "- cancelling" do
       before(:each) do
         class ::SamplePipeline
           define_stages FirstStage >> RecoverableInputRequiredStage
@@ -417,9 +367,22 @@ module Pipeline
         @pipeline.cancel
         @pipeline.reload.status.should == :failed
       end
+      
+      it "should refresh object (in case it was updated after job was scheduled)" do
+        # Gets paused on the first time
+        @pipeline.save!
+        
+        # Status gets updated to failed on the database (not on the current instance)
+        same_pipeline = SamplePipeline.find(@pipeline.id)
+        same_pipeline.update_attribute(:status, :failed)
+        
+        # Retrying should fail because pipeline is now failed
+        lambda {@pipeline.cancel}.should raise_error(InvalidStatusError, "Status is already failed")
+      end
+      
     end
 
-    describe "- cancelling (state transitions)" do
+    context "- cancelling (state transitions)" do
       before(:each) do
         @pipeline = Base.new
       end
@@ -429,29 +392,105 @@ module Pipeline
       end
 
       it "should cancel if status is :paused (for retrying)" do
-        @pipeline.send(:status=, :paused)
+        @pipeline.update_attribute(:status, :paused)
         
         lambda {@pipeline.cancel}.should_not raise_error(InvalidStatusError)
       end
       
       it "should not cancel if status is :in_progress" do
-        @pipeline.send(:status=, :in_progress)
+        @pipeline.update_attribute(:status, :in_progress)
         
         lambda {@pipeline.cancel}.should raise_error(InvalidStatusError, "Status is already in progress")
       end
 
       it "should not cancel if status is :completed" do
-        @pipeline.send(:status=, :completed)
+        @pipeline.update_attribute(:status, :completed)
         
         lambda {@pipeline.cancel}.should raise_error(InvalidStatusError, "Status is already completed")
       end
 
       it "should not cancel if status is :failed" do
-        @pipeline.send(:status=, :failed)
+        @pipeline.update_attribute(:status, :failed)
         
         lambda {@pipeline.cancel}.should raise_error(InvalidStatusError, "Status is already failed")
       end
     end
+
+    context "- resuming" do
+      before(:each) do
+        class ::SamplePipeline
+          define_stages FirstStage >> RecoverableInputRequiredStage
+        end
+        @pipeline = SamplePipeline.new
+        @pipeline.perform
+      end
+
+      it "should refresh object (in case it was updated after job was scheduled)" do
+        # Gets paused on the first time
+        @pipeline.save!
+        
+        # Status gets updated to failed on the database (not on the current instance)
+        same_pipeline = SamplePipeline.find(@pipeline.id)
+        same_pipeline.update_attribute(:status, :failed)
+        
+        # Retrying should fail because pipeline is now failed
+        lambda {@pipeline.resume}.should raise_error(InvalidStatusError, "Status is already failed")
+      end
+    end
     
+    context "- resuming (state transitions)" do
+      before(:each) do
+        @pipeline = Base.new
+      end
+      
+      it "should resume if status is :not_started" do
+        lambda {@pipeline.resume}.should_not raise_error(InvalidStatusError)
+      end
+
+      it "should resume if status is :paused (for retrying)" do
+        @pipeline.update_attribute(:status, :paused)
+        
+        lambda {@pipeline.resume}.should_not raise_error(InvalidStatusError)
+      end
+      
+      it "should not resume if status is :in_progress" do
+        @pipeline.update_attribute(:status, :in_progress)
+        
+        lambda {@pipeline.resume}.should raise_error(InvalidStatusError, "Status is already in progress")
+      end
+
+      it "should not resume if status is :completed" do
+        @pipeline.update_attribute(:status, :completed)
+        
+        lambda {@pipeline.resume}.should raise_error(InvalidStatusError, "Status is already completed")
+      end
+
+      it "should not resume if status is :failed" do
+        @pipeline.update_attribute(:status, :failed)
+        
+        lambda {@pipeline.resume}.should raise_error(InvalidStatusError, "Status is already failed")
+      end
+    end
+   
+    context "- callbacks" do
+      before(:each) do
+        @pipeline = ::SamplePipeline.new
+      end
+      
+      it "should allow callback before running the pipeline" do
+        @pipeline.should_receive(:before_pipeline_callback).once
+        @pipeline.perform
+      end
+      
+      it "should allow callback after running the pipeline" do
+        @pipeline.should_receive(:after_pipeline_callback).once
+        @pipeline.perform
+      end
+      
+      it "should run callback after cancelling a pipeline" do
+        @pipeline.should_receive(:after_pipeline_callback).once
+        @pipeline.cancel
+      end
+    end
   end
 end

data/spec/pipeline/core_ext/symbol_attribute_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
+require 'spec/spec_helper'
 
 # Reusing stage table to simplify database integration tests
 class FakeForSymbolAttribute < ActiveRecord::Base

data/spec/pipeline/core_ext/transactional_attribute_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
+require 'spec/spec_helper'
 
 # Reusing stage table to simplify database integration tests
 class FakeForTransactionalAttribute < ActiveRecord::Base

data/spec/pipeline/errors_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require 'spec/spec_helper'
 
 module Pipeline
   describe InvalidPipelineError do

data/spec/pipeline/stage/base_spec.rb

@@ -1,20 +1,10 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
-
-class SampleStage < Pipeline::Stage::Base
-  def run
-    @executed = true
-  end
-  
-  def executed?
-    !!@executed
-  end
-end
+require 'spec/spec_helper'
 
 module Pipeline
   module Stage
     describe Base do
 
-      describe "- chaining" do
+      context "- chaining" do
         class Step1 < Base; end
         class Step2 < Base; end
         class Step3 < Base; end
@@ -32,23 +22,23 @@ module Pipeline
         end
       end
       
-      describe "- setup" do
+      context "- setup" do
         it "should set default name" do
           Base.new.name.should == "Pipeline::Stage::Base"
-          SampleStage.new.name.should == "SampleStage"
+          ::SampleStage.new.name.should == "SampleStage"
         end
         
         it "should allow overriding name at class level" do
-          SampleStage.default_name = "My custom stage name"
-          SampleStage.new.name.should == "My custom stage name"
+          StubStage.default_name = "My custom stage name"
+          StubStage.new.name.should == "My custom stage name"
 
-          SampleStage.default_name = :some_symbol
-          SampleStage.new.name.should == "some_symbol"
+          StubStage.default_name = :some_symbol
+          StubStage.new.name.should == "some_symbol"
         end
 
         it "should allow specifying a name on creation" do
           Base.new(:name => "My Name").name.should == "My Name"
-          SampleStage.new(:name => "Customized Name").name.should == "Customized Name"
+          StubStage.new(:name => "Customized Name").name.should == "Customized Name"
         end
 
         it "should start with status not_started" do
@@ -57,24 +47,28 @@ module Pipeline
         
         it "should validate status" do
           lambda {Base.new(:status => :something_else)}.should raise_error
+        end        
+
+        it "should raise error if subclass doesn't implement #run" do
+          lambda {Base.new.run}.should raise_error("This method must be implemented by any subclass of Pipeline::Stage::Base")
         end
       end
       
-      describe "- persistence" do
+      context "- persistence" do
         before(:each) do
-          @stage = SampleStage.new
+          @stage = StubStage.new
         end
         
         it "should persist stage" do
-          @stage.id.should be_nil
+          @stage.should be_new_record
           lambda {@stage.save!}.should_not raise_error
-          @stage.id.should_not be_nil
+          @stage.should_not be_new_record
         end
         
         it "should allow retrieval by id" do
           @stage.save!
 
-          s = SampleStage.find(@stage.id)
+          s = StubStage.find(@stage.id)
           s.should === @stage
           
           lambda {Base.find('invalid_id')}.should raise_error(ActiveRecord::RecordNotFound)          
@@ -83,7 +77,7 @@ module Pipeline
         it "should persist type as single table inheritance" do
           @stage.save!
           stage = Base.find(@stage.id)
-          stage.should be_an_instance_of(SampleStage)
+          stage.should be_an_instance_of(StubStage)
         end
         
         it "should belong to pipeline instance" do
@@ -96,9 +90,9 @@ module Pipeline
         
       end
 
-      describe "- execution (success)" do
+      context "- execution (success)" do
         before(:each) do
-          @stage = SampleStage.new
+          @stage = StubStage.new
         end
         
         it "should update status after finished" do
@@ -128,89 +122,90 @@ module Pipeline
                 
       end
       
-      describe "- execution (failure)" do
-        before(:each) do
-          @stage = SampleStage.new
-          @stage.stub!(:run).and_raise(StandardError.new)
-        end
-
+      context "- execution (failure)" do
         it "should re-raise error" do
-          lambda {@stage.perform}.should raise_error
+          stage = FailedStage.new
+          lambda {stage.perform}.should raise_error
         end
         
         it "should update status on irrecoverable error" do
-          @stage.should_receive(:run).and_raise(IrrecoverableError.new)
-          lambda {@stage.perform}.should raise_error(IrrecoverableError)
-          @stage.status.should == :failed
-          @stage.reload.status.should == :failed
+          stage = IrrecoverableStage.new
+          lambda {stage.perform}.should raise_error(IrrecoverableError)
+          stage.status.should == :failed
+          stage.reload.status.should == :failed
         end
 
         it "should update message on irrecoverable error" do
-          @stage.should_receive(:run).and_raise(IrrecoverableError.new("message"))
-          lambda {@stage.perform}.should raise_error(IrrecoverableError)
-          @stage.message.should == "message"
-          @stage.reload.message.should == "message"
+          stage = IrrecoverableStage.new
+          lambda {stage.perform}.should raise_error(IrrecoverableError)
+          stage.message.should == "message"
+          stage.reload.message.should == "message"
         end
 
         it "should update status on recoverable error (not requiring input)" do
-          @stage.should_receive(:run).and_raise(RecoverableError.new)
-          lambda {@stage.perform}.should raise_error(RecoverableError)
-          @stage.status.should == :failed
-          @stage.reload.status.should == :failed
+          stage = RecoverableStage.new
+          lambda {stage.perform}.should raise_error(RecoverableError)
+          stage.status.should == :failed
+          stage.reload.status.should == :failed
         end
 
         it "should update status on recoverable error (requiring input)" do
-          @stage.should_receive(:run).and_raise(RecoverableError.new("message", true))
-          lambda {@stage.perform}.should raise_error(RecoverableError)
-          @stage.status.should == :failed
-          @stage.reload.status.should == :failed
+          stage = RecoverableInputRequiredStage.new
+          lambda {stage.perform}.should raise_error(RecoverableError)
+          stage.status.should == :failed
+          stage.reload.status.should == :failed
         end
 
         it "should update message on recoverable error" do
-          @stage.should_receive(:run).and_raise(RecoverableError.new("message"))
-          lambda {@stage.perform}.should raise_error(RecoverableError)
-          @stage.message.should == "message"
-          @stage.reload.message.should == "message"
+          stage = RecoverableStage.new
+          lambda {stage.perform}.should raise_error(RecoverableError)
+          stage.message.should == "message"
+          stage.reload.message.should == "message"
         end
         
         it "should capture generic Exception" do
-          @stage.should_receive(:run).and_raise(Exception.new)
-          lambda {@stage.perform}.should raise_error(Exception)
-          @stage.status.should == :failed
-          @stage.reload.status.should == :failed
+          stage = GenericErrorStage.new
+          lambda {stage.perform}.should raise_error(Exception)
+          stage.status.should == :failed
+          stage.reload.status.should == :failed
         end
         
         it "should log exception message and backtrace" do
-          SampleStage.default_name = "SampleStage"
-          error = StandardError.new("error message")
-          error.set_backtrace(['a', 'b', 'c'])
-          @stage.should_receive(:run).and_raise(error)
+          class StageFailWithDetails < StubStage
+            self.default_name = "Fail With Details"
+            
+            def run
+              super
+              error = StandardError.new("error message")
+              error.set_backtrace(['a', 'b', 'c'])
+              raise error
+            end
+          end
+          stage = StageFailWithDetails.new
 
-          @stage.logger.should_receive(:info).with("Error on stage SampleStage: error message")
-          @stage.logger.should_receive(:info).with("a\nb\nc")
-          lambda {@stage.perform}.should raise_error
+          stage.logger.should_receive(:info).with("Error on stage Fail With Details: error message")
+          stage.logger.should_receive(:info).with("a\nb\nc")
+          lambda {stage.perform}.should raise_error
         end
 
         it "should refresh object (in case it was cancelled after job was scheduled)" do
           # Gets failed on the first time
-          @stage.save!
-          @stage.should_receive(:run).and_raise(RecoverableError.new("message"))
-          lambda {@stage.perform}.should raise_error(RecoverableError)
+          stage = RecoverableStage.create!
+          lambda {stage.perform}.should raise_error(RecoverableError)
 
           # Status gets updated to completed on the database (not on the current instance)
-          same_stage = SampleStage.find(@stage.id)
-          same_stage.send(:status=, :completed)
-          same_stage.save!
+          same_stage = StubStage.find(stage.id)
+          same_stage.update_attribute(:status, :completed)
 
           # Retrying should fail because stage is now completed
-          lambda {@stage.perform}.should raise_error(InvalidStatusError, "Status is already completed")
+          lambda {stage.perform}.should raise_error(InvalidStatusError, "Status is already completed")
         end
 
       end
       
-      describe "- execution (in progress)" do
+      context "- execution (in progress)" do
         it "should set status to in_progress" do
-          stage = SampleStage.new
+          stage = StubStage.new
           stage.send(:_setup)
           
           stage.status.should == :in_progress
@@ -218,7 +213,7 @@ module Pipeline
         end
 
         it "should clear message when restarting" do
-          stage = SampleStage.new(:message => 'some message')
+          stage = StubStage.new(:message => 'some message')
           stage.send(:_setup)
           
           stage.message.should be_nil
@@ -226,35 +221,55 @@ module Pipeline
         end
       end
       
-      describe "- execution (state transitions)" do
+      context "- execution (state transitions)" do
+        before(:each) do
+          @stage = StubStage.new
+        end
+
         it "should execute if status is :not_started" do
-          stage = SampleStage.new
-          
-          lambda {stage.perform}.should_not raise_error(InvalidStatusError)
+          lambda {@stage.perform}.should_not raise_error(InvalidStatusError)
         end
 
         it "should execute if status is :failed (for retrying)" do
-          stage = SampleStage.new
-          stage.send(:status=, :failed)
+          @stage.update_attribute(:status, :failed)
           
-          lambda {stage.perform}.should_not raise_error(InvalidStatusError)
+          lambda {@stage.perform}.should_not raise_error(InvalidStatusError)
         end
         
         it "should not execute if status is :in_progress" do
-          stage = SampleStage.new
-          stage.send(:status=, :in_progress)
+          @stage.update_attribute(:status, :in_progress)
           
-          lambda {stage.perform}.should raise_error(InvalidStatusError, "Status is already in progress")
+          lambda {@stage.perform}.should raise_error(InvalidStatusError, "Status is already in progress")
         end
 
         it "should not execute if status is :completed" do
-          stage = SampleStage.new
-          stage.send(:status=, :completed)
+          @stage.update_attribute(:status, :completed)
 
-          lambda {stage.perform}.should raise_error(InvalidStatusError, "Status is already completed")
+          lambda {@stage.perform}.should raise_error(InvalidStatusError, "Status is already completed")
         end
       end
 
+      context "- callbacks" do
+        before(:each) do
+          @stage = ::SampleStage.new
+        end
+
+        it "should allow callback before running the stage" do
+          @stage.should_receive(:before_stage_callback).once
+          @stage.perform
+        end
+
+        it "should allow callback after running the stage on success" do
+          @stage.should_receive(:after_stage_callback).once
+          @stage.perform
+        end
+
+        it "should allow callback after running the stage on failure" do
+          @stage.stub!(:run).and_raise("error")
+          @stage.should_receive(:after_stage_callback).once
+          lambda {@stage.perform}.should raise_error
+        end
+      end
     end
   end
 end