rutema 2.0.0.pre5 → 2.0.0.pre6

data/lib/rutema/parsers/xml.rb

@@ -1,154 +1,156 @@
-#  Copyright (c) 2007-2015 Vassilis Rizopoulos. All rights reserved.
-require 'rexml/document'
-require 'patir/command'
-require_relative '../core/parser'
-require_relative '../core/objectmodel'
-require_relative '../elements/minimal'
-
-module Rutema
-  module Parsers
-    #Rutema::Parsers::XML is a basic XML parser that is easily extended
-    #
-    #Derive your parser from this class and define for each element 'foo' that you want to parse 
-    #a method element_foo(step)
-    #
-    #The method will receive a Rutema::Step instance as a parameter which it should return
-    class XML<SpecificationParser
-      include Rutema::Elements::Minimal
-      #:nodoc:
-      ELEM_SPEC="specification"
-      #:nodoc:
-      ELEM_DESC="specification/description"
-      #:nodoc:
-      ELEM_TITLE="specification/title"
-      #:nodoc:
-      ELEM_SCENARIO="specification/scenario"
-      #Parses __param__ and returns the Rutema::Specification instance
-      #
-      #param can be the filename of the specification or the contents of that file.
-      #
-      #Will throw Rutema::ParserError if something goes wrong
-      def parse_specification param
-        @parsed||=[]
-        begin
-          if File.exist?(param)
-            txt=File.read(param)
-            filename=File.expand_path(param)
-          else
-            txt=param
-            filename=Dir.pwd
-          end
-          spec=parse_case(txt,filename)
-          raise Rutema::ParserError,"Missing required attribute 'name' in specification element" unless spec.has_name? && !spec.name.empty?
-          raise Rutema::ParserError,"Duplicate test name '#{spec.name}' in #{filename}" if @parsed.include?(spec.name)
-          @parsed<<spec.name
-          extension_handling(spec)
-        end
-      end
-      private
-      #Parses the XML specification of a testcase and creates the corresponding Rutema::Specification instance
-      def parse_case xmltxt,filename
-        spec=Rutema::Specification.new({})
-        xmldoc=REXML::Document.new( xmltxt )
-        validate_case(xmldoc)
-        xmldoc.root.attributes.each do |attr,value|
-          add_attribute(spec,attr,value)
-        end
-        spec.title=xmldoc.elements[ELEM_TITLE].text
-        spec.title||=""
-        spec.title.strip!
-        spec.description=xmldoc.elements[ELEM_DESC].text
-        spec.description||=""
-        unless spec.description.empty?
-          spec.description.strip!
-          spec.description.gsub!(/\t/,'')  
-        end 
-        Dir.chdir(File.dirname(filename)) do
-          spec.scenario=parse_scenario(xmldoc.elements[ELEM_SCENARIO].to_s) if xmldoc.elements[ELEM_SCENARIO]
-        end
-        spec.filename=filename
-        return spec
-      end
-      #Validates the XML file from our point of view.
-      def validate_case xmldoc
-        raise Rutema::ParserError,"missing #{ELEM_SPEC} element in #{xmldoc}" unless xmldoc.elements[ELEM_SPEC]
-        raise Rutema::ParserError,"missing #{ELEM_DESC} element in #{xmldoc}" unless xmldoc.elements[ELEM_DESC]
-        raise Rutema::ParserError,"missing #{ELEM_TITLE} element in #{xmldoc}" unless xmldoc.elements[ELEM_TITLE]
-      end
-      #Parses the 'scenario' XML element and returns the Rutema::Scenario instance
-      def parse_scenario xmltxt
-        scenario=Rutema::Scenario.new([])
-        xmldoc=REXML::Document.new( xmltxt )
-        xmldoc.root.attributes.each do |attr,value|
-          add_attribute(scenario,attr,value)
-        end
-        number=0
-        xmldoc.root.elements.each do |el| 
-          step=parse_step(el.to_s)
-          if step.step_type=="include_scenario"
-            included_scenario=include_scenario(step)
-            included_scenario.steps.each do |st|
-              number+=1
-              st.number=number
-              st.included_in=step.file
-              scenario.add_step(st)
-            end
-          else
-            number+=1
-            step.number=number
-            scenario.add_step(step)
-          end
-        end
-        return scenario
-      end
-      #Parses xml and returns the Rutema::Step instance
-      def parse_step xmltxt
-        xmldoc=REXML::Document.new( xmltxt )
-        #any step element
-        step=Rutema::Step.new()
-        step.ignore=false
-        xmldoc.root.attributes.each do |attr,value|
-         add_attribute(step,attr,value)
-        end
-        step.text=xmldoc.root.text.strip if xmldoc.root.text
-        step.step_type=xmldoc.root.name
-        return step
-      end
-      def add_attribute element,attr,value
-        if boolean?(value)
-         element.attribute(attr,eval(value))
-        else
-          element.attribute(attr,value)
-        end
-      end
-      def boolean? attribute_value
-        return true if attribute_value=="true" || attribute_value=="false"
-        return false
-      end
-      #handles <include_scenario> elements, adding the steps to the current scenario
-      def include_scenario step
-        raise Rutema::ParserError,"missing required attribute file in #{step}" unless step.has_file?
-        raise Rutema::ParserError,"Cannot find #{File.expand_path(step.file)}" unless File.exist?(File.expand_path(step.file))
-        step.file=File.expand_path(step.file)
-        include_content=File.read(step.file)
-        return parse_scenario(include_content)
-      end
-      def extension_handling spec
-        #change into the directory the spec is in to handle relative paths correctly
-        Dir.chdir(File.dirname(File.expand_path(spec.filename))) do |path|
-          spec.scenario.steps.each do |step|
-            #do we have a method to handle the element?
-            if respond_to?(:"element_#{step.step_type}")
-              begin
-                self.send(:"element_#{step.step_type}",step)
-              rescue
-                raise ParserError, $!.message
-              end
-            end#begin
-          end#each
-        end#chdir
-        return spec
-      end
-    end
-  end
-end
+#  Copyright (c) 2007-2015 Vassilis Rizopoulos. All rights reserved.
+require 'rexml/document'
+require 'patir/command'
+require_relative '../core/parser'
+require_relative '../core/objectmodel'
+require_relative '../elements/minimal'
+
+module Rutema
+  module Parsers
+    #Rutema::Parsers::XML is a basic XML parser that is easily extended
+    #
+    #Derive your parser from this class and define for each element 'foo' that you want to parse 
+    #a method element_foo(step)
+    #
+    #The method will receive a Rutema::Step instance as a parameter which it should return
+    class XML<SpecificationParser
+      include Rutema::Elements::Minimal
+      #:nodoc:
+      ELEM_SPEC="specification"
+      #:nodoc:
+      ELEM_DESC="specification/description"
+      #:nodoc:
+      ELEM_TITLE="specification/title"
+      #:nodoc:
+      ELEM_SCENARIO="specification/scenario"
+      #Parses __param__ and returns the Rutema::Specification instance
+      #
+      #param can be the filename of the specification or the contents of that file.
+      #
+      #Will throw Rutema::ParserError if something goes wrong
+      def parse_specification param
+        @parsed||=[]
+        begin
+          if File.exist?(param)
+            txt=File.read(param)
+            filename=File.expand_path(param)
+          else
+            txt=param
+            filename=Dir.pwd
+          end
+          spec=parse_case(txt,filename)
+          raise Rutema::ParserError,"Missing required attribute 'name' in specification element" unless spec.has_name? && !spec.name.empty?
+          raise Rutema::ParserError,"Duplicate test name '#{spec.name}' in #{filename}" if @parsed.include?(spec.name)
+          @parsed<<spec.name
+          extension_handling(spec)
+        rescue REXML::ParseException
+          raise Rutema::ParserError,$!.message
+        end
+      end
+      private
+      #Parses the XML specification of a testcase and creates the corresponding Rutema::Specification instance
+      def parse_case xmltxt,filename
+        spec=Rutema::Specification.new({})
+        xmldoc=REXML::Document.new( xmltxt )
+        validate_case(xmldoc)
+        xmldoc.root.attributes.each do |attr,value|
+          add_attribute(spec,attr,value)
+        end
+        spec.title=xmldoc.elements[ELEM_TITLE].text
+        spec.title||=""
+        spec.title.strip!
+        spec.description=xmldoc.elements[ELEM_DESC].text
+        spec.description||=""
+        unless spec.description.empty?
+          spec.description.strip!
+          spec.description.gsub!(/\t/,'')  
+        end 
+        Dir.chdir(File.dirname(filename)) do
+          spec.scenario=parse_scenario(xmldoc.elements[ELEM_SCENARIO].to_s) if xmldoc.elements[ELEM_SCENARIO]
+        end
+        spec.filename=filename
+        return spec
+      end
+      #Validates the XML file from our point of view.
+      def validate_case xmldoc
+        raise Rutema::ParserError,"missing #{ELEM_SPEC} element in #{xmldoc}" unless xmldoc.elements[ELEM_SPEC]
+        raise Rutema::ParserError,"missing #{ELEM_DESC} element in #{xmldoc}" unless xmldoc.elements[ELEM_DESC]
+        raise Rutema::ParserError,"missing #{ELEM_TITLE} element in #{xmldoc}" unless xmldoc.elements[ELEM_TITLE]
+      end
+      #Parses the 'scenario' XML element and returns the Rutema::Scenario instance
+      def parse_scenario xmltxt
+        scenario=Rutema::Scenario.new([])
+        xmldoc=REXML::Document.new( xmltxt )
+        xmldoc.root.attributes.each do |attr,value|
+          add_attribute(scenario,attr,value)
+        end
+        number=0
+        xmldoc.root.elements.each do |el| 
+          step=parse_step(el.to_s)
+          if step.step_type=="include_scenario"
+            included_scenario=include_scenario(step)
+            included_scenario.steps.each do |st|
+              number+=1
+              st.number=number
+              st.included_in=step.file
+              scenario.add_step(st)
+            end
+          else
+            number+=1
+            step.number=number
+            scenario.add_step(step)
+          end
+        end
+        return scenario
+      end
+      #Parses xml and returns the Rutema::Step instance
+      def parse_step xmltxt
+        xmldoc=REXML::Document.new( xmltxt )
+        #any step element
+        step=Rutema::Step.new()
+        step.ignore=false
+        xmldoc.root.attributes.each do |attr,value|
+         add_attribute(step,attr,value)
+        end
+        step.text=xmldoc.root.text.strip if xmldoc.root.text
+        step.step_type=xmldoc.root.name
+        return step
+      end
+      def add_attribute element,attr,value
+        if boolean?(value)
+         element.attribute(attr,eval(value))
+        else
+          element.attribute(attr,value)
+        end
+      end
+      def boolean? attribute_value
+        return true if attribute_value=="true" || attribute_value=="false"
+        return false
+      end
+      #handles <include_scenario> elements, adding the steps to the current scenario
+      def include_scenario step
+        raise Rutema::ParserError,"missing required attribute file in #{step}" unless step.has_file?
+        raise Rutema::ParserError,"Cannot find #{File.expand_path(step.file)}" unless File.exist?(File.expand_path(step.file))
+        step.file=File.expand_path(step.file)
+        include_content=File.read(step.file)
+        return parse_scenario(include_content)
+      end
+      def extension_handling spec
+        #change into the directory the spec is in to handle relative paths correctly
+        Dir.chdir(File.dirname(File.expand_path(spec.filename))) do |path|
+          spec.scenario.steps.each do |step|
+            #do we have a method to handle the element?
+            if respond_to?(:"element_#{step.step_type}")
+              begin
+                self.send(:"element_#{step.step_type}",step)
+              rescue
+                raise ParserError, $!.message
+              end
+            end#begin
+          end#each
+        end#chdir
+        return spec
+      end
+    end
+  end
+end

data/lib/rutema/reporters/json.rb

@@ -1,34 +1,34 @@
-#  Copyright (c) 2007-2010 Vassilis Rizopoulos. All rights reserved.
-require 'json'
-require_relative "../core/reporter"
-
-module Rutema
-  module Reporters
-    #Experimental reporter used to dump the data of a run on disk
-    #
-    #The following configuration keys are used by Rutema::Reporters::JSON
-    #
-    # filename - the filename to use to save the YAML dump. Default is 'rutema.results.json'
-    class JSON<Rutema::Reporters::BlockReporter
-      #Default report filename
-      DEFAULT_FILENAME="rutema.results.json"
-    
-      def initialize configuration,dispatcher
-        super(configuration,dispatcher)
-        @filename=configuration.reporters.fetch(self.class,{}).fetch("filename",DEFAULT_FILENAME)
-      end
-      #We get all the data from a test run in here.
-      def report specs,states,errors
-        run_entry={}
-        run_entry["specs"]=specs.size
-        if @configuration && @configuration.context
-          run_entry["context"]=@configuration.context
-        end
-        run_entry["errors"]=errors
-        run_entry["states"]=states
-        
-        Rutema::Utilities.write_file(@filename,::JSON.dump(run_entry))
-      end
-    end
-  end
-end
+#  Copyright (c) 2007-2010 Vassilis Rizopoulos. All rights reserved.
+require 'json'
+require_relative "../core/reporter"
+
+module Rutema
+  module Reporters
+    #Experimental reporter used to dump the data of a run on disk
+    #
+    #The following configuration keys are used by Rutema::Reporters::JSON
+    #
+    # filename - the filename to use to save the YAML dump. Default is 'rutema.results.json'
+    class JSON<Rutema::Reporters::BlockReporter
+      #Default report filename
+      DEFAULT_FILENAME="rutema.results.json"
+    
+      def initialize configuration,dispatcher
+        super(configuration,dispatcher)
+        @filename=configuration.reporters.fetch(self.class,{}).fetch("filename",DEFAULT_FILENAME)
+      end
+      #We get all the data from a test run in here.
+      def report specs,states,errors
+        run_entry={}
+        run_entry["specs"]=specs.size
+        if @configuration && @configuration.context
+          run_entry["context"]=@configuration.context
+        end
+        run_entry["errors"]=errors
+        run_entry["states"]=states
+        
+        Rutema::Utilities.write_file(@filename,::JSON.dump(run_entry))
+      end
+    end
+  end
+end

data/lib/rutema/reporters/junit.rb

@@ -1,97 +1,101 @@
-#  Copyright (c) 2015 Vassilis Rizopoulos. All rights reserved.
-require 'rexml/document'
-require_relative "../core/reporter"
-
-module Rutema
-  module Reporters
-    #This reporter generates an JUnit style XML result file that can be parsed by CI plugins
-    #
-    #It has been tested with Jenkins (>1.6.20)
-    #
-    #The following configuration keys are used by Rutema::Reporters::JUnit
-    #
-    # filename - the filename to use when saving the report. Default is 'rutema.results.junit.xml'
-    #
-    #Example configuration:
-    #
-    # require "rutema/reporters/junit"
-    # cfg.reporter={:class=>Rutema::Reporters::JUnit,"filename"=>"rutema.junit.xml"}
-    class JUnit<BlockReporter
-      DEFAULT_FILENAME="rutema.results.junit.xml"
-    
-      def initialize configuration,dispatcher
-        super(configuration,dispatcher)
-        @filename=configuration.reporters.fetch(self.class,{}).fetch("filename",DEFAULT_FILENAME)
-      end
-      #We get all the data from a test run in here.
-      def report specs,states,errors
-        tests=[]
-        number_of_failed=0
-        total_duration=0
-        states.each do |k,v|
-          tests<<test_case(k,v)
-          number_of_failed+=1 if v['status']!=:success
-          total_duration+=v["duration"].to_f
-        end
-        crashes=errors.map{|error| crash(error[:test],error[:error])}
-
-        
-        #<testsuite disabled="0" errors="0" failures="1" hostname="" id=""
-        #name="" package="" skipped="" tests="" time="" timestamp="">
-        attributes={"id"=>@configuration.context[:config_name],
-          "name"=>@configuration.context[:config_name],
-          "errors"=>crashes.size,
-          "failures"=>number_of_failed,
-          "tests"=>specs.size,
-          "time"=>total_duration,
-          "timestamp"=>@configuration.context[:start_time]
-        }
-        element_suite=REXML::Element.new("testsuite")
-        element_suite.add_attributes(attributes)        
-        
-        crashes.each{|t| element_suite.add_element(t)}
-        tests.each{|t| element_suite.add_element(t)}
-        xmldoc=REXML::Document.new
-        xmldoc<<REXML::XMLDecl.new
-        xmldoc.add_element(element_suite)
-        
-        Rutema::Utilities.write_file(@filename,xmldoc.to_s)
-      end
-      private
-      def test_case name,state
-        #<testcase name="" time="">      => the results from executing a test method
-        #  <system-out>  => data written to System.out during the test run
-        #  <system-err>  => data written to System.err during the test run
-        #  <skipped/>    => test was skipped
-        #  <failure>     => test failed
-        #  <error>       => test encountered an error
-        #</testcase>
-        element_test=REXML::Element.new("testcase")
-        element_test.add_attributes("name"=>name,"time"=>state["duration"],"classname"=>@configuration.context[:config_name])
-        if state['status']!=:success
-          fail=REXML::Element.new("failure")
-          fail.add_attribute("message","Step #{state["steps"].last["number"]} failed.")
-          fail.text="Step #{state["steps"].last["number"]} failed."
-          element_test.add_element(fail)
-          out=REXML::Element.new("system-out")
-          out.text=state["steps"].last["out"]
-          element_test.add_element(out)
-          err=REXML::Element.new("system-err")
-          err.text=state["steps"].last["err"]
-          element_test.add_element(err)
-        end
-        return element_test
-      end
-      
-      def crash name,message
-        failed=REXML::Element.new("testcase")
-        failed.add_attributes("name"=>name,"classname"=>@configuration.context[:config_name],"time"=>0)
-        msg=REXML::Element.new("error")
-        msg.add_attribute("message",message)
-        msg.text=message
-        failed.add_element(msg)
-        return failed
-      end
-    end
-  end
-end
+#  Copyright (c) 2015 Vassilis Rizopoulos. All rights reserved.
+require 'rexml/document'
+require_relative "../core/reporter"
+
+module Rutema
+  module Reporters
+    #This reporter generates an JUnit style XML result file that can be parsed by CI plugins
+    #
+    #It has been tested with Jenkins (>1.6.20)
+    #
+    #The following configuration keys are used by Rutema::Reporters::JUnit
+    #
+    # filename - the filename to use when saving the report. Default is 'rutema.results.junit.xml'
+    #
+    #Example configuration:
+    #
+    # require "rutema/reporters/junit"
+    # cfg.reporter={:class=>Rutema::Reporters::JUnit,"filename"=>"rutema.junit.xml"}
+    class JUnit<BlockReporter
+      DEFAULT_FILENAME="rutema.results.junit.xml"
+    
+      def initialize configuration,dispatcher
+        super(configuration,dispatcher)
+        @filename=configuration.reporters.fetch(self.class,{}).fetch("filename",DEFAULT_FILENAME)
+      end
+      #We get all the data from a test run in here.
+      def report specs,states,errors
+        cnt=process_data(specs,states,errors)
+        Rutema::Utilities.write_file(@filename,cnt)
+      end
+      def process_data specs,states,errors
+        tests=[]
+        number_of_failed=0
+        total_duration=0
+        states.each do |k,v|
+          tests<<test_case(k,v)
+          number_of_failed+=1 if v['status']!=:success
+          total_duration+=v["duration"].to_f
+        end
+        #<testsuite disabled="0" errors="0" failures="1" hostname="" id=""
+        #name="" package="" skipped="" tests="" time="" timestamp="">
+        attributes={"id"=>@configuration.context[:config_name],
+          "name"=>@configuration.context[:config_name],
+          "errors"=>errors.size,
+          "failures"=>number_of_failed,
+          "tests"=>specs.size,
+          "time"=>total_duration,
+          "timestamp"=>@configuration.context[:start_time]
+        }
+        return junit_content(specs,attributes,errors)
+      end
+      private
+      def test_case name,state
+        #<testcase name="" time="">      => the results from executing a test method
+        #  <system-out>  => data written to System.out during the test run
+        #  <system-err>  => data written to System.err during the test run
+        #  <skipped/>    => test was skipped
+        #  <failure>     => test failed
+        #  <error>       => test encountered an error
+        #</testcase>
+        element_test=REXML::Element.new("testcase")
+        element_test.add_attributes("name"=>name,"time"=>state["duration"],"classname"=>@configuration.context[:config_name])
+        if state['status']!=:success
+          fail=REXML::Element.new("failure")
+          fail.add_attribute("message","Step #{state["steps"].last["number"]} failed.")
+          fail.text="Step #{state["steps"].last["number"]} failed."
+          element_test.add_element(fail)
+          out=REXML::Element.new("system-out")
+          out.text=state["steps"].last["out"]
+          element_test.add_element(out)
+          err=REXML::Element.new("system-err")
+          err.text=state["steps"].last["err"]
+          element_test.add_element(err)
+        end
+        return element_test
+      end
+      def crash name,message
+        failed=REXML::Element.new("testcase")
+        failed.add_attributes("name"=>name,"classname"=>@configuration.context[:config_name],"time"=>0)
+        msg=REXML::Element.new("error")
+        msg.add_attribute("message",message)
+        msg.text=message
+        failed.add_element(msg)
+        return failed
+      end
+      def junit_content tests,attributes,errors
+        element_suite=REXML::Element.new("testsuite")
+        element_suite.add_attributes(attributes)        
+        errors.each{|error| element_suite.add_element(crash(error.test,error.text))}
+        tests.each{|t| element_suite.add_element(t)}
+        return document(element_suite).to_s
+      end
+      def document suite
+        xmldoc=REXML::Document.new
+        xmldoc<<REXML::XMLDecl.new
+        xmldoc.add_element(suite)
+        return xmldoc
+      end
+    end
+  end
+end

data/lib/rutema/version.rb

@@ -1,9 +1,9 @@
-module Rutema
-  #This module defines the version numbers for the library
-  module Version
-    MAJOR=2
-    MINOR=0
-    TINY="0.pre5"
-    STRING=[ MAJOR, MINOR, TINY ].join( "." )
-  end
+module Rutema
+  #This module defines the version numbers for the library
+  module Version
+    MAJOR=2
+    MINOR=0
+    TINY="0.pre6"
+    STRING=[ MAJOR, MINOR, TINY ].join( "." )
+  end
 end