rules_engine 0.1.1 → 0.1.3

data/spec/rules_engine/discovery_spec.rb

@@ -2,12 +2,40 @@ 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"])
+    Dir.stub!(:glob).and_return(["#{RAILS_ROOT}/app/rules/mock_rule.rb"])
+  end
+
+  describe "setting the rules path" do
+    it "use the path to find rules" do
+      RulesEngine::Discovery.rules_path = 'dummy'
+      Dir.should_receive(:glob).with(/^dummy\/\*\*\/\*.rb$/).and_return([])
+      RulesEngine::Discovery.discover!
+    end        
+    
+    it "should return the rules path when set" do
+      RulesEngine::Discovery.rules_path = 'dummy'
+      RulesEngine::Discovery.rules_path.should =='dummy'
+    end
+    
+    it "should return the \#{RAILS_ROOT}/app/rules" do
+      RulesEngine::Discovery.rules_path = nil
+      RulesEngine::Discovery.rules_path.should == "#{RAILS_ROOT}/app/rules"
+    end
+
+    it "should throw an exception if not using rails" do
+      Rails.stub!(:root).and_return(nil)
+      lambda {
+        RulesEngine::Discovery.rules_path
+      }.should raise_error      
+    end
+          
   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!
+  describe "rules path not defined" do
+    it "should find all of the rules ruby files in the \#{RAILS_ROOT}/app/rules directory " do
+      Dir.should_receive(:glob).with(/^#{RAILS_ROOT}\/app\/rules\/\*\*\/\*.rb$/).and_return([])
+      RulesEngine::Discovery.discover!
+    end
   end
 
   it "should use the rules filename to define the rule class name" do
@@ -15,6 +43,14 @@ describe "RulesEngine::Discovery" do
     RulesEngine::Discovery.rule_classes.should include(MockRule)
   end
 
+  it "should undefine an existing the rule class" do
+    RulesEngine::Discovery.discover! 
+    RulesEngine::Discovery.rule_class('MockRule').options.should == {:group=>"mock group"}
+    RulesEngine::Discovery.rule_class('MockRule').options[:name] = "test"
+    RulesEngine::Discovery.discover! 
+    RulesEngine::Discovery.rule_class('MockRule').options.should == {:group=>"mock group"}
+  end
+
   it "should add the rule to the rule group" do
     RulesEngine::Discovery.discover!      
     RulesEngine::Discovery.rule_groups['mock group'].should include(MockRule)

data/spec/rules_engine/process/auditor/db_auditor_spec.rb

@@ -0,0 +1,115 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+describe "RulesEngine::Process::ReProcessAudit" do
+  before(:each) do
+    RulesEngine::Process.auditor = :db_auditor
+    
+    @now = Time.now
+    @re_process_audit_1 = RulesEngine::Process::ReProcessAudit.create(:process_id => 1001, 
+                                                                         :created_at => @now,
+                                                                         :code => RulesEngine::Process::AUDIT_INFO,
+                                                                         :message => "message 1")
+    
+    @re_process_audit_2 = RulesEngine::Process::ReProcessAudit.create(:process_id => 1001, 
+                                                                         :created_at => @now + 1.minute,
+                                                                         :code => RulesEngine::Process::AUDIT_INFO,
+                                                                         :message => "message 2")
+                                                                         
+    @re_process_audit_3 = RulesEngine::Process::ReProcessAudit.create(:process_id => 1001, 
+                                                                         :created_at => @now + 2.minute,
+                                                                         :code => RulesEngine::Process::AUDIT_INFO,
+                                                                         :message => "message 3")
+
+    @re_process_audit_4 = RulesEngine::Process::ReProcessAudit.create(:process_id => 1002, 
+                                                                         :created_at => @now,
+                                                                         :code => RulesEngine::Process::AUDIT_INFO,
+                                                                         :message => "message 4")
+                                                 
+  end
+  
+  describe "history" do
+    describe "no plan code set" do
+      it "should get all the active proceses in start date order" do
+        RulesEngine::Process::ReProcessAudit.history(1001).should == [@re_process_audit_1, @re_process_audit_2, @re_process_audit_3]
+      end
+
+      # it "should use pagination" do
+      #   RulesEngine::Process::ReProcessAudit.should_receive(:paginate).with(hash_including(:page => 1, :per_page => 10))
+      #   RulesEngine::Process::ReProcessAudit.history(1001)
+      # end
+      # 
+      # it "should use set pagination" do
+      #   RulesEngine::Process::ReProcessAudit.should_receive(:paginate).with(hash_including(:page => 2, :per_page => 999))
+      #   RulesEngine::Process::ReProcessAudit.history(1001, {:page => 2, :per_page => 999})
+      # end
+    end
+  end
+end
+
+describe "RulesEngine::Process::DbAuditor" do
+  before(:each) do
+    RulesEngine::Process.auditor = :db_auditor
+    
+    @now = Time.now
+    Time.stub!(:now).and_return(@now)
+    
+    @re_process_audit = mock_model(RulesEngine::Process::ReProcessAudit)
+    @re_process_audit.stub!(:process_id).and_return(1001)
+    @re_process_audit.stub!(:created_at).and_return(@now)
+    @re_process_audit.stub!(:code).and_return(RulesEngine::Process::AUDIT_INFO)
+    @re_process_audit.stub!(:message).and_return('mock message')
+
+    page_data = [@re_process_audit, @re_process_audit]
+    # page_data.stub!(:next_page => "103")
+    # page_data.stub!(:previous_page => "101")
+    
+    RulesEngine::Process::ReProcessAudit.stub!(:create).and_return(@re_process_audit)
+    RulesEngine::Process::ReProcessAudit.stub!(:history).and_return(page_data)    
+  end
+  
+  describe "setting the auditor" do
+    it "should set the auditor to the database process auditor" do
+      RulesEngine::Process.auditor.should be_instance_of(RulesEngine::Process::DbAuditor)
+    end
+  end
+  
+  describe "auditting a message" do
+    it "should create a new audit message" do
+      RulesEngine::Process::ReProcessAudit.should_receive(:create).with(hash_including(:process_id => 2002, 
+                                                                                        :created_at => @now.utc, 
+                                                                                        :message => "audit message", 
+                                                                                        :code => RulesEngine::Process::AUDIT_FAILURE))
+      RulesEngine::Process.auditor.audit(2002, "audit message", RulesEngine::Process::AUDIT_FAILURE)
+    end
+  end      
+
+  describe "getting the process audit history" do
+    it "should returns a hash of the process data " do
+      data = RulesEngine::Process.auditor.history(1001)
+      data.should be_instance_of(Hash)
+    end
+    
+    it "should include an array of audits" do
+      data = RulesEngine::Process.auditor.history(1001)
+      audits = data["audits"]
+      audits.should be_instance_of(Array)
+    end  
+    
+    it "should include the audit information" do
+      data = RulesEngine::Process.auditor.history(1001)
+      audits = data["audits"]
+      
+      audits.length.should == 2
+      audits[0]["process_id"].should == 1001
+      audits[0]["created_at"].should == @now.utc.to_s
+      audits[0]["code"].should == RulesEngine::Process::AUDIT_INFO
+      audits[0]["message"].should == "mock message"
+  
+      audits[1]["process_id"].should == 1001
+      audits[1]["created_at"].should == @now.utc.to_s
+      audits[1]["code"].should == RulesEngine::Process::AUDIT_INFO
+      audits[1]["message"].should == "mock message"
+    end
+  end
+    
+end

data/spec/rules_engine/process/auditor_spec.rb

@@ -0,0 +1,111 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe "RulesEngine::Process::Runner" do
+
+  describe "setting the auditor" do
+    it "should set the auditor as a instance of a class" do
+      mock_auditor = mock('mock_auditor')
+      RulesEngine::Process.auditor = mock_auditor
+      RulesEngine::Process.auditor.should == mock_auditor
+    end
+
+    it "should set the auditor to the database plan auditor" do
+      RulesEngine::Process.auditor = :db_auditor
+      RulesEngine::Process.auditor.should be_instance_of(RulesEngine::Process::DbAuditor)
+    end
+  end
+  
+  describe "getting the auditor" do
+    it "should get the default auditor when not set" do
+      RulesEngine::Process.auditor = nil
+      RulesEngine::Process.auditor.should be_instance_of(RulesEngine::Process::Auditor)
+    end        
+  end
+  
+  describe "auditing a message" do
+    before(:each) do
+      @auditor = RulesEngine::Process::Auditor.new
+    end
+    
+    describe "rails logger defined" do
+      before(:each) do
+        # Rails = mock("Rails")
+        @mock_logger = mock('Logger')
+        @mock_logger.stub!(:error)
+        @mock_logger.stub!(:info)
+        Rails.stub(:logger).and_return(@mock_logger)
+      end
+      
+      it "should not audit if perform_audit? false" do
+        @mock_logger.should_not_receive(:error)
+        @auditor.stub!(:perform_audit?).and_return(false)
+        @auditor.audit(1001, "failure", RulesEngine::Process::AUDIT_FAILURE)
+      end
+      
+      it "should wite to the error log for error audit messaged" do
+        @mock_logger.should_receive(:error)
+        @auditor.audit(1001, "failure", RulesEngine::Process::AUDIT_FAILURE)
+      end
+
+      it "should wite to the info log for success audit messaged" do
+        @mock_logger.should_receive(:info)
+        @auditor.audit(1001, "failure", RulesEngine::Process::AUDIT_SUCCESS)
+      end
+
+      it "should wite to the info log for info audit messaged" do
+        @mock_logger.should_receive(:info)
+        @auditor.audit(1001, "failure", RulesEngine::Process::AUDIT_INFO)
+      end
+    end
+    
+    describe "rails logger not defined" do
+      before(:each) do
+        Rails.stub(:logger).and_return(nil)
+      end
+      
+      it "should wite to the $stderr" do
+        $stderr.should_receive(:puts)
+        @auditor.audit(1001, "failure")
+      end
+    end
+    
+  end
+  
+  describe "getting the audit history" do
+    it "should return a hash " do
+      auditor = RulesEngine::Process::Auditor.new
+      auditor.history(1001, {}).should be_instance_of(Hash)
+    end
+
+    it "should return an array of audits" do
+      auditor = RulesEngine::Process::Auditor.new
+      auditor.history(1001, {})["audits"].should be_instance_of(Array)
+    end
+  end
+
+  describe "perform_audit" do
+    before(:each) do
+      @auditor = RulesEngine::Process::Auditor.new
+    end
+
+    it "should be true if audit_level is not set " do
+      @auditor.audit_level = nil
+      @auditor.perform_audit?(RulesEngine::Process::AUDIT_INFO).should == true
+    end
+
+    it "should be false if audit_level is AUDIT_NONE " do
+      @auditor.audit_level = RulesEngine::Process::AUDIT_NONE
+      @auditor.perform_audit?(RulesEngine::Process::AUDIT_INFO).should == false
+    end
+
+    it "should be true if audit_level is AUDIT_INFO " do
+      @auditor.audit_level = RulesEngine::Process::AUDIT_INFO
+      @auditor.perform_audit?(RulesEngine::Process::AUDIT_INFO).should == true
+    end
+
+    it "should be false if audit_level is AUDIT_SUCCESS " do
+      @auditor.audit_level = RulesEngine::Process::AUDIT_SUCCESS
+      @auditor.perform_audit?(RulesEngine::Process::AUDIT_INFO).should == false
+    end
+  end
+end

data/spec/rules_engine/process/runner/db_runner_spec.rb

@@ -0,0 +1,229 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+describe "RulesEngine::Process::ReProcessRun" do
+  before(:each) do
+    RulesEngine::Process.runner = :db_runner
+    RulesEngine::Process.auditor = nil
+    
+    @now = Time.now
+    @re_process_run_1 = RulesEngine::Process::ReProcessRun.create(:plan_code => 'mock_code', 
+                                                                         :process_status => RulesEngine::Process::PROCESS_STATUS_NONE,
+                                                                         :started_at => nil,
+                                                                         :finished_at => nil)
+    
+    @re_process_run_2 = RulesEngine::Process::ReProcessRun.create(:plan_code => 'mock_code', 
+                                                                         :process_status => RulesEngine::Process::PROCESS_STATUS_RUNNING,
+                                                                         :started_at => @now, 
+                                                                         :finished_at => nil)
+    
+    @re_process_run_3 = RulesEngine::Process::ReProcessRun.create(:plan_code => 'mock_code', 
+                                                                         :process_status => RulesEngine::Process::PROCESS_STATUS_SUCCESS,
+                                                                         :started_at => @now - 1.minute, 
+                                                                         :finished_at => @now + 1.minute)
+                                                                         
+    @re_process_run_4 = RulesEngine::Process::ReProcessRun.create(:plan_code => 'mock_code', 
+                                                                         :process_status => RulesEngine::Process::PROCESS_STATUS_FAILURE,
+                                                                         :started_at => @now - 2.minute, 
+                                                                         :finished_at => @now + 2.minute)
+
+    @re_process_run_5 = RulesEngine::Process::ReProcessRun.create(:plan_code => 'invalid_dates', 
+                                                                         :process_status => RulesEngine::Process::PROCESS_STATUS_RUNNING,
+                                                                         :started_at => @now - 3.minute, 
+                                                                         :finished_at => nil)
+                                                 
+  end
+  
+  describe "history" do
+    describe "no plan code set" do
+      it "should get all the active proceses in start date order" do
+        RulesEngine::Process::ReProcessRun.history(nil).should == [@re_process_run_2, @re_process_run_3, @re_process_run_4, @re_process_run_5]
+      end
+
+      it "should use pagination" do
+        RulesEngine::Process::ReProcessRun.should_receive(:paginate).with(hash_including(:page => 1, :per_page => 10))
+        RulesEngine::Process::ReProcessRun.history(nil)
+      end
+
+      it "should use set pagination" do
+        RulesEngine::Process::ReProcessRun.should_receive(:paginate).with(hash_including(:page => 2, :per_page => 999))
+        RulesEngine::Process::ReProcessRun.history(nil, {:page => 2, :per_page => 999})
+      end
+    end
+  end
+end
+
+describe "RulesEngine::Process::DbRunner" do
+  before(:each) do
+    RulesEngine::Process.runner = :db_runner
+    RulesEngine::Process.auditor = nil
+    
+    @now = Time.now
+    @re_process_run = mock_model(RulesEngine::Process::ReProcessRun)
+    @re_process_run.stub!(:plan_code).and_return('mock code')
+    @re_process_run.stub!(:plan_version).and_return(1002)
+    @re_process_run.stub!(:process_status).and_return(RulesEngine::Process::PROCESS_STATUS_FAILURE)
+    @re_process_run.stub!(:started_at).and_return(@now)
+    @re_process_run.stub!(:finished_at).and_return(@now + 1.minute)
+    @re_process_run.stub!(:update_attributes)
+    
+    page_data = [@re_process_run, @re_process_run]
+    page_data.stub!(:next_page => "103")
+    page_data.stub!(:previous_page => "101")
+    
+    RulesEngine::Process::ReProcessRun.stub!(:create).and_return(@re_process_run)
+    RulesEngine::Process::ReProcessRun.stub!(:history).and_return(page_data)    
+    RulesEngine::Process::ReProcessRun.stub!(:find_by_id).and_return(@re_process_run)
+    
+  end
+  
+  describe "setting the runner" do
+    it "should set the runner to the database process runner" do
+      RulesEngine::Process.runner.should be_instance_of(RulesEngine::Process::DbRunner)
+    end
+  end
+  
+  describe "creating a new process" do
+    it "should create a new process with status NONE" do
+      RulesEngine::Process::ReProcessRun.should_receive(:create).with(hash_including(:process_status => RulesEngine::Process::PROCESS_STATUS_NONE))
+      RulesEngine::Process.runner.create
+    end
+    
+    it "should return the new id of the created run" do
+      @re_process_run.stub!(:id).and_return(101999)
+      RulesEngine::Process.runner.create.should == 101999
+    end
+  end      
+  
+  describe "running a plan" do
+    before(:each) do
+      @plan = {"code" => 'mock_plan', "version" => 1009}
+    end
+    
+    it "should get the created process" do      
+      RulesEngine::Process::ReProcessRun.should_receive(:find_by_id).with(1009)
+      RulesEngine::Process.runner.run(1009, @plan, {})
+    end
+    
+    describe "process not found" do
+      before(:each) do
+        RulesEngine::Process::ReProcessRun.stub!(:find_by_id).with(1009).and_return(nil)
+      end
+      
+      it "should return false" do
+        RulesEngine::Process.runner.run(1009, @plan, {}).should == false
+      end
+      
+      it "should audit the error" do
+        RulesEngine::Process.auditor.should_receive(:audit).with(1009, "Process missing", RulesEngine::Process::AUDIT_FAILURE)
+        RulesEngine::Process.runner.run(1009, @plan, {})
+      end              
+    end
+    
+    describe "updateing the plan" do
+      it "should update the plan code" do
+        @re_process_run.should_receive(:update_attributes).once.with(hash_including(:plan_code => 'mock_plan'))
+        RulesEngine::Process.runner.run(1009, @plan, {})                                                        
+      end
+    
+      it "should update the plan version" do
+        @re_process_run.should_receive(:update_attributes).once.with(hash_including(:plan_version => 1009))
+        RulesEngine::Process.runner.run(1009, @plan, {})                                                        
+      end
+    
+      it "should update the plan as running" do
+        @re_process_run.should_receive(:update_attributes).once.with(hash_including(:process_status => RulesEngine::Process::PROCESS_STATUS_RUNNING))
+        RulesEngine::Process.runner.run(1009, @plan, {})                                                        
+      end
+    end
+    
+    it "should run the plan" do
+      RulesEngine::Process.runner.should_receive(:_run_plan).with(1009, @plan, {:test => "data"})
+      RulesEngine::Process.runner.run(1009, @plan, {:test => "data"})                                                        
+    end                  
+
+  
+    describe "running the plan was successfull" do
+      before(:each) do
+        RulesEngine::Process.runner.should_receive(:_run_plan).and_return(true)
+      end
+      
+      it "should update the status as finished success" do
+        @re_process_run.should_receive(:update_attributes).once.with(hash_including(:process_status => RulesEngine::Process::PROCESS_STATUS_SUCCESS))
+        RulesEngine::Process.runner.run(1009, @plan, {})                                                        
+      end
+      
+      it "should return success" do
+        RulesEngine::Process.runner.run(1009, @plan, {}).should == true
+      end
+    end  
+    
+    describe "running the plan failed" do
+      before(:each) do
+        RulesEngine::Process.runner.should_receive(:_run_plan).and_return(false)
+      end
+      
+      it "should update the status as failed" do
+        @re_process_run.should_receive(:update_attributes).once.with(hash_including(:process_status => RulesEngine::Process::PROCESS_STATUS_FAILURE))
+        RulesEngine::Process.runner.run(1009, @plan, {})                                                        
+      end
+
+      it "should return failure" do
+        RulesEngine::Process.runner.run(1009, @plan, {}).should == false
+      end
+    end      
+  end
+  
+  describe "getting the process status" do
+    it "should get the process" do
+      RulesEngine::Process::ReProcessRun.should_receive(:find_by_id).with(1009)
+      RulesEngine::Process.runner.status(1009)
+    end
+    
+    describe "process not found" do
+      it "should return status NONE" do
+        RulesEngine::Process::ReProcessRun.stub!(:find_by_id).and_return(nil)
+        RulesEngine::Process.runner.status(1009).should == RulesEngine::Process::PROCESS_STATUS_NONE
+      end
+    end    
+
+    describe "process found" do
+      it "should return process status" do
+        RulesEngine::Process::ReProcessRun.stub!(:find_by_id).and_return(@re_process_run)
+        @re_process_run.should_receive(:process_status).and_return(1002)
+        RulesEngine::Process.runner.status(1009).should == 1002
+      end
+    end    
+  end
+  
+  describe "getting the process run history" do
+    it "should returns a hash of the process data " do
+      data = RulesEngine::Process.runner.history('mock_code')
+      data.should be_instance_of(Hash)
+    end
+    
+    it "should include an array of publications" do
+      data = RulesEngine::Process.runner.history('mock_code')
+      versions = data["processes"]
+      versions.should be_instance_of(Array)
+    end  
+    
+    it "should include the publication information" do
+      data = RulesEngine::Process.runner.history('mock_code')
+      processes = data["processes"]
+      
+      processes.length.should == 2
+      processes[0]["plan_code"].should == 'mock code'
+      processes[0]["plan_version"].should == 1002
+      processes[0]["process_status"].should == RulesEngine::Process::PROCESS_STATUS_FAILURE
+      processes[0]["started_at"].should == @now.utc.to_s
+      processes[0]["finished_at"].should == (@now + 1.minute).utc.to_s
+  
+      processes[1]["plan_code"].should == 'mock code'
+      processes[0]["plan_version"].should == 1002
+      processes[1]["process_status"].should == RulesEngine::Process::PROCESS_STATUS_FAILURE
+      processes[1]["started_at"].should == @now.utc.to_s
+      processes[1]["finished_at"].should == (@now + 1.minute).utc.to_s
+    end
+  end
+    
+end