rutema 1.3.0 → 2.0.0.pre

data/lib/rutema/reporters/text.rb

@@ -1,77 +0,0 @@
-#  Copyright (c) 2007-2010 Vassilis Rizopoulos. All rights reserved.
-
-module Rutema
-  #This reporter creates a simple text summary of a test run
-  #
-  #The following configuration keys are used by TextReporter:
-  #
-  #:verbose - when true, the report contains info on setup and teardown specs. Optional. Default is false
-  class TextReporter
-    def initialize params=nil
-      @verbose=params[:verbose] if params
-      @verbose||=false 
-    end
-    #Returns the text summary
-    #
-    #runner_states is an Array of Patir::CommandSequenceStatus containing the stati of the last run (so it contains all the Scenario stati for the loaded tests)
-    #
-    #parse_errors is an Array of {:filename,:error} hashes containing the errors encountered by the parser when loading the specifications
-    def report specifications,runner_states,parse_errors,configuration
-      return text_report(specifications,runner_states,parse_errors)
-    end
-    private
-    def text_report specifications,runner_states,parse_errors
-      msg=""
-      #Report on parse errors
-      msg<<"No parse errors" if parse_errors.empty?
-      msg<<"One parse error:" if parse_errors.size==1
-      msg<<"#{parse_errors.size} parse errors:" if parse_errors.size>1
-      parse_errors.each do |er|
-        msg<<"\n\tin #{er[:filename]} : #{er[:error]}"
-      end
-      msg<<"\n---"
-      #Report on scenarios
-      runner_states.compact!#make sure no nil elements make it through
-      msg<<"\nNo scenarios in this run" if runner_states.empty?
-      if @verbose
-        states=runner_states
-      else
-        states=runner_states.select{|state| state.sequence_name !~ /[_setup|_teardown]$/}
-      end
-      msg<<"\nOne scenario in the current run" if states.size==1
-      msg<<"\n#{states.size} scenarios in the current run" if states.size>1
-      
-      not_run = states.select{|state| state.status == :not_executed }.sort_by {|state| state.sequence_id.to_i}
-      errors = states.select{|state| state.status == :error }.sort_by {|state| state.sequence_id.to_i}
-      warnings = states.select{|state| state.status == :warning }.sort_by {|state| state.sequence_id.to_i}
-      successes = states.select{|state| state.status == :success }.sort_by {|state| state.sequence_id.to_i}
-      msg<<"\n#{errors.size} errors, #{warnings.size} warnings, #{successes.size} successes, #{not_run.size} not executed (setup failure)"
-      msg<<"\nErrors:" unless errors.empty?
-      msg<<scenario_summaries(errors,specifications)
-      msg<<"\nWarnings:" unless warnings.empty?
-      msg<<scenario_summaries(warnings,specifications)
-      msg<<"\nNot executed:" unless not_run.empty?
-      not_run.each do |state|
-        if specifications[state.sequence_name]
-          msg<<"\n#{specifications[state.sequence_name].title}"
-        else
-           msg<<"\n#{state.sequence_name}"
-        end
-      end
-      msg<<"\nSuccesses:" unless successes.empty?
-      msg<<scenario_summaries(successes,specifications)
-      return msg
-    end
-    
-    def scenario_summaries scenarios,specifications
-      msg=""
-      unless scenarios.empty?
-        scenarios.each do |state|
-          msg<<"\n#{specifications[state.sequence_name].title}" if specifications[state.sequence_name]
-          msg<<"\n#{state.summary}\n---"
-        end
-      end
-      return msg
-    end
-  end
-end

data/lib/rutema/runners/default.rb

@@ -1,157 +0,0 @@
-#  Copyright (c) 2007-2011 Vassilis Rizopoulos. All rights reserved.
-$:.unshift File.join(File.dirname(__FILE__),'..','..')
-
-module Rutema
-  #Runner executes TestScenario instances and maintains the state of all scenarios run.
-  class Runner
-    attr_reader :states,:number_of_runs,:context
-    attr_accessor :setup,:teardown
-    attr_writer :attended
-
-    #setup and teardown are TestScenario instances that will run before and after each call
-    #to the scenario.
-    def initialize context=nil,setup=nil, teardown=nil,logger=nil
-      @setup=setup
-      @teardown=teardown
-      @attended=false
-      @logger=logger
-      @logger||=Patir.setup_logger
-      @states=Hash.new
-      @number_of_runs=0
-      @context=context || Hash.new
-    end
-    
-    #Tells you if the system runs in the mode that expects user input
-    def attended?
-      return @attended
-    end
-    #Runs a scenario and stores the result internally
-    #
-    #Returns the result of the run as a Patir::CommandSequenceStatus
-    def run name,scenario, run_setup=true
-      @logger.debug("Starting run for #{name} with #{scenario.inspect}")
-      @context[:scenario_name]=name
-      #if setup /teardown is defined we need to execute them before and after
-      if @setup && run_setup
-        @logger.info("Setup for #{name}")
-        @states["#{name}_setup"]=run_scenario("#{name}_setup",@setup)
-        @states["#{name}_setup"].sequence_id="s#{@number_of_runs}"
-        if @states["#{name}_setup"].executed? 
-          #do not execute the scenario unless the setup was succesful
-          if @states["#{name}_setup"].success?
-            @logger.info("Scenario for #{name}")
-            @states[name]=run_scenario(name,scenario)
-            @states[name].sequence_id="#{@number_of_runs}"
-          else
-            @states[name]=initialize_state(name,scenario)
-            @states[name].sequence_id="#{@number_of_runs}"
-          end
-        end
-      else
-        @logger.info("Scenario for #{name}")
-        @states[name]=run_scenario(name,scenario)
-        @states[name].sequence_id="#{@number_of_runs}"
-      end
-      #no setup means no teardown
-      if @teardown && run_setup
-        #always execute teardown
-        @logger.warn("Teardown for #{name}")
-        @states["#{name}_teardown"]=run_scenario("#{name}_teardown",@teardown)
-        @states["#{name}_teardown"].sequence_id="#{@number_of_runs}t"
-      end
-      @number_of_runs+=1
-      @context[:scenario_name]=nil
-      return @states[name]
-    end
-    
-    #Returns the state of the scenario with the given name.
-    #
-    #Will return nil if no scenario is found under that name.
-    def [](name)
-      return @states[name]
-    end
-    
-    #Resets the Runner's internal state
-    def reset
-      @states.clear
-      @number_of_runs=0
-    end
-
-    #returns true if all the scenarios in the last run were succesful or if nothing was run yet
-    def success?
-      @success=true
-      @states.each  do |k,v|
-        @success&=(v.status!=:error)
-      end
-      return @success
-    end
-    private
-    def run_scenario name,scenario
-      state=initialize_state(name,scenario)
-      begin 
-        if evaluate_attention(scenario,state)
-          stps=scenario.steps
-          if stps.empty?
-            @logger.warn("Scenario #{name} contains no steps")
-            state.status=:warning
-          else
-            stps.each do |s| 
-              state.step=run_step(s)
-              break if :error==state.status
-            end
-          end
-        end
-      rescue  
-        @logger.error("Encountered error in #{name}: #{$!.message}")
-        @logger.debug($!)
-        state.status=:error
-      end
-      state.stop_time=Time.now
-      state.sequence_id=@number_of_runs
-      return state
-    end
-    def initialize_state name,scenario
-      state=Patir::CommandSequenceStatus.new(name,scenario.steps)
-    end
-    def evaluate_attention scenario,state
-      if scenario.attended?
-        if !self.attended?
-          @logger.warn("Attended scenario cannot be run in unattended mode")
-          state.status=:warning
-          return false
-        end
-        state.strategy=:attended
-      else
-        state.strategy=:unattended
-      end
-      return true
-    end
-    def run_step step
-      @logger.info("Running step #{step.number} - #{step.name}")
-      if step.has_cmd? && step.cmd.respond_to?(:run)
-        step.cmd.run(@context)
-        msg=step.to_s
-        if !step.cmd.success?
-          msg<<"\n#{step.cmd.output}" unless step.cmd.output.empty?
-          msg<<"\n#{step.cmd.error}" unless step.cmd.error.empty?
-        end
-      else
-        @logger.warn("No command associated with step '#{step.step_type}'. Step number is #{step.number}")
-      end
-      step.status=:success if step.status==:error && step.ignore?
-      log_step_result(step,msg)
-      return step
-    end
-    def log_step_result step,msg
-      if step.status==:error
-        if step.ignore?
-          @logger.warn("Step failed but result is being ignored!\n#{msg}")
-        else
-          @logger.error(msg) 
-        end
-      else
-        @logger.info(msg) if msg && !msg.empty?
-      end
-    end
-  end
-end

data/lib/rutema/runners/step.rb

@@ -1,23 +0,0 @@
-#  Copyright (c) 2007-2011 Vassilis Rizopoulos. All rights reserved.
-$:.unshift File.join(File.dirname(__FILE__),'..','..')
-
-require 'rutema/runners/default'
-
-module Rutema
-  #StepRunner halts before every step and asks if it should be executed or not.
-  class StepRunner<Runner
-    def initialize setup=nil, teardown=nil,logger=nil
-      @questioner=HighLine.new
-      super(setup,teardown,logger)
-    end
-    def run_step step
-      if @questioner.agree("Execute #{step.to_s}?")
-        return super(step)
-      else
-        msg="#{step.number} - #{step.step_type} - #{step.status}"
-        @logger.info(msg)
-        return step
-      end
-    end
-  end
-end

data/lib/rutema/system.rb

@@ -1,302 +0,0 @@
-#  Copyright (c) 2007-2012 Vassilis Rizopoulos. All rights reserved.
-$:.unshift File.join(File.dirname(__FILE__),"..")
-require 'patir/command'
-require 'patir/base'
-require 'rutema/configuration'
-
-require 'rutema/parsers/base'
-         
-require 'rutema/runners/default'
-require 'rutema/runners/step'
-
-require 'rutema/reporters/text'
-
-module Rutema
-  #This module defines the version numbers for the library
-  module Version
-    MAJOR=1
-    MINOR=3
-    TINY=0
-    STRING=[ MAJOR, MINOR, TINY ].join( "." )
-  end
-  #This class coordinates parsing, execution and reporting of test specifications
-  class Coordinator
-    attr_accessor :configuration,:parse_errors,:parsed_files
-    attr_reader :test_states
-    def initialize configuration,logger=nil
-      @logger=logger
-      @logger||=Patir.setup_logger
-      @parse_errors=Array.new
-      @configuration=configuration
-      @parser=instantiate_class(@configuration.parser)
-      raise "Could not instantiate parser" unless @parser
-      @reporters=@configuration.reporters.collect{ |reporter| instantiate_class(reporter) }
-      @reporters.compact!
-      #this will hold any specifications that are succesfully parsed.
-      @specifications=Hash.new
-      @parsed_files=Array.new
-      @test_states=Hash.new
-    end
-    #Runs a set of tests
-    #
-    #mode can be :all, :attended, :unattended or a test filename
-    def run mode
-      @runner||=create_runner
-      @configuration.context[:start_time]=Time.now
-      @logger.info("Run started in mode '#{mode}'")
-      begin
-        case mode
-        when :all
-          @runner.attended=true
-          specs=parse_all_specifications
-          run_scenarios(specs)
-        when :attended
-          @runner.attended=true
-          specs=parse_all_specifications
-          run_scenarios(specs.select{|s| s.scenario && s.scenario.attended?})
-        when :unattended
-          specs=parse_all_specifications
-          run_scenarios(specs.select{|s| s.scenario && !s.scenario.attended?})
-        when String
-          @runner.attended=true
-          spec=parse_specification(mode)
-          run_test(spec) if spec
-        else
-          @logger.fatal("Don't know how to run '#{mode}'")
-          raise "Don't know how to run '#{mode}'"
-        end
-      rescue
-        @logger.debug($!)
-        @logger.fatal("Runner error: #{$!.message}")
-        raise 
-      end
-      @configuration.context[:end_time]=Time.now
-      @logger.info("Run completed in #{@configuration.context[:end_time]-@configuration.context[:start_time]}s")
-    end
-    
-    #Parses all specification files defined in the configuration
-    def parse_all_specifications
-      @configuration.tests.collect do |t| 
-        begin
-          spec=parse_specification(t)
-        rescue
-          @logger.debug($!)
-          @logger.error($!.message)
-        end
-      end.compact
-    end
-    #Delegates reporting to all configured reporters spawning one thread per reporter
-    #
-    #It then joins the threads and returns when all of them are finished.
-    def report
-      #get the states from the runner
-      @runner.states.each do |k,v|
-        if v
-          @test_states[k]=v
-        else
-          @logger.warn("State for #{k} is nil")
-        end
-      end
-      threads=Array.new
-      #get the runner stati and the configuration and give it to the reporters
-      @reporters.each do |reporter|
-        threads<<Thread.new(reporter,@specifications,@test_states.values,@parse_errors,@configuration) do |reporter,specs,status,perrors,configuration|
-          begin
-            @logger.debug(reporter.report(specs,status,perrors,configuration))
-          rescue RuntimeError
-            @logger.error("Error in #{reporter.class}: #{$!.message}")
-            @logger.debug($!)
-          end
-        end
-      end
-      threads.each do |t| 
-        @logger.debug("Joining #{t}")
-        t.join
-      end
-    end
-
-    #returns true if all scenarios in the last run were succesful
-    def last_run_a_success?
-      return @runner.success?
-    end
-    def to_s#:nodoc:
-      "Parsed #{@parsed_files.size} files\n#{TextReporter.new.report(@specifications,@runner.states.values,@parse_errors,@configuration)}"
-    end
-    private
-    def instantiate_class definition
-      if definition[:class]
-        #add the logger to the definition
-        definition[:logger]=@logger
-        #add the configuration to the definition
-        definition[:configuration]=@configuration
-        klass=definition[:class]
-        return klass.new(definition)
-      end
-      return nil
-    end
-
-    def create_runner
-      setup=nil
-      teardown=nil
-      if @configuration.setup
-        @logger.info("Parsing setup specification from '#{@configuration.setup}'")
-        setup=@parser.parse_setup(@configuration.setup).scenario
-      end
-      if @configuration.teardown
-        @logger.info("Parsing teardown specification from '#{@configuration.teardown}'")
-        teardown=@parser.parse_teardown(@configuration.teardown).scenario
-      end
-      if @configuration.use_step_by_step
-        @logger.info("Using StepRunner")
-        return StepRunner.new(@configuration.context,setup,teardown,@logger)
-      else
-        return Runner.new(@configuration.context,setup,teardown,@logger)
-      end
-    end
-
-    def parse_specification spec_identifier
-      spec=nil
-      begin
-        @parsed_files<<spec_identifier
-        @parsed_files.uniq!
-        spec=@parser.parse_specification(spec_identifier)
-        if @specifications[spec.name]
-          msg="Duplicate specification name '#{spec.name}' in '#{spec_identifier}'"
-          @logger.error(msg)
-          @parse_errors<<{:filename=>spec_identifier,:error=>msg}
-          @test_states[spec.name]=Patir::CommandSequenceStatus.new(spec.name,[])
-        else
-          @specifications[spec.name]=spec
-          @test_states[spec.name]=Patir::CommandSequenceStatus.new(spec.name,spec.scenario.steps)
-        end
-      rescue ParserError
-        @logger.error("Error parsing '#{spec_identifier}': #{$!.message}")
-        @parse_errors<<{:filename=>spec_identifier,:error=>$!.message}
-      end
-      return spec
-    end
-
-    def run_scenarios specs
-      specs.compact!
-      if specs.empty?
-        @logger.error("No tests to run")
-      else
-        if @configuration.check
-          @logger.info("Parsing check test '#{@configuration.check}'")
-          spec=parse_specification(@configuration.check)
-          if spec
-            @logger.info("Running check test '#{spec.to_s}'")
-            if run_test(spec,false).success?
-              specs.each{|s| run_test(s)}
-            else
-              @logger.error("Check test failed")
-            end
-          else
-            @logger.error("Error parsing check test")
-          end
-        else
-          specs.each{|s| run_test(s)}
-        end
-      end
-    end
-    
-    def run_test specification,run_setup=true
-      @logger.info("Running #{specification.name} -  #{specification.title}")
-      if specification.scenario
-        status=@runner.run(specification.name,specification.scenario,run_setup)
-      else
-        @logger.warn("#{specification.name} has no scenario")
-        status=:not_executed
-      end
-      @test_states[specification.name]=status
-      return status
-    end
-  end
-  #The "executioner" application class
-  #
-  #Parses the commandline, sets up the configuration and launches Cordinator
-  class RutemaX
-    require  'optparse'
-    def initialize command_line_args
-      parse_command_line(command_line_args)
-      @logger=Patir.setup_logger(@log_file)
-      @logger.info("rutema v#{Version::STRING}")
-      begin
-        raise "No configuration file defined!" if !@config_file
-        @configuration=RutemaConfigurator.new(@config_file,@logger).configuration
-        @configuration.context[:config_file]=File.basename(@config_file)
-        @configuration.use_step_by_step=@step
-        Dir.chdir(File.dirname(@config_file)) do 
-          @coordinator=Coordinator.new(@configuration,@logger)
-          application_flow
-        end 
-      rescue Patir::ConfigurationException
-        @logger.debug($!)
-        @logger.fatal("Configuration error '#{$!.message}'")
-        raise "Configuration error '#{$!.message}'"
-      rescue
-        @logger.debug($!)
-        @logger.fatal("#{$!.message}")
-        raise
-      end
-    end
-    private
-    def parse_command_line args
-      args.options do |opt|
-        opt.on("Options:")
-        opt.on("--debug", "-d","Turns on debug messages") { $DEBUG=true }
-        opt.on("--config FILE", "-c FILE",String,"Loads the configuration from FILE") { |config_file| @config_file=config_file}
-        opt.on("--log FILE", "-l FILE",String,"Redirects the log output to FILE") { |log_file| @log_file=logfile}
-        opt.on("--check","Runs just the check test"){@check=true}
-        opt.on("--step","Runs test cases step by step"){@step=true}
-        opt.on("-v", "--version","Displays the version") { $stdout.puts("rutema v#{Version::STRING}");exit 0 }
-        opt.on("--help", "-h", "-?", "This text") { $stdout.puts opt; exit 0 }
-        opt.on("The commands are:")
-        opt.on("\tall - Runs all tests")
-        opt.on("\tattended - Runs all attended tests")
-        opt.on("\tunattended - Runs all unattended tests")
-        opt.on("You can also provide a specification filename in order to run a single test")
-        opt.parse!
-        #and now the rest
-        if args.empty?
-          @mode=:unattended
-        else
-          command=args.shift
-          case command
-          when "attended"
-            @mode=:attended
-          when "all"
-            @mode=:all
-          when "unattended"
-            @mode=:unattended
-          else
-            @mode=command
-          end
-        end
-      end
-    end
-
-    def application_flow
-      if @check
-        #run just the check test
-        if @configuration.check
-          @coordinator.run(@configuration.check)
-        else
-          @logger.fatal("There is no check test defined in the configuration.")
-          raise "There is no check test defined in the configuration."
-        end
-      else
-        #run everything
-        @coordinator.run(@mode)
-      end
-      @logger.info("Report:\n#{@coordinator.to_s}")
-      @coordinator.report
-      if @coordinator.parse_errors.empty? && @coordinator.last_run_a_success?
-        @logger.info("All tests successful")
-      else
-        @logger.warn("Not all tests were successful")
-        raise "Not all tests were successful"
-      end
-    end
-  end
-end