resat 0.7.0

data/lib/log.rb

@@ -0,0 +1,114 @@
+# Log info, warnings and errors
+# See resat.rb for usage information.
+#
+
+require 'logger'
+
+# Add ability to output colored text to console
+# e.g.: puts "Hello".red
+class String
+  def bold; colorize("\e[1m\e[29m"); end
+  def grey; colorize("\e[30m"); end
+  def red; colorize("\e[1m\e[31m"); end
+  def dark_red; colorize("\e[31m"); end
+  def green; colorize("\e[1m\e[32m"); end
+  def dark_green; colorize("\e[32m"); end
+  def yellow; colorize("\e[1m\e[33m"); end
+  def blue; colorize("\e[1m\e[34m"); end
+  def dark_blue; colorize("\e[34m"); end
+  def pur; colorize("\e[1m\e[35m"); end
+  def colorize(color_code)  
+    # Doesn't work with the Windows prompt...
+    RUBY_PLATFORM =~ /(win|w)32$/ ? to_s : "#{color_code}#{to_s}\e[0m" 
+  end
+end
+
+module Resat
+
+  class LogFormatter
+    
+    def call(severity, time, progname, msg)
+      msg.gsub!("\n", "\n   ")
+      res = ""
+      res << "*** " if severity == Logger::ERROR || severity == Logger::FATAL
+      res << "#{severity} [#{time.strftime('%H:%M:%S')}]: #{msg.to_s}\n"
+      res
+    end
+  end
+
+  class Log
+
+    LEVELS = %w{ debug info warn error fatal }
+    
+    # Initialize singleton instance
+    def Log.init(options)
+      File.delete(options.logfile) rescue nil
+      if options.dry_run
+        options.logfile = STDOUT
+      else
+        options.logfile = 'resat.log' unless File.directory?(File.dirname(options.logfile))
+      end
+      @logger = Logger.new(options.logfile)
+      @logger.formatter = LogFormatter.new
+      @level = LEVELS.index(options.loglevel.downcase) if options.loglevel
+      @level = Logger::WARN unless @level # default to warning
+      @logger.level = @level
+      @verbose = options.verbose
+      @quiet = options.quiet
+    end 
+    
+    def Log.debug(debug)
+      @logger.debug { debug } if @logger
+      puts "\n#{debug}".grey if @level == Logger::DEBUG
+    end
+
+    def Log.info(info)
+      puts "\n#{info}".dark_green if @verbose
+      @logger.info { info } if @logger
+    end
+    
+    def Log.warn(warning)
+      puts "\nWarning: #{warning}".yellow unless @quiet
+      @logger.warn { warning } if @logger
+    end
+    
+    def Log.error(error)
+      puts "\nError: #{error}".dark_red
+      @logger.error { error } if @logger
+    end
+
+    def Log.fatal(fatal)
+      puts "\nCrash: #{fatal}".red
+      @logger.fatal { fatal } if @logger
+    end
+    
+    def Log.request(request)
+      msg = "REQUEST #{request.method} #{request.path}"
+      if request.size > 0
+        msg << "\nheaders:"
+        request.each_header do |name, value|
+          msg << "\n   #{name}: #{value}"
+        end
+      end
+      msg << "\nbody: #{request.body}" unless request.body.nil?
+      Log.info(msg)
+    end
+
+    def Log.response(response, succeeded = true)
+      msg = "RESPONSE #{response.code} #{response.message}"
+      if response.size > 0
+        msg << "\nheaders:"
+        response.each_header do |name, value|
+          msg << "\n   #{name}: #{value}"
+        end
+      end
+      msg << "\nbody: #{response.body}" unless response.body.nil?
+      if succeeded
+        Log.info(msg)
+      else
+        Log.warn(msg)
+      end
+    end
+
+  end    
+end

data/lib/net_patch.rb

@@ -0,0 +1,15 @@
+# Patch Net::HTTP so that SSL requests don't output:
+# warning: peer certificate won't be verified in this SSL session
+# See resat.rb for usage information.
+#
+
+require 'net/http'
+require 'net/https'
+
+module Net
+  class HTTP
+    def warn(*obj)
+    end
+  end
+end
+

data/lib/rdoc_patch.rb

@@ -0,0 +1,37 @@
+# Patch RDoc so that RDoc::usage works even when the application is started via
+# a proxy such as a bash script instead of being run directly.
+# See resat.rb for usage information.
+#
+
+require 'rdoc/usage'
+
+module RDoc
+  # Force the use of comments in this file so RDoc::usage works even when
+  # invoked from a proxy (e.g. 'resat' bash script)
+  def usage_no_exit(*args)
+    main_program_file = caller[-1].sub(/:\d+$/, '')
+    usage_from_file(main_program_file)
+  end
+
+  # Display usage from the given file
+  def RDoc.usage_from_file(input_file, *args)
+    comment = File.open(input_file) do |file|
+      find_comment(file)
+    end
+    comment = comment.gsub(/^\s*#/, '')
+    markup = SM::SimpleMarkup.new
+    flow_convertor = SM::ToFlow.new
+    flow = markup.convert(comment, flow_convertor)
+    format = "plain"
+    unless args.empty?
+      flow = extract_sections(flow, args)
+    end
+    options = RI::Options.instance
+    if args = ENV["RI"]
+      options.parse(args.split)
+    end
+    formatter = options.formatter.new(options, "")
+    formatter.display_flow(flow)
+  end
+end
+

data/lib/resat.rb

@@ -0,0 +1,5 @@
+# This file is here so Resat can be used as a Rails plugin.
+# Use the 'resat.rb' in the root folder to run resat from the command line.
+#
+
+require File.join(File.dirname(__FILE__), 'engine')

data/lib/scenario_runner.rb

@@ -0,0 +1,203 @@
+# Resat test scenario, sequence of api calls and filters.
+# See resat.rb for usage information.
+#
+
+require 'kwalify/util/hashlike'
+require File.join(File.dirname(__FILE__), 'kwalify_helper')
+require File.join(File.dirname(__FILE__), 'config')
+require File.join(File.dirname(__FILE__), 'variables')
+require File.join(File.dirname(__FILE__), 'api_request')
+require File.join(File.dirname(__FILE__), 'guard')
+require File.join(File.dirname(__FILE__), 'filter')
+require File.join(File.dirname(__FILE__), 'handler')
+
+module Resat
+
+  class ScenarioRunner
+
+    attr_accessor :requests_count, :parser_errors, :failures
+
+    # Instantiate new scenario runner with given YAML definition document and
+    # schemas directory.
+    # If parsing the scenario YAML definition fails then 'valid?' returns false
+    # and 'parser_errors' contains the error messages.
+    def initialize(doc, schemasdir, config, variables, failonerror, dry_run)
+      @schemasdir     = schemasdir
+      @valid          = true
+      @ignored        = false
+      @name           = ''
+      @failures       = Array.new
+      @requests_count = 0
+      @failonerror    = failonerror
+      @dry_run        = dry_run
+      parse(doc)
+      if @valid
+        Config.init(config || @cfg_file, schemasdir)
+        @valid = Config.valid?
+        if @valid
+          Variables.reset
+          Variables.load(Config.input, schemasdir) if Config.input && File.readable?(Config.input)
+          Config.variables.each { |v| Variables[v['name']] = v['value'] } if Config.variables
+          variables.each { |k, v| Variables[k] = v } if variables
+        end
+      end
+    end
+    
+    def ignored?;   @ignored;         end
+    def valid?;     @valid;           end # parser_errors contains the details
+    def succeeded?; @failures.empty?; end
+
+    # Run the scenario.
+    # Once scenario has run check 'succeeded?'.
+    # If 'succeeded?' returns false, use 'failures' to retrieve error messages.
+    def run
+      return if @ignored || !@valid
+      Log.info("-" * 80 + "\nRunning scenario #{@name}")
+      unless Variables.empty?
+        info_msg = Variables.all.inject("Using variables:") do |msg, (k, v)|
+          msg << "\n   - #{k}: #{v}"
+        end
+        Log.info(info_msg)
+      end
+      @steps.each_index do |index|
+        @current_step = index
+        @current_file = @steps[index][:origin]
+        step = @steps[index][:step]
+        case step
+        when ApiRequest
+          @requests_count += @request.send_count if @request # Last request
+          @request = step
+          @request.prepare
+          @request.send unless @dry_run
+        when Guard
+          step.prepare
+          step.wait(@request) unless @dry_run
+        when Filter, Handler
+          step.prepare
+          step.run(@request) unless @dry_run 
+        end
+        puts step.inspect if step.failures.nil?
+        step.failures.each { |f| add_failure(f) }
+        break if @failonerror && !succeeded? # Abort on failure
+      end
+
+      @requests_count += @request.send_count
+      Variables.save(Config.output) if Config.output
+    end
+
+    protected
+
+    # Parse YAML definition file and set 'valid?' and 'parser_errors' 
+    # accordingly
+    def parse(doc)
+      parser = KwalifyHelper.new_parser(File.join(@schemasdir, 'scenarios.yaml'))
+      scenario = parser.parse_file(doc)
+      if parser.errors.empty?
+        @ignored = !scenario || scenario.ignore
+        @cfg_file = File.expand_path(File.join(File.dirname(doc), scenario.config)) if scenario.config
+        unless @ignored
+          @name = scenario.name
+          @steps = Array.new
+          scenario.includes.each do |inc|
+            process_include(inc, File.dirname(doc))
+          end if scenario.includes
+          scenario.steps.each do |step|
+            @steps << { :step => step.request, :origin => doc }
+            if step.filters
+              @steps.concat(step.filters.map { |f| { :step => f, :origin => doc } })
+            end
+            if step.handlers
+              @steps.concat(step.handlers.map { |h| { :step => h, :origin => doc } })
+            end
+            if step.guards
+              @steps.concat(step.guards.map { |g| { :step => g, :origin => doc } })
+            end
+          end if scenario.steps
+        end
+      else
+        @valid = false
+        @parser_errors = KwalifyHelper.parser_error(parser)
+      end
+    end
+    
+    def process_include(inc, dir)
+       if File.directory?(File.join(dir, inc))
+        includes = FileSet.new(File.join(dir, inc), %{.yml .yaml})
+      else
+        path = find_include(inc, dir)
+        if path
+          includes = [path]
+        else
+          Log.warn("Cannot find include file or directory '#{inc}'")
+          includes = []
+        end
+      end
+      includes.each { |i| include_steps(i) }
+    end
+
+    def include_steps(path)
+      parser = KwalifyHelper.new_parser(File.join(@schemasdir, 'scenarios.yaml'))
+      scenario = parser.parse_file(path)
+      if parser.errors.empty?
+        scenario.includes.each do |inc|
+           process_include(inc, File.dirname(path))
+        end if scenario.includes
+        scenario.steps.each do |step|
+          @steps << { :step => step.request, :origin => path }
+          if step.filters
+            @steps.concat(step.filters.map { |f| { :step => f, :origin => path } })
+          end
+          if step.handlers
+            @steps.concat(step.handlers.map { |h| { :step => h, :origin => path } })
+          end
+          if step.guards
+            @steps.concat(step.guards.map { |g| { :step => g, :origin => path } })
+          end
+        end
+      else
+        Log.error("Cannot include file '#{path}': #{parser.errors.join(", ")}")
+      end
+    end
+    
+    # Path to include file if it's found, nil otherwise
+    def find_include(inc, dir)
+      # File extension is optional in YAML definition
+      # We'll use the one in the current folder if we can't find it in the same
+      # folder as the including file
+      path = test if File.file?(test = File.join(dir, inc + '.yml'))
+      path = test if File.file?(test = File.join(dir, inc + '.yaml'))
+      path = test if File.file?(test = File.join(dir, inc))
+      return path if path
+      subs = Dir.entries(dir).select { |f| File.directory?(f) }
+      subs = subs - FileSet::IGNORED_FOLDERS
+      subs.detect { |sub| find_include(inc, File.join(dir, sub)) }
+    end
+
+
+    # Append error message to list of failures
+    def add_failure(failure)
+      @failures << "Step ##{@current_step} from '#{@current_file}': #{failure}"
+    end
+    
+  end
+
+  # Classes automatically hydrated with Kwalify from YAML definition
+ 
+  class Scenario
+    include Kwalify::Util::HashLike # defines [], []= and keys?
+    attr_accessor :name, :config, :includes, :steps
+    def ignore; @ignore || false; end
+  end
+  
+  class Step
+    include Kwalify::Util::HashLike
+    attr_accessor :request, :filters, :handlers, :guards
+  end
+  
+  class CustomOperation
+    include Kwalify::Util::HashLike
+    attr_accessor :name, :type
+    def separator; @separator || "/"; end
+  end
+
+end

data/lib/variables.rb

@@ -0,0 +1,116 @@
+# Resat scenario variables
+# Manages variables and provides substitution.
+# See resat.rb for usage information.
+#
+
+require 'singleton'
+
+module Resat
+
+  class Variables
+    include Singleton
+
+    attr_reader :vars, :marked_for_save, :exported
+
+    # Replace occurrences of environment variables in +raw+ with their value
+    def Variables.substitute!(raw)
+      instance().substitute!(raw)
+    end
+    def substitute!(raw)
+      if raw.kind_of?(String)
+        scans = Array.new
+        raw.scan(/[^\$]*\$(\w+)+/) { |scan| scans << scan }
+        scans.each do |scan|
+          scan.each do |var|
+            raw.gsub!('$' + var, @vars[var]) if @vars.include?(var)
+          end
+        end
+      elsif raw.kind_of?(Array)
+        raw.each { |i| substitute!(i) }
+      elsif raw.kind_of?(Hash)
+        raw.each { |k, v| substitute!(v) }
+      end
+    end
+    
+    def Variables.[](key)
+      instance().vars[key]
+    end
+
+    def Variables.[]=(key, value)
+      instance().vars[key] = value
+    end
+
+    def Variables.include?(key)
+      instance().vars.include?(key)
+    end
+    
+    def Variables.empty?
+      instance().vars.empty?
+    end
+    
+    def Variables.all
+      instance().vars.sort
+    end
+
+    def Variables.load(file, schemasdir)
+      schemafile = File.join(schemasdir, 'variables.yaml')
+      schema = Kwalify::Yaml.load_file(schemafile)
+      validator = Kwalify::Validator.new(schema)
+      parser = Kwalify::Yaml::Parser.new(validator)
+      serialized_vars = parser.parse_file(file)
+      parser.errors.push(Kwalify::ValidationError.new("No variables defined")) unless serialized_vars
+      if parser.errors.empty?
+        vars = instance().vars
+        serialized_vars.each { |v| vars[v['name']] = v['value'] }
+      else
+        Log.warn("Error loading variables from '#{file}': #{KwalifyHelper.parser_error(parser)}")
+      end
+    end
+    
+    def Variables.save(file)
+      serialized_vars = []
+      i = instance()
+      i.vars.each do |k, v|
+        if i.marked_for_save.include?(k)
+          serialized_vars << { 'name' => k, 'value' => v }
+        end
+      end
+      File.open(file, 'w') do |out|
+        YAML.dump(serialized_vars, out)
+      end
+    end
+    
+    def Variables.mark_for_save(key)
+      instance().mark_for_save(key)
+    end
+    def mark_for_save(key)
+      @marked_for_save << key
+    end      
+    
+    # Exported values will be kept even after a call to reset
+    def Variables.export(key)
+      instance().export(key)
+    end
+    def export(key)
+      @exported[key] = @vars[key]
+    end      
+    
+    def Variables.reset
+      instance().reset
+    end
+    def reset
+      @vars = @exported.clone
+      @marked_for_save = Array.new
+    end
+
+    protected
+
+    def initialize
+      @exported = Hash.new
+      reset
+      super
+    end
+
+  end
+
+end