parse_decision 0.0.5

data/spec/parser_spec.rb

@@ -0,0 +1,308 @@
+require 'spec_helper'
+
+describe ParseDecision::Parser do
+
+    let(:parser) { ParseDecision::Parser.new }
+    let(:outdir) { 'tmp/spec/parser' }
+    let(:wfsrc_log) { 'spec/data/wf.decision.txt' }
+
+    before :each do
+      out = Pathname.new outdir
+      out.rmtree if out.exist? && out.directory?
+    end
+
+  it "raises an error if an output dir is not set" do
+    expect { parser.parseFile(wfsrc_log) }.to raise_error("outdir missing")
+  end
+
+    let(:wfrules_output)  { outdir+'/001-WF-DataClearing-Pre-Rules.xml' }
+    let(:wfapp_output)    { outdir+'/001-APP.xml' }
+    let(:wflog_output)    { outdir+'/wf.decision.txt' }
+
+    let(:wfrules_file)    { Pathname.new wfrules_output }
+    let(:wfapp_file)      { Pathname.new wfapp_output }
+    let(:wfsource_file)   { Pathname.new wflog_output }
+
+  it "parses a file" do
+    parser.parse wfsrc_log, outdir
+
+    wfrules_file.exist?.should be_truthy
+    wfapp_file.exist?.should be_truthy
+    wfsource_file.exist?.should be_truthy
+  end
+
+  describe "parsed workflow decisions" do
+
+      # Reference files
+      let(:wfapp_reference)     { 'spec/data/reference/workflow/001-APP.xml' }
+      let(:wfrules_reference)   { 'spec/data/reference/workflow/001-WF-DataClearing-Pre-Rules.xml' }
+
+      let(:wfrules_result)      { file_to_array( wfrules_output ) }
+      let(:wfapp_result)        { file_to_array( wfapp_output ) }
+      let(:wf_ref_file)         { file_to_array( wfrules_reference ) }
+      let(:wfapp_ref_file)      { file_to_array( wfapp_reference ) }
+
+    it "contain rules" do
+      parser.parse wfsrc_log, outdir
+
+      wfrules_result.should include 'CURRENT LOAN STAGE'
+      wfrules_result.should include '<Rule Name='
+    end
+
+    it "match reference output files" do
+      parser.parse wfsrc_log, outdir
+
+      wfrules_result.should eq wf_ref_file
+      wfapp_result.should eq wfapp_ref_file
+    end
+  end
+
+  describe "parsed product decisions" do
+
+    let(:src_log)       { 'spec/data/prod.decision.txt' }
+
+    let(:log_output)    { outdir+'/prod.decision.txt' }
+    let(:app_output)    { outdir+'/002-APP.xml' }
+    let(:rules_output)  { outdir+'/002-FAPIILoanModification-PRODUCT.xml' }
+
+      # Reference files
+      let(:app_reference)     { 'spec/data/reference/product/002-APP.xml' }
+      let(:rules_reference)   { 'spec/data/reference/product/002-FAPIILoanModification-PRODUCT.xml' }
+
+      let(:app_result)        { file_to_array( app_output ) }
+      let(:rules_result)      { file_to_array( rules_output ) }
+      let(:app_ref_file)      { file_to_array( app_reference ) }
+      let(:rules_ref_file)    { file_to_array( rules_reference ) }
+
+    it "contain rules" do
+      parser.parse src_log, outdir
+
+      app_result.should include '<DECISION_REQUEST>'
+      rules_result.should include '<Rule Name='
+    end
+
+    it "match reference output files" do
+      parser.parse src_log, outdir
+
+      app_result.should eq app_ref_file
+      rules_result.should eq rules_ref_file
+    end
+
+  end
+
+  describe "parsed validation decisions" do
+
+    let(:src_log)       { 'spec/data/prod.decision.txt' }
+
+    let(:log_output)    { outdir+'/prod.decision.txt' }
+    let(:app_output)    { outdir+'/001-APP.xml' }
+    let(:rules_output)  { outdir+'/001-Validation-Rules.xml' }
+
+      # Reference files
+      let(:app_reference)     { 'spec/data/reference/product/001-APP.xml' }
+      let(:rules_reference)   { 'spec/data/reference/product/001-Validation-Rules.xml' }
+
+      let(:app_result)        { file_to_array( app_output ) }
+      let(:rules_result)      { file_to_array( rules_output ) }
+      let(:app_ref_file)      { file_to_array( app_reference ) }
+      let(:rules_ref_file)    { file_to_array( rules_reference ) }
+
+    it "contain rules" do
+      parser.parse src_log, outdir
+
+      app_result.should include '<DECISION_REQUEST>'
+      rules_result.should include '<Rule Name='
+    end
+
+    it "match reference output files" do
+      parser.parse src_log, outdir
+
+      app_result.should eq app_ref_file
+      rules_result.should eq rules_ref_file
+    end
+
+  end
+
+  describe "parsed validation decisions with discard data" do
+
+    let(:src_log)       { 'spec/data/validation.decision.txt' }
+
+    let(:log_output)    { outdir+'/validation.decision.txt' }
+    let(:app_output)    { outdir+'/001-APP.xml' }
+    let(:rules_output)  { outdir+'/001-Validation-Rules.xml' }
+
+      # Reference files
+      let(:app_reference)     { 'spec/data/reference/validation/001-APP.xml' }
+      let(:rules_reference)   { 'spec/data/reference/validation/001-Validation-Rules.xml' }
+
+      let(:app_result)        { file_to_array( app_output ) }
+      let(:rules_result)      { file_to_array( rules_output ) }
+      let(:app_ref_file)      { file_to_array( app_reference ) }
+      let(:rules_ref_file)    { file_to_array( rules_reference ) }
+
+    it "contain request XML" do
+      parser.parse src_log, outdir
+
+      app_result.should include '<DECISION_REQUEST>'
+    end
+
+    it "contain Decision open tag element" do
+      parser.parse src_log, outdir
+
+      rules_result.should include '<Decision GuidelineId="39"'
+    end
+
+    it "contain Rules open tag" do
+      parser.parse src_log, outdir
+
+      rules_result.should include '<Rules>'
+    end
+
+    it "contain at least one rule tag" do
+      parser.parse src_log, outdir
+
+      app_result.should include '<DECISION_REQUEST>'
+      rules_result.should include '<Decision GuidelineId="39"'
+      rules_result.should include '<Rules>'
+      rules_result.should include '<Rule Name='
+    end
+
+    it "match reference output files" do
+      parser.parse src_log, outdir
+
+      app_result.should eq app_ref_file
+      rules_result.should eq rules_ref_file
+    end
+
+  end
+
+  describe "parsed workflow2 decisions" do
+
+    let(:src_log)       { 'spec/data/wf2.decision.txt' }
+
+    let(:log_output)    { outdir+'/wf2.decision.txt' }
+    let(:app_output)    { outdir+'/001-APP.xml' }
+    let(:rules_output)  { outdir+'/001-WF-ProdSel-Post-Rules.xml' }
+
+      # Reference files
+      let(:app_reference)     { 'spec/data/reference/workflow-2/001-APP.xml' }
+      let(:rules_reference)   { 'spec/data/reference/workflow-2/001-WF-ProdSel-Post-Rules.xml' }
+
+      let(:app_result)        { file_to_array( app_output ) }
+      let(:rules_result)      { file_to_array( rules_output ) }
+      let(:app_ref_file)      { file_to_array( app_reference ) }
+      let(:rules_ref_file)    { file_to_array( rules_reference ) }
+
+    it "contain rules" do
+      parser.parse src_log, outdir
+
+      app_result.should include '<DECISION_REQUEST>'
+      rules_result.should include '<Rule Name='
+    end
+
+    it "match reference output files" do
+      parser.parse src_log, outdir
+
+      app_result.should eq app_ref_file
+      rules_result.should eq rules_ref_file
+    end
+
+  end
+
+  describe "parsed multi-product decisions" do
+
+    let(:src_log)       { 'spec/data/multiproduct.decision.txt' }
+
+    let(:app_output)    { outdir+'/001-APP.xml' }
+    let(:rules_output1) { outdir+'/001-Mod-Forbear-PRODUCT.xml' }
+    let(:rules_output2) { outdir+'/001-Mod-Forgive-PRODUCT.xml' }
+    let(:rules_output3) { outdir+'/001-Mod-RateTerm-PRODUCT.xml' }
+    let(:rules_output4) { outdir+'/001-Mod-SAM-PRODUCT.xml' }
+    let(:log_output)    { outdir+'/multiproduct.decision.txt' }
+
+      # Reference files
+      let(:app_reference)     { 'spec/data/reference/multiproduct/001-APP.xml' }
+      let(:rules_reference1)  { 'spec/data/reference/multiproduct/001-Mod-Forbear-PRODUCT.xml' }
+      let(:rules_reference2)  { 'spec/data/reference/multiproduct/001-Mod-Forgive-PRODUCT.xml' }
+      let(:rules_reference3)  { 'spec/data/reference/multiproduct/001-Mod-RateTerm-PRODUCT.xml' }
+      let(:rules_reference4)  { 'spec/data/reference/multiproduct/001-Mod-SAM-PRODUCT.xml' }
+
+      let(:app_result)        { file_to_array( app_output ) }
+      let(:rules_result1)     { file_to_array( rules_output1 ) }
+      let(:rules_result2)     { file_to_array( rules_output2 ) }
+      let(:rules_result3)     { file_to_array( rules_output3 ) }
+      let(:rules_result4)     { file_to_array( rules_output4 ) }
+      let(:app_ref_file)      { file_to_array( app_reference ) }
+      let(:rules_ref_file1)   { file_to_array( rules_reference1 ) }
+      let(:rules_ref_file2)   { file_to_array( rules_reference2 ) }
+      let(:rules_ref_file3)   { file_to_array( rules_reference3 ) }
+      let(:rules_ref_file4)   { file_to_array( rules_reference4 ) }
+
+    it "contain rules" do
+      parser.parse src_log, outdir
+
+      app_result.should include '<DECISION_REQUEST>'
+      rules_result1.should include '<Rule Name='
+      rules_result2.should include '<Rule Name='
+      rules_result3.should include '<Rule Name='
+      rules_result4.should include '<Rule Name='
+    end
+
+    it "match reference output files" do
+      parser.parse src_log, outdir
+
+      app_result.should eq app_ref_file
+      rules_result1.should eq rules_ref_file1
+      rules_result2.should eq rules_ref_file2
+      rules_result3.should eq rules_ref_file3
+      rules_result4.should eq rules_ref_file4
+    end
+
+  end
+
+  describe "parsed web decisions" do
+
+    let(:src_log)       { 'spec/data/web.decision.txt' }
+
+    let(:app_output1)   { outdir+'/001-APP.xml' }
+    let(:app_output2)   { outdir+'/002-APP.xml' }
+    let(:rules_output1) { outdir+'/001-Product01-PRODUCT.xml' }
+    let(:rules_output2) { outdir+'/002-Product01-PRODUCT.xml' }
+    let(:log_output)    { outdir+'/web.decision.txt' }
+
+      # Reference files
+      let(:app_reference1)    { 'spec/data/reference/web/001-APP.xml' }
+      let(:app_reference2)    { 'spec/data/reference/web/002-APP.xml' }
+      let(:rules_reference1)  { 'spec/data/reference/web/001-Product01-PRODUCT.xml' }
+      let(:rules_reference2)  { 'spec/data/reference/web/002-Product01-PRODUCT.xml' }
+
+      let(:app_result1)       { file_to_array( app_output1 ) }
+      let(:app_result2)       { file_to_array( app_output2 ) }
+      let(:rules_result1)     { file_to_array( rules_output1 ) }
+      let(:rules_result2)     { file_to_array( rules_output2 ) }
+      let(:app_ref_file1)     { file_to_array( app_reference1 ) }
+      let(:app_ref_file2)     { file_to_array( app_reference2 ) }
+      let(:rules_ref_file1)   { file_to_array( rules_reference1 ) }
+      let(:rules_ref_file2)   { file_to_array( rules_reference2 ) }
+
+    it "contain rules" do
+      parser.parse src_log, outdir
+
+      app_result1.should include '<DECISION_REQUEST>'
+      app_result2.should include '<DECISION_REQUEST>'
+      rules_result1.should include '<Rule Name='
+      rules_result2.should include '<Rule Name='
+    end
+
+    it "match reference output files" do
+      parser.parse src_log, outdir
+
+      app_result1.should eq app_ref_file1
+      app_result2.should eq app_ref_file2
+      rules_result1.should eq rules_ref_file1
+      rules_result2.should eq rules_ref_file2
+    end
+
+  end
+
+end

data/spec/plugin_app_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe "Plugin::Application" do
+
+  def a_context
+    ctx = ParseDecision::PDContext.new
+    ctx.outdir = 'tmp/spec'
+    ctx
+  end
+
+  context "when #execute is called" do
+
+    Given (:context) { a_context }
+    Given (:plug) { ParseDecision::Plugin::Application.new }
+    Given (:line) { '<DECISION_REQUEST><APPLICATION Blah="bleh"/></DECISION_REQUEST>' }
+
+    context "with line containing '<APPLICATION '" do
+      When (:result) { plug.execute( context, line ) }
+
+      Then { result.should eq true }
+
+      context "and context state will change" do
+        Then { context.state.should eq :app }
+      end
+    end
+
+    Given(:another_line) { '<Guideline Name="Blargh" />' }
+
+    context "with line that does not contain '<APPLICATION '" do
+      When(:result) { plug.execute( context, another_line ) }
+
+      Then { result.should eq false }
+
+      context "and context state will not change" do
+        Then { context.state.should eq nil }
+      end
+    end
+  end
+end
+

data/spec/plugin_ppmxpath_spec.rb

@@ -0,0 +1,74 @@
+require "spec_helper"
+
+describe "Plugin::PpmXpath" do
+
+  def a_context( _state=nil )
+    ctx = ParseDecision::PDContext.new
+    ctx.outdir = 'tmp/spec'
+    ctx.state = _state
+    ctx
+  end
+
+  start_string = '*APP XPATH xml*'
+  end_string = '<PPXPATH>'
+
+  context "when #execute is called" do
+
+    Given (:context) { a_context }
+    Given (:plug) { ParseDecision::Plugin::PpmXpath.new }
+
+    context "with a current state of :app" do
+      Given (:context) { a_context( :app ) }
+
+      context "with line containing '#{start_string}'" do
+        Given (:line) { start_string }
+
+        When (:result) { plug.execute( context, line ) }
+
+        Then { result.should eq true }
+
+        context "and context state will change" do
+          Then { context.state.should eq :appPpmXpath }
+        end
+      end
+
+      context "any other lines are refused" do
+        Given (:line) { "anything other than start_string" }
+        Given! (:start_state) { context.state }
+
+        When (:result) { plug.execute( context, line ) }
+
+        Then { result.should eq false }
+
+        context "and context state will not change" do
+          Then { context.state.should eq start_state }
+        end
+      end
+    end
+
+    context "with a current state of :appPpmXpath" do
+      Given (:context) { a_context( :appPpmXpath ) }
+
+      context "accept any line without #{end_string}" do
+        Given (:line) { "anything" }
+
+        When (:result) { plug.execute( context, line ) }
+
+        Then { result.should eq true }
+      end
+
+      context "stop accepting lines after #{end_string} received" do
+        Given (:line) { end_string }
+
+        When (:result) { plug.execute( context, line ) }
+
+        Then { result.should eq true }
+
+        context "and context state will change to :app" do
+          Then { context.state.should eq :app }
+        end
+      end
+    end
+  end
+end
+

data/spec/plugin_predecision_spec.rb

@@ -0,0 +1,81 @@
+require "spec_helper"
+
+def start_decision_element(name)
+  '<Decision GuidelineId="123" GuidelineName="'+name+'"'
+end
+
+describe "Plugin::PreDecisionGuideline" do
+
+  ppms_string = '<PARAMS><_DATA_SET'
+  gdl_string = '<Guideline '
+  end_string = '</Decision>'
+
+  context "when #execute is called" do
+
+    Given (:context) { create_context }
+    Given (:plug) { ParseDecision::Plugin::PreDecisionGuideline.new }
+
+    context "with a current state of :app" do
+      Given (:context) { create_context( :app ) }
+      Given! (:start_state) { context.state }
+
+      context "with line containing '#{ppms_string}'" do
+        Given (:line) { ppms_string }
+
+        When (:result) { plug.execute( context, line ) }
+
+        Then { result.should eq true }
+
+        context "and context state will not change" do
+          Then { context.state.should eq start_state }
+        end
+      end
+
+      context "with line containing '#{gdl_string}'" do
+        Given (:line) { "#{gdl_string}blahblahblah" }
+
+        When (:result) { plug.execute( context, line ) }
+
+        Then { result.should eq true }
+
+        context "and context state will change to :preDecisionGdl" do
+          Then { context.state.should eq :preDecisionGdl }
+        end
+      end
+    end
+
+    context "with a current state of :preDecisionGdl" do
+      Given (:context) { create_context( :preDecisionGdl ) }
+
+      context "accept any line" do
+        Given (:line) { "anything" }
+
+        When (:result) { plug.execute( context, line ) }
+
+        Then { result.should eq true }
+      end
+
+      context "creates filename from Decision element's GuidelineName attribute" do
+        Given (:line) { "#{start_decision_element('TestGdl')} blahblahblah" }
+
+        When (:result) { plug.execute( context, line ) }
+
+        Then { result.should eq true }
+        Then { plug.outfile.should eq "000-TestGdl-Rules.xml" }
+      end
+
+      context "stop accepting lines after #{end_string} received" do
+        Given (:line) { end_string }
+
+        When (:result) { plug.execute( context, line ) }
+
+        Then { result.should eq true }
+
+        context "and context state will change to :app" do
+          Then { context.state.should eq :app }
+        end
+      end
+    end
+  end
+end
+

data/spec/plugin_product_spec.rb

@@ -0,0 +1,117 @@
+require "spec_helper"
+
+def start_product_element(name)
+  '<PRODUCTS><PRODUCT Name="'+name+'"'
+end
+
+describe "Plugin::Product" do
+
+  ppm_start_string  = "<PARAMS><_DATA_SET"
+  rule_start_string = "<Rules>"
+  rule_end_string   = "</Decision>"
+  end_string        = '</Decision>'
+
+  context "when #execute is called" do
+
+    # Can't use #let here. We want the same plugin to be used so it's
+    # updated as we move through the flow.
+    plug = ParseDecision::Plugin::Product.new
+
+    context "with a current state of :app" do
+      # Can't use #let here. We want the same context to be used so it's
+      # updated as we move through the flow.
+      ctx = create_context( :app )
+
+      context "with line containing '#{start_product_element('Test')}'" do
+        let (:line) { start_product_element('Test') }
+
+        it "returns true and state should change to :productXml" do
+
+          result = plug.execute( ctx, line )
+
+          result.should eq true
+          ctx.state.should eq :productXml
+        end
+
+        context "with a current state of :productXml" do
+
+          context "with line containing '#{ppm_start_string}'" do
+            let (:line) { ppm_start_string }
+
+            it "returns true and state should change to :productPpms" do
+              result = plug.execute( ctx, line )
+
+              result.should eq true
+              ctx.state.should eq :productPpms
+            end
+
+            context "with a current state of :productPpms" do
+
+              context "with line containing '#{rule_start_string}'" do
+                let (:line) { rule_start_string }
+
+                it "returns true and state should change to :productRules" do
+                  result = plug.execute( ctx, line )
+
+                  result.should eq true
+                  ctx.state.should eq :productRules
+                end
+
+                context "then plugin will accept all lines" do
+                  let (:line) { "any old line" }
+
+                  it "returns true and state should not change" do
+                    result = plug.execute( ctx, line )
+
+                    result.should eq true
+                    ctx.state.should eq :productRules
+                  end # it "returns true and state should not change"
+
+                  context "until it receives '#{rule_end_string}'" do
+                    let (:line) { rule_end_string }
+
+                    it "returns true and state should change to :app" do
+                      result = plug.execute( ctx, line )
+
+                      result.should eq true
+                      ctx.state.should eq :app
+                    end # it "returns true and state should change to :app"
+                  end # context "until it receives '#{rule_end_string}'"
+                end # context "then plugin will accept all lines"
+              end # context "with line containing '#{rule_start_string}'"
+            end # context "with a current state of :productPpms"
+          end # context "with line containing '#{ppm_start_string}'"
+        end # context "with a current state of :productXml"
+      end # context "with line containing '#{start_product_element('Test')}'"
+
+      context "with line containing anything else" do
+        ctx = create_context( :app )
+        let (:line) { "blahblahblah" }
+
+        it "should return false and not change state" do
+          result = plug.execute( ctx, line )
+
+          result.should eq false
+          ctx.state.should eq :app
+        end
+      end # context "with line containing anything else"
+    end # context "with a current state of :app"
+  end # context "when #execute is called"
+
+=begin
+      context "with line containing '#{end_string}'" do
+        Given (:line) { "#{end_string}blahblahblah" }
+
+        When (:result) { plug.execute( ctx, line ) }
+
+        Then { result.should eq true }
+
+        context "and context state will change to :app" do
+          Then { ctx.state.should eq :app }
+        end
+      end
+    end
+  end
+=end
+end # describe "Plugin::Product"
+

data/spec/plugin_productxpath_spec.rb

@@ -0,0 +1,76 @@
+require "spec_helper"
+
+def start_decision_element(name)
+  '<Decision GuidelineId="123" GuidelineName="'+name+'"'
+end
+
+describe "Plugin::ProductXpath" do
+
+  start_string = '*PRODUCT XPATH xml*'
+  end_string = '<PPXPATH>'
+
+  context "when #execute is called" do
+
+    Given (:context) { create_context }
+    Given (:plug) { ParseDecision::Plugin::ProductXpath.new }
+
+    context "with a current state of :app" do
+      Given (:context) { create_context( :app ) }
+      Given! (:start_state) { context.state }
+
+      context "with line containing '#{start_string}'" do
+        Given (:line) { start_string }
+
+        When (:result) { plug.execute( context, line ) }
+
+        Then { result.should eq true }
+
+        context "and context state will change to :productXpath" do
+          Then { context.state.should eq :productXpath }
+        end
+      end
+
+      context "with line containing anything else" do
+        Given (:line) { "blahblahblah" }
+
+        When (:result) { plug.execute( context, line ) }
+
+        Then { result.should eq false }
+
+        context "and context state will not change" do
+          Then { context.state.should eq start_state }
+        end
+      end
+    end
+
+    context "with a current state of :productXpath" do
+      Given (:context) { create_context( :productXpath ) }
+      Given! (:start_state) { context.state }
+
+      context "accept any line" do
+        Given (:line) { "anything" }
+
+        When (:result) { plug.execute( context, line ) }
+
+        Then { result.should eq true }
+
+        context "and context state will not change" do
+          Then { context.state.should eq start_state }
+        end
+      end
+
+      context "with line containing '#{end_string}'" do
+        Given (:line) { "#{end_string}blahblahblah" }
+
+        When (:result) { plug.execute( context, line ) }
+
+        Then { result.should eq true }
+
+        context "and context state will change to :app" do
+          Then { context.state.should eq :app }
+        end
+      end
+    end
+  end
+end
+