rules_engine 0.0.1 → 0.0.3

data/rails_generators/templates/spec/controllers/re_rules_controller_spec.rb

@@ -0,0 +1,390 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe ReRulesController do
+  extend RulesEngineMacros
+  
+  before(:each) do
+    controller.instance_eval { flash.stub!(:sweep) }
+    controller.stub!(:rules_engine_reader_access_required).and_return(true)
+    controller.stub!(:rules_engine_editor_access_required).and_return(true)
+    
+    @rule = mock("Rule", :valid? => true)
+    
+    @re_pipeline = mock_model(RePipeline)
+    RePipeline.stub!(:find).and_return(@re_pipeline)    
+    
+    @re_rule = mock_model(ReRule, :re_pipeline_id => @re_pipeline.id)
+    @re_rule.stub!(:rule).and_return(@rule)    
+    ReRule.stub!(:new).and_return(@re_rule)
+    ReRule.stub!(:find).and_return(@re_rule)
+  end  
+
+  describe "help" do
+    it_should_require_rules_engine_reader_access(:help)
+    
+    before(:each) do
+      @rule_class = mock("RuleClass")
+      RulesEngine::Discovery.stub!(:rule_class).and_return(@rule_class)
+      @rule_class.stub!(:new).and_return(@rule)      
+    end
+    
+    it "should assign the re_pipeline" do
+      get :help, :re_pipeline => 1001, :rule_class_name => "mock_rule_class"
+      assigns[:re_pipeline].should == @re_pipeline
+    end      
+    
+    it "should call load discover the rule" do
+      RulesEngine::Discovery.should_receive(:rule_class).with("mock_rule_class").and_return(@rule_class)
+      get :help, :re_pipeline => 1001, :rule_class_name => "mock_rule_class"
+    end
+
+    describe "rule class not found" do
+      it "should render the 'error' template" do
+        RulesEngine::Discovery.should_receive(:rule_class).with("mock_rule_class").and_return(nil)
+        get :help, :re_pipeline => 1001, :rule_class_name => "mock_rule_class"
+        response.should render_template(:error)
+      end
+    end  
+    
+    describe "rule class found" do        
+      it "should assign the rule_class" do
+        get :help, :re_pipeline => 1001, :rule_class_name => "mock_rule_class"
+        assigns[:rule_class].should == @rule_class
+      end      
+
+      it "should assign the rule" do
+        get :help, :re_pipeline => 1001, :rule_class_name => "mock_rule_class"
+        assigns[:rule].should == @rule
+      end      
+    end  
+  end
+
+  describe "error" do
+    it_should_require_rules_engine_reader_access(:error)
+  
+    it "should assign the re_pipeline" do
+      get :error, :re_pipeline => 1001, :rule_class_name => "mock_rule_class"
+      assigns[:re_pipeline].should == @re_pipeline
+    end      
+  end
+  
+  describe "new" do
+    it_should_require_rules_engine_editor_access(:new)
+  
+    it "should assign the re_pipeline" do
+      get :new, :re_pipeline_id => 1001, :rule_class_name => "mock_rule_class"
+      assigns[:re_pipeline].should == @re_pipeline
+    end      
+    
+    it "should assign a new re_rule record" do
+      ReRule.should_receive(:new).and_return(@re_rule)
+      get :new, :re_pipeline_id => 1001, :rule_class_name => "mock_rule_class"
+      assigns[:re_rule].should == @re_rule
+    end
+    
+    describe "rule class not found" do
+      it "should render the 'error' template" do
+        @re_rule.should_receive(:rule).and_return(nil)
+        get :new, :re_pipeline_id => 1001, :rule_class_name => "mock_rule_class"
+        response.should render_template(:error)
+      end
+    end  
+        
+    describe "rule class found" do
+      it "should render the 'new' template" do
+        get :new, :re_pipeline_id => 1001, :rule_class_name => "mock_rule_class"
+        response.should render_template(:new)
+      end
+    end    
+  end
+  
+  describe "create" do
+    
+    before(:each) do
+      @re_rule.stub!(:rule_attributes=)
+      @re_rule.stub!(:valid?).and_return(true)      
+      @re_rule.stub!(:save).and_return(true)      
+    end
+    
+    it_should_require_rules_engine_editor_access(:create)
+  
+    it "should assign the re_pipeline" do
+      post :create, :re_pipeline_id => 1001, :rule_class_name => "mock_rule_class", :re_rule => { :key => "value" }
+      assigns[:re_pipeline].should == @re_pipeline
+    end      
+    
+    it "should assign the new re_rule record with the re_pipeline id" do
+      ReRule.should_receive(:new).with(hash_including(:re_pipeline_id => @re_pipeline.id)).and_return(@re_rule)
+      post :create, :re_pipeline_id => 1001, :rule_class_name => "mock_rule_class", :re_rule => { :key => "value" }
+      assigns[:re_rule].should == @re_rule
+    end
+    
+    it "should assign the new re_rule record with the rule class name" do
+      ReRule.should_receive(:new).with(hash_including(:rule_class_name => "mock_rule_class")).and_return(@re_rule)
+      post :create, :re_pipeline_id => 1001, :rule_class_name => "mock_rule_class", :re_rule => { :key => "value" }
+      assigns[:re_rule].should == @re_rule
+    end
+    
+    describe "rule class not found" do
+      it "should render the 'error' template" do
+        @re_rule.should_receive(:rule).and_return(nil)
+        post :create, :re_pipeline_id => 1001, :rule_class_name => "mock_rule_class", :re_rule => { :key => "value" }
+        response.should render_template(:error)
+      end
+    end  
+
+    describe "rule class found" do
+      it "should assign the rule attributes" do
+        @re_rule.should_receive(:rule_attributes=).with(hash_including("re_pipeline" => "1001", "rule_class_name" => "mock_rule_class", "re_rule" => { "key" => "value" }))
+        post :create, :re_pipeline => 1001, :rule_class_name => "mock_rule_class", :re_rule => { :key => "value" }
+      end
+      
+      describe "re_rule invalid" do
+        it "should render the 'new' template" do
+          @re_rule.should_receive(:valid?).and_return(false)
+          post :create, :re_pipeline_id => 1001, :rule_class_name => "mock_rule_class", :re_rule => { :key => "value" }
+          response.should render_template(:new)
+        end
+      end
+      
+      describe "re_rule cannot be saved" do
+        it "should render the 'new' template" do
+          @re_rule.should_receive(:save).and_return(false)
+          post :create, :re_pipeline_id => 1001, :rule_class_name => "mock_rule_class", :re_rule => { :key => "value" }
+          response.should render_template(:new)
+        end
+      end
+      
+      describe "re_rule valid and saved" do
+        it "should set the success message" do
+          post :create, :re_pipeline_id => 1001, :rule_class_name => "mock_rule_class", :re_rule => { :key => "value" }
+          flash[:success].should_not be_blank
+        end
+      
+        it "should redirect to the change re_pipeline page for HTML" do
+          post :create, :re_pipeline_id => 1001, :rule_class_name => "mock_rule_class", :re_rule => { :key => "value" }
+          response.should redirect_to(change_re_pipeline_path(@re_pipeline))
+        end
+      
+        it "should render 'update' template for JAVASCRIPT" do
+          xhr :post, :create, :re_pipeline_id => 1001, :rule_class_name => "mock_rule_class", :re_rule => { :key => "value" }
+          response.should render_template(:update)
+        end
+      end
+    end  
+  end
+    
+  describe "edit" do
+    it_should_require_rules_engine_editor_access(:edit)
+  
+    it "should assign the re_pipeline" do
+      get :edit, :re_pipeline_id => 1001, :re_rule_id => 2002
+      assigns[:re_pipeline].should == @re_pipeline
+    end      
+    
+    it "should assign a new re_rule record" do
+      ReRule.should_receive(:find).and_return(@re_rule)
+      get :edit, :re_pipeline_id => 1001, :re_rule_id => 2002
+      assigns[:re_rule].should == @re_rule
+    end
+    
+    describe "rule class not found" do
+      it "should render the 'error' template" do
+        @re_rule.should_receive(:rule).and_return(nil)
+        get :edit, :re_pipeline_id => 1001, :re_rule_id => 2002
+        response.should render_template(:error)
+      end
+    end  
+
+    it "should render the 'edit' template" do
+      get :edit, :re_pipeline_id => 1001, :re_rule_id => 2002
+      response.should render_template(:edit)
+    end
+  end
+
+  describe "update" do
+    before(:each) do
+      @re_rule.stub!(:rule_attributes=)
+      @re_rule.stub!(:valid?).and_return(true)      
+      @re_rule.stub!(:save).and_return(true)      
+    end
+
+    it_should_require_rules_engine_editor_access(:update)
+  
+    it "should assign the re_pipeline" do
+      put :update, :re_pipeline_id => 1001, :re_rule_id => 2002, :re_rule => { :key => "value" }
+      assigns[:re_pipeline].should == @re_pipeline
+    end      
+    
+    it "should assign the re_rule record" do
+      ReRule.should_receive(:find).and_return(@re_rule)
+      put :update, :re_pipeline_id => 1001, :re_rule_id => 2002, :re_rule => { :key => "value" }
+      assigns[:re_rule].should == @re_rule
+    end
+    
+    describe "rule class not found" do
+      it "should render the 'error' template" do
+        @re_rule.should_receive(:rule).and_return(nil)
+        put :update, :re_pipeline_id => 1001, :re_rule_id => 2002, :re_rule => { :key => "value" }
+        response.should render_template(:error)
+      end
+    end  
+
+    describe "rule class found" do
+      it "should assign the rule attributes" do
+        @re_rule.should_receive(:rule_attributes=).with(hash_including("re_pipeline_id" => "1001", "re_rule_id" => "2002", "re_rule" => { "key" => "value" }))
+        put :update, :re_pipeline_id => 1001, :re_rule_id => 2002, :re_rule => { :key => "value" }
+      end
+      
+      describe "re_rule invalid" do
+        it "should render the 'edit' template" do
+          @re_rule.should_receive(:valid?).and_return(false)
+          put :update, :re_pipeline_id => 1001, :re_rule_id => 2002, :re_rule => { :key => "value" }
+          response.should render_template(:edit)
+        end
+      end
+      
+      describe "re_rule cannot be saved" do
+        it "should render the 'new' template" do
+          @re_rule.should_receive(:save).and_return(false)
+          put :update, :re_pipeline_id => 1001, :re_rule_id => 2002, :re_rule => { :key => "value" }
+          response.should render_template(:edit)
+        end
+      end
+      
+      describe "re_rule valid and saved" do
+        it "should set the success message" do
+          put :update, :re_pipeline_id => 1001, :re_rule_id => 2002, :re_rule => { :key => "value" }
+          flash[:success].should_not be_blank
+        end
+      
+        it "should redirect to the change re_pipeline page for HTML" do
+          put :update, :re_pipeline_id => 1001, :re_rule_id => 2002, :re_rule => { :key => "value" }
+          response.should redirect_to(change_re_pipeline_path(@re_pipeline))
+        end
+      
+        it "should render 'update' template for JAVASCRIPT" do
+          xhr :put, :update, :re_pipeline_id => 1001, :re_rule_id => 2002, :re_rule => { :key => "value" }
+          response.should render_template(:update)
+        end            
+      end
+    end  
+  end
+  
+  describe "destroy" do
+    before(:each) do
+      @re_rule.stub!(:destroy).and_return(true)      
+    end
+    
+    it_should_require_rules_engine_editor_access(:destroy)
+  
+    it "should assign the re_pipeline" do
+      delete :destroy, :re_pipeline_id => 1001, :re_rule_id => 2002
+      assigns[:re_pipeline].should == @re_pipeline
+    end      
+    
+    it "should assign the re_rule record" do
+      ReRule.should_receive(:find).and_return(@re_rule)
+      delete :destroy, :re_pipeline_id => 1001, :re_rule_id => 2002
+      assigns[:re_rule].should == @re_rule
+    end
+
+    it "should destroy the re_rule" do
+      @re_rule.should_receive(:destroy)
+      delete :destroy, :re_pipeline_id => 1001, :re_rule_id => 2002
+    end
+    
+    it "should set the success message" do
+      delete :destroy, :re_pipeline_id => 1001, :re_rule_id => 2002
+      flash[:success].should_not be_blank
+    end
+
+    it "should redirect to the change re_pipeline page for HTML" do
+      delete :destroy, :re_pipeline_id => 1001, :re_rule_id => 2002
+      response.should redirect_to(change_re_pipeline_path(@re_pipeline))
+    end
+
+    it "should render 'destroy' template for JAVASCRIPT" do
+      xhr :delete, :destroy, :re_pipeline_id => 1001, :re_rule_id => 2002
+      response.should render_template(:destroy)
+    end          
+  end
+  
+  describe "move_up" do
+    before(:each) do
+      @re_rule.stub!(:move_higher).and_return(true)      
+    end
+    
+    it_should_require_rules_engine_editor_access(:move_up)
+  
+    it "should assign the re_pipeline" do
+      put :move_up, :re_pipeline_id => 1001, :re_rule_id => 2002
+      assigns[:re_pipeline].should == @re_pipeline
+    end      
+    
+    it "should assign the re_rule record" do
+      ReRule.should_receive(:find).and_return(@re_rule)
+      put :move_up, :re_pipeline_id => 1001, :re_rule_id => 2002
+      assigns[:re_rule].should == @re_rule
+    end
+
+    it "should call move_higher for the re_rule" do
+      @re_rule.should_receive(:move_higher)
+      put :move_up, :re_pipeline_id => 1001, :re_rule_id => 2002
+    end
+    
+    it "should set the success message" do
+      put :move_up, :re_pipeline_id => 1001, :re_rule_id => 2002
+      flash[:success].should_not be_blank
+    end
+
+    it "should redirect to the change re_pipeline page for HTML" do
+      put :move_up, :re_pipeline_id => 1001, :re_rule_id => 2002
+      response.should redirect_to(change_re_pipeline_path(@re_pipeline))
+    end
+
+    it "should render 'update' template for JAVASCRIPT" do
+      xhr :put, :move_up, :re_pipeline_id => 1001, :re_rule_id => 2002
+      response.should render_template(:update)
+    end          
+  end
+
+  describe "move_down" do
+    before(:each) do
+      @re_rule.stub!(:move_lower).and_return(true)      
+    end
+    
+    it_should_require_rules_engine_editor_access(:move_down)
+  
+    it "should assign the re_pipeline" do
+      put :move_down, :re_pipeline_id => 1001, :re_rule_id => 2002
+      assigns[:re_pipeline].should == @re_pipeline
+    end      
+    
+    it "should assign the re_rule record" do
+      ReRule.should_receive(:find).and_return(@re_rule)
+      put :move_down, :re_pipeline_id => 1001, :re_rule_id => 2002
+      assigns[:re_rule].should == @re_rule
+    end
+
+    it "should call move_lower for the re_rule" do
+      @re_rule.should_receive(:move_lower)
+      put :move_down, :re_pipeline_id => 1001, :re_rule_id => 2002
+    end
+    
+    it "should set the success message" do
+      put :move_down, :re_pipeline_id => 1001, :re_rule_id => 2002
+      flash[:success].should_not be_blank
+    end
+
+    it "should redirect to the change re_pipeline page for HTML" do
+      put :move_down, :re_pipeline_id => 1001, :re_rule_id => 2002
+      response.should redirect_to(change_re_pipeline_path(@re_pipeline))
+    end
+
+    it "should render 'update' template for JAVASCRIPT" do
+      xhr :put, :move_down, :re_pipeline_id => 1001, :re_rule_id => 2002
+      response.should render_template(:update)
+    end          
+  end
+end

data/rails_generators/templates/spec/helpers/re_pipeline_helper_spec.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe RePipelineHelper do 
+  
+  before(:each) do
+    @re_pipeline = mock("RePipeline")
+  end
+  
+  it "should be 'draft' when changed status is CHANGED_STATUS_DRAFT" do
+    @re_pipeline.should_receive(:changed_status).and_return(RePipelineBase::CHANGED_STATUS_DRAFT)
+    helper.re_pipeline_status(@re_pipeline).should == 'draft'
+  end
+
+  it "should be 'changed' when changed status is CHANGED_STATUS_CHANGED" do
+    @re_pipeline.should_receive(:changed_status).and_return(RePipelineBase::CHANGED_STATUS_CHANGED)
+    helper.re_pipeline_status(@re_pipeline).should == 'changed'
+  end
+
+  it "should be 'current' when changed status is CHANGED_STATUS_CURRENT" do
+    @re_pipeline.should_receive(:changed_status).and_return(RePipelineBase::CHANGED_STATUS_CURRENT)
+    helper.re_pipeline_status(@re_pipeline).should == 'current'
+  end
+
+  it "should be 'current' when changed status is unknown" do
+    @re_pipeline.should_receive(:changed_status).and_return(20202020202)
+    helper.re_pipeline_status(@re_pipeline).should == 'current'
+  end
+      
+end

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

@@ -0,0 +1,336 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe <%=rule_class%>Rule do
+
+  def valid_attributes
+    {
+      :<%=rule_name%>_title => 'Valid Title',
+      :<%=rule_name%>_words => {
+                    "1" => { "word" => 'first word'  },
+                    "2" => { "word" => 'second word' }
+                  }
+    }
+  end
+  
+  def valid_json_data
+    '["Rule Title", ["one", "two"], "start_pipeline", "Other Pipeline"]'
+  end
+  
+  it "should be discoverable" do
+    RulesEngine::Discovery.rule_class("<%=rule_class%>Rule").should == <%=rule_class%>Rule
+  end
+
+  describe "the expected class options" do    
+    it "should be in the '<%=rule_class%> Rules' group" do
+      <%=rule_class%>Rule.options[:group].should == "<%=rule_class%>"
+    end
+    
+    it "should have the diplay name of '<%=rule_class%>'" do
+      <%=rule_class%>Rule.options[:display_name].should == "<%=rule_class%>"
+    end
+
+    it "should have the help template of '/re_rule_definitions/<%=rule_name%>_rule/help'" do
+      <%=rule_class%>Rule.options[:help_partial].should == '/re_rule_definitions/<%=rule_name%>_rule/help'
+    end
+
+    it "should have the new template of '/re_rule_definitions/<%=rule_name%>_rule/new'" do
+      <%=rule_class%>Rule.options[:new_partial].should == '/re_rule_definitions/<%=rule_name%>_rule/new'
+    end
+
+    it "should have the edit view partial template of '/re_rule_definitions/<%=rule_name%>_rule/edit'" do
+      <%=rule_class%>Rule.options[:edit_partial].should == '/re_rule_definitions/<%=rule_name%>_rule/edit'
+    end
+  end
+  
+  describe "setting the rule data" do
+    before(:each) do
+      @<%=rule_name%>_rule = <%=rule_class%>Rule.new
+      @<%=rule_name%>_rule.data = valid_json_data
+    end  
+    
+    describe "the json data is valid" do
+      it "should be valid" do
+        @<%=rule_name%>_rule.should be_valid
+      end
+            
+      it "should set the title" do
+        @<%=rule_name%>_rule.title.should == "Rule Title"        
+      end
+
+      it "should set the words" do
+        @<%=rule_name%>_rule.words.should == ["one", "two"]
+      end
+
+      it "should set the pipeline_action" do
+        @<%=rule_name%>_rule.pipeline_action.should == "start_pipeline"
+      end
+
+      it "should set the pipeline" do
+        @<%=rule_name%>_rule.pipeline.should == "Other Pipeline"
+      end        
+    end
+
+    describe "the data is nil" do
+      it "should set the title to nil" do
+        @<%=rule_name%>_rule.title.should_not be_nil
+        @<%=rule_name%>_rule.data = nil
+        @<%=rule_name%>_rule.title.should be_nil
+      end
+      
+      it "should set the words to nil" do
+        @<%=rule_name%>_rule.words.should_not be_nil
+        @<%=rule_name%>_rule.data = nil
+        @<%=rule_name%>_rule.words.should be_nil
+      end
+
+      it "should se the pipeline action to 'continue'" do
+        @<%=rule_name%>_rule.pipeline_action.should_not == 'continue'
+        @<%=rule_name%>_rule.data = nil
+        @<%=rule_name%>_rule.pipeline_action.should == 'continue'
+      end
+      
+      it "should set the 'pipeline' to nil" do
+        @<%=rule_name%>_rule.pipeline.should_not be_nil
+        @<%=rule_name%>_rule.data = nil
+        @<%=rule_name%>_rule.pipeline.should be_nil
+      end              
+    end
+  end
+  
+  describe "the summary" do
+    it "should be singluar if there is one word" do
+      <%=rule_name%>_rule = <%=rule_class%>Rule.new
+      <%=rule_name%>_rule.stub!(:words).and_return(["one"])
+      <%=rule_name%>_rule.summary.should == "Match the word one"
+    end
+
+    it "should be plural if there are multiple words" do
+      <%=rule_name%>_rule = <%=rule_class%>Rule.new
+      <%=rule_name%>_rule.stub!(:words).and_return(["one", "two", "three"])
+      <%=rule_name%>_rule.summary.should == "Match the words one, two, three"
+    end        
+  end
+
+  describe "the data" do
+    it "should be converted to a json string" do
+      <%=rule_name%>_rule = <%=rule_class%>Rule.new
+      <%=rule_name%>_rule.should_receive(:title).and_return(["mock title"])
+      <%=rule_name%>_rule.should_receive(:words).and_return(["one", "two"])
+      <%=rule_name%>_rule.should_receive(:pipeline_action).and_return(["pipeline action"])
+      <%=rule_name%>_rule.should_receive(:pipeline).and_return(["pipeline"])
+      <%=rule_name%>_rule.data.should == '[["mock title"],["one","two"],["pipeline action"],["pipeline"]]'
+    end
+  end
+  
+  describe "the expected_outcomes" do
+    it "should be next" do
+      <%=rule_name%>_rule = <%=rule_class%>Rule.new
+      <%=rule_name%>_rule.should_receive(:pipeline_action).and_return('next')
+      <%=rule_name%>_rule.expected_outcomes.should == [:outcome => RulesEngine::RuleOutcome::OUTCOME_NEXT]
+    end
+    
+    it "should be stop success" do
+      <%=rule_name%>_rule = <%=rule_class%>Rule.new
+      <%=rule_name%>_rule.should_receive(:pipeline_action).and_return('stop_success')
+      <%=rule_name%>_rule.expected_outcomes.should == [:outcome => RulesEngine::RuleOutcome::OUTCOME_STOP_SUCCESS]
+    end
+    
+    it "should be stop failure" do
+      <%=rule_name%>_rule = <%=rule_class%>Rule.new
+      <%=rule_name%>_rule.should_receive(:pipeline_action).and_return('stop_failure')
+      <%=rule_name%>_rule.expected_outcomes.should == [:outcome => RulesEngine::RuleOutcome::OUTCOME_STOP_FAILURE]
+    end
+    
+    it "should be start pipeline" do
+      <%=rule_name%>_rule = <%=rule_class%>Rule.new
+      <%=rule_name%>_rule.should_receive(:pipeline_action).and_return('start_pipeline')
+      <%=rule_name%>_rule.should_receive(:pipeline).and_return('mock pipeline')
+      <%=rule_name%>_rule.expected_outcomes.should == [:outcome => RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE, :pipeline_code => "mock pipeline"]
+    end
+    
+    it "should be next be default" do
+      <%=rule_name%>_rule = <%=rule_class%>Rule.new
+      <%=rule_name%>_rule.should_receive(:pipeline_action).and_return('this is not valid')
+      <%=rule_name%>_rule.expected_outcomes.should == [:outcome => RulesEngine::RuleOutcome::OUTCOME_NEXT]
+    end
+    
+  end
+  
+  describe "setting the rule attributes" do
+    before(:each) do
+      @<%=rule_name%>_rule = <%=rule_class%>Rule.new
+    end  
+    
+    it "should be valid with valid attributes" do
+      @<%=rule_name%>_rule.attributes = valid_attributes
+      @<%=rule_name%>_rule.should be_valid
+    end            
+
+    describe "setting the <%=rule_name%>_title" do
+      it "should set the title" do
+        @<%=rule_name%>_rule.attributes = valid_attributes
+        @<%=rule_name%>_rule.title.should == 'Valid Title'
+      end            
+    
+      it "should not be valid if the '<%=rule_name%>_title' attribute is missing" do
+        @<%=rule_name%>_rule.attributes = valid_attributes.except(:<%=rule_name%>_title)
+        @<%=rule_name%>_rule.should_not be_valid
+        @<%=rule_name%>_rule.errors.should include(:<%=rule_name%>_title)      
+      end            
+    
+      it "should not be valid if the '<%=rule_name%>_title' attribute is blank" do
+        @<%=rule_name%>_rule.attributes = valid_attributes.merge(:<%=rule_name%>_title => "")
+        @<%=rule_name%>_rule.should_not be_valid
+        @<%=rule_name%>_rule.errors.should include(:<%=rule_name%>_title)
+      end                
+    end
+
+    describe "setting the <%=rule_name%>_words" do
+      it "should set the words" do
+        @<%=rule_name%>_rule.attributes = valid_attributes
+        @<%=rule_name%>_rule.words.should == ['first word', 'second word']
+      end            
+    
+      it "should not be valid if the '<%=rule_name%>_words' attribute is missing" do
+        @<%=rule_name%>_rule.attributes = valid_attributes.except(:<%=rule_name%>_words)
+        @<%=rule_name%>_rule.should_not be_valid
+        @<%=rule_name%>_rule.errors.should include(:<%=rule_name%>_words)      
+      end            
+    
+      it "should not be valid if the '<%=rule_name%>_words' is not a hash" do
+        @<%=rule_name%>_rule.attributes = valid_attributes.merge(:<%=rule_name%>_words => "<%=rule_name%> word")
+        @<%=rule_name%>_rule.should_not be_valid
+        @<%=rule_name%>_rule.errors.should include(:<%=rule_name%>_words)
+      end                
+
+      it "should not be valid if the '<%=rule_name%>_words' is empty" do
+        @<%=rule_name%>_rule.attributes = valid_attributes.merge(:<%=rule_name%>_words => {})
+        @<%=rule_name%>_rule.should_not be_valid
+        @<%=rule_name%>_rule.errors.should include(:<%=rule_name%>_words)
+      end                
+      
+      it "should not include parameters that are marked for deletion" do
+        @<%=rule_name%>_rule.attributes = valid_attributes.merge(:<%=rule_name%>_words => {
+                                                                              "1" => { "word" => 'first word', "_delete" => '1'  },
+                                                                              "2" => { "word" => 'second word' }
+                                                                            }         
+         )
+        @<%=rule_name%>_rule.should be_valid
+        @<%=rule_name%>_rule.words.should == ['second word']
+      end
+          
+    end
+
+    describe "setting the <%=rule_name%>_pipeline" do
+      it "should set the pipeline action" do
+        @<%=rule_name%>_rule.attributes = valid_attributes.merge(:<%=rule_name%>_pipeline_action => "mock action")        
+        @<%=rule_name%>_rule.should be_valid
+        @<%=rule_name%>_rule.pipeline_action.should == 'mock action'
+      end
+
+      it "should set the pipeline action to 'continue' by default" do
+        @<%=rule_name%>_rule.attributes = valid_attributes.except(:<%=rule_name%>_pipeline_action)        
+        @<%=rule_name%>_rule.should be_valid
+        @<%=rule_name%>_rule.pipeline_action.should == 'continue'
+      end
+
+      it "should set the pipeline" do
+        @<%=rule_name%>_rule.attributes = valid_attributes.merge(:<%=rule_name%>_pipeline => "mock pipeline")        
+        @<%=rule_name%>_rule.should be_valid
+        @<%=rule_name%>_rule.pipeline.should == 'mock pipeline'
+      end
+          
+      describe "pipeline action is start_pipeline" do
+        it "should be valid with valid '<%=rule_name%>_pipeline'" do
+          @<%=rule_name%>_rule.attributes = valid_attributes.merge(:<%=rule_name%>_pipeline_action => "start_pipeline", :<%=rule_name%>_pipeline => "mock pipeline")        
+          @<%=rule_name%>_rule.should be_valid
+          @<%=rule_name%>_rule.pipeline.should == 'mock pipeline'
+        end            
+        
+        it "should not be valid if the '<%=rule_name%>_pipeline' attribute is missing" do
+          @<%=rule_name%>_rule.attributes = valid_attributes.merge(:<%=rule_name%>_pipeline_action => "start_pipeline").except(:<%=rule_name%>_pipeline)        
+          @<%=rule_name%>_rule.should_not be_valid
+          @<%=rule_name%>_rule.errors.should include(:<%=rule_name%>_pipeline)
+        end            
+
+        it "should not be valid if the '<%=rule_name%>_pipeline' attribute is blank" do
+          @<%=rule_name%>_rule.attributes = valid_attributes.merge(:<%=rule_name%>_pipeline_action => "start_pipeline", :<%=rule_name%>_pipeline => "")        
+          @<%=rule_name%>_rule.should_not be_valid
+          @<%=rule_name%>_rule.errors.should include(:<%=rule_name%>_pipeline)
+        end            
+      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
+    before(:each) do
+      @<%=rule_name%>_rule = <%=rule_class%>Rule.new
+      @<%=rule_name%>_rule.stub!(:words).and_return(["mock", "words"])      
+      @data = {:sentence => "there was a mock sentence"}
+      
+      @job = mock("job")
+      @job.stub!(:audit)      
+    end
+    
+    it "should do nothing if there is no sentance" do
+      @<%=rule_name%>_rule = <%=rule_class%>Rule.new
+      @<%=rule_name%>_rule.process(@job, {}).should be_nil
+    end        
+
+    it "should do nothing if there is no match" do
+      @<%=rule_name%>_rule = <%=rule_class%>Rule.new
+      @<%=rule_name%>_rule.stub!(:words).and_return(["no", "words"])      
+      @<%=rule_name%>_rule.process(@job, @data).should be_nil
+    end        
+    
+    describe "a match found" do
+      it "should add the match to the data" do      
+        @<%=rule_name%>_rule.process(@job, @data)
+        @data[:match].should == "mock"
+      end        
+
+      it "should audit the match" do  
+        @job.should_receive(:audit) do |one, two|
+          one.should =~ /mock$/
+        end
+        @<%=rule_name%>_rule.process(@job, @data)
+      end        
+    
+      it "should return next" do
+        @<%=rule_name%>_rule.should_receive(:pipeline_action).and_return('next')
+        @<%=rule_name%>_rule.process(@job, @data).outcome.should == RulesEngine::RuleOutcome::OUTCOME_NEXT
+      end
+
+      it "should return stop success" do
+        @<%=rule_name%>_rule.should_receive(:pipeline_action).and_return('stop_success')
+        @<%=rule_name%>_rule.process(@job, @data).outcome.should == RulesEngine::RuleOutcome::OUTCOME_STOP_SUCCESS
+      end
+
+      it "should return stop failure" do
+        @<%=rule_name%>_rule.should_receive(:pipeline_action).and_return('stop_failure')
+        @<%=rule_name%>_rule.process(@job, @data).outcome.should == RulesEngine::RuleOutcome::OUTCOME_STOP_FAILURE
+      end
+
+      it "should return start pipeline with the pipeline_code" do
+        @<%=rule_name%>_rule.should_receive(:pipeline_action).and_return('start_pipeline')
+        @<%=rule_name%>_rule.should_receive(:pipeline).and_return('mock_pipeline')
+        <%=rule_name%>_rule_outcome = @<%=rule_name%>_rule.process(@job, @data)
+        <%=rule_name%>_rule_outcome.outcome.should == RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE
+        <%=rule_name%>_rule_outcome.pipeline_code.should == "mock_pipeline"
+      end
+
+      it "should return nextv for an unknown action" do
+        @<%=rule_name%>_rule.should_receive(:pipeline_action).and_return('this is not a valid action')
+        @<%=rule_name%>_rule.process(@job, @data).outcome.should == RulesEngine::RuleOutcome::OUTCOME_NEXT
+      end
+    end    
+  end
+end