rutema 1.3.0 → 2.0.0.pre

data/lib/rutema/core/framework.rb

@@ -0,0 +1,28 @@
+module Rutema
+  module Messaging
+    def error identifier,message
+      message(:test=>identifier,:error=>message)
+    end
+    def message message
+      msg=message
+      if message.is_a?(String)
+        msg={:message=>message,:timestamp=>Time.now}
+      elsif message.is_a?(Hash)
+        msg[:timestamp]=Time.now
+      end
+      @queue.push(msg)
+    end
+  end
+  #Generic error class for errors in the engine
+  class RutemaError<RuntimeError
+  end
+  #Is raised when an error is found in a specification
+  class ParserError<RutemaError
+  end
+  #Is raised on an unexpected error during execution
+  class RunnerError<RutemaError
+  end
+  #Errors in reporters should use this class
+  class ReportError<RutemaError
+  end
+end

data/lib/rutema/{objectmodel.rb → core/objectmodel.rb}

@@ -1,5 +1,4 @@
-#  Copyright (c) 2007-2010 Vassilis Rizopoulos. All rights reserved.
-$:.unshift File.join(File.dirname(__FILE__),"..")
+#  Copyright (c) 2007-2015 Vassilis Rizopoulos. All rights reserved.
 require 'patir/command'
 
 module Rutema
@@ -7,9 +6,10 @@ module Rutema
   #arbitrarily add attributes to a class and then have 
   #the accessor methods for these attributes appear automagically.
   #
-  #It will also add a has_attribute? method to query if an attribute is part of the object or not.
+  #It will also add a has_attribute? method to query if _attribute_ is part of the object or not.
   module SpecificationElement
-    #adds an attribute to the class with the given __value__. __symbol__ can be a Symbol or a String, the rest are silently ignored
+    #adds an attribute to the class with the given __value__. __symbol__ can be a Symbol or a String, 
+    #the rest are silently ignored
     def attribute symbol,value
       @attributes||=Hash.new
       case symbol
@@ -35,12 +35,24 @@ module Rutema
         super(symbol,*args)
       end
     end
+
+    def respond_to? symbol,include_all
+      @attributes||=Hash.new
+      key=symbol.id2name.chomp('?').chomp('=').sub(/^has_/,"")
+      if @attributes.has_key?(:"#{key}")
+          return true
+      else
+        super(symbol,include_all)
+      end
+    end
   end
-  #A TestSpecification encompasses all elements required to run a test, the builds used, the scenario to run,
+  #A Rutema::Specification encompasses all elements required to run a test, the builds used, the scenario to run,
   #together with a textual description and information that aids in tracing the test back to the requirements.
-  class TestSpecification
+  class Specification
     include SpecificationElement
-    attr_accessor :scenario,:requirements
+    attr_accessor :scenario
+    #Expects a Hash of parameters
+    #
     #Following keys have meaning in initialization:
     #
     #:name - the name of the testcase. Should uniquely identify the testcase
@@ -51,15 +63,12 @@ module Rutema
     #
     #:description - a full textual description for the testcase. To be used in reports and documents
     #
-    #:scenario - An instance of TestScenario
-    #
-    #:requirements - An Array of String. The idea is that the strings can lead you back to the requirements specification that is tested here.
+    #:scenario - An instance of Rutema::Scenario
     #
     #:version - The version of this specification
     #
     #Default values are empty strings and arrays. (scenario is nil)
-    def initialize *args
-      params=args[0] if args
+    def initialize params
       begin
         @attributes=params
       end if params
@@ -68,59 +77,44 @@ module Rutema
       @attributes[:title]||=""
       @attributes[:filename]||=""
       @attributes[:description]||=""
-      @scenario=TestScenario.new(@attributes[:version])
-      @requirements||=Array.new
+      @scenario=@attributes[:scenario]
     end
     def to_s#:nodoc: 
       return "#{@attributes[:name]} - #{@attributes[:title]}"
     end
   end
-  #A TestScenario is a sequence of TestStep instances.
+  #A Rutema::Scenario is a sequence of Rutema::Step instances.
   #
-  #TestStep instances are run in the definition sequence and the scenario
+  #Rutema::Step instances are run in the definition sequence and the scenario
   #is succesfull when all steps are succesfull. 
   #
   #From the execution point of view each step is either succesfull or failed and it depends on 
   #the exit code of the step's command. 
   #
   #Failure in a step results in the interruption of execution and the report of the errors.
-  class TestScenario
+  class Scenario
     include SpecificationElement
     attr_reader :steps
     
-    def initialize version=nil
+    def initialize steps
       @attributes=Hash.new
-      #attended is off by default
-      @attributes[:attended]=false
-      @version=version
-      @steps=Array.new
+      @steps=steps
+      @steps||=Array.new
     end
-    
-    def attended?
-      ret=@attributes[:attended]
-      @steps.each do |step|
-        ret=true if step.attended?
-      end
-      return ret
-    end
-    
+    #Adds a step at the end of the step sequence
     def add_step step
       @steps<<step
-      @attended=true if step.attended?
     end
-    
+    #Overwrites the step sequence
     def steps= array_of_steps
       @steps=array_of_steps
-      @steps.each do |step|
-        @attributes[:attended]=true if step.attended?
-      end
     end
   end
-  #Represents a step in a TestScenario.
+  #Represents a step in a Scenario.
   #
-  #Each TestStep can have text and a command associated with it. 
+  #Each Rutema::Step can have text and a command associated with it. 
   #
-  #TestStep standard attributes are.
+  #Step standard attributes are.
   #
   #attended - the step can only run in attended mode, it requires user input.
   #
@@ -136,20 +130,20 @@ module Rutema
   #
   #==Dynamic behaviour
   #
-  #A TestStep can be queried dynamicaly about the attributes it posesses:
+  #A Rutema::Step can be queried dynamicaly about the attributes it posesses:
   # step.has_script? - will return true if script is step's attribute.
   #Attribute's are mostly assigned by the parser, i.e. the Rutema::BaseXMLParser from the XML element
   # <test script="some_script"/>
-  #will create a TestStep instance with step_type=="test" and script="some_script". In this case
+  #will create a Step instance with step_type=="test" and script="some_script". In this case
   #
   # step.has_script? returns true
   # step.script returns "some_script"
   #
-  #Just like an OpenStruct, TestStep attributes will be created by direct assignment:
+  #Just like an OpenStruct, Step attributes will be created by direct assignment:
   # step.script="some_script" creates the script attribute if it does not exist.
   #
   #See Rutema::SpecificationElement for the implementation details. 
-  class TestStep
+  class Step
     include SpecificationElement
     include Patir::Command
     
@@ -158,8 +152,6 @@ module Rutema
       @attributes=Hash.new
       #ignore is off by default
       @attributes[:ignore]=false
-      #attended is off by default
-      @attributes[:attended]=false
       #assign
       @attributes[:cmd]=cmd if cmd
       @attributes[:text]=txt
@@ -206,9 +198,12 @@ module Rutema
     end
     def to_s#:nodoc:
       param=""
-      param=" - #{self.cmd.to_s}" if self.has_cmd?
-      msg="#{self.number} - #{self.step_type}#{param} - #{self.status}"
-      msg<<" in #{self.included_in}" if self.has_included_in?
+      if self.has_cmd?
+        msg="#{self.number} - #{self.cmd.to_s}"
+      else
+        msg="#{self.number} - #{self.name}"
+      end
+        msg<<" in #{self.included_in}" if self.has_included_in?
       return msg
     end
   end

data/lib/rutema/core/parser.rb

@@ -0,0 +1,35 @@
+#  Copyright (c) 2007-2015 Vassilis Rizopoulos. All rights reserved.
+require_relative 'framework'
+
+module Rutema
+  module Parsers  
+    #Base class that bombs out when used.
+    #
+    #Derive your parser class from this class and implement parse_specification and validate_configuration
+    class SpecificationParser
+      attr_reader :configuration
+      def initialize configuration
+        @configuration=configuration
+        @configuration||={}
+        validate_configuration
+      end
+      #parses a specification
+      def parse_specification param
+        raise ParserError,"not implemented. You should derive a parser implementation from SpecificationParser!"
+      end
+      #parses the setup script. By default calls parse_specification
+      def parse_setup param
+        parse_specification(param)
+      end
+      #parses the teardown script. By default calls parse_specification
+      def parse_teardown param
+        parse_specification(param)
+      end
+      #The parser stores it's configuration in @configuration
+      #
+      #To avoid validating the configuration in element_* methods repeatedly, do all configuration validation here
+      def validate_configuration
+      end
+    end
+  end
+end

data/lib/rutema/core/reporter.rb

@@ -0,0 +1,105 @@
+#  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']
+          @states[data[:test]]||=[]
+          @states[data[:test]]<<data
+        end
+      end
+    end
+
+    class Console<EventReporter
+      def initialize configuration,dispatcher
+        super(configuration,dispatcher)
+        @silent=configuration.reporters.fetch(self.class,{})["silent"]
+      end
+      def update data
+        if data[:error]
+          puts ">ERROR: #{data[:error]}"
+        elsif data[:test] 
+          if data["phase"]
+            puts ">#{data["phase"]} #{data[:test]}" unless @silent
+          elsif data[:message]
+            puts ">#{data[:test]} #{data[:message]}" unless @silent
+          elsif data["status"]==:error
+            puts ">FATAL: #{data[:test]}(#{data["number"]}) failed"
+            puts data.fetch("out","")
+            puts data.fetch("error","")
+          end
+        elsif data[:message] 
+          puts ">#{data[:message]}" unless @silent
+        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=0
+        states.each do |k,v|
+          failures+=1 if v.last['status']==:error
+        end
+        puts "#{errors.size} errors. #{states.size} test cases executed. #{failures} failed" unless @silent
+        return failures
+      end
+    end
+  end
+end

data/lib/rutema/core/runner.rb

@@ -0,0 +1,83 @@
+#  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
+        state={'start_time'=>Time.now, "sequence_id"=>@number_of_runs,:test=>spec.name}
+        steps=[]
+        status=:success
+        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}")
+        end
+        step.status=:success if step.status==:error && step.ignore?
+        return step
+      end
+    end
+  end
+end

data/lib/rutema/elements/minimal.rb

@@ -1,45 +1,48 @@
-#  Copyright (c) 2007-2011 Vassilis Rizopoulos. All rights reserved.
-$:.unshift File.join(File.dirname(__FILE__),'..','..')
-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}
-      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
-      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))      
-      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