rules_engine 0.1.3 → 0.1.4

data/rails_generators/templates/app/views/re_rule_definitions/simple/_edit.html.erb

@@ -0,0 +1 @@
+<%%= render '/re_rule_definitions/rule_<%=rule_name%>/form' %>

data/rails_generators/templates/app/views/re_rule_definitions/simple/_form.html.erb

@@ -0,0 +1,16 @@
+<%%= re_text_field "Simple Title", 
+                        "rule_<%=rule_name%>_title", 
+                        params[:rule_<%=rule_name%>_title] || @re_rule.rule.title,
+                        :size => 30, 
+                        :required => true, 
+												:error => @re_rule.rule.errors[:rule_<%=rule_name%>_title],
+                        :span => '4x13' %>
+
+
+<%%= re_text_field "Description", 
+                        "rule_<%=rule_name%>_description", 
+                        params[:rule_<%=rule_name%>_description] || @re_rule.rule.description,
+                        :size => 40, 
+                        :required => false, 
+												:error => @re_rule.rule.errors[:rule_<%=rule_name%>_description],
+                        :span => '4x13' %>

data/rails_generators/templates/app/views/re_rule_definitions/simple/_help.html.erb

@@ -0,0 +1 @@
+<p> Simple : This rule does nothing </p>

data/rails_generators/templates/app/views/re_rule_definitions/simple/_new.html.erb

@@ -0,0 +1 @@
+<%%= render '/re_rule_definitions/rule_<%=rule_name%>/form' %>

data/rails_generators/templates/doc/README.rules_engine

@@ -150,7 +150,7 @@ class ApplicationController < ActionController::Base
 
 ######################################
 # 9. Create a Complex Rule
-  ./script/generate rules_engine rule_complex match_words
+  ./script/generate rules_engine complex match_words
 
 ######################################
 # 10. Run the Tests

data/rails_generators/templates/spec/lib/rules/{rule_complex_spec.rb → complex_spec.rb}

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
-describe <%=rule_class%> do
+describe RulesEngine::Rule::<%=rule_class%> do
 
   def valid_attributes
     {
@@ -17,34 +17,34 @@ describe <%=rule_class%> do
   end
   
   it "should be discoverable" do
-    RulesEngine::Discovery.rule_class("<%=rule_class%>").should == <%=rule_class%>
+    RulesEngine::Discovery.rule_class("RulesEngine::Rule::<%=rule_class%>").should == RulesEngine::Rule::<%=rule_class%>
   end
 
   describe "the expected class options" do    
     it "should be in the 'General' group" do
-      <%=rule_class%>.options[:group].should == "General"
+      RulesEngine::Rule::<%=rule_class%>.options[:group].should == "General"
     end
     
-    it "should have the diplay name of '<%=rule_class%> Rule'" do
-      <%=rule_class%>.options[:display_name].should == "<%=rule_class%> Rule"
+    it "should have the diplay name of '<%=rule_class%>'" do
+      RulesEngine::Rule::<%=rule_class%>.options[:display_name].should == "<%=rule_class%>"
     end
 
     it "should have the help template of '/re_rule_definitions/<%=rule_name%>/help'" do
-      <%=rule_class%>.options[:help_partial].should == '/re_rule_definitions/<%=rule_name%>/help'
+      RulesEngine::Rule::<%=rule_class%>.options[:help_partial].should == '/re_rule_definitions/<%=rule_name%>/help'
     end
 
     it "should have the new template of '/re_rule_definitions/<%=rule_name%>/new'" do
-      <%=rule_class%>.options[:new_partial].should == '/re_rule_definitions/<%=rule_name%>/new'
+      RulesEngine::Rule::<%=rule_class%>.options[:new_partial].should == '/re_rule_definitions/<%=rule_name%>/new'
     end
 
     it "should have the edit view partial template of '/re_rule_definitions/<%=rule_name%>/edit'" do
-      <%=rule_class%>.options[:edit_partial].should == '/re_rule_definitions/<%=rule_name%>/edit'
+      RulesEngine::Rule::<%=rule_class%>.options[:edit_partial].should == '/re_rule_definitions/<%=rule_name%>/edit'
     end
   end
   
   describe "setting the rule data" do
     before(:each) do
-      @<%=rule_name%> = <%=rule_class%>.new
+      @<%=rule_name%> = RulesEngine::Rule::<%=rule_class%>.new
       @<%=rule_name%>.data = valid_json_data
     end  
     
@@ -99,13 +99,13 @@ describe <%=rule_class%> do
   
   describe "the summary" do
     it "should be singluar if there is one word" do
-      <%=rule_name%> = <%=rule_class%>.new
+      <%=rule_name%> = RulesEngine::Rule::<%=rule_class%>.new
       <%=rule_name%>.stub!(:words).and_return(["one"])
       <%=rule_name%>.summary.should == "Match the word one"
     end
 
     it "should be plural if there are multiple words" do
-      <%=rule_name%> = <%=rule_class%>.new
+      <%=rule_name%> = RulesEngine::Rule::<%=rule_class%>.new
       <%=rule_name%>.stub!(:words).and_return(["one", "two", "three"])
       <%=rule_name%>.summary.should == "Match the words one, two, three"
     end        
@@ -113,7 +113,7 @@ describe <%=rule_class%> do
 
   describe "the data" do
     it "should be converted to a json string" do
-      <%=rule_name%> = <%=rule_class%>.new
+      <%=rule_name%> = RulesEngine::Rule::<%=rule_class%>.new
       <%=rule_name%>.should_receive(:title).and_return(["mock title"])
       <%=rule_name%>.should_receive(:words).and_return(["one", "two"])
       <%=rule_name%>.should_receive(:workflow_action).and_return(["workflow action"])
@@ -124,41 +124,41 @@ describe <%=rule_class%> do
   
   describe "the expected_outcomes" do
     it "should be next" do
-      <%=rule_name%> = <%=rule_class%>.new
+      <%=rule_name%> = RulesEngine::Rule::<%=rule_class%>.new
       <%=rule_name%>.should_receive(:workflow_action).and_return('next')
-      <%=rule_name%>.expected_outcomes.should == [:outcome => RulesEngine::RuleOutcome::OUTCOME_NEXT]
+      <%=rule_name%>.expected_outcomes.should == [:outcome => RulesEngine::Rule::Outcome::NEXT]
     end
     
     it "should be stop success" do
-      <%=rule_name%> = <%=rule_class%>.new
+      <%=rule_name%> = RulesEngine::Rule::<%=rule_class%>.new
       <%=rule_name%>.should_receive(:workflow_action).and_return('stop_success')
-      <%=rule_name%>.expected_outcomes.should == [:outcome => RulesEngine::RuleOutcome::OUTCOME_STOP_SUCCESS]
+      <%=rule_name%>.expected_outcomes.should == [:outcome => RulesEngine::Rule::Outcome::STOP_SUCCESS]
     end
     
     it "should be stop failure" do
-      <%=rule_name%> = <%=rule_class%>.new
+      <%=rule_name%> = RulesEngine::Rule::<%=rule_class%>.new
       <%=rule_name%>.should_receive(:workflow_action).and_return('stop_failure')
-      <%=rule_name%>.expected_outcomes.should == [:outcome => RulesEngine::RuleOutcome::OUTCOME_STOP_FAILURE]
+      <%=rule_name%>.expected_outcomes.should == [:outcome => RulesEngine::Rule::Outcome::STOP_FAILURE]
     end
     
     it "should be start workflow" do
-      <%=rule_name%> = <%=rule_class%>.new
+      <%=rule_name%> = RulesEngine::Rule::<%=rule_class%>.new
       <%=rule_name%>.should_receive(:workflow_action).and_return('start_workflow')
       <%=rule_name%>.should_receive(:workflow).and_return('mock workflow')
-      <%=rule_name%>.expected_outcomes.should == [:outcome => RulesEngine::RuleOutcome::OUTCOME_START_WORKFLOW, :workflow_code => "mock workflow"]
+      <%=rule_name%>.expected_outcomes.should == [:outcome => RulesEngine::Rule::Outcome::START_WORKFLOW, :workflow_code => "mock workflow"]
     end
     
     it "should be next be default" do
-      <%=rule_name%> = <%=rule_class%>.new
+      <%=rule_name%> = RulesEngine::Rule::<%=rule_class%>.new
       <%=rule_name%>.should_receive(:workflow_action).and_return('this is not valid')
-      <%=rule_name%>.expected_outcomes.should == [:outcome => RulesEngine::RuleOutcome::OUTCOME_NEXT]
+      <%=rule_name%>.expected_outcomes.should == [:outcome => RulesEngine::Rule::Outcome::NEXT]
     end
     
   end
   
   describe "setting the rule attributes" do
     before(:each) do
-      @<%=rule_name%> = <%=rule_class%>.new
+      @<%=rule_name%> = RulesEngine::Rule::<%=rule_class%>.new
     end  
     
     it "should be valid with valid attributes" do
@@ -272,16 +272,16 @@ describe <%=rule_class%> do
   
   describe "processing the rule" do
     before(:each) do
-      @<%=rule_name%> = <%=rule_class%>.new
+      @<%=rule_name%> = RulesEngine::Rule::<%=rule_class%>.new
       @<%=rule_name%>.stub!(:words).and_return(["found", "word"])
     end
     
     it "should do nothing if there is no tweet" do      
-      @<%=rule_name%>.process(1001, {}).outcome.should == RulesEngine::RuleOutcome::OUTCOME_NEXT
+      @<%=rule_name%>.process(1001, {}).outcome.should == RulesEngine::Rule::Outcome::NEXT
     end        
   
     it "should do nothing if there is no match" do
-      @<%=rule_name%>.process(@job, {:tweet => "not here"}).outcome.should == RulesEngine::RuleOutcome::OUTCOME_NEXT
+      @<%=rule_name%>.process(@job, {:tweet => "not here"}).outcome.should == RulesEngine::Rule::Outcome::NEXT
     end        
     
     describe "a match found" do
@@ -305,24 +305,24 @@ describe <%=rule_class%> do
       describe "matching workflow actions" do
         it "should return next" do
           @<%=rule_name%>.should_receive(:workflow_action).and_return('next')
-          @<%=rule_name%>.process(1001, @matched_data).outcome.should == RulesEngine::RuleOutcome::OUTCOME_NEXT
+          @<%=rule_name%>.process(1001, @matched_data).outcome.should == RulesEngine::Rule::Outcome::NEXT
         end
 
         it "should return stop_success" do
           @<%=rule_name%>.should_receive(:workflow_action).and_return('stop_success')
-          @<%=rule_name%>.process(1001, @matched_data).outcome.should == RulesEngine::RuleOutcome::OUTCOME_STOP_SUCCESS
+          @<%=rule_name%>.process(1001, @matched_data).outcome.should == RulesEngine::Rule::Outcome::STOP_SUCCESS
         end
 
         it "should return stop_failure" do
           @<%=rule_name%>.should_receive(:workflow_action).and_return('stop_failure')
-          @<%=rule_name%>.process(1001, @matched_data).outcome.should == RulesEngine::RuleOutcome::OUTCOME_STOP_FAILURE
+          @<%=rule_name%>.process(1001, @matched_data).outcome.should == RulesEngine::Rule::Outcome::STOP_FAILURE
         end
         
         it "should return start workflow with the workflow_code" do
           @<%=rule_name%>.should_receive(:workflow_action).and_return('start_workflow')
           @<%=rule_name%>.should_receive(:workflow).and_return('mock_workflow')
           <%=rule_name%>_outcome = @<%=rule_name%>.process(1001, @matched_data)
-          <%=rule_name%>_outcome.outcome.should == RulesEngine::RuleOutcome::OUTCOME_START_WORKFLOW
+          <%=rule_name%>_outcome.outcome.should == RulesEngine::Rule::Outcome::START_WORKFLOW
           <%=rule_name%>_outcome.workflow_code.should == "mock_workflow"
         end        
       end

data/rails_generators/templates/spec/lib/rules/simple_spec.rb

@@ -0,0 +1,161 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe RulesEngine::Rule::Simple do
+
+  def valid_attributes
+    {
+      :rule_<%=rule_name%>_title => 'Valid Title'
+      # :rule_<%=rule_name%>_description => 'Valid Description'
+    }
+  end
+  
+  def valid_json_data
+    '["Valid Title", "Valid Description"]'
+  end
+  
+  it "should be discoverable" do
+    RulesEngine::Discovery.rule_class("RulesEngine::Rule::Simple").should == RulesEngine::Rule::Simple
+  end
+
+  describe "the expected class options" do    
+    it "should be in the 'General' group" do
+      RulesEngine::Rule::Simple.options[:group].should == "General"
+    end
+    
+    it "should have the diplay name of 'Simple'" do
+      RulesEngine::Rule::Simple.options[:display_name].should == "Simple"
+    end
+
+    it "should have the help template of '/re_rule_definitions/rule_<%=rule_name%>/help'" do
+      RulesEngine::Rule::Simple.options[:help_partial].should == '/re_rule_definitions/rule_<%=rule_name%>/help'
+    end
+
+    it "should have the new template of '/re_rule_definitions/rule_<%=rule_name%>/new'" do
+      RulesEngine::Rule::Simple.options[:new_partial].should == '/re_rule_definitions/rule_<%=rule_name%>/new'
+    end
+
+    it "should have the edit view partial template of '/re_rule_definitions/rule_<%=rule_name%>/edit'" do
+      RulesEngine::Rule::Simple.options[:edit_partial].should == '/re_rule_definitions/rule_<%=rule_name%>/edit'
+    end
+  end
+  
+  describe "setting the rule data" do
+    before(:each) do
+      @rule_<%=rule_name%> = RulesEngine::Rule::Simple.new
+      @rule_<%=rule_name%>.data = valid_json_data
+    end  
+    
+    describe "the data is valid" do
+      it "should be valid" do
+        @rule_<%=rule_name%>.should be_valid
+      end
+            
+      it "should set the title" do
+        @rule_<%=rule_name%>.title.should == "Valid Title"        
+      end
+
+      it "should set the description" do
+        @rule_<%=rule_name%>.description.should == "Valid Description"        
+      end
+    end
+
+    describe "the data is nil" do
+      it "should set the title to nil" do
+        @rule_<%=rule_name%>.title.should_not be_nil
+        @rule_<%=rule_name%>.data = nil
+        @rule_<%=rule_name%>.title.should be_nil
+      end
+
+      it "should set the description to nil" do
+        @rule_<%=rule_name%>.title.should_not be_nil
+        @rule_<%=rule_name%>.data = nil
+        @rule_<%=rule_name%>.description.should be_nil
+      end
+    end
+  end
+  
+  describe "the summary" do
+    describe "description set" do
+      it "should be the rule description" do
+        rule_<%=rule_name%> = RulesEngine::Rule::Simple.new
+        rule_<%=rule_name%>.should_receive(:description).and_return("mock description")
+        rule_<%=rule_name%>.summary.should == "mock description"
+      end
+    end
+    describe "description not set" do
+      it "should be Does Nothing" do
+        rule_<%=rule_name%> = RulesEngine::Rule::Simple.new
+        rule_<%=rule_name%>.should_receive(:description).and_return(nil)
+        rule_<%=rule_name%>.summary.should == "Does Nothing"
+      end
+    end
+  end
+
+  describe "the data" do
+    it "should be converted to a json string" do
+      rule_<%=rule_name%> = RulesEngine::Rule::Simple.new
+      rule_<%=rule_name%>.should_receive(:title).and_return("mock title")
+      rule_<%=rule_name%>.should_receive(:description).and_return("mock description")
+      rule_<%=rule_name%>.data.should == '["mock title","mock description"]'
+    end
+  end
+  
+  describe "the expected_outcomes" do
+    it "should be outcome next" do
+      rule_<%=rule_name%> = RulesEngine::Rule::Simple.new
+      rule_<%=rule_name%>.expected_outcomes.should == [:outcome => RulesEngine::Rule::Outcome::NEXT]
+    end
+  end
+  
+  describe "setting the rule attributes" do
+    before(:each) do
+      @rule_<%=rule_name%> = RulesEngine::Rule::Simple.new
+    end  
+    
+    it "should be valid with valid attributes" do
+      @rule_<%=rule_name%>.attributes = valid_attributes
+      @rule_<%=rule_name%>.should be_valid
+    end            
+  
+    describe "setting the rule_<%=rule_name%>_title" do
+      it "should set the title" do
+        @rule_<%=rule_name%>.attributes = valid_attributes
+        @rule_<%=rule_name%>.title.should == 'Valid Title'
+      end            
+    
+      it "should not be valid if the 'rule_<%=rule_name%>_title' attribute is missing" do
+        @rule_<%=rule_name%>.attributes = valid_attributes.except(:rule_<%=rule_name%>_title)
+        @rule_<%=rule_name%>.should_not be_valid
+        @rule_<%=rule_name%>.errors.should include(:rule_<%=rule_name%>_title)
+      end            
+    
+      it "should not be valid if the 'rule_<%=rule_name%>_title' attribute is blank" do
+        @rule_<%=rule_name%>.attributes = valid_attributes.merge(:rule_<%=rule_name%>_title => "")
+        @rule_<%=rule_name%>.should_not be_valid
+        @rule_<%=rule_name%>.errors.should include(:rule_<%=rule_name%>_title)
+      end                
+    end
+
+    describe "setting the rule_<%=rule_name%>_description" do
+      it "should set the description" do
+        @rule_<%=rule_name%>.attributes = valid_attributes.merge(:rule_<%=rule_name%>_description => 'Valid Description')
+        @rule_<%=rule_name%>.description.should == 'Valid Description'
+      end            
+    end
+  end
+  
+  describe "after a rule is created" do
+    # xit "There is nothing to do here"
+  end
+  
+  describe "after a rule is created" do
+    # xit "There is nothing to do here"
+  end
+  
+  describe "processing the rule" do
+    it "should do nothing" do
+      @rule_<%=rule_name%> = RulesEngine::Rule::Simple.new
+      @rule_<%=rule_name%>.process(1001, {}).outcome.should == RulesEngine::Rule::Outcome::NEXT
+    end        
+  end
+end

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

@@ -3,7 +3,7 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 describe ReRuleExpectedOutcome do
   def valid_attributes
     {
-      :outcome => RulesEngine::RuleOutcome::OUTCOME_NEXT
+      :outcome => RulesEngine::Rule::Outcome::NEXT
     }
   end
   
@@ -15,13 +15,13 @@ describe ReRuleExpectedOutcome do
 
   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 = ReRuleExpectedOutcome.new(:outcome => RulesEngine::Rule::Outcome::START_WORKFLOW)
       re_rule_expected_outcome.should_not be_valid
       re_rule_expected_outcome.errors.on(:workflow_code).should_not be_blank
     end      
   
     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 = ReRuleExpectedOutcome.new(:outcome => RulesEngine::Rule::Outcome::START_WORKFLOW, :workflow_code => "mock code")
       re_rule_expected_outcome.should be_valid
     end      
   end

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

@@ -187,32 +187,32 @@ describe ReRule do
     end
     
     it "should return the first outcome that is a OUTCOME_NEXT" do
-      outcome_1 = ReRuleExpectedOutcome.new(:outcome => RulesEngine::RuleOutcome::OUTCOME_NEXT)
-      outcome_2 = ReRuleExpectedOutcome.new(:outcome => RulesEngine::RuleOutcome::OUTCOME_NEXT)
+      outcome_1 = ReRuleExpectedOutcome.new(:outcome => RulesEngine::Rule::Outcome::NEXT)
+      outcome_2 = ReRuleExpectedOutcome.new(:outcome => RulesEngine::Rule::Outcome::NEXT)
       @re_rule.re_rule_expected_outcomes << outcome_1
       @re_rule.re_rule_expected_outcomes << outcome_2
       @re_rule.re_rule_expected_outcome_next.should == outcome_1
     end
   
     it "should return the first outcome that is a OUTCOME_STOP_SUCCESS" do
-      outcome_1 = ReRuleExpectedOutcome.new(:outcome => RulesEngine::RuleOutcome::OUTCOME_STOP_SUCCESS)
-      outcome_2 = ReRuleExpectedOutcome.new(:outcome => RulesEngine::RuleOutcome::OUTCOME_STOP_SUCCESS)
+      outcome_1 = ReRuleExpectedOutcome.new(:outcome => RulesEngine::Rule::Outcome::STOP_SUCCESS)
+      outcome_2 = ReRuleExpectedOutcome.new(:outcome => RulesEngine::Rule::Outcome::STOP_SUCCESS)
       @re_rule.re_rule_expected_outcomes << outcome_1
       @re_rule.re_rule_expected_outcomes << outcome_2
       @re_rule.re_rule_expected_outcome_success.should == outcome_1
     end
   
     it "should return the first outcome that is a OUTCOME_STOP_FAILURE" do
-      outcome_1 = ReRuleExpectedOutcome.new(:outcome => RulesEngine::RuleOutcome::OUTCOME_STOP_FAILURE)
-      outcome_2 = ReRuleExpectedOutcome.new(:outcome => RulesEngine::RuleOutcome::OUTCOME_STOP_FAILURE)
+      outcome_1 = ReRuleExpectedOutcome.new(:outcome => RulesEngine::Rule::Outcome::STOP_FAILURE)
+      outcome_2 = ReRuleExpectedOutcome.new(:outcome => RulesEngine::Rule::Outcome::STOP_FAILURE)
       @re_rule.re_rule_expected_outcomes << outcome_1
       @re_rule.re_rule_expected_outcomes << outcome_2
       @re_rule.re_rule_expected_outcome_failure.should == outcome_1
     end
   
     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)
+      outcome_1 = ReRuleExpectedOutcome.new(:outcome => RulesEngine::Rule::Outcome::START_WORKFLOW)
+      outcome_2 = ReRuleExpectedOutcome.new(:outcome => RulesEngine::Rule::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_workflow.should == [outcome_1, outcome_2]
@@ -239,21 +239,21 @@ describe ReRule do
     end
   
     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)
+      re_rule_expected_outcome = mock_model(ReRuleExpectedOutcome, :workflow_code => "mock_workflow_code", :outcome => RulesEngine::Rule::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 '[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)
+      re_rule_expected_outcome = mock_model(ReRuleExpectedOutcome, :workflow_code => "mock_workflow_code", :outcome => RulesEngine::Rule::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_workflow_code missing"
     end
     
     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)
+      re_rule_expected_outcome = mock_model(ReRuleExpectedOutcome, :workflow_code => "mock_workflow_code", :outcome => RulesEngine::Rule::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_workflow_code invalid"