rules_engine 0.1.7 → 0.1.8

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

@@ -96,12 +96,12 @@ describe "RulesEngine::Process::DbRunner" do
   
   describe "running a plan" do
     before(:each) do
-      @plan = {"code" => 'mock_plan', "version" => 1009}
+      @plan = {"code" => 'mock_plan', "version" => 1009, "workflow" => "db_runner_workflow"}
     end
     
     it "should get the created process" do      
       RulesEngine::Process::ReProcessRun.should_receive(:find_by_id).with(1009)
-      RulesEngine::Process.runner.run(1009, @plan, {})
+      RulesEngine::Process.runner.run_plan(1009, @plan, {})
     end
     
     describe "process not found" do
@@ -110,65 +110,64 @@ describe "RulesEngine::Process::DbRunner" do
       end
       
       it "should return false" do
-        RulesEngine::Process.runner.run(1009, @plan, {}).should == false
+        RulesEngine::Process.runner.run_plan(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, {})
+        RulesEngine::Process.runner.run_plan(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, {})                                                        
+        RulesEngine::Process.runner.run_plan(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, {})                                                        
+        RulesEngine::Process.runner.run_plan(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, {})                                                        
+        RulesEngine::Process.runner.run_plan(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"})                                                        
+      RulesEngine::Process.runner.should_receive(:_run_plan_workflow).with(1009, @plan, "db_runner_workflow", {:test => "data"})
+      RulesEngine::Process.runner.run_plan(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)
+        RulesEngine::Process.runner.should_receive(:_run_plan_workflow).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, {})                                                        
+        RulesEngine::Process.runner.run_plan(1009, @plan, {})                                                        
       end
       
       it "should return success" do
-        RulesEngine::Process.runner.run(1009, @plan, {}).should == true
+        RulesEngine::Process.runner.run_plan(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)
+        RulesEngine::Process.runner.should_receive(:_run_plan_workflow).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, {})                                                        
+        RulesEngine::Process.runner.run_plan(1009, @plan, {})                                                        
       end
 
       it "should return failure" do
-        RulesEngine::Process.runner.run(1009, @plan, {}).should == false
+        RulesEngine::Process.runner.run_plan(1009, @plan, {}).should == false
       end
     end      
   end

data/spec/rules_engine/process/runner_spec.rb

@@ -49,7 +49,7 @@ describe "RulesEngine::Process::Runner" do
     end
   end
 
-  describe "running the plan" do
+  describe "running plans and workflows" do
     before(:each) do
       @rule_class = mock("Rule Class")
       @rule_class.stub!(:new).and_return(@rule_class)
@@ -63,8 +63,9 @@ describe "RulesEngine::Process::Runner" do
       @runner = RulesEngine::Process::Runner.new      
       
       @plan = {"code" => "plan_code",
-               "first_workflow" => "one",
-               
+               "version" => "1001",
+               "workflow" => "one",
+             
                "workflow_one" => {
                  "rules" => [{
                    "rule_class_name" => "one_one",
@@ -93,144 +94,196 @@ describe "RulesEngine::Process::Runner" do
                  "next_workflow" => ""
                }               
               }
+      
     end
+  
+    describe "running the plan" do
     
-    it "should use the _run_plan method" do
-      @runner.should_receive(:_run_plan)
-      @runner.run(10001, @plan, {})
-    end
-    
-    it "should be successfull with a valid plan" do
-      @runner.run(10001, @plan, {}).should == true
-    end
-        
-    it "should audit the plan has started" do
-      RulesEngine::Process.auditor.should_receive(:audit).once.with(10001, "Plan : plan_code : started", RulesEngine::Process::AUDIT_INFO)
-      @runner.run(10001, @plan, {})
-    end
-
-    describe "first_workflow missing" do
-      it "should audit the failure" do
-        RulesEngine::Process.auditor.should_receive(:audit).once.with(10001, anything, RulesEngine::Process::AUDIT_FAILURE)
-        @runner.run(10001, @plan.except("first_workflow"), {})
+      it "should use the _run_plan_workflow method" do
+        @runner.should_receive(:_run_plan_workflow)
+        @runner.run_plan(10001, @plan, {})
       end
-      
-      it "should return false" do
-        @runner.run(10001, @plan.except("first_workflow"), {}).should == false
-      end
-    end    
     
-    describe "endless loop" do
-      it "should return false" do
-        @plan["workflow_one"].merge!("next_workflow" => "one")
-        @runner.run(10001, @plan, {}).should == false
+      it "should be successfull with a valid plan" do
+        @runner.run_plan(10001, @plan, {}).should == true
       end
-    end
-    
-    describe "workflow missing" do
-      it "should return false" do
-        @plan["workflow_one"].merge!("next_workflow" => "not_there")
-        @runner.run(10001, @plan, {}).should == false
+
+      it "should fail with an invalid plan" do
+        @runner.run_plan(10001, {}, {}).should == false
       end
-    end
+        
+      it "should audit the plan has started" do
+        RulesEngine::Process.auditor.should_receive(:audit).once.with(10001, "Plan : plan_code : started", RulesEngine::Process::AUDIT_INFO)
+        @runner.run_plan(10001, @plan, {})
+      end
+
+      describe "run_workflow missing" do
+        it "should audit the failure" do
+          RulesEngine::Process.auditor.should_receive(:audit).once.with(10001, anything, RulesEngine::Process::AUDIT_FAILURE)
+          @runner.run_plan(10001, @plan.except("workflow"), {})
+        end
+      
+        it "should return false" do
+          @runner.run_plan(10001, @plan.except("workflow"), {}).should == false
+        end
+      end    
     
-    describe "processing the workflows" do
-      it "should process each follow the next_workflow " do
-        # testing this by checking it runs one rule in each workflow
-        RulesEngine::Discovery.should_receive(:rule_class).with("one_one").and_return(@rule_class)
-        RulesEngine::Discovery.should_receive(:rule_class).with("two_one").and_return(@rule_class)
-        RulesEngine::Discovery.should_receive(:rule_class).with("three_one").and_return(@rule_class)
-         @runner.run(10001, @plan, {})
+      it "should process the workflow " do
+        @runner.should_receive(:_run_workflow_rules).with(10001, @plan, @plan["workflow_one"],  {:data => "mock data"})
+        @runner.run_plan(10001, @plan, {:data => "mock data"})
       end          
-    end
     
-    describe "processing the rules" do
-      it "should load the rule" do
-        RulesEngine::Discovery.should_receive(:rule_class).with("one_one").and_return(@rule_class)
-        @rule_class.should_receive(:new).and_return(@rule_class)
-        @rule_class.should_receive(:data=).with("one_one_data")
-        @runner.run(10001, @plan, {}).should == true
-      end
-      
-      describe "the rules does not exist" do
-        it "should return an error" do
-          RulesEngine::Discovery.should_receive(:rule_class).with("one_one").and_return(nil)
-          @runner.run(10001, @plan, {}).should == false
-        end            
-      end
-      
-      it "should proces the rule" do
-        @rule_class.should_receive(:process)
-        @runner.run(10001, @plan, {})
-      end
+      describe "_run_workflow_rules outcomes" do
+        describe "it returns no outcome" do
+          it "should return success" do
+            @runner.stub!(:_run_workflow_rules).and_return(nil)
+            @runner.run_plan(10001, @plan, {}).should == true
+          end
+        end
       
-      describe "processing a rule" do
-        before(:each) do
-          @test_rule = mock("Test Rule")
-          @test_rule.stub!(:new).and_return(@test_rule)
-          @test_rule.stub!(:title).and_return('mock title')
-          @test_rule.stub!(:data=)
-          RulesEngine::Discovery.stub!(:rule_class).with("one_one").and_return(@test_rule)
+        describe "it returns NEXT" do
+          it "should return success" do
+            @runner.stub!(:_run_workflow_rules).and_return(RulesEngine::Rule::Outcome.new(RulesEngine::Rule::Outcome::NEXT))
+            @runner.run_plan(10001, @plan, {}).should == true
+          end
         end
-        
-        describe "rule returns nil" do
-          it "should proceed to the next rule" do
-            @test_rule.stub!(:process).and_return(nil)
-            RulesEngine::Discovery.should_receive(:rule_class).with("one_two")
-            @runner.run(10001, @plan, {})
+
+        describe "it returns STOP SUCCESS" do
+          it "should return success" do
+            @runner.stub!(:_run_workflow_rules).and_return(RulesEngine::Rule::Outcome.new(RulesEngine::Rule::Outcome::STOP_SUCCESS))
+            @runner.run_plan(10001, @plan, {}).should == true
           end
         end
 
-        describe "rule returns NEXT" do
-          it "should proceed to the next rule" do
-            @test_rule.stub!(:process).and_return(RulesEngine::Rule::Outcome.new(RulesEngine::Rule::Outcome::NEXT))
-            RulesEngine::Discovery.should_receive(:rule_class).with("one_two")
-            @runner.run(10001, @plan, {})
+        describe "it returns STOP FAILURE" do
+          it "should return failure" do
+            @runner.stub!(:_run_workflow_rules).and_return(RulesEngine::Rule::Outcome.new(RulesEngine::Rule::Outcome::STOP_FAILURE))
+            @runner.run_plan(10001, @plan, {}).should == false
           end
         end
-        
-        describe "rule returns STOP_SUCCESS" do
-          it "should not proceed to the next rule" do
-            @test_rule.stub!(:process).and_return(RulesEngine::Rule::Outcome.new(RulesEngine::Rule::Outcome::STOP_SUCCESS))
-            RulesEngine::Discovery.should_not_receive(:rule_class).with("one_two")
-            @runner.run(10001, @plan, {})
+      
+        describe "it returns START_WORKFLOW" do
+          it "should return run the next workflow" do
+            @runner.should_receive(:_run_workflow_rules).with(10001, @plan, @plan["workflow_one"],  {:data => "mock data"}).and_return(RulesEngine::Rule::Outcome.new(RulesEngine::Rule::Outcome::START_WORKFLOW, 'two'))
+            @runner.should_receive(:_run_workflow_rules).with(10001, @plan, @plan["workflow_two"],  {:data => "mock data"})
+            @runner.run_plan(10001, @plan, {:data => "mock data"}).should == true
           end
+        end
 
-          it "should return success" do
-            @test_rule.stub!(:process).and_return(RulesEngine::Rule::Outcome.new(RulesEngine::Rule::Outcome::STOP_SUCCESS))
-            @runner.run(10001, @plan, {}) == true
-          end
+        it "should return false" do
+          @runner.stub!(:_run_workflow_rules).and_return(RulesEngine::Rule::Outcome.new(RulesEngine::Rule::Outcome::START_WORKFLOW, 'one'))
+          @runner.run_plan(10001, @plan, {}).should == false
+        end
+      end
+    
+      describe "running the workflow" do
+        it "should load the rule" do
+          RulesEngine::Discovery.should_receive(:rule_class).with("one_one").and_return(@rule_class)
+          @rule_class.should_receive(:new).and_return(@rule_class)
+          @rule_class.should_receive(:data=).with("one_one_data")
+          @runner.run_plan(10001, @plan, {}).should == true
+        end
+
+        describe "the rules does not exist" do
+          it "should return an error" do
+            RulesEngine::Discovery.should_receive(:rule_class).with("one_one").and_return(nil)
+            @runner.run_plan(10001, @plan, {}).should == false
+          end            
+        end
+
+        it "should proces the rule" do
+          @rule_class.should_receive(:process)
+          @runner.run_plan(10001, @plan, {})
         end
 
-        describe "rule returns STOP_FAILURE" do
-          it "should not proceed to the next rule" do
-            @test_rule.stub!(:process).and_return(RulesEngine::Rule::Outcome.new(RulesEngine::Rule::Outcome::STOP_FAILURE))
-            RulesEngine::Discovery.should_not_receive(:rule_class).with("one_two")
-            @runner.run(10001, @plan, {})
+        describe "processing a rule" do
+          before(:each) do
+            @test_rule = mock("Test Rule")
+            @test_rule.stub!(:new).and_return(@test_rule)
+            @test_rule.stub!(:title).and_return('mock title')
+            @test_rule.stub!(:data=)
+            RulesEngine::Discovery.stub!(:rule_class).with("one_one").and_return(@test_rule)
+          end        
+          
+          it "should pass the plan to the process" do
+            @test_rule.should_receive(:process).with(10001, @plan, {:plan => "data"})
+            @runner.run_plan(10001, @plan, {:plan => "data"})
+          end
+              
+          describe "rule returns nil" do
+            it "should proceed to the next rule" do
+              @test_rule.stub!(:process).and_return(nil)
+              RulesEngine::Discovery.should_receive(:rule_class).with("one_two")
+              @runner.run_plan(10001, @plan, {})
+            end
           end
 
-          it "should return failure" do
-            @test_rule.stub!(:process).and_return(RulesEngine::Rule::Outcome.new(RulesEngine::Rule::Outcome::STOP_FAILURE))
-            @runner.run(10001, @plan, {}) == false
+          describe "rule returns NEXT" do
+            it "should proceed to the next rule" do
+              @test_rule.stub!(:process).and_return(RulesEngine::Rule::Outcome.new(RulesEngine::Rule::Outcome::NEXT))
+              RulesEngine::Discovery.should_receive(:rule_class).with("one_two")
+              @runner.run_plan(10001, @plan, {})
+            end
           end
-        end
 
-        describe "rule returns START_WORKFLOW" do
-          it "should not proceed to the next rule" do
-            @test_rule.stub!(:process).and_return(RulesEngine::Rule::Outcome.new(RulesEngine::Rule::Outcome::START_WORKFLOW, 'three'))
-            RulesEngine::Discovery.should_not_receive(:rule_class).with("one_two")
-            @runner.run(10001, @plan, {})
+          describe "rule returns STOP_SUCCESS" do
+            it "should not proceed to the next rule" do
+              @test_rule.stub!(:process).and_return(RulesEngine::Rule::Outcome.new(RulesEngine::Rule::Outcome::STOP_SUCCESS))
+              RulesEngine::Discovery.should_not_receive(:rule_class).with("one_two")
+              @runner.run_plan(10001, @plan, {})
+            end
+
+            it "should return success" do
+              @test_rule.stub!(:process).and_return(RulesEngine::Rule::Outcome.new(RulesEngine::Rule::Outcome::STOP_SUCCESS))
+              @runner.run_plan(10001, @plan, {}) == true
+            end
           end
 
-          it "should start the defined workflow" do
-            @test_rule.stub!(:process).and_return(RulesEngine::Rule::Outcome.new(RulesEngine::Rule::Outcome::START_WORKFLOW, 'three'))
-            RulesEngine::Discovery.should_not_receive(:rule_class).with("two_one")
-            RulesEngine::Discovery.should_receive(:rule_class).with("three_one")
-            @runner.run(10001, @plan, {})
+          describe "rule returns STOP_FAILURE" do
+            it "should not proceed to the next rule" do
+              @test_rule.stub!(:process).and_return(RulesEngine::Rule::Outcome.new(RulesEngine::Rule::Outcome::STOP_FAILURE))
+              RulesEngine::Discovery.should_not_receive(:rule_class).with("one_two")
+              @runner.run_plan(10001, @plan, {})
+            end
+      
+            it "should return failure" do
+              @test_rule.stub!(:process).and_return(RulesEngine::Rule::Outcome.new(RulesEngine::Rule::Outcome::STOP_FAILURE))
+              @runner.run_plan(10001, @plan, {}) == false
+            end
           end
+
+          describe "rule returns START_WORKFLOW" do
+            it "should not proceed to the next rule" do
+              @test_rule.stub!(:process).and_return(RulesEngine::Rule::Outcome.new(RulesEngine::Rule::Outcome::START_WORKFLOW, 'three'))
+              RulesEngine::Discovery.should_not_receive(:rule_class).with("one_two")
+              @runner.run_plan(10001, @plan, {})
+            end
+      
+            it "should start the defined workflow" do
+              @test_rule.stub!(:process).and_return(RulesEngine::Rule::Outcome.new(RulesEngine::Rule::Outcome::START_WORKFLOW, 'three'))
+              RulesEngine::Discovery.should_not_receive(:rule_class).with("two_one")
+              RulesEngine::Discovery.should_receive(:rule_class).with("three_one")
+              @runner.run_plan(10001, @plan, {})
+            end
+          end        
         end
+      end    
+    end  
+  
+    describe "running the workflow" do
+      it "should use the _run_plan_workflow method" do
+        @runner.should_receive(:_run_plan_workflow)
+        @runner.run_workflow(10001, @plan, "one", {})
+      end
+    
+      it "should be successfull with a valid plan" do
+        @runner.run_workflow(10001, @plan, "one", {}).should == true
+      end
+
+      it "should fail with an invalid plan" do
+        @runner.run_workflow(10001, {}, {}).should == false
       end
     end
-  end
-  
+  end  
+
 end

data/spec/rules_engine/rule/definition_spec.rb

@@ -69,11 +69,11 @@ describe "RulesEngine::Rule::Definition" do
   
   describe "processing a rule" do
     it "should return a rule_outcome" do
-      MockRule.new.process(101, {}).should be_instance_of(RulesEngine::Rule::Outcome)
+      MockRule.new.process(101, {}, {}).should be_instance_of(RulesEngine::Rule::Outcome)
     end
 
     it "should set the outcome to NEXT by default" do
-      MockRule.new.process(101, {}).outcome.should == RulesEngine::Rule::Outcome::NEXT
+      MockRule.new.process(101, {}, {}).outcome.should == RulesEngine::Rule::Outcome::NEXT
     end        
   end
   

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rules_engine
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 11
   prerelease: false
   segments: 
   - 0
   - 1
-  - 7
-  version: 0.1.7
+  - 8
+  version: 0.1.8
 platform: ruby
 authors: 
 - Chris Douglas
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-29 00:00:00 +10:00
+date: 2010-08-09 00:00:00 +10:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -148,15 +148,15 @@ files:
 - rails_generators/templates/app/views/re_publications/_show_update.html.erb
 - rails_generators/templates/app/views/re_publications/show.html.erb
 - rails_generators/templates/app/views/re_publications/show.js.erb
-- rails_generators/templates/app/views/re_rule_definitions/complex/_edit.html.erb
-- rails_generators/templates/app/views/re_rule_definitions/complex/_form.html.erb
-- rails_generators/templates/app/views/re_rule_definitions/complex/_form_word.html.erb
-- rails_generators/templates/app/views/re_rule_definitions/complex/_help.html.erb
-- rails_generators/templates/app/views/re_rule_definitions/complex/_new.html.erb
-- rails_generators/templates/app/views/re_rule_definitions/simple/_edit.html.erb
-- rails_generators/templates/app/views/re_rule_definitions/simple/_form.html.erb
-- rails_generators/templates/app/views/re_rule_definitions/simple/_help.html.erb
-- rails_generators/templates/app/views/re_rule_definitions/simple/_new.html.erb
+- rails_generators/templates/app/views/re_rules/complex/_edit.html.erb
+- rails_generators/templates/app/views/re_rules/complex/_form.html.erb
+- rails_generators/templates/app/views/re_rules/complex/_form_word.html.erb
+- rails_generators/templates/app/views/re_rules/complex/_help.html.erb
+- rails_generators/templates/app/views/re_rules/complex/_new.html.erb
+- rails_generators/templates/app/views/re_rules/simple/_edit.html.erb
+- rails_generators/templates/app/views/re_rules/simple/_form.html.erb
+- rails_generators/templates/app/views/re_rules/simple/_help.html.erb
+- rails_generators/templates/app/views/re_rules/simple/_new.html.erb
 - rails_generators/templates/app/views/re_workflow_rules/_edit.html.erb
 - rails_generators/templates/app/views/re_workflow_rules/_error.html.erb
 - rails_generators/templates/app/views/re_workflow_rules/_help.html.erb