rutema 2.0.1 → 2.0.2

data/lib/rutema/core/runner.rb

@@ -4,132 +4,151 @@ require_relative "framework"
 
 module Rutema
   module Runners
+    # The default test runner
     class Default
       include Rutema::Messaging
 
       attr_reader :context
-      attr_accessor :setup,:teardown
-      def initialize context,queue
-        @setup=nil
-        @teardown=nil
-        @context=context || Hash.new
+      attr_accessor :setup, :teardown
+
+      def initialize(context, queue)
+        @setup = nil
+        @teardown = nil
+        @context = context || {}
         @queue = queue
-        @number_of_runs=0
+        @number_of_runs = 0
         @cleanup_blocks = []
       end
 
       def run(spec, is_special = false)
-        begin
-          @context["spec_name"]=spec.name
-          steps=[]
-          status=:success
-          state={'start_time'=>Time.now, "sequence_id"=>@number_of_runs,:test=>spec.name}
-          message(:test=>spec.name,:text=>'started')
-          if @setup
-            message(:test=>spec.name,:text=>'setup')
-            executed_steps,setup_status = run_scenario("_setup_", @setup.scenario, @context, true)
-            status=setup_status unless STATUS_CODES.find_index(setup_status) < STATUS_CODES.find_index(status)
-            steps+=executed_steps
-          end
-          if status!=:error
-            message(:test=>spec.name,:text=>'running')
-            executed_steps,testspec_status = run_scenario(spec.name, spec.scenario, @context, is_special)
-            status=testspec_status unless STATUS_CODES.find_index(testspec_status) < STATUS_CODES.find_index(status)
-            steps+=executed_steps
-          else
-            message(:test=>spec.name,'number'=>0,'status'=>:error,'out'=>"Setup failed",'err'=>"",'duration'=>0)
-          end
-          @context['rutema_status']=status
-          if @teardown
-            message(:test=>spec.name,:text=>'teardown')
-            executed_steps,teardown_status = run_scenario("_teardown_", @teardown.scenario, @context, true)
-            status=teardown_status unless STATUS_CODES.find_index(teardown_status) < STATUS_CODES.find_index(status)
-          end
-          @context['rutema_status']=status
-          message(:test=>spec.name,:text=>'finished')
-          state['status']=status
-          state["stop_time"]=Time.now
-          state['steps']=steps
-          @number_of_runs+=1
-          return state
-        ensure
-          begin
-            cleanup_exception = nil
-            @cleanup_blocks.each do |cleanup_block|
-              # Try all blocks
-              begin
-                cleanup_block.run(@context) if cleanup_block.respond_to?(:run)
-              rescue Exception => e
-                # Ignore errors, ensure all cleanup steps are attempted
-                cleanup_exception = e
-              end
-            end
-            raise cleanup_exception if !cleanup_exception.nil?
-          ensure
-            @cleanup_blocks = []
-          end
+        @context["spec_name"] = spec.name
+        steps = []
+        run_status = :success
+        state = { "start_time" => Time.now, "sequence_id" => @number_of_runs, :test => spec.name }
+        message(:test => spec.name, :text => "started")
+        if @setup
+          message(:test => spec.name, :text => "setup")
+          run_status, steps = execute_and_collect_state("_setup_", @setup.scenario, true, run_status, steps)
+        end
+        if run_status == :error
+          message(:test => spec.name, "number" => 0, "status" => :error, "out" => "Setup failed", "err" => "", "duration" => 0)
+        else
+          message(:test => spec.name, :text => "running")
+          run_status, steps = execute_and_collect_state(spec.name, spec.scenario, is_special, run_status, steps)
         end
+        @context["rutema_status"] = run_status
+        if @teardown
+          message(:test => spec.name, :text => "teardown")
+          run_status, steps = execute_and_collect_state("_teardown_", @teardown.scenario, true, run_status, steps)
+        end
+        wrap_up_execution(run_status, steps, spec, state)
+      ensure
+        ensure_cleanup_on_exception
       end
 
       private
 
+      def execute_and_collect_state(test_name, scenario, is_special, current_run_status, steps_until_now)
+        executed_steps, scenario_status = run_scenario(test_name, scenario, @context, is_special)
+        current_run_status = scenario_status unless STATUS_CODES.find_index(scenario_status) < STATUS_CODES.find_index(current_run_status)
+        steps_until_now += executed_steps
+        return current_run_status, steps_until_now
+      end
+
+      def wrap_up_execution(run_status, executed_steps, last_run_spec, state)
+        @context["rutema_status"] = run_status
+        message(:test => last_run_spec.name, :text => "finished")
+        state["status"] = run_status
+        state["stop_time"] = Time.now
+        state["steps"] = executed_steps
+        @number_of_runs += 1
+        return state
+      end
+
+      def ensure_cleanup_on_exception
+        cleanup_exception = nil
+        @cleanup_blocks.each do |cleanup_block|
+          # Try all blocks
+
+          cleanup_block.run(@context) if cleanup_block.respond_to?(:run)
+        # rubocop:disable Lint/RescueException
+        rescue Exception => e
+          # Ignore errors, ensure all cleanup steps are attempted
+          cleanup_exception = e
+        end
+        # rubocop:enable Lint/RescueException
+        raise cleanup_exception unless cleanup_exception.nil?
+      ensure
+        @cleanup_blocks = []
+      end
+
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       def run_scenario(name, scenario, meta, is_special)
-        executed_steps=[]
-        status=:skipped
-        begin 
-          stps=scenario.steps
+        executed_steps = []
+        status = :skipped
+        begin
+          stps = scenario.steps
           if stps.empty?
-            error(name,"Scenario #{name} contains no steps")
-            status=:error
+            error(name, "Scenario #{name} contains no steps")
+            status = :error
           else
             stps.each do |s|
               if status == :error && s.skip_on_error?
-                message(:test=>name,:text=>s.to_s,'number'=>s.number,'status'=>:skipped,'is_special'=>is_special)
+                message(:test => name, :text => s.to_s, "number" => s.number, "status" => :skipped, "is_special" => is_special)
               else
-                message(
-                  :test => name, :text => s.to_s, 'number' => s.number,
-                  'status' => :started, 'is_special' => is_special
-                )
-                sleep 0.05
-                begin
-                  cache_cleanup(s)
-                  executed_steps << run_step(s, meta)
-                rescue Exception => e
-                  throw e unless s.continue?
-                  s.status = :error
-                end
-                message(
-                  :test => name, :text => s.to_s, 'number' => s.number,
-                  'status' => s.status, 'out' => s.output, 'err' => s.error,
-                  'backtrace' => s.backtrace, 'duration' => s.exec_time,
-                  'is_special' => is_special
-                )
-                status=s.status unless STATUS_CODES.find_index(s.status) < STATUS_CODES.find_index(status)
-                break if :error == s.status and !s.continue?
+                executed_step = next_step(s, name, meta, is_special)
+                status = executed_step.status unless STATUS_CODES.find_index(executed_step.status) < STATUS_CODES.find_index(status)
+                executed_steps << executed_step
+                break if s.status == :error && !s.continue?
               end
             end
           end
-        rescue
-          error(name,$!.message)
-          status=:error
+        rescue StandardError
+          error(name, "#{$!.message}\n#{$!.backtrace.join("\n")}")
+          status = :error
         end
-        return executed_steps,status
+        return executed_steps, status
       end
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-      def cache_cleanup(step)
-        if step.has_cleanup? && step.cleanup.respond_to?(:run)
-          @cleanup_blocks << step.cleanup
+      def next_step(step_spec, test_name, meta, test_is_special)
+        message(
+          :test => test_name, :text => step_spec.to_s, "number" => step_spec.number,
+          "status" => :started, "is_special" => test_is_special
+        )
+        sleep 0.05
+        begin
+          cache_cleanup(step_spec)
+          executed_step = run_step(step_spec, meta)
+          # rubocop:disable Lint/RescueException
+        rescue Exception => e
+          throw e unless step_spec.continue?
+          step_spec.status = :error
+          # rubocop:enable Lint/RescueException
         end
+        message(
+          :test => test_name, :text => step_spec.to_s, "number" => step_spec.number,
+          "status" => step_spec.status, "out" => step_spec.output, "err" => step_spec.error,
+          "backtrace" => step_spec.backtrace, "duration" => step_spec.exec_time,
+          "is_special" => test_is_special
+        )
+        return executed_step
+      end
+
+      def cache_cleanup(step)
+        return unless step.has_cleanup? && step.cleanup.respond_to?(:run)
+
+        @cleanup_blocks << step.cleanup
       end
 
-      def run_step step,meta
+      def run_step(step, meta)
         if step.has_cmd? && step.cmd.respond_to?(:run)
           step.cmd.run(meta)
         else
           message("No command associated with step '#{step.step_type}'. Step number is #{step.number}")
-          step.status=:warning
+          step.status = :warning
         end
-        step.status=:success if step.ignore?
+        step.status = :success if step.ignore?
         return step
       end
     end
@@ -141,20 +160,20 @@ module Rutema
     # Steps that do not respond to +:run+ have their status set to +:warning+.
     #
     # Returns the step after "executing" it successfully
-    class NoOp<Default
+    class NoOp < Default
       ##
       # Simulate running the step by setting its status to +:success+
       #
       # If the step does not respond to +:run+ then +:warning+ is set as its
       # status.
       #
-      # * +step+ - 
-      def run_step step,meta
+      # * +step+ -
+      def run_step(step, _meta)
         unless step.has_cmd? && step.cmd.respond_to?(:run)
           message("No command associated with step '#{step.step_type}'. Step number is #{step.number}")
-          step.status=:warning
+          step.status = :warning
         end
-        step.status=:success if step.ignore?
+        step.status = :success if step.ignore?
         return step
       end
     end

data/lib/rutema/elements/minimal.rb

@@ -1,6 +1,6 @@
 #  Copyright (c) 2007-2021 Vassilis Rizopoulos. All rights reserved.
 
-require 'highline'
+require "highline"
 
 module Rutema
   ##
@@ -8,43 +8,47 @@ module Rutema
   # functionality which can then be utilized in test specifications
   module Elements
     ##
-    # Module offering an examplary minimal set of elements for use as steps in
+    # Module offering an example of a minimal set of elements for use as steps in
     # test specifications
     module Minimal
-      #echo prints a message on the screen:
+      # echo prints a message on the screen:
       # <echo text="A meaningful message"/>
       # <echo>A meaningful message</echo>
-      def element_echo step
-        step.cmd=Patir::RubyCommand.new("echo"){|cmd| cmd.error="";cmd.output="#{step.text}";$stdout.puts(cmd.output) ;:success}
+      def element_echo(step)
+        step.cmd = Patir::RubyCommand.new("echo") do |cmd|
+          cmd.error = ""
+          cmd.output = step.text.to_s
+          $stdout.puts(cmd.output)
+          :success
+        end
         return step
       end
 
-      #prompt asks the user a yes/no question. Answering yes means the step is succesful.
+      # prompt asks the user a yes/no question. Answering yes means the step is successful.
       # <prompt text="Do you want fries with that?"/>
       #
-      #A prompt element automatically makes a specification "attended"
-      def element_prompt step
-         step.attended=true
-         step.cmd=Patir::RubyCommand.new("prompt") do |cmd|  
-          cmd.output=""
-          cmd.error=""
-          if HighLine.new.agree("#{step.text}")
-            step.output="y"
-          else
-            raise "n"
-          end#if
-        end#do rubycommand
+      # A prompt element automatically makes a specification "attended"
+      def element_prompt(step)
+        step.attended = true
+        step.cmd = Patir::RubyCommand.new("prompt") do |cmd|
+          cmd.output = ""
+          cmd.error = ""
+          raise "n" unless HighLine.new.agree(step.text.to_s)
+
+          step.output = "y"
+        end
         return step
       end
 
-      #command executes a shell command
+      # command executes a shell command
       # <command cmd="useful_command.exe with parameters", working_directory="some/directory"/>
-      def element_command step
-        raise ParserError,"missing required attribute cmd in #{step}" unless step.has_cmd?
-        wd=Dir.pwd
-        wd=step.working_directory if step.has_working_directory?
-        step.cmd=Patir::ShellCommand.new(:cmd=>step.cmd,:working_directory=>File.expand_path(wd))
-        return step  
+      def element_command(step)
+        raise ParserError, "missing required attribute cmd in #{step}" unless step.has_cmd?
+
+        wd = Dir.pwd
+        wd = step.working_directory if step.has_working_directory?
+        step.cmd = Patir::ShellCommand.new(:cmd => step.cmd, :working_directory => File.expand_path(wd))
+        return step
       end
     end
   end

data/lib/rutema/parsers/xml.rb

@@ -1,10 +1,10 @@
 #  Copyright (c) 2007-2021 Vassilis Rizopoulos. All rights reserved.
 
-require 'rexml/document'
-require 'patir/command'
-require_relative '../core/parser'
-require_relative '../core/objectmodel'
-require_relative '../elements/minimal'
+require "rexml/document"
+require "patir/command"
+require_relative "../core/parser"
+require_relative "../core/objectmodel"
+require_relative "../elements/minimal"
 
 module Rutema
   module Parsers
@@ -16,17 +16,17 @@ module Rutema
     # +element_foo+.
     #
     # The method will receive a Rutema::Step instance as a parameter which it should return
-    class XML<SpecificationParser
+    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"
+      # :nodoc:
+      ELEM_SPEC = "specification".freeze
+      # :nodoc:
+      ELEM_DESC = "specification/description".freeze
+      # :nodoc:
+      ELEM_TITLE = "specification/title".freeze
+      # :nodoc:
+      ELEM_SCENARIO = "specification/scenario".freeze
 
       ##
       # Pass the given test specification and return a corresponding
@@ -36,28 +36,30 @@ module Rutema
       # or the test specification itself.
       #
       # This will raise ParserError if an error occurs during parsing.
-      def parse_specification param
-        @parsed||=[]
+      def parse_specification(param)
+        @parsed ||= []
         begin
           if File.exist?(param)
-            txt=File.read(param)
-            filename=File.expand_path(param)
+            txt = File.read(param)
+            filename = File.expand_path(param)
           else
-            txt=param
-            filename=Dir.pwd
+            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
+          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
+          raise Rutema::ParserError, $!.message
         end
       end
 
       private
 
+      # rubocop:disable Metrics/AbcSize
       ##
       # Parse the XML specification of a testcase and create a corresponding
       # Rutema::Specification instance
@@ -65,30 +67,31 @@ module Rutema
       # * +xmltext+ - the actual test specification text which must be an XML
       #   document
       # * +filename+ - the filename of the test specification file or the
-      #   current working directory of the test execution (this 
-      def parse_case xmltxt,filename
-        spec=Rutema::Specification.new({})
-        xmldoc=REXML::Document.new( xmltxt )
+      #   current working directory of the test execution (this
+      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)
+        xmldoc.root.attributes.each do |attr, value|
+          add_attribute(spec, attr, value)
         end
-        spec.title=xmldoc.elements[ELEM_TITLE].text
-        spec.title||=""
+        spec.title = xmldoc.elements[ELEM_TITLE].text
+        spec.title ||= ""
         spec.title.strip!
-        spec.description=xmldoc.elements[ELEM_DESC].text
-        spec.description||=""
+        spec.description = xmldoc.elements[ELEM_DESC].text
+        spec.description ||= ""
         unless spec.description.empty?
           spec.description.strip!
-          spec.description.gsub!(/\t/,'')  
-        end 
+          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]
+          spec.scenario = parse_scenario(xmldoc.elements[ELEM_SCENARIO].to_s) if xmldoc.elements[ELEM_SCENARIO]
         end
-        spec.filename=filename
+        spec.filename = filename
         return spec
       end
 
+      # rubocop:enable Metrics/AbcSize
       ##
       # Conduct a simple validation of the XML document by checking if it
       # contains all necessary elements
@@ -97,51 +100,51 @@ module Rutema
       #
       # * +xmldoc+ - the text of the XML document to be checked for the
       # necessary elements
-      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]
+      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)
+      # 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)
+        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
+              number += 1
+              st.number = number
+              st.included_in = step.file
               scenario.add_step(st)
             end
           else
-            number+=1
-            step.number=number
+            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
-        step.continue=false
-        xmldoc.root.attributes.each do |attr,value|
-         add_attribute(step,attr,value)
+      # 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
+        step.continue = 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
+        step.text = xmldoc.root.text.strip if xmldoc.root.text
+        step.step_type = xmldoc.root.name
         return step
       end
 
@@ -153,13 +156,15 @@ module Rutema
       # * +attr+ - the name of the attribute which shall either be created or
       #   whose current value will be overridden
       # * +value+ - the value which shall be set for the attribute
-      def add_attribute element,attr,value
+      def add_attribute(element, attr, value)
         # If the string is a textual representation of a boolean value ...
         if boolean?(value)
+          # rubocop:disable Security/Eval
           # ... convert it to a boolean value
-         element.attribute(attr,eval(value))
+          element.attribute(attr, eval(value))
+          # rubocop:enable Security/Eval
         else
-          element.attribute(attr,value)
+          element.attribute(attr, value)
         end
       end
 
@@ -171,38 +176,40 @@ module Rutema
       #
       # * +attribute_value+ - the entity which shall be checked if it's a string
       # representing a boolean value
-      def boolean? attribute_value
-        return true if attribute_value=="true" || attribute_value=="false"
+      def boolean?(attribute_value)
+        return true if ["true", "false"].include?(attribute_value)
+
         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)
+      # 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|
+      #
+      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?
+            # 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 + "\n" + $@.join("\n"))
-              end#begin
+                send(:"element_#{step.step_type}", step)
+              rescue StandardError
+                raise ParserError, ("#{$!.message}\n#{$@.join("\n")}")
+              end
             elsif @configuration.parser["strict_mode"]
-              raise ParserError,"No command element associated with #{step.step_type}. Missing element_#{step.step_type}"
+              raise ParserError, "No command element associated with #{step.step_type}. Missing element_#{step.step_type}"
             end
-          end#each
-        end#chdir
+          end
+        end
         return spec
       end
     end