rutema 1.3.0 → 2.0.0.pre

data/lib/rutema/models/activerecord.rb

@@ -1,159 +0,0 @@
-#  Copyright (c) 2007-2010 Vassilis Rizopoulos. All rights reserved.
-$:.unshift File.join(File.dirname(__FILE__),'..','..')
-require 'rutema/models/base'
-require 'active_record'
-
-#this fixes the AR Logger hack that annoys me sooooo much
-class Logger
-  private
-  def format_message(severity, datetime, progname, msg)
-    (@formatter || @default_formatter).call(severity, datetime, progname, msg)
-  end
-end
-module Rutema
-  module ActiveRecord
-    #This is the schema for the AR database used to store test results
-    #
-    #We store the RutemaConfiguration#context for every run so that reports for past runs can be recreated without running the actual tests again.
-    class Schema< ::ActiveRecord::Migration
-      def self.up
-        create_table :runs do |t|
-          t.column :context, :string
-        end
-
-        create_table :scenarios do |t|
-          t.column :name, :string, :null=>false
-          t.column :run_id,:integer, :null=>false
-          t.column :attended,:bool, :null=>false
-          t.column :status, :string,:null=>false
-          t.column :number,:integer
-          t.column :start_time, :datetime,:null=>false
-          t.column :stop_time, :datetime
-          t.column :version, :string
-          t.column :title, :string
-          t.column :description, :string
-        end
-
-        create_table :steps do |t|
-          t.column :scenario_id,:integer, :null=>false
-          t.column :name, :string
-          t.column :number, :integer,:null=>false
-          t.column :status, :string,:null=>false
-          t.column :output, :text
-          t.column :error, :text
-          t.column :duration, :decimal
-        end
-
-        create_table :parse_errors do |t|
-          t.column :filename, :string,:null=>false
-          t.column :error, :string
-          t.column :run_id,:integer, :null=>false
-        end
-      end
-    end
-    class Run< ::ActiveRecord::Base
-      has_many :scenarios
-      has_many :parse_errors
-      serialize :context    
-    end
-    class Scenario< ::ActiveRecord::Base
-      belongs_to :run
-      has_many :steps
-    end
-    class Step< ::ActiveRecord::Base
-      belongs_to :scenario
-    end
-    class ParseError< ::ActiveRecord::Base
-      belongs_to :run
-    end
-    #Exports the contents of the database/model as a yaml dump
-    class Export
-      def initialize params
-        @logger = params[:logger]
-        @logger ||= Patir.setup_logger
-        @result_set_size = params[:result_set_size]
-        @result_set_size ||= 1000
-        @currently_on_no=0
-        database_configuration = params[:db]
-        raise "No database configuration defined, missing :db configuration key." unless database_configuration
-        ActiveRecord.connect(database_configuration,@logger)
-      end
-      def next
-        @logger.info("Found #{Run.count} runs") if @currently_on_no==0
-        @logger.info("Exporting from #{@currently_on_no} to #{@currently_on_no+@result_set_size}")
-        export(@result_set_size)
-      end
-      def all
-        @logger.info("Found #{Run.count} runs")
-        export(nil)
-      end
-      private 
-      def export offset=nil
-        if offset
-          runs=Run.find(:all,:order=>"id ASC",:limit=>@result_set_size,:offset=>@currently_on_no)
-          @currently_on_no+=offset
-        else
-          runs=Run.find(:all)
-        end
-        return nil if runs.empty?
-        export=[]
-        runs.each do |run|
-          e={:parse_errors=>[],:scenarios=>[],:context=>run.context}
-          run.parse_errors.each { |pe| e[:parse_errors]<<{:filename=>pe.filename, :error=>pe.error} }
-          run.scenarios.each { |sc| e[:scenarios]<<export_scenario(sc)  }
-          export<<e
-          @logger.debug("Exported #{run.id}")
-        end
-        return export
-      end
-      def export_scenario sc
-        scenario={:name=>sc[:name],
-          :attended=>sc[:attended],
-          :status=>sc[:status],
-          :number=>sc[:number],
-          :start_time=>sc[:start_time], 
-          :stop_time=>sc[:stop_time],
-          :version=>sc[:version],
-          :title=>sc[:title], 
-          :description=>sc[:description],
-          :steps=>[]
-        }
-        sc.steps.each do |step|
-          st={:name=>step[:name],
-            :number=>step[:number], 
-            :status=>step[:status], 
-            :output=>step[:output], 
-            :error=>step[:error],
-            :duration=>step[:duration]
-          }
-          scenario[:steps]<<st
-        end
-        return scenario
-      end
-    end  
-    #Establishes an ActiveRecord connection
-    def self.connect cfg,logger
-      conn=cnct(cfg,logger)
-      Schema.migrate(:up) if perform_migration?(cfg)
-    end
-    private
-    #Establishes an active record connection using the cfg hash
-    #There is only a rudimentary check to ensure the integrity of cfg
-    def self.cnct cfg,logger
-      if cfg[:adapter] && cfg[:database]
-        logger.debug("Connecting to #{cfg[:database]}")
-        return ::ActiveRecord::Base.establish_connection(cfg)
-      else
-        raise Rutema::ConnectionError,"Erroneous database configuration. Missing :adapter and/or :database"
-      end
-    end
-    def self.perform_migration? cfg
-      return true if cfg[:migrate]
-      #special case for sqlite3
-      if cfg[:adapter]=="sqlite3" && !File.exists?(cfg[:database])
-        return true
-      end
-      return false
-    end
-  end
-end

data/lib/rutema/models/base.rb

@@ -1,5 +0,0 @@
-module Rutema
-  #Exception occuring when connecting to a database
-  class ConnectionError<RuntimeError
-  end
-end

data/lib/rutema/parsers/base.rb

@@ -1,45 +0,0 @@
-#  Copyright (c) 2007-2011 Vassilis Rizopoulos. All rights reserved.
-$:.unshift File.join(File.dirname(__FILE__),'..','..')
-
-module Rutema
-  #Is raised when an error is found in a specification
-  class ParserError<RuntimeError
-  end
-  #Base class that bombs out when used.
-  #
-  #By default the internal logger will log to the console if no logger is provided.
-  class SpecificationParser
-    attr_reader :configuration
-    #Expects a hash with at least {:configuration, :logger}
-    #
-    #At the end validate_configuration is called
-    def initialize params
-      @configuration=params[:configuration]
-      @logger=params[:logger]
-      unless @logger
-        @logger=Patir.setup_logger
-        @configuration||={}
-        @configuration[:logger]=@logger
-      end
-      @logger.warn("No system configuration provided to the parser") unless @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

data/lib/rutema/rake.rb

@@ -1,62 +0,0 @@
-require 'rutema/system'
-require 'optparse'
-require 'rake'
-
-module Rutema
-  #Integrates rutema with rake.
-  #
-  #You can pass a hash with the parameters or use the block syntax:
-  # RakeTask.new do |rt|
-  #   rt.config_file="config.rutema"
-  #   rt.dependencies=[]
-  #   rt.add_dependency("some_other_task")
-  #   rt.name="name"
-  #   rt.log_file="."
-  # end
-  class RakeTask
-    attr_accessor :config_file, :log_file, :name
-    attr_reader :rake_task
-    #Params is a parameter hash.
-    #
-    #Valid parameters are:
-    #
-    #:config_file => path to the configuration file
-    #
-    #:log_file => path to the file where the log is saved. If missing then the logger prints in stdout
-    #
-    #:name => the name for the rutema task. If missing then the task is named rutema, otherwise it will be rutema:name
-    #
-    #:dependencies => an array of dependencies for the task
-    def initialize params=nil
-      params||={}
-      @config_file=params[:config_file]
-      @log_file=params[:log]
-      @name=params[:name]
-      @dependencies=params[:dependencies]
-      @dependencies||=[]
-      yield self if block_given?
-      @dependencies||=[]
-      raise "No rutema configuration given, :config_file is nil" unless @config_file
-      args=['-c',@config_file]
-      args+=['-l',@log_file] if @log_file
-      args<<"all"
-      OptionParser::Arguable.extend_object(args)
-      if @name
-        desc "Executes the tests in #{File.basename(@config_file)}" 
-        @rake_task=task :"rutema:#{@name}" => @dependencies do
-          Rutema::RutemaX.new(args)
-        end
-      else
-        desc "Executes the tests in #{File.basename(@config_file)}" 
-        @rake_task=task :rutema => @dependencies do
-          Rutema::RutemaX.new(args)
-        end
-      end
-    end
-    #Adds a dependency to the rutema task created
-    def add_dependency dependency
-      @dependencies<<dependency
-      task @rake_task => [dependency] if @rake_task
-    end
-  end
-end

data/lib/rutema/reporters/activerecord.rb

@@ -1,82 +0,0 @@
-#  Copyright (c) 2007-2010 Vassilis Rizopoulos. All rights reserved.
-require 'rutema/models/activerecord'
-
-module Rutema
-  #The ActiveRecordReporter will store the results of a test run in a database using ActiveRecord.
-  class ActiveRecordReporter
-    #The required keys in this reporter's configuration are:
-    # :db - the database configuration. A Hash with the DB adapter information
-    #  :db=>{:database=>"sample.rb"}
-    def initialize definition
-      @logger=definition[:logger]
-      @logger||=Patir.setup_logger
-      database_configuration = definition[:db]
-      raise "No database configuration defined, missing :db configuration key." unless database_configuration
-      $:.unshift File.join(File.dirname(__FILE__),"..","..")
-      require 'rutema/models/activerecord'
-      Rutema::ActiveRecord.connect(database_configuration,@logger)
-      @logger.info("Reporter #{self.to_s} registered")
-    end
-    #We get all the data for a Rutema::ActiveRecord::Run entry in here.
-    #
-    #If the configuration is given and there is a context defined, this will be YAML-dumped into Rutema::ActiveRecord::Run#context
-    def report specifications,runner_states,parse_errors,configuration
-      run_entry=Rutema::ActiveRecord::Run.new
-      if configuration && configuration.context
-        run_entry.context=configuration.context
-      end
-      parse_errors.each do |pe|
-        er=Rutema::ActiveRecord::ParseError.new()
-        er.filename=pe[:filename]
-        er.error=pe[:error]
-        run_entry.parse_errors<<er
-      end
-      runner_states.compact!
-      runner_states.each do |scenario|
-        sc=Rutema::ActiveRecord::Scenario.new
-        sc.name=scenario.sequence_name
-        sc.number=scenario.sequence_id
-        sc.start_time=scenario.start_time
-        sc.stop_time=scenario.stop_time
-        sc.status=scenario.status.to_s
-        #get the specification for this scenario
-        spec=specifications[scenario.sequence_name]
-        if spec
-          sc.version=spec.version if spec.has_version?
-          sc.title=spec.title
-          sc.description=spec.description
-        else
-          @logger.debug("Could not find specification for #{scenario.sequence_name}")
-          sc.title=scenario.sequence_name
-          sc.description=""
-        end
-        if scenario.strategy==:attended
-          sc.attended=true
-        else
-          sc.attended=false
-        end
-        scenario.step_states.each do |number,step|
-          st=Rutema::ActiveRecord::Step.new
-          st.name=step[:name]
-          st.number=number
-          st.status="#{step[:status]}"
-          st.output=sanitize(step[:output])
-          st.error=sanitize(step[:error])
-          st.duration=step[:duration]
-          sc.steps<<st
-        end
-        run_entry.scenarios<<sc
-      end
-      run_entry.save!
-      "activerecord reporter done"
-    end
-    def to_s#:nodoc:
-      "ActiveRecordReporter"
-    end
-    private
-    def sanitize text
-      return text.gsub("\000","") if text
-      return ""
-    end
-  end
-end

data/lib/rutema/reporters/base.rb

@@ -1,23 +0,0 @@
-#  Copyright (c) 2007-2010 Vassilis Rizopoulos. All rights reserved.
-$:.unshift File.join(File.dirname(__FILE__),"..")
-module Rutema
-  #Reporter is meant as a base class for reporter classes. Which means that it is here for ducumentation purposes.
-  #
-  #In order to create act as a Reporter for Rutema a class only need to implement the #report method
-  class Reporter
-    #params should be a Hash containing the parameters used to initialize the class
-    def initialize params
-    end
-
-    #Coordinator will pass the Rutema __configuration__ giving you access to the context which can contain data like 
-    #headings and build numbers to use in the report. 
-    #
-    #It will also pass the specifications used in the last run so that data like the title and the specification version can be used.
-    #
-    #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
-    end
-  end
-end

data/lib/rutema/reporters/email.rb

@@ -1,84 +0,0 @@
-#  Copyright (c) 2007-2010 Vassilis Rizopoulos. All rights reserved.
-$:.unshift File.join(File.dirname(__FILE__),"..","..")
-require 'net/smtp'
-require 'mailfactory'
-require 'rutema/reporters/text'
-
-module Rutema
-  #The following configuration keys are used by EmailReporter:
-  #
-  #:server - the smtp server to use
-  #
-  #:port - the port to use (defaults to 25)
-  #
-  #:domain - the domain the mail is coming from
-  #
-  #:sender - the sender of the email (defaults to rutema@domain)
-  #
-  #:recipients - an array of strings with the recipients of the report emails
-  #
-  #The :logger key is set by the Coordinator
-  #
-  #Customization keys:
-  #
-  #:subject - the string of this key will be prefixed as a subject for the email
-  #
-  #:verbose - when true, the report contains info on setup and teardown specs. Optional. Default is false
-  class EmailReporter
-    attr_reader :last_message
-    def initialize definition
-      #get the logger
-      @logger=definition[:logger]
-      @logger||=Patir.setup_logger
-      #extract the parameters from the definition
-      #address and port of the smtp server
-      @server=definition[:server]
-      @port=definition[:port]
-      @port||=25
-      #the domain we're coming from
-      @domain=definition[:domain]
-      #construct the mail factory object
-      @mail = MailFactory.new()
-      @mail.from = definition[:sender]
-      @mail.from||="rutema@#{@domain}"
-      @recipients=definition[:recipients]
-      #customize
-      @subject=definition[:subject]
-      @subject||=""
-      @footer=definition[:footer]
-      @footer||=""
-      @verbose=definition[:verbose]
-      @verbose||=false
-      @logger.info("Reporter '#{self.to_s}' registered")
-    end
-    def to_s#:nodoc:
-      list=@recipients.join(', ')
-      "EmailReporter - #{@server}:#{@port} from #{@mail.from} to #{list}"
-    end
-    
-    def report specifications,runner_states,parse_errors,configuration
-      @mail.subject = "#{@subject}"
-      txt=TextReporter.new(:verbose=>@verbose).report(specifications,runner_states,parse_errors,configuration)
-      txt<<"\n\n#{@footer}"
-      @mail.text = txt 
-      begin
-        if @recipients.empty?
-          @logger.error("No recipients for the report mail")
-        else
-          #
-          #~ if @password
-          #~ #if a password is defined, use cram_md5 authentication
-          #~ else
-          @logger.info("Emailing through #{@server}:#{@port}(#{@domain})")
-          Net::SMTP.start(@server, @port, @domain) {|smtp| smtp.send_message(@mail.to_s(),@mail.from,@recipients)}
-          #~ end
-        end#recipients empty
-      rescue
-        @logger.debug($!)
-        @logger.error("Sending of email report failed: #{$!}")
-        @logger.debug("Tried to sent to #{@recipients}")
-      end
-      @mail.to_s
-    end
-  end
-end