rutema 1.3.0 → 2.0.0.pre

data/lib/rutema/parsers/xml.rb

@@ -1,186 +1,154 @@
-#  Copyright (c) 2007-2011 Vassilis Rizopoulos. All rights reserved.
-$:.unshift File.join(File.dirname(__FILE__),'..','..')
-require 'rexml/document'
-require 'patir/command'
-require 'rutema/objectmodel'
-require 'rutema/parsers/base'
-require 'rutema/elements/minimal'
-
-module Rutema
-  #BaseXMLParser encapsulates all the XML parsing code
-  class BaseXMLParser<SpecificationParser
-    ELEM_SPEC="specification"
-    ELEM_DESC="specification/description"
-    ELEM_TITLE="specification/title"
-    ELEM_SCENARIO="specification/scenario"
-    ELEM_REQ="requirement"
-    #Parses __param__ and returns the Rutema::TestSpecification instance
-    #
-    #param can be the filename of the specification or the contents of that file.
-    #
-    #Will throw ParserError if something goes wrong
-    def parse_specification param
-      @logger.debug("Loading #{param}")
-      begin
-        if File.exists?(param)
-          #read the file
-          txt=File.read(param)
-          filename=File.expand_path(param)
-        else
-          filename=Dir.pwd
-          #try to parse the parameter
-          txt=param
-        end
-        spec=parse_case(txt,filename)
-        raise "Missing required attribute 'name' in specification element" unless spec.has_name? && !spec.name.empty?
-        return spec
-      rescue
-        @logger.debug($!)
-        raise ParserError,"Error loading #{param}: #{$!.message}"
-      end
-    end
-    
-    private
-    #Parses the XML specification of a testcase and creates the corresponding TestSpecification instance
-    def parse_case xmltxt,filename
-      #the testspec to return
-      spec=TestSpecification.new
-      #read the test spec
-      xmldoc=REXML::Document.new( xmltxt )
-      #validate it
-      validate_case(xmldoc)
-      #parse it
-      el=xmldoc.elements[ELEM_SPEC]
-      xmldoc.root.attributes.each do |attr,value|
-        add_attribute(spec,attr,value)
-      end
-      #get the title
-      spec.title=xmldoc.elements[ELEM_TITLE].text
-      spec.title||=""
-      spec.title.strip!
-      #get the description
-      #strip line feeds, cariage returns and remove all tabs
-      spec.description=xmldoc.elements[ELEM_DESC].text
-      spec.description||=""
-      begin
-        spec.description.strip!
-        spec.description.gsub!(/\t/,'')  
-      end unless spec.description.empty?
-      #get the requirements
-      reqs=el.elements.select{|e| e.name==ELEM_REQ}
-      reqs.collect!{|r| r.attributes["name"]}
-      spec.requirements=reqs
-      #Get the scenario
-      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.
-    #
-    #Checks for the existence of ELEM_SPEC, ELEM_DESC and ELEM_TITLE and raises ParserError if they're missing.
-    def validate_case xmldoc
-      raise ParserError,"missing #{ELEM_SPEC} element" unless xmldoc.elements[ELEM_SPEC]
-      raise ParserError,"missing #{ELEM_DESC} element" unless xmldoc.elements[ELEM_DESC]
-      raise ParserError,"missing #{ELEM_TITLE} element" unless xmldoc.elements[ELEM_TITLE]
-    end
-    
-    #Parses the scenario XML element and returns the Rutema::TestScenario instance
-    def parse_scenario xmltxt
-      @logger.debug("Parsing scenario from #{xmltxt}")
-      scenario=Rutema::TestScenario.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|
-            @logger.debug("Adding included step #{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::TestStep instance
-    def parse_step xmltxt
-      xmldoc=REXML::Document.new( xmltxt )
-      #any step element
-      step=Rutema::TestStep.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
-      @logger.debug("Including file from #{step}")
-      raise ParserError,"missing required attribute file in #{step}" unless step.has_file?
-      raise ParserError,"Cannot find #{File.expand_path(step.file)}" unless File.exists?(File.expand_path(step.file))
-      #Load the scenario
-      step.file=File.expand_path(step.file)
-      include_content=File.read(step.file)
-      @logger.debug(include_content)
-      return parse_scenario(include_content)
-    end
-  end
-  #The ExtensibleXMLParser allows you to easily add methods to handle specification elements.
-  #
-  #A method element_foo(step) allows you to add behaviour for foo scenario elements.
-  #
-  #The method will receive a Rutema::TestStep instance. 
-  class ExtensibleXMLParser<BaseXMLParser
-    def parse_specification param
-      spec = super(param)
-      #change into the directory the spec is in to handle relative paths correctly
-      Dir.chdir(File.dirname(File.expand_path(spec.filename))) do |path|
-        #iterate through the steps
-        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
-        end
-      end
-      return spec
-    end
-  end
-  #MinimalXMLParser offers three runnable steps in the scenarios as defined in Rutema::Elements::Minimal
-  class MinimalXMLParser<ExtensibleXMLParser
-    include Rutema::Elements::Minimal
-  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)
+        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/version.rb

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

metadata

@@ -1,20 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: rutema
 version: !ruby/object:Gem::Version
-  version: 1.3.0
-  prerelease: 
+  version: 2.0.0.pre
 platform: ruby
 authors:
 - Vassilis Rizopoulos
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-28 00:00:00.000000000 Z
+date: 2015-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: patir
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -22,7 +20,6 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -30,136 +27,82 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: highline
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.6.15
+        version: 1.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.6.15
-- !ruby/object:Gem::Dependency
-  name: mailfactory
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 1.4.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: 1.7.0
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.10'
+        version: '4.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.10'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: hoe
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.3'
+        version: '3.13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.3'
-description: ! "rutema is a test execution tool.\nIt allows the  combination of  various
-  test tools while it takes care of logging, reporting, archiving of results and formalizes
-  execution of automated and manual tests.\nIt's purpose is to make testing in heterogeneous
+        version: '3.13'
+description: "rutema [http://github.com/damphyr/rutema](http://github.com/damphyr/rutema)\n\nrutema
+  is a test execution tool and a framework for organizing and managing test execution
+  across different tools.\n\nIt enables the combination of different test tools while
+  it takes care of logging, reporting, archiving of results and formalizes execution
+  of automated and manual tests.\n\nIt's purpose is to make testing in heterogeneous
   environments easier. \n\n###Why?\nRequire consistency, repeatability and reliability
-  from your test infrastructure while gathering data on every run.\n\nWhether running
-  through a checklist of manual steps, or executing a sequence of fully automated
-  commands we always want in the end to know if a test has failed, where it failed
-  and what was the state of the system at that time.\n\nrutema will gather all logs,
-  timestamp them, store them and report on them. "
-email: vassilisrizopoulos@gmail.com
+  from your test infrastructure while gathering data on every run."
+email:
+- vassilisrizopoulos@gmail.com
 executables:
 - rutema
 extensions: []
 extra_rdoc_files:
 - History.txt
 - Manifest.txt
-- README.txt
+- README.md
 files:
-- bin/rutema
 - History.txt
-- examples/config/database.rutema
-- examples/config/full.rutema
-- examples/config/minimal.rutema
-- examples/README.md
-- examples/specs/check.spec
-- examples/specs/fail.spec
-- examples/specs/include.scenario
-- examples/specs/rutema.spec
-- examples/specs/setup.spec
-- examples/specs/T001.spec
-- examples/specs/T002.spec
-- examples/specs/T003.spec
-- examples/specs/T004.spec
-- examples/specs/T005.spec
-- examples/specs/T006.spec
-- examples/specs/teardown.spec
-- lib/rutema/configuration.rb
-- lib/rutema/elements/minimal.rb
-- lib/rutema/models/activerecord.rb
-- lib/rutema/models/base.rb
-- lib/rutema/objectmodel.rb
-- lib/rutema/parsers/base.rb
-- lib/rutema/parsers/xml.rb
-- lib/rutema/rake.rb
-- lib/rutema/reporters/activerecord.rb
-- lib/rutema/reporters/base.rb
-- lib/rutema/reporters/email.rb
-- lib/rutema/reporters/text.rb
-- lib/rutema/runners/default.rb
-- lib/rutema/runners/step.rb
-- lib/rutema/system.rb
 - Manifest.txt
-- Rakefile
 - README.md
-- README.txt
-- test/data/duplicate_name.spec
-- test/data/no_title.spec
-- test/data/sample.spec
-- test/data/test_identifiers.rutema
-- test/test_activerecord.rb
-- test/test_configuration.rb
-- test/test_objectmodel.rb
-- test/test_parsers.rb
-- test/test_reporters.rb
-- test/test_runners.rb
-- test/test_system.rb
+- bin/rutema
+- lib/rutema/application.rb
+- lib/rutema/core/configuration.rb
+- lib/rutema/core/engine.rb
+- lib/rutema/core/framework.rb
+- lib/rutema/core/objectmodel.rb
+- lib/rutema/core/parser.rb
+- lib/rutema/core/reporter.rb
+- lib/rutema/core/runner.rb
+- lib/rutema/elements/minimal.rb
+- lib/rutema/parsers/xml.rb
+- lib/rutema/version.rb
 - .gemtest
 homepage: http://github.com/damphyr/rutema
-licenses: []
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options:
 - --main
@@ -167,32 +110,20 @@ rdoc_options:
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 1271940349164417717
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubyforge_project: patir
-rubygems_version: 1.8.24
+rubyforge_project: 
+rubygems_version: 2.0.14
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: rutema is a test execution and management framework for heterogeneous testing
   environments
-test_files:
-- test/test_activerecord.rb
-- test/test_configuration.rb
-- test/test_objectmodel.rb
-- test/test_parsers.rb
-- test/test_reporters.rb
-- test/test_runners.rb
-- test/test_system.rb
+test_files: []