rutema 2.0.0.pre5 → 2.0.0.pre6

data/lib/rutema/core/reporter.rb

@@ -1,129 +1,133 @@
-#  Copyright (c) 2007-2015 Vassilis Rizopoulos. All rights reserved.
-module Rutema
-  #Rutema supports two kinds of reporters.
-  #
-  #Block (from en bloc) reporters receive data via the report() method at the end of a Rutema run
-  #while event reporters receive events continuously during a run via the update() method
-  #
-  #Nothing prevents you from creating a class that implements both behaviours
-  module Reporters
-    class BlockReporter
-      def initialize configuration,dispatcher
-        @configuration=configuration
-      end
-      def report specifications,states,errors
-      end
-    end
-    class EventReporter
-      def initialize configuration,dispatcher
-        @configuration=configuration
-        @queue=dispatcher.subscribe(self.object_id)
-      end
-
-      def run!
-        @thread=Thread.new do
-          while true do
-            if  @queue.size>0
-              data=@queue.pop
-              update(data) if data
-            end
-            sleep 0.1
-          end
-        end
-      end
-
-      def update data
-      end
-
-      def exit
-        if @thread
-          while @queue.size>0 do
-            sleep 0.1
-          end
-          Thread.kill(@thread)
-        end
-      end
-    end
-  
-    class Collector<EventReporter
-      attr_reader :errors,:states
-      def initialize params,dispatcher
-        super(params,dispatcher)
-        @errors=[]
-        @states={}
-      end
-
-      def update data
-        if data[:error]
-          @errors<<data
-        elsif data[:test] && data['status']
-          test_state=@states.fetch(data[:test],{})
-          test_state["timestamp"]||=data[:timestamp]
-          duration=test_state.fetch("duration",0)+data["duration"]
-          test_state["duration"]=duration
-          test_state["status"]= data["status"]
-          steps=test_state.fetch("steps",[])
-          steps<<data
-          test_state["steps"]=steps
-          
-          @states[data[:test]]=test_state
-        end
-      end
-    end
-
-    class Console<EventReporter
-      def initialize configuration,dispatcher
-        super(configuration,dispatcher)
-        @mode=configuration.reporters.fetch(self.class,{})["mode"]
-      end
-      def update data
-        if data[:error]
-          puts ">ERROR: #{data.fetch(:test,"")} #{data[:error]}" unless @mode=="off"
-        elsif data[:test] 
-          if data["phase"]
-            puts ">#{data["phase"]} #{data[:test]}" unless @mode=="silent" || @mode=="off"
-          elsif data[:message]
-            puts ">#{data[:test]} #{data[:message]}" unless @mode=="silent" || @mode=="off"
-          elsif data["status"]==:error
-            if @mode!="off"
-              puts ">FATAL: #{data[:test]}(#{data["number"]}) failed"
-              puts data.fetch("out","")
-              puts data.fetch("err","")
-            end
-          end
-        elsif data[:message] 
-          puts ">#{data[:message]}" unless @mode=="silent" || @mode=="off"
-        end
-      end
-    end
-
-    class Summary<BlockReporter
-      def initialize configuration,dispatcher
-        super(configuration,dispatcher)
-        @silent=configuration.reporters.fetch(self.class,{})["silent"]
-      end
-      def report specs,states,errors
-        failures=[]
-        states.each do |k,v|
-          failures<<k if v.fetch("steps",[]).last['status']==:error
-        end
-        unless @silent
-          puts "#{errors.size} errors. #{states.size} test cases executed. #{failures.size} failed"
-          unless failures.empty?
-            puts "Failures:"
-            puts specs.map{|spec| "  #{spec.name} - #{spec.filename}" if failures.include?(spec.name)}.compact.join("\n")
-          end
-        end
-        return failures.size+errors.size
-      end
-    end
-  end
-
-  module Utilities
-    require "fileutils"
-    def self.write_file filename,content
-      FileUtils.mkdir_p(File.dirname(filename),:verbose=>false)
-      File.open(filename, 'wb') {|f| f.write(content) }
-    end  
-  end
-end
+#  Copyright (c) 2007-2015 Vassilis Rizopoulos. All rights reserved.
+module Rutema
+  #Rutema supports two kinds of reporters.
+  #
+  #Block (from en bloc) reporters receive data via the report() method at the end of a Rutema run
+  #while event reporters receive events continuously during a run via the update() method
+  #
+  #Nothing prevents you from creating a class that implements both behaviours
+  module Reporters
+    class BlockReporter
+      def initialize configuration,dispatcher
+        @configuration=configuration
+      end
+      def report specifications,states,errors
+      end
+    end
+    class EventReporter
+      def initialize configuration,dispatcher
+        @configuration=configuration
+        @queue=dispatcher.subscribe(self.object_id)
+      end
+
+      def run!
+        @thread=Thread.new do
+          while true do
+            if  @queue.size>0
+              data=@queue.pop
+              begin
+                update(data) if data
+              rescue
+                puts "#{self.class} failed with #{$!.message}"
+                raise
+              end
+            end
+            sleep 0.1
+          end
+        end
+      end
+
+      def update data
+      end
+
+      def exit
+        puts "Exiting #{self.class}" if $DEBUG
+        if @thread
+          puts "Reporter died with #{@queue.size} messages in the queue" unless @thread.alive?
+          while @queue.size>0 && @thread.alive? do
+            sleep 0.1
+          end
+          Thread.kill(@thread)
+        end
+      end
+    end
+  
+    class Collector<EventReporter
+      attr_reader :errors,:states
+      def initialize params,dispatcher
+        super(params,dispatcher)
+        @errors=[]
+        @states={}
+      end
+
+      def update message
+        case message
+        when RunnerMessage
+          test_state=@states.fetch(message.test,{})
+          test_state["timestamp"]||=message.timestamp
+          duration=test_state.fetch("duration",0)+message.duration
+          test_state["duration"]=duration
+          test_state["status"]= message.status
+          steps=test_state.fetch("steps",[])
+          steps<<message
+          test_state["steps"]=steps
+          @states[message.test]=test_state
+        when ErrorMessage
+          @errors<<message
+        end
+      end
+    end
+
+    class Console<EventReporter
+      def initialize configuration,dispatcher
+        super(configuration,dispatcher)
+        @mode=configuration.reporters.fetch(self.class,{})["mode"]
+      end
+      def update message
+        unless @mode=="off"
+          case message
+          when RunnerMessage
+            if message.status == :error
+              puts "FATAL|#{message.to_s}"
+            else
+              puts message.to_s if @mode=="verbose"
+            end
+          when ErrorMessage
+            puts message.to_s 
+          when Message
+            puts message.to_s if @mode=="verbose"
+          end
+        end
+      end
+    end
+
+    class Summary<BlockReporter
+      def initialize configuration,dispatcher
+        super(configuration,dispatcher)
+        @silent=configuration.reporters.fetch(self.class,{})["silent"]
+      end
+      def report specs,states,errors
+        failures=[]
+        states.each do |k,v|
+          failures<<k if v.fetch("steps",[]).last.status==:error
+        end
+        unless @silent
+          puts "#{errors.size} errors. #{states.size} test cases executed. #{failures.size} failed"
+          unless failures.empty?
+            puts "Failures:"
+            puts specs.map{|spec| "  #{spec.name} - #{spec.filename}" if failures.include?(spec.name)}.compact.join("\n")
+          end
+        end
+        return failures.size+errors.size
+      end
+    end
+  end
+
+  module Utilities
+    require "fileutils"
+    def self.write_file filename,content
+      FileUtils.mkdir_p(File.dirname(filename),:verbose=>false)
+      File.open(filename, 'wb') {|f| f.write(content) }
+    end  
+  end
+end

data/lib/rutema/core/runner.rb

@@ -1,84 +1,94 @@
-#  Copyright (c) 2007-2015 Vassilis Rizopoulos. All rights reserved.
-
-require_relative "framework"
-
-module Rutema
-  module Runners
-    class Default
-      include Rutema::Messaging
-      attr_reader :context
-      attr_accessor :setup,:teardown
-      def initialize context,queue
-        @setup=nil
-        @teardown=nil
-        @context=context || Hash.new
-        @queue = queue
-        @number_of_runs=0
-      end
-
-      def run spec
-        steps=[]
-        status=:success
-        state={'start_time'=>Time.now, "sequence_id"=>@number_of_runs,:test=>spec.name}
-        message(:test=>spec.name,'phase'=>'started')
-        if @setup
-          message(:test=>spec.name,'phase'=>'setup')
-          executed_steps,status=run_scenario("_setup_",@setup.scenario,@context)
-          steps+=executed_steps
-        end
-        if status!=:error
-          message(:test=>spec.name,'phase'=>'running')
-          executed_steps,status=run_scenario(spec.name,spec.scenario,@context)
-          steps+=executed_steps
-        else
-          message(:test=>spec.name,'number'=>0,'status'=>:error,'out'=>"Setup failed",'err'=>"",'duration'=>0)
-        end
-        state['status']=status
-        if @teardown
-          message(:test=>spec.name,'phase'=>'teardown')
-          executed_steps,status=run_scenario("_teardown_",@teardown.scenario,@context)
-        end
-        message(:test=>spec.name,'phase'=>'finished')
-        state["stop_time"]=Time.now
-        state['steps']=steps
-        @number_of_runs+=1
-        return state
-      end
-
-      private
-      def run_scenario name,scenario,meta
-        executed_steps=[]
-        status=:warning
-        begin 
-          stps=scenario.steps
-          if stps.empty?
-            error(name,"Scenario #{name} contains no steps")
-            status=:error
-          else
-            stps.each do |s| 
-              message(:test=>name,:message=>s.to_s)
-              executed_steps<<run_step(s,meta)
-              message(:test=>name,'number'=>s.number,'status'=>s.status,'out'=>s.output,'err'=>s.error,'duration'=>s.exec_time)
-              status=s.status
-              break if :error==s.status
-            end
-          end
-        rescue  
-          error(name,$!.message)
-          status=:error
-        end
-        return executed_steps,status
-      end
-      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
-        end
-        step.status=:success if step.ignore?
-        return step
-      end
-    end
-  end
+#  Copyright (c) 2007-2015 Vassilis Rizopoulos. All rights reserved.
+
+require_relative "framework"
+
+module Rutema
+  module Runners
+    class Default
+      include Rutema::Messaging
+      attr_reader :context
+      attr_accessor :setup,:teardown
+      def initialize context,queue
+        @setup=nil
+        @teardown=nil
+        @context=context || Hash.new
+        @queue = queue
+        @number_of_runs=0
+      end
+
+      def run spec
+        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,status=run_scenario("_setup_",@setup.scenario,@context)
+          steps+=executed_steps
+        end
+        if status!=:error
+          message(:test=>spec.name,:text=>'running')
+          executed_steps,status=run_scenario(spec.name,spec.scenario,@context)
+          steps+=executed_steps
+        else
+          message(:test=>spec.name,'number'=>0,'status'=>:error,'out'=>"Setup failed",'err'=>"",'duration'=>0)
+        end
+        state['status']=status
+        if @teardown
+          message(:test=>spec.name,:text=>'teardown')
+          executed_steps,status=run_scenario("_teardown_",@teardown.scenario,@context)
+        end
+        message(:test=>spec.name,:text=>'finished')
+        state["stop_time"]=Time.now
+        state['steps']=steps
+        @number_of_runs+=1
+        return state
+      end
+
+      private
+      def run_scenario name,scenario,meta
+        executed_steps=[]
+        status=:warning
+        begin 
+          stps=scenario.steps
+          if stps.empty?
+            error(name,"Scenario #{name} contains no steps")
+            status=:error
+          else
+            stps.each do |s|
+              executed_steps<<run_step(s,meta)
+              message(:test=>name,:text=>s.to_s,'number'=>s.number,'status'=>s.status,'out'=>s.output,'err'=>s.error,'duration'=>s.exec_time)
+              status=s.status
+              break if :error==s.status
+            end
+          end
+        rescue  
+          error(name,$!.message)
+          status=:error
+        end
+        return executed_steps,status
+      end
+      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
+        end
+        step.status=:success if step.ignore?
+        return step
+      end
+    end
+
+    class NoOp<Default
+      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
+        end
+        step.status=:success if step.ignore?
+        return step
+      end
+    end
+  end
 end

data/lib/rutema/elements/minimal.rb

@@ -1,48 +1,48 @@
-#  Copyright (c) 2007-2015 Vassilis Rizopoulos. All rights reserved.
-require 'highline'
-module Rutema
-  #The Elements module provides the namespace for the various modules adding parser functionality
-  module Elements
-    #Minimal offers a minimal(chic) set of elements for use in specifications
-    #
-    #These are:
-    # echo
-    # command
-    # prompt
-    module Minimal
-      #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}
-        return step
-      end
-      #prompt asks the user a yes/no question. Answering yes means the step is succesful.
-      # <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
-        return step
-      end
-      #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  
-      end
-    end
-  end
+#  Copyright (c) 2007-2015 Vassilis Rizopoulos. All rights reserved.
+require 'highline'
+module Rutema
+  #The Elements module provides the namespace for the various modules adding parser functionality
+  module Elements
+    #Minimal offers a minimal(chic) set of elements for use in specifications
+    #
+    #These are:
+    # echo
+    # command
+    # prompt
+    module Minimal
+      #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}
+        return step
+      end
+      #prompt asks the user a yes/no question. Answering yes means the step is succesful.
+      # <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
+        return step
+      end
+      #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  
+      end
+    end
+  end
 end