rules_engine 0.0.1 → 0.0.3

data/spec/rules_engine/discovery_spec.rb

@@ -0,0 +1,32 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "RulesEngine::Discovery" do
+  before(:each) do
+    Dir.stub!(:glob).and_return(["#{RAILS_ROOT}/app/rules/mock_rule"])
+  end
+  
+  it "should does find all of the rules ruby files in the /app/rules directory " do
+    Dir.should_receive(:glob).with(/app\/rules\/\*\*\/\*.rb/).and_return([])
+    RulesEngine::Discovery.discover!
+  end
+
+  it "should use the rules filename to define the rule class name" do
+    RulesEngine::Discovery.discover!      
+    RulesEngine::Discovery.rule_classes.should include(MockRule)
+  end
+
+  it "should add the rule to the rule group" do
+    RulesEngine::Discovery.discover!      
+    RulesEngine::Discovery.rule_groups['mock group'].should include(MockRule)
+  end
+  
+  it "should return the class that matches the name" do
+    RulesEngine::Discovery.discover!      
+    RulesEngine::Discovery.rule_class('MockRule').should == MockRule
+  end
+
+  it "should return nil if the class is unknown" do
+    RulesEngine::Discovery.discover!      
+    RulesEngine::Discovery.rule_class('unknown').should be_nil
+  end
+end

data/spec/rules_engine/job_spec.rb

@@ -0,0 +1,266 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+class ReJob
+  JOB_STATUS_NONE =     1234
+  JOB_STATUS_RUNNING =  2345
+  JOB_STATUS_SUCCESS =  3456
+  JOB_STATUS_FAILURE =  4567
+end
+
+class RePipelineActivated
+end
+
+class ReJobAudit
+  AUDIT_INFO =      1234
+  AUDIT_SUCCESS =   2345
+  AUDIT_FAILURE =   3456
+end
+
+describe "RulesEngine::Job" do
+  describe "create" do
+    before(:each) do
+      @re_job = ReJob.new
+      ReJob.stub!(:create).and_return(@re_job)
+    end
+    
+    it "should create a new job" do
+      ReJob.should_receive(:create)
+      RulesEngine::Job.create
+    end
+    
+    it "should set the job status as none" do
+      ReJob.should_receive(:create).with(:job_status => ReJob::JOB_STATUS_NONE)
+      RulesEngine::Job.create
+    end
+        
+    it "should return the created job" do
+      RulesEngine::Job.should_receive(:new).with(@re_job).and_return(job = mock('job'))
+      RulesEngine::Job.create.should == job
+    end
+  end
+
+  describe "open" do
+    before(:each) do
+      @re_job = ReJob.new
+      @re_job.stub!(:update_attributes)
+      ReJob.stub!(:find_by_id).with(1001).and_return(@re_job)
+      ReJob.stub!(:create).and_return(@re_job)
+    end
+    
+    it "should load the job" do
+      ReJob.should_receive(:find_by_id).with(1001).and_return(@re_job)
+      RulesEngine::Job.open(1001)
+    end
+
+    it "should create the if not loaded" do
+      ReJob.should_receive(:find_by_id).with(1001).and_return(nil)
+      ReJob.should_receive(:create).and_return(@re_job)
+      RulesEngine::Job.open(1001)
+    end
+        
+    it "should set the job status as none" do
+      @re_job.should_receive(:update_attributes).with(:job_status => ReJob::JOB_STATUS_NONE)
+      RulesEngine::Job.open(1001)
+    end
+        
+    it "should return the created job" do
+      RulesEngine::Job.should_receive(:new).with(@re_job).and_return(job = mock('job'))
+      RulesEngine::Job.open(1001).should == job
+    end
+  end
+  
+  describe "run" do
+#     def run_pipeline
+#       RulesEngine::JobRunner.run_pipleine(1001, 'mock pipeline code',{:data_key => "data value"})
+#     end
+#     
+    before(:each) do
+      @re_job = ReJob.new
+      @re_job.stub!(:id).and_return(1001)
+      @re_job.stub!(:update_attributes)
+      ReJob.stub!(:create).and_return(@re_job)
+            
+      @re_pipeline_activated = RePipelineActivated.new
+      @re_pipeline_activated.stub!(:id)
+      RePipelineActivated.stub!(:find_by_code).and_return(@re_pipeline_activated)
+      
+      @re_pipeline = mock("RePipeline")
+      @re_pipeline.stub!(:id).and_return(2001)
+      @re_pipeline_activated.stub!(:re_pipeline).and_return(@re_pipeline)
+            
+      @rule_1 = mock("Rule")
+      @rule_1.stub!(:process).and_return(nil)      
+      
+      @re_rule_1 = mock("ReRule")
+      @re_rule_1.stub!(:id).and_return(3001)
+      @re_rule_1.stub!(:title).and_return('rule 1')
+      @re_rule_1.stub!(:rule_class_name).and_return('rule_1')
+      @re_rule_1.stub!(:rule).and_return(@rule_1)
+      
+      @rule_2 = mock("Rule")
+      @rule_2.stub!(:process).and_return(nil)
+
+      @re_rule_2 = mock("ReRule")
+      @re_rule_2.stub!(:id).and_return(3002)
+      @re_rule_2.stub!(:title).and_return('rule 2')
+      @re_rule_2.stub!(:rule_class_name).and_return('rule_2')
+      @re_rule_2.stub!(:rule).and_return(@rule_2)
+      
+      @re_pipeline_activated.stub!(:re_rules).and_return([@re_rule_1, @re_rule_2])
+      
+      ReJobAudit.stub!(:create)
+    end
+    
+    it "should fail if the job if it is not found" do
+      ReJob.should_receive(:create).and_return(nil)
+      job = RulesEngine::Job.create
+      job.run("test").should == false
+    end
+
+    it "should set the job as running" do
+      @re_job.should_receive(:update_attributes).at_least(:once).with(:job_status => ReJob::JOB_STATUS_RUNNING)
+      RulesEngine::Job.create.run("test")
+    end
+
+    it "should fail if the activated pipeline is not found" do
+      RePipelineActivated.should_receive(:find_by_code).and_return(nil)
+      RulesEngine::Job.create.run("test").should == false
+    end
+
+    it "should fail if the activated pipeline has no rules" do
+      @re_pipeline_activated.should_receive(:re_rules).and_return([])
+      RulesEngine::Job.create.run("test").should == false
+    end
+
+    it "should fail if the Rules Engine does not know about the rule" do
+      @re_rule_1.should_receive(:rule).and_return(nil)
+      RulesEngine::Job.create.run("test").should == false
+    end
+
+    it "should process all of the rules if the outcome is nil" do
+      @rule_1.should_receive(:process).and_return(nil)
+      @rule_2.should_receive(:process).and_return(nil)
+      
+      RulesEngine::Job.create.run("test").should == true
+    end
+
+    it "should process all of the rules if the outcome is OUTCOME_NEXT" do
+      rule_outcome = RulesEngine::RuleOutcome.new
+      rule_outcome.outcome = RulesEngine::RuleOutcome::OUTCOME_NEXT
+      
+      @rule_1.should_receive(:process).and_return(rule_outcome)
+      @rule_2.should_receive(:process).and_return(rule_outcome)
+      
+      RulesEngine::Job.create.run("test").should == true
+    end
+
+    it "should not process rule 2 if rule 1 is OUTCOME_STOP_FAILURE" do
+      rule_outcome = RulesEngine::RuleOutcome.new
+      rule_outcome.outcome = RulesEngine::RuleOutcome::OUTCOME_STOP_FAILURE
+      
+      @rule_1.should_receive(:process).and_return(rule_outcome)
+      @rule_2.should_not_receive(:process)
+      
+      RulesEngine::Job.create.run("test").should == false
+    end
+
+    it "should not process rule 2 if rule 1 is OUTCOME_STOP_SUCCESS" do
+      rule_outcome = RulesEngine::RuleOutcome.new
+      rule_outcome.outcome = RulesEngine::RuleOutcome::OUTCOME_STOP_SUCCESS
+      
+      @rule_1.should_receive(:process).and_return(rule_outcome)
+      @rule_2.should_not_receive(:process)
+      
+      RulesEngine::Job.create.run("test").should == true
+    end
+
+    it "should start a new pipeline if rule 1 is OUTCOME_START_PIPELINE" do
+      rule_outcome_pipeline = RulesEngine::RuleOutcome.new
+      rule_outcome_pipeline.outcome = RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE
+      rule_outcome_pipeline.pipeline_code = "next pipeline"
+      
+      rule_outcome_stop = RulesEngine::RuleOutcome.new
+      rule_outcome_stop.outcome = RulesEngine::RuleOutcome::OUTCOME_STOP_SUCCESS
+      
+      RePipelineActivated.should_receive(:find_by_code).with("next pipeline").and_return(@re_pipeline_activated)
+      
+      @rule_1.should_receive(:process).and_return(rule_outcome_pipeline, rule_outcome_stop)
+      @rule_2.should_not_receive(:process)
+      
+      RulesEngine::Job.create.run("test").should == true
+    end
+
+    it "should stop if we are starting too many pipelines" do
+      rule_outcome = RulesEngine::RuleOutcome.new
+      rule_outcome.outcome = RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE
+      rule_outcome.pipeline_code = "next pipeline"
+      
+      @rule_1.stub!(:process).and_return(rule_outcome)
+      @rule_2.should_not_receive(:process)
+      
+      RulesEngine::Job.create.run("test").should == false
+    end
+  end
+  
+  describe "audit_rule" do
+    before(:each) do
+      @re_job = ReJob.new
+      @re_job.stub!(:id).and_return(1001)
+      # @re_job.stub(:update_attributes)
+      ReJob.stub!(:create).and_return(@re_job)
+    end
+    
+    it "should set the job_id" do
+      now = Time.now
+      Time.stub!(:now).and_return(now)
+    
+      ReJobAudit.should_receive(:create).with(hash_including(
+        :re_job_id => 1001,
+        :re_pipeline_id => nil, 
+        :re_rule_id => nil,
+        :audit_date => now,  
+        :audit_code => "mock_code",
+        :audit_message => "mock_message"
+      ))
+      
+      job = RulesEngine::Job.create
+      job.audit("mock_message", "mock_code")
+    end
+
+    it "should set the re_pipeline_id" do
+      now = Time.now
+      Time.stub!(:now).and_return(now)
+    
+      ReJobAudit.should_receive(:create).with(hash_including(
+        :re_job_id => 1001,
+        :re_pipeline_id => 2001, 
+        :re_rule_id => nil,
+        :audit_date => now,  
+        :audit_code => "mock_code",
+        :audit_message => "mock_message"
+      ))
+      
+      job = RulesEngine::Job.create
+      job.stub!(:re_pipeline).and_return(mock("RePipeline", :id => 2001))
+      job.audit("mock_message", "mock_code")
+    end
+    
+    it "should set the re_rule_id" do
+      now = Time.now
+      Time.stub!(:now).and_return(now)
+    
+      ReJobAudit.should_receive(:create).with(hash_including(
+        :re_job_id => 1001,
+        :re_pipeline_id => nil, 
+        :re_rule_id => 3001,
+        :audit_date => now,  
+        :audit_code => "mock_code",
+        :audit_message => "mock_message"
+      ))
+      
+      job = RulesEngine::Job.create
+      job.stub!(:re_rule).and_return(mock("ReRule", :id => 3001))
+      job.audit("mock_message", "mock_code")
+    end
+  end
+end

data/spec/rules_engine/rule_spec.rb

@@ -0,0 +1,76 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+class MockRule < RulesEngine::Rule
+end
+
+describe "RulesEngine::Rule" do
+  it "should add a class method rule_class_name" do
+    MockRule.methods.should include("rule_class_name")
+  end
+  
+  it "should return the rule_class_name as the rule class" do    
+    MockRule.rule_class_name.should == "MockRule"
+  end
+
+  it "should be able to set the attribute 'data'" do
+    RulesEngine::Rule.new.methods.should include("data=")
+  end
+
+  describe "title" do
+    it "should be nil by default" do
+      RulesEngine::Rule.new.title.should be_nil
+    end
+  end
+  
+  describe "summary" do
+    it "should be nil by default" do
+      RulesEngine::Rule.new.summary.should be_nil
+    end
+  end
+  
+  describe "data" do
+    it "should be nil by default" do
+      RulesEngine::Rule.new.data.should be_nil
+    end
+  end
+  
+  describe "expected_outcomes" do
+    it "should be set the default as NEXT" do
+      RulesEngine::Rule.new.expected_outcomes.should be_instance_of(Array)
+      RulesEngine::Rule.new.expected_outcomes[0][:outcome].should == RulesEngine::RuleOutcome::OUTCOME_NEXT
+      RulesEngine::Rule.new.expected_outcomes[0][:pipeline_code].should be_nil
+    end
+  end
+  
+  describe "valid?" do
+    it "should be valid by default" do
+      MockRule.new.valid?.should be_true
+    end    
+  end
+
+  describe "errors" do
+    it "should be a hash" do
+      RulesEngine::Rule.new.errors.should be_instance_of(Hash)
+      rule = RulesEngine::Rule.new 
+    end    
+  end
+
+  it "should have the helper function 'after_add_to_pipeline' to tell the rule has been added to a pipeline" do
+    RulesEngine::Rule.new.methods.should include("after_add_to_pipeline")
+  end
+
+  it "should have the helper function 'before_remove_from_pipeline' to tell the rule is about to be removed from a pipeline" do
+    RulesEngine::Rule.new.methods.should include("before_remove_from_pipeline")
+  end
+  
+  describe "processing a rule" do
+    it "should return a rule_outcome" do
+      MockRule.new.process(1, {}).should be_instance_of(RulesEngine::RuleOutcome)
+    end
+
+    it "should set the outcome to OUTCOME_NEXT by default" do
+      MockRule.new.process(1, {}).outcome.should == RulesEngine::RuleOutcome::OUTCOME_NEXT
+    end        
+  end
+  
+end

data/spec/rules_engine_view/alerts_spec.rb

@@ -0,0 +1,142 @@
+require File.expand_path(File.dirname(__FILE__) ) + "/../spec_helper"
+
+describe "re_alert", :type => :helper do 
+  def call_re_alert(error, success, notice)
+    src = <<-END_SRC
+    <% 
+      flash[:error] = "#{error}"
+      flash[:success] = "#{success}"
+      flash[:notice] = "#{notice}"
+    %>    
+    <%= re_alert %>
+    END_SRC
+    eval_erb(src)
+  end
+  
+  it "should be accessible to rails apps by default" do 
+    ActionView::Base.new.methods.should include("re_alert")
+  end
+  
+  describe "setting an error message" do
+    it "should display the message" do
+      call_re_alert("error", "", "").should have_tag('div#re_alert > div.error > strong', :text => "Error :")
+      call_re_alert("error", "", "").should have_tag('div#re_alert > div.error > span', :text => "error")
+    end
+
+    it "should not display the success message or notice message" do
+      call_re_alert("error", "success", "notice").should_not have_tag('div.success')
+      call_re_alert("error", "success", "notice").should_not have_tag('div.notice')
+    end
+
+    it "should reset the error, success and notice message" do
+      call_re_alert("error", "success", "notice")
+      eval_erb("<%=flash[:error] %>").should == ""
+      eval_erb("<%=flash[:success] %>").should == ""
+      eval_erb("<%=flash[:notice] %>").should == ""
+    end
+  end
+
+  describe "setting a success message" do
+    it "should display the message" do
+      call_re_alert("", "success", "").should have_tag('div#re_alert > div.success > strong', :text => "Success :")
+      call_re_alert("", "success", "").should have_tag('div#re_alert > div.success > span', :text => "success")
+    end
+
+    it "should not display the notice message" do
+      call_re_alert("", "success", "notice").should_not have_tag('div.notice')
+    end
+
+    it "should reset the success and notice message" do
+      call_re_alert("", "success", "notice")
+      eval_erb("<%=flash[:error] %>").should == ""
+      eval_erb("<%=flash[:success] %>").should == ""
+      eval_erb("<%=flash[:notice] %>").should == ""
+    end
+  end
+
+  describe "setting a notice message" do
+    it "should display the message" do
+      call_re_alert("", "", "notice").should have_tag('div#re_alert > div.notice > strong', :text => "Warning :")
+      call_re_alert("", "", "notice").should have_tag('div#re_alert > div.notice > span', :text => "notice")
+    end
+
+    it "should reset the notice message" do
+      call_re_alert("", "", "notice")
+      eval_erb("<%=flash[:notice] %>").should == ""
+    end
+  end
+
+  describe "setting nothing" do
+    it "should have an empty re_alert block" do
+      call_re_alert("", "", "").should have_tag('div#re_alert', :text => "")
+    end
+  end
+  
+end
+
+
+describe "re_alert_js", :type => :helper do 
+  def call_re_alert_js(error, success, notice)
+    src = <<-END_SRC
+    <% 
+      flash[:error] = "#{error}"
+      flash[:success] = "#{success}"
+      flash[:notice] = "#{notice}"
+    %>    
+    <%= re_alert_js %>
+    END_SRC
+    eval_erb(src)
+  end
+  
+  it "should be accessible to rails apps by default" do 
+    ActionView::Base.new.methods.should include("re_alert_js")
+  end
+  
+  describe "setting an error message" do
+    it "should display the message" do
+      call_re_alert_js("<p>error</p>", "", "").should =~ /\$.re_error_message/
+    end
+
+    it "should not display the success message or notice message" do
+      call_re_alert_js("error", "success", "notice").should_not =~ /\$.re_success_message/
+      call_re_alert_js("error", "success", "notice").should_not =~ /\$.re_notice_message/
+    end
+  
+    it "should reset the error, success and notice message" do
+      call_re_alert_js("error", "success", "notice")
+      eval_erb("<%=flash[:error] %>").should == ""
+      eval_erb("<%=flash[:success] %>").should == ""
+      eval_erb("<%=flash[:notice] %>").should == ""
+    end
+  end
+  
+  describe "setting a success message" do
+    it "should display the message" do
+      call_re_alert_js("", "success", "").should =~ /\$.re_success_message/
+    end
+  
+    it "should not display the notice message" do
+      call_re_alert_js("", "success", "notice").should_not =~ /\$.re_notice_message/
+    end
+  
+    it "should reset the success and notice message" do
+      call_re_alert_js("", "success", "notice")
+      eval_erb("<%=flash[:error] %>").should == ""
+      eval_erb("<%=flash[:success] %>").should == ""
+      eval_erb("<%=flash[:notice] %>").should == ""
+    end
+  end
+  
+  describe "setting a notice message" do
+    it "should display the message" do
+      call_re_alert_js("", "", "notice").should =~ /\$.re_notice_message/
+    end
+  
+    it "should reset the notice message" do
+      call_re_alert_js("", "", "notice")
+      eval_erb("<%=flash[:notice] %>").should == ""
+    end
+  end
+  
+end
+