rules_engine 0.1.1 → 0.1.3

data/rails_generators/templates/spec/models/re_plan_spec.rb

@@ -0,0 +1,349 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe RePlan do
+  def valid_attributes
+    {
+      :code => "AA MOCK",
+      :title => "Mock Title"
+    }
+  end
+
+  it "should be valid with valid attributes" do
+    RePlan.new(valid_attributes).should be_valid
+  end
+
+  should_have_many :re_plan_workflows
+  should_have_many :re_workflows, :through => :re_plan_workflows
+          
+  should_validate_presence_of :code
+  should_validate_presence_of :title
+  
+  describe "unique attributes" do
+    before(:each) do
+      RePlan.create!(valid_attributes)
+    end
+  
+    should_validate_uniqueness_of :code, :case_sensitive => false, :message=>"alread taken."    
+  end  
+
+  describe "creating a plan" do
+    it "should set the plan_status to draft" do
+      re_plan = RePlan.create!(valid_attributes.except(:plan_status))
+      re_plan.plan_status.should == RePlan::PLAN_STATUS_DRAFT
+    end        
+  end  
+  
+  describe "changing a plan" do
+    describe "changing a plan back to it's reverted state" do
+      it "should mark the plan as published when saving" do
+        re_plan = RePlan.create!(valid_attributes)
+        re_plan.plan_status = RePlan::PLAN_STATUS_REVERTED
+        re_plan.save      
+        re_plan.plan_status.should == RePlan::PLAN_STATUS_PUBLISHED
+      end        
+
+      it "should not mark the plan as changed" do
+        re_plan = RePlan.create!(valid_attributes)
+        re_plan.plan_status = RePlan::PLAN_STATUS_REVERTED
+        re_plan.title = "new title"
+        re_plan.should_not_receive(:changed!)
+        re_plan.save      
+      end        
+    end
+
+    it "should mark the plan as changed" do
+      re_plan = RePlan.create!(valid_attributes)
+      re_plan.title = "new title"
+      re_plan.should_receive(:changed!).with(false)
+      re_plan.save      
+    end        
+    
+    it "should not be changed if the field changed was an ignore attribute" do
+      re_plan = RePlan.create!(valid_attributes)
+      re_plan.updated_at = Time.now + 5.days
+      re_plan.should_not_receive(:changed!)
+      re_plan.save      
+    end        
+  end  
+  
+  it "should replace any nonprint cahracters with an _" do
+    re_plan = RePlan.new(valid_attributes.merge(:code => "my code"))
+    re_plan.save!
+    re_plan.code.should == "my_code"
+  end
+    
+  it "should change the code to lower case when creating" do
+    re_plan = RePlan.new(valid_attributes.merge(:code => "My code"))
+    re_plan.save!
+    re_plan.code.should == "my_code"
+  end
+
+  it "should strip any leading or trailing spaces" do
+    re_plan = RePlan.new(valid_attributes.merge(:code => "  My code  "))
+    re_plan.save!
+    re_plan.code.should == "my_code"
+  end
+    
+  describe "code cannot be changed after creation" do
+    it "should save the code with a new record" do
+      re_plan = RePlan.new(valid_attributes.merge(:code => "my code"))
+      re_plan.save!
+      re_plan.code.should == "my_code"
+    end
+    
+    it "should ignore the code attribute for an existing record" do
+      re_plan = RePlan.new(valid_attributes.merge(:code => "my code"))
+      re_plan.save!
+      re_plan.code = "new_code"
+      re_plan.save!
+      re_plan.code.should == "my_code"
+    end            
+  end
+  
+  describe "publish" do
+    it "should convert the plan to a hash" do
+      re_plan = RePlan.new(valid_attributes)
+      re_plan.stub!(:re_workflows).and_return([mock('workflow one', :code => 'one', :publish => {"workflow" => "one"}), 
+                                               mock('workflow two', :code => 'two', :publish => {"workflow" => "two"})])      
+      publish_data = re_plan.publish
+      publish_data["code"].should == 'aa_mock'
+      publish_data["title"].should == valid_attributes[:title]
+      publish_data["description"].should == valid_attributes[:description]
+      publish_data["first_workflow"].should == "one"
+      publish_data["workflow_one"]["workflow"].should == "one"
+      publish_data["workflow_one"]["next_workflow"].should == "two"
+      publish_data["workflow_two"]["workflow"].should == "two"
+      publish_data["workflow_two"]["next_workflow"].should == ""
+    end
+  end
+
+  describe "revert!" do
+    it "should return self" do
+      re_plan = RePlan.new
+      re_plan.revert!({}).should == re_plan
+    end
+    
+    it "should set the plan as reverted" do
+      re_plan = RePlan.new
+      re_plan.revert!({})
+      re_plan.plan_status.should == RePlan::PLAN_STATUS_REVERTED
+    end
+        
+    it "should set the plan based on the data" do
+      re_workflow_1 = mock_model(ReWorkflow)
+      re_workflow_2 = mock_model(ReWorkflow)
+      re_workflow_1.should_receive(:revert!).with(hash_including('workflow' => 'one')).and_return(re_workflow_1)
+      re_workflow_2.should_receive(:revert!).with(hash_including('workflow' => 'two')).and_return(re_workflow_2)
+      ReWorkflow.stub!(:new).and_return(re_workflow_1, re_workflow_2)
+      
+      re_plan = RePlan.new
+      re_plan.should_receive(:re_workflows=).with([re_workflow_1, re_workflow_2])
+      
+      re_plan.revert!({"code" => "mock_workflow_code", 
+                            "title" => "mock_title", 
+                            "description" => "mock_description",
+                            "first_workflow" => "one",
+                            "workflow_one" => {"workflow" => "one", "next_workflow" => "two"},
+                            "workflow_two" => {"workflow" => "two", "next_workflow" => ""}
+                        })
+                            
+     re_plan.code.should == "mock_workflow_code"
+     re_plan.title.should == "mock_title"
+     re_plan.description.should == "mock_description"
+    end
+  end
+  
+  describe "adding a workflow" do
+    it "should be false if it already has the workflow" do
+      re_plan = RePlan.new
+      re_workflow = mock_model(ReWorkflow)
+      re_plan.stub!(:re_workflows).and_return([re_workflow])
+      re_plan.add_workflow(re_workflow).should == false
+    end
+    
+    it "should add the workflow" do
+      re_plan = RePlan.new
+      re_workflow = mock_model(ReWorkflow)
+      re_workflows = []
+      re_plan.stub!(:re_workflows).and_return(re_workflows)
+      re_plan.add_workflow(re_workflow)
+      re_workflows.should == [re_workflow]
+    end
+    
+    it "should mark the plan as changed" do
+      re_plan = RePlan.new
+      re_workflow = mock_model(ReWorkflow)
+      re_plan.should_receive(:changed!)
+      re_plan.add_workflow(re_workflow)
+    end
+  end
+
+  describe "removing a workflow" do
+    it "should be false if it does not have the workflow" do
+      re_plan = RePlan.new
+      re_workflow = mock_model(ReWorkflow)
+      re_plan.stub!(:re_workflows).and_return([])
+      re_plan.remove_workflow(re_workflow).should == false
+    end
+    
+    it "should remove the workflow" do
+      re_plan = RePlan.new
+      re_workflow = mock_model(ReWorkflow)
+      re_workflows = [re_workflow]
+      re_plan.stub!(:re_workflows).and_return(re_workflows)
+      re_plan.remove_workflow(re_workflow)
+      re_workflows.should == []
+    end
+    
+    it "should mark the plan as changed" do
+      re_plan = RePlan.new
+      re_workflow = mock_model(ReWorkflow)
+      re_plan.stub!(:re_workflows).and_return([re_workflow])
+      re_plan.should_receive(:changed!)
+      re_plan.remove_workflow(re_workflow)
+    end
+  end
+  
+  describe "setting thew default workflow" do
+    
+    it "should not change the list if the workflow is not in the list" do
+      re_plan = RePlan.new
+      re_workflow = mock_model(ReWorkflow, :id => 1001)
+      re_plan.stub!(:re_workflows).and_return([])
+
+      re_plan.should_not_receive(:changed!)
+      re_plan.default_workflow = re_workflow
+    end
+    
+    it "should not change the list if the workflow is alreasy the default" do
+      re_plan = RePlan.new
+      re_workflow = mock_model(ReWorkflow, :id => 1001)
+      re_plan.stub!(:re_workflows).and_return([re_workflow])
+      
+      re_plan.should_not_receive(:changed!)
+      re_plan.default_workflow = re_workflow      
+    end
+    
+    it "should move the workflow to the top of the list" do
+      re_plan = RePlan.new
+      re_workflow = mock_model(ReWorkflow, :id => 1001)
+      re_plan.stub!(:re_workflows).and_return([mock_model(ReWorkflow, :id => 1001), re_workflow])
+      
+      re_plan_workflow = mock_model(RePlanWorkflow, :re_workflow_id => 1001)
+      re_plan.stub!(:re_plan_workflows).and_return([re_plan_workflow])      
+      
+      re_plan_workflow.should_receive(:move_to_top)
+      re_plan.default_workflow = re_workflow
+    end
+    
+    it "should mark the plan as changed" do
+      re_plan = RePlan.new
+      re_workflow = mock_model(ReWorkflow, :id => 1001)
+      re_plan.stub!(:re_workflows).and_return([mock_model(ReWorkflow, :id => 1001), re_workflow])
+      
+      re_plan_workflow = mock_model(RePlanWorkflow, :re_workflow_id => 1001)
+      re_plan_workflow.stub!(:move_to_top)
+      re_plan.stub!(:re_plan_workflows).and_return([re_plan_workflow])      
+      
+      re_plan.should_receive(:changed!)
+      re_plan.default_workflow = re_workflow
+    end        
+  end
+  
+  describe "getting the default workflow" do
+    it "should return nil if the workflow list empty" do
+      re_plan = RePlan.new
+      re_plan.stub!(:re_workflows).and_return([])
+      re_plan.default_workflow.should == nil
+    end
+
+    it "should return the first workflow in the list" do
+      re_workflow_1 = mock_model(ReWorkflow)
+      re_workflow_2 = mock_model(ReWorkflow)
+      re_plan = RePlan.new
+      re_plan.stub!(:re_workflows).and_return([re_workflow_1, re_workflow_2])
+      re_plan.default_workflow.should == re_workflow_1
+    end
+  end
+  
+  describe "checking for plan errors" do
+    before(:each) do
+      @re_workflow_1 = mock_model(ReRule, :title => "workflow 1")
+      @re_workflow_1.stub!(:workflow_error).and_return(nil)
+      
+      @re_workflow_2 = mock_model(ReRule, :title => "workflow 2")
+      @re_workflow_2.stub!(:workflow_error).and_return(nil)
+  
+      @re_plan = RePlan.new
+      @re_plan.stub!(:re_workflows).and_return([@re_workflow_1, @re_workflow_2])
+    end
+    
+    it "should return a failed message if there are no workflows" do
+      src = RePlan.new(valid_attributes)
+      src.plan_error.should == "workflows req'd"
+    end
+    
+    it "should validate each workflow" do
+      @re_workflow_1.should_receive(:workflow_error).at_least(:once).and_return(nil)
+      @re_workflow_2.should_receive(:workflow_error).at_least(:once).and_return(nil)
+      
+      @re_plan.plan_error.should be_nil
+    end
+  
+    it "should stop on the first workflow error" do
+      @re_workflow_1.should_receive(:workflow_error).at_least(:once).and_return("oops")
+      @re_workflow_2.should_not_receive(:workflow)
+      
+      @re_plan.plan_error.should == "workflow error"
+    end
+  end
+
+  describe "published!" do
+    it "should update the status to PLAN_STATUS_PUBLISHED" do
+      re_plan = RePlan.create!(valid_attributes)
+      re_plan.plan_status.should == RePlan::PLAN_STATUS_DRAFT
+      re_plan.published!
+      re_plan.plan_status.should == RePlan::PLAN_STATUS_PUBLISHED
+    end
+  end
+
+  describe "changed!" do
+    it "should not update the status when PLAN_STATUS_DRAFT" do
+      re_plan = RePlan.create!(valid_attributes)
+      re_plan.plan_status.should == RePlan::PLAN_STATUS_DRAFT
+      re_plan.should_not_receive(:save!)
+      re_plan.changed!
+      re_plan.plan_status.should == RePlan::PLAN_STATUS_DRAFT
+    end
+
+    it "should not update the status when PLAN_STATUS_CHANGED" do
+      re_plan = RePlan.create!(valid_attributes)
+      re_plan.published!
+      re_plan.plan_status.should == RePlan::PLAN_STATUS_PUBLISHED
+      re_plan.update_attributes({:title => "new title"})
+      re_plan.plan_status.should == RePlan::PLAN_STATUS_CHANGED
+      re_plan.should_not_receive(:save!)
+      re_plan.changed!
+      re_plan.plan_status.should == RePlan::PLAN_STATUS_CHANGED
+    end
+
+    it "should update the status to PLAN_STATUS_CHANGED changed when PLAN_STATUS_PUBLISHED" do
+      re_plan = RePlan.create!(valid_attributes)
+      re_plan.published!
+      re_plan.plan_status.should == RePlan::PLAN_STATUS_PUBLISHED
+      re_plan.should_receive(:save!)
+      re_plan.changed!
+      re_plan.plan_status.should == RePlan::PLAN_STATUS_CHANGED
+    end
+
+    it "should not save the plan whe the save flag is false" do
+      re_plan = RePlan.create!(valid_attributes)
+      re_plan.published!
+      re_plan.plan_status.should == RePlan::PLAN_STATUS_PUBLISHED
+      re_plan.should_not_receive(:save!)
+      re_plan.changed!(false)
+      re_plan.plan_status.should == RePlan::PLAN_STATUS_CHANGED
+    end
+  end
+  
+end

data/rails_generators/templates/spec/models/re_plan_workflow_spec.rb

@@ -0,0 +1,6 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe RePlanWorkflow do
+  should_belong_to :re_plan
+  should_belong_to :re_workflow
+end

data/rails_generators/templates/spec/models/re_rule_expected_outcome_spec.rb

@@ -13,61 +13,17 @@ describe ReRuleExpectedOutcome do
   
   should_validate_presence_of :outcome
 
-  describe "START PIPELINE" do
-    it "should be invalid when the outcome pipeline code is blank" do
-      re_rule_expected_outcome = ReRuleExpectedOutcome.new(:outcome => RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE)
+  describe "START WORKFLOW" do
+    it "should be invalid when the outcome workflow code is blank" do
+      re_rule_expected_outcome = ReRuleExpectedOutcome.new(:outcome => RulesEngine::RuleOutcome::OUTCOME_START_WORKFLOW)
       re_rule_expected_outcome.should_not be_valid
-      re_rule_expected_outcome.errors.on(:pipeline_code).should_not be_blank
+      re_rule_expected_outcome.errors.on(:workflow_code).should_not be_blank
     end      
-
-    it "should be valid when outcome pipeline code is present" do
-      re_rule_expected_outcome = ReRuleExpectedOutcome.new(:outcome => RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE, :pipeline_code => "mock code")
+  
+    it "should be valid when outcome workflow code is present" do
+      re_rule_expected_outcome = ReRuleExpectedOutcome.new(:outcome => RulesEngine::RuleOutcome::OUTCOME_START_WORKFLOW, :workflow_code => "mock code")
       re_rule_expected_outcome.should be_valid
     end      
   end
 
-  describe "copying the details from another rule outcome" do
-    
-    %W(pipeline_code).each do |key|
-      it "should copy the attribute #{key}" do
-        src = ReRuleExpectedOutcome.new(valid_attributes.merge(key.to_sym => "mock source value"))
-        dest = ReRuleExpectedOutcome.new(valid_attributes.merge(key.to_sym => "mock dest value"))
-        dest.copy!(src)
-        dest.read_attribute(key).should == "mock source value"
-      end
-    end
-
-    %W(outcome).each do |key|
-      it "should copy the attribute #{key}" do
-        src = ReRuleExpectedOutcome.new(valid_attributes.merge(key.to_sym => 101))
-        dest = ReRuleExpectedOutcome.new(valid_attributes.merge(key.to_sym => 202))
-        dest.copy!(src)
-        dest.read_attribute(key).should == 101
-      end
-    end
-  end
-
-  describe "comparing rule outcomes" do
-    it "should be equal if the attributes are equal" do
-      src = ReRuleExpectedOutcome.new(valid_attributes)
-      dest = ReRuleExpectedOutcome.new(valid_attributes)
-      dest.equals?(src).should be_true
-    end
-    
-    %W(outcome).each do |key|
-      it "should not be equal if the attribute #{key} are different" do
-        src = ReRuleExpectedOutcome.new(valid_attributes.merge(key.to_sym => 101))
-        dest = ReRuleExpectedOutcome.new(valid_attributes.merge(key.to_sym => 202))
-        dest.equals?(src).should be_false
-      end
-    end
-    
-    it "should not be equal if the outcome is OUTCOME_START_PIPELINE and pipeline_code are different" do
-      src = ReRuleExpectedOutcome.new(:outcome => RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE, :pipeline_code => "value 1")
-      dest = ReRuleExpectedOutcome.new(:outcome => RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE, :pipeline_code => "value 2")
-      dest.equals?(src).should be_false
-    end
-    
-  end
-  
 end

data/rails_generators/templates/spec/models/re_rule_spec.rb

@@ -6,7 +6,7 @@ describe ReRule do
       :rule_class_name => "MockRuleClass",
       :title => "Mock Title",      
       :summary => "Mock Summary",
-      :data => "Lots Of Data"
+      :data => '["Rule Title", ["one", "two"], "start_workflow", "Other Pipeline"]'
     }
   end
   
@@ -15,22 +15,25 @@ describe ReRule do
     @rule.stub!(:title=)
     @rule.stub!(:summary=)
     @rule.stub!(:data=)
-    @rule.stub!(:after_add_to_pipeline)
-    @rule.stub!(:before_remove_from_pipeline)
+    @rule.stub!(:after_add_to_workflow)
+    @rule.stub!(:before_remove_from_workflow)
     @rule.stub!(:expected_outcomes).and_return([])
     @rule.stub!(:valid?).and_return(true)
     @rule_class = mock("MockRuleClass")
     @rule_class.stub!(:new).and_return(@rule)      
     RulesEngine::Discovery.stub!(:rule_class).and_return(@rule_class)
+    
+    @re_workflow = mock('workflow', :valid? => true)
+    @re_workflow.stub!(:code).and_return('mock code')
+    @re_workflow.stub!(:changed!)
   end
   
   it "should be valid with valid attributes" do
     ReRule.new(valid_attributes).should be_valid
   end
-
-  should_have_many :re_rule_expected_outcomes
-  should_have_many :re_job_audits
   
+  should_belong_to :re_workflow
+  should_have_many :re_rule_expected_outcomes
   should_validate_presence_of :rule_class_name
 
   describe "validate the rule" do
@@ -49,102 +52,6 @@ describe ReRule do
     end
   end
     
-    
-  describe "copying the rule" do    
-    
-    %W(rule_class_name title summary data).each do |key|
-      it "should copy the attribute #{key}" do
-        src = ReRule.new(valid_attributes.merge(key.to_sym => "mock source value"))
-        dest = ReRule.new(valid_attributes.merge(key.to_sym => "mock dest value"))
-        dest.copy!(src)
-        dest.read_attribute(key).should == "mock source value"
-      end
-    end
-  
-    %W(position).each do |key|
-      it "should copy the attribute #{key}" do
-        src = ReRule.new(valid_attributes.merge(key.to_sym => 101))
-        dest = ReRule.new(valid_attributes.merge(key.to_sym => 202))
-        dest.copy!(src)
-        dest.read_attribute(key).should == 101
-      end
-    end
-    
-    it "should copy the rule outcomes" do
-      src = ReRule.new(valid_attributes)
-      dest = ReRule.new(valid_attributes)
-      
-      src_outcome = mock_model(ReRuleExpectedOutcome)
-      dest_outcome = mock_model(ReRuleExpectedOutcome )
-              
-      ReRuleExpectedOutcome.should_receive(:new).and_return(dest_outcome)
-      dest_outcome.should_receive(:copy!).with(src_outcome).and_return(dest_outcome)
-      
-      src.should_receive(:re_rule_expected_outcomes).and_return([src_outcome])
-      dest.should_receive(:re_rule_expected_outcomes=).with([dest_outcome])
-      
-      dest.copy!(src)
-    end
-  end
-  
-  describe "comparing rules" do
-    it "should be equal if the attributes are equal" do
-      src = ReRule.new(valid_attributes)
-      dest = ReRule.new(valid_attributes)
-      dest.equals?(src).should be_true
-    end
-    
-    %W(rule_class_name title summary data).each do |key|
-      it "should not be equal if the attribute #{key} are different" do
-        src = ReRule.new(valid_attributes.merge(key.to_sym => "mock source value"))
-        dest = ReRule.new(valid_attributes.merge(key.to_sym => "mock dest value"))
-        dest.equals?(src).should be_false
-      end
-    end
-  
-    %W(position).each do |key|
-      it "should not be equal if the attribute #{key} are different" do
-        src = ReRule.new(valid_attributes.merge(key.to_sym => 101))
-        dest = ReRule.new(valid_attributes.merge(key.to_sym => 202))
-        dest.equals?(src).should be_false
-      end
-    end
-  
-    describe "equals rule outcome" do
-      before(:each) do
-        @re_rule_re_rule_expected_outcome_1 = mock_model(ReRuleExpectedOutcome)
-        @re_rule_re_rule_expected_outcome_2 = mock_model(ReRuleExpectedOutcome)
-        @re_rule_1 = ReRule.new(valid_attributes)
-        @re_rule_2 = ReRule.new(valid_attributes)
-        @re_rule_1.stub!(:re_rule_expected_outcomes).and_return([@re_rule_re_rule_expected_outcome_1, @re_rule_re_rule_expected_outcome_2])
-        @re_rule_2.stub!(:re_rule_expected_outcomes).and_return([@re_rule_re_rule_expected_outcome_1, @re_rule_re_rule_expected_outcome_2])
-        
-      end
-      it "should not compare the outcomes if the the number is different" do
-        @re_rule_2.stub!(:re_rule_expected_outcomes).and_return([@re_rule_re_rule_expected_outcome_1])
-        
-        @re_rule_re_rule_expected_outcome_1.should_not_receive(:equals?)
-        @re_rule_re_rule_expected_outcome_2.should_not_receive(:equals?)
-      
-        @re_rule_1.equals?(@re_rule_2)
-      end
-    
-      it "should check the equals status of each rule outcome" do
-        @re_rule_re_rule_expected_outcome_1.should_receive(:equals?).with(@re_rule_re_rule_expected_outcome_1).and_return(true)
-        @re_rule_re_rule_expected_outcome_2.should_receive(:equals?).with(@re_rule_re_rule_expected_outcome_2).and_return(true)
-      
-        @re_rule_1.equals?(@re_rule_2).should be_true
-      end
-      
-      it "should stop on the rule outcome equals error" do
-        @re_rule_re_rule_expected_outcome_1.should_receive(:equals?).with(@re_rule_re_rule_expected_outcome_1).and_return(false)
-        @re_rule_re_rule_expected_outcome_2.should_not_receive(:equals?)
-      
-        @re_rule_1.equals?(@re_rule_2).should be_false
-      end
-    end
-  end  
-  
   describe "loading a rule" do
     before(:each) do
       @re_rule = ReRule.new(valid_attributes)
@@ -176,7 +83,7 @@ describe ReRule do
     end
   
     it "should set the rule data with the model data attribute" do
-      @rule.should_receive(:data=).with("Lots Of Data")
+      @rule.should_receive(:data=).with(valid_attributes[:data])
       @re_rule.rule
     end
   end
@@ -196,18 +103,26 @@ describe ReRule do
   end
     
   describe "saving a re_rule" do
+    before(:each) do
+      @re_rule = ReRule.new(valid_attributes)
+      @re_rule.stub!(:re_workflow).and_return(@re_workflow)
+    end
+    
     it "should fail if the rule does not exist" do
-      re_rule = ReRule.new(valid_attributes)
-      re_rule.should_receive(:rule).and_return(nil)
-      re_rule.save.should == false
+      @re_rule.should_receive(:rule).and_return(nil)
+      @re_rule.save.should == false
     end
-  
+
+    it "should set tell the workflow the rule has changed" do
+      @re_workflow.should_receive(:changed!)
+      @re_rule.save
+    end
+          
     describe "a valid rule" do
       before(:each) do
-        @re_rule = ReRule.new(valid_attributes)
         @re_rule.stub(:rule).and_return(@rule)
       end
-
+  
       it "should be successful" do
         @re_rule.save.should == true
       end
@@ -229,9 +144,9 @@ describe ReRule do
       
       it "should set the expected outcomes to the expected outcomes generated by the rule" do
         re_rule_expected_outcome = ReRuleExpectedOutcome.new
-        ReRuleExpectedOutcome.should_receive(:new).with(:outcome => 101, :pipeline_code => "one").and_return(re_rule_expected_outcome)
-        ReRuleExpectedOutcome.should_receive(:new).with(:outcome => 202, :pipeline_code => "two").and_return(re_rule_expected_outcome)
-        @rule.stub(:expected_outcomes).and_return([{:outcome => 101, :pipeline_code => "one"}, {:outcome => 202, :pipeline_code => "two"}])
+        ReRuleExpectedOutcome.should_receive(:new).with(:outcome => 101, :workflow_code => "one").and_return(re_rule_expected_outcome)
+        ReRuleExpectedOutcome.should_receive(:new).with(:outcome => 202, :workflow_code => "two").and_return(re_rule_expected_outcome)
+        @rule.stub(:expected_outcomes).and_return([{:outcome => 101, :workflow_code => "one"}, {:outcome => 202, :workflow_code => "two"}])
         @re_rule.save
         @re_rule.re_rule_expected_outcomes.should == [re_rule_expected_outcome, re_rule_expected_outcome]
       end      
@@ -240,23 +155,28 @@ describe ReRule do
   
   describe "after saving a re_rule" do
     it "should notify the rule" do
-      @re_rule = ReRule.new(valid_attributes)
-      @re_pipeline_id = nil
-      @re_rule_id = nil
-      @rule.should_receive(:after_add_to_pipeline) do |re_pipeline_id, re_rule_id|
-        @re_pipeline_id = re_pipeline_id
-        @re_rule_id = re_rule_id
+      re_rule = ReRule.new(valid_attributes)
+      re_rule.stub!(:re_workflow).and_return(@re_workflow)
+
+      @re_workflow.stub!(:code).and_return('1001')
+      re_rule.stub!(:rule).and_return(@rule)
+
+      updated_code = nil
+      @rule.should_receive(:after_add_to_workflow) do |re_workflow_code|
+        updated_code = re_workflow_code
       end
-      @re_rule.save
-      @re_rule.re_pipeline_id.should == @re_pipeline_id
-      @re_rule.id.should == @re_rule_id
+      re_rule.save
+      updated_code.should == '1001'
     end  
   end
-
+  
   describe "before destroying a re_rule" do
     it "should notify the rule" do
-      @re_rule = ReRule.create(valid_attributes)
-      @rule.should_receive(:before_remove_from_pipeline).with(@re_rule.re_pipeline_id, @re_rule.id)
+      @re_workflow = mock('re_workflow', :code => "1001", :valid? => true)
+      @re_rule = ReRule.new(valid_attributes)
+      @re_rule.stub!(:re_workflow).and_return(@re_workflow)
+
+      @rule.should_receive(:before_remove_from_workflow).with("1001")
       @re_rule.destroy
     end  
   end
@@ -290,12 +210,12 @@ describe ReRule do
       @re_rule.re_rule_expected_outcome_failure.should == outcome_1
     end
   
-    it "should return all outcomes that are a OUTCOME_START_PIPELINE" do
-      outcome_1 = ReRuleExpectedOutcome.new(:outcome => RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE)
-      outcome_2 = ReRuleExpectedOutcome.new(:outcome => RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE)
+    it "should return all outcomes that are a OUTCOME_START_WORKFLOW" do
+      outcome_1 = ReRuleExpectedOutcome.new(:outcome => RulesEngine::RuleOutcome::OUTCOME_START_WORKFLOW)
+      outcome_2 = ReRuleExpectedOutcome.new(:outcome => RulesEngine::RuleOutcome::OUTCOME_START_WORKFLOW)
       @re_rule.re_rule_expected_outcomes << outcome_1
       @re_rule.re_rule_expected_outcomes << outcome_2
-      @re_rule.re_rule_expected_outcomes_start_pipeline.should == [outcome_1, outcome_2]
+      @re_rule.re_rule_expected_outcomes_start_workflow.should == [outcome_1, outcome_2]
     end
   end
   
@@ -309,54 +229,90 @@ describe ReRule do
     
     it "should return '[title] class [class] invalid' if the rule is missing" do
       @re_rule.should_receive(:rule).and_return(nil)
-      @re_rule.rule_error.should == "Mock Title class MockRuleClass invalid"
+      @re_rule.rule_error.should == "class MockRuleClass missing"
     end
     
-    it "should ignore outcomes where the pipeline_code is nil" do
-      re_rule_expected_outcome = mock_model(ReRuleExpectedOutcome, :pipeline_code => nil)
+    it "should ignore outcomes where the workflow_code is nil" do
+      re_rule_expected_outcome = mock_model(ReRuleExpectedOutcome, :workflow_code => nil)
       @re_rule.stub!(:re_rule_expected_outcomes).and_return([re_rule_expected_outcome])
       @re_rule.rule_error.should be_nil
     end
-
-    it "should validate the pipeline is present and activated" do
-      re_rule_expected_outcome = mock_model(ReRuleExpectedOutcome, :pipeline_code => "mock_pipeline_code", :outcome => RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE)
-      RePipeline.should_receive(:find_by_code).and_return(mock("RePipeline", :pipeline_error => nil))      
+  
+    it "should validate the workflow is present and activated" do
+      re_rule_expected_outcome = mock_model(ReRuleExpectedOutcome, :workflow_code => "mock_workflow_code", :outcome => RulesEngine::RuleOutcome::OUTCOME_START_WORKFLOW)
+      ReWorkflow.should_receive(:find_by_code).and_return(mock("ReWorkflow", :workflow_error => nil))      
       @re_rule.stub!(:re_rule_expected_outcomes).and_return([re_rule_expected_outcome])
       @re_rule.rule_error.should be_nil
     end
       
-    it "should return '[pipeline_code] missing' if the required pipeline is missing" do
-      re_rule_expected_outcome = mock_model(ReRuleExpectedOutcome, :pipeline_code => "mock_pipeline_code", :outcome => RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE)
-      RePipeline.should_receive(:find_by_code).and_return(nil)
+    it "should return '[workflow_code] missing' if the required workflow is missing" do
+      re_rule_expected_outcome = mock_model(ReRuleExpectedOutcome, :workflow_code => "mock_workflow_code", :outcome => RulesEngine::RuleOutcome::OUTCOME_START_WORKFLOW)
+      ReWorkflow.should_receive(:find_by_code).and_return(nil)
       @re_rule.stub!(:re_rule_expected_outcomes).and_return([re_rule_expected_outcome])
-      @re_rule.rule_error.should == "mock_pipeline_code missing"
+      @re_rule.rule_error.should == "mock_workflow_code missing"
     end
     
-    it "should return '[pipeline_code] invalid' if the required pipeline has errors" do
-      re_rule_expected_outcome = mock_model(ReRuleExpectedOutcome, :pipeline_code => "mock_pipeline_code", :outcome => RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE)
-      RePipeline.should_receive(:find_by_code).and_return(mock("RePipeline", :pipeline_error => "pipeline error"))      
+    it "should return '[workflow_code] invalid' if the required workflow has errors" do
+      re_rule_expected_outcome = mock_model(ReRuleExpectedOutcome, :workflow_code => "mock_workflow_code", :outcome => RulesEngine::RuleOutcome::OUTCOME_START_WORKFLOW)
+      ReWorkflow.should_receive(:find_by_code).and_return(mock("ReWorkflow", :workflow_error => "workflow error"))      
       @re_rule.stub!(:re_rule_expected_outcomes).and_return([re_rule_expected_outcome])
-      @re_rule.rule_error.should == "mock_pipeline_code invalid"
+      @re_rule.rule_error.should == "mock_workflow_code invalid"
     end
     
   end
   
   describe "moving items in a list" do
     it "should move a rule down in the list" do
-      re_pipeline = RePipelineBase.create!(:code => "AA-MOCK",:title => "Mock Title")
-
+      re_workflow = ReWorkflow.create!(:code => "AA-MOCK",:title => "Mock Title")
+      
       re_rule_1 = ReRule.new(valid_attributes)
       re_rule_2 = ReRule.new(valid_attributes)
-      re_pipeline.re_rules << re_rule_1
-      re_pipeline.re_rules << re_rule_2
+      re_workflow.re_rules << re_rule_1
+      re_workflow.re_rules << re_rule_2
       
-      re_pipeline.reload    
+      re_workflow.reload    
       
-      re_pipeline.re_rules.should == [re_rule_1, re_rule_2]
-      re_pipeline.re_rules[1].move_higher
-      re_pipeline.reload    
+      re_workflow.re_rules.should == [re_rule_1, re_rule_2]
+      re_workflow.re_rules[1].move_higher
+      re_workflow.reload    
   
-      re_pipeline.re_rules.should == [re_rule_2, re_rule_1]
+      re_workflow.re_rules.should == [re_rule_2, re_rule_1]
     end
   end    
+  
+  describe "publish" do
+    it "should convert the rule to a hash" do
+      re_rule = ReRule.new(valid_attributes)
+      
+      publish_data = re_rule.publish
+      publish_data["rule_class_name"].should == valid_attributes[:rule_class_name]
+      publish_data["title"].should == valid_attributes[:title]
+      publish_data["summary"].should == valid_attributes[:summary]
+      publish_data["data"].should == valid_attributes[:data]
+    end
+  end
+
+  describe "revert!" do
+    it "should return self" do
+      re_rule = ReRule.new
+      re_rule.revert!({}).should == re_rule
+    end
+
+    it "should set the rule based on the data" do
+      re_rule = ReRule.new
+      RulesEngine::Discovery.should_receive(:rule_class).with('mock_rule_class_name').and_return(@rule_class)      
+      
+      re_rule.revert!({
+        "rule_class_name" => 'mock_rule_class_name',
+        "title" => 'mock title',
+        "summary" => 'mock summary',
+        "data" => 'mock data'
+      })
+      
+      re_rule[:rule_class_name].should == 'mock_rule_class_name'
+      re_rule[:title].should == 'mock title'
+      re_rule[:summary].should == 'mock summary'
+      re_rule[:data].should == 'mock data'
+    end
+  end
 end