resat 0.7.0

data/lib/config.rb

@@ -0,0 +1,94 @@
+# Configuration information read from given configuration file 
+# ('config/resat.yaml' by default).
+#
+# Configuration example:
+#
+# # Hostname used for API calls
+# host:     my.rightscale.com
+# 
+# # Common base URL to all API calls
+# base_url: '/api/acct/71/'
+# 
+# # Use HTTPS?
+# use_ssl:  yes
+# 
+# # Basic auth username if any
+# username: raphael@rightscale.com
+# 
+# # Basic auth password if any
+# password: Secret
+# 
+# # Common request headers for all API calls
+# headers:
+#   - name:  X-API-VERSION
+#     value: '1.0'
+#     
+# # Common parameters for all API calls
+# params:
+#
+# See resat.rb for usage information.
+#
+
+module Resat
+
+  class Config
+   
+    DEFAULT_FILE = 'config/resat.yaml'
+    
+    DEFAULT_SCHEMA_DIR = File.expand_path(File.join(File.dirname(__FILE__), '..', 'schemas'))
+
+    DEFAULTS = {
+      'base_url' => '',
+      'use_ssl' => false,
+      'variables' => {}
+    }
+
+    def Config.init(filename, schemasdir)
+      (Config.methods - (Object.methods + [ 'init', 'valid?', 'method_missing' ])).each { |m| class << Config;self;end.send :remove_method, m.to_sym }
+      schemafile = File.join(schemasdir || DEFAULT_SCHEMA_DIR, 'config.yaml')
+      unless File.exists?(schemafile)
+        Log.error("Missing configuration file schema '#{schemafile}'")
+        @valid = false
+        return
+      end
+      schema    = Kwalify::Yaml.load_file(schemafile)
+      validator = Kwalify::Validator.new(schema)
+      parser    = Kwalify::Yaml::Parser.new(validator)
+      @valid    = true
+      @config   = { 'use_ssl' => false, 'username' => nil, 'password' => nil, 'port' => nil }
+      cfg_file  = filename || DEFAULT_FILE
+      config    = parser.parse_file(cfg_file)
+      if parser.errors.empty?
+        if config.nil?
+          Log.error("Configuration file '#{cfg_file}' is empty.")
+          @valid = false
+        else
+          @config.merge!(config)
+          # Dynamically define the methods to forward to the config hash
+          @config.each_key do |meth|
+            (class << self; self; end).class_eval do
+              define_method meth do |*args|
+                @config[meth] || DEFAULTS[meth]
+              end
+            end
+          end
+        end
+      else
+        errors = parser.errors.inject("") do |msg, e|
+          msg << "#{e.linenum}:#{e.column} [#{e.path}] #{e.message}\n\n"
+        end
+        Log.error("Configuration file '#{cfg_file}' is invalid:\n#{errors}")
+        @valid = false
+      end
+    end
+
+    def Config.valid?
+      @valid
+    end
+    
+    def self.method_missing(*args)
+      nil
+    end
+
+  end
+end

data/lib/engine.rb

@@ -0,0 +1,98 @@
+# Resat test engine, reads test files and run them.
+# See resat.rb for usage information.
+#
+
+ENG_DIR = File.dirname(__FILE__)
+require File.join(ENG_DIR, 'file_set')
+require File.join(ENG_DIR, 'log')
+require File.join(ENG_DIR, 'scenario_runner')
+
+module Resat
+
+  class Engine
+
+    attr_accessor :run_count      # Total number of run scenarios
+    attr_accessor :requests_count # Total number of HTTP requests
+    attr_accessor :ignored_count  # Total number of ignored scenarios
+    attr_accessor :skipped_count  # Total number of skipped YAML files
+    attr_accessor :failures       # Hash of error messages (string arrays)
+                                  # indexed by scenario filename
+
+    def initialize(options)
+      @options        = options
+      @failures       = Hash.new
+      @run_count      = 0
+      @ignored_count  = 0
+      @requests_count = 0
+      @skipped_count  = 0
+    end
+    
+    # Was test run successful?
+    def succeeded?
+      @failures.size == 0
+    end
+
+    # Run all scenarios and set attributes accordingly
+    def run(target=nil)
+      target ||= @options.target
+      begin
+        if File.directory?(target)
+          files = FileSet.new(target, %w{.yml .yaml})
+        elsif File.file?(target)
+          files = [target]
+        else
+          @failures[target] << "Invalid taget #{target}: Not a directory, nor a file"
+          return
+        end
+        @failures[target] ||= []
+        schemasdir = @options.schemasdir || Config::DEFAULT_SCHEMA_DIR
+        files.each do |file|
+          runner = ScenarioRunner.new(file, schemasdir, @options.config, 
+                     @options.variables, @options.failonerror, @options.dry_run)
+          @ignored_count += 1 if runner.ignored?
+          @skipped_count += 1 unless runner.valid?
+          if runner.valid? && !runner.ignored?
+            runner.run
+            @run_count += 1
+            @requests_count += runner.requests_count
+            @failures[file] = runner.failures unless runner.failures.empty?
+          else
+            unless runner.valid?
+              Log.info "Skipping '#{file}' (#{runner.parser_errors})"
+            end
+            Log.info "Ignoring '#{file}'" if runner.ignored?
+          end
+        end 
+      rescue Exception => e
+        Log.error(e.message)
+        backtrace = "   " + e.backtrace.inject("") { |msg, s| msg << "#{s}\n" }
+        Log.debug(backtrace)
+      end
+    end
+
+    def summary
+      if succeeded?
+        case run_count
+          when 0 then res = "\nNo scenario to run."
+          when 1 then res = "\nOne scenario SUCCEEDED"
+          else res = "\n#{run_count} scenarios SUCCEEDED"
+        end
+      else
+        i = 1
+        res = "\nErrors summary:\n"
+        failures.each do |file, errors|
+          res << "\n#{i.to_s}) Scenario '#{file}' failed with: "
+          errors.each do |error|
+            res << "\n     "
+            res << error
+          end
+          i = i + 1
+        end
+        res << "\n\n#{i - 1} of #{run_count} scenario#{'s' if run_count > 1} FAILED"
+      end
+      res
+    end
+          
+  end
+end
+

data/lib/file_set.rb

@@ -0,0 +1,33 @@
+# Set of files with given extension in given directory
+# See resat.rb for usage information.
+#
+
+module Resat
+  class FileSet < Array
+
+    # Folders that won't be scanned for files
+    IGNORED_FOLDERS = %w{ . .. .svn .git }
+
+    # Initialize with all file names found in 'dir' and its sub-directories
+    # with given file extensions
+    def initialize(dir, extensions)
+      super(0)
+      concat(FileSet.gather_files(dir, extensions))
+    end
+    
+    def self.gather_files(dir, extensions)
+      files = Array.new
+      Dir.foreach(dir) do |filename|
+        if File.directory?(filename)
+          unless IGNORED_FOLDERS.include?(filename)
+            files.concat(FileSet.gather_files(filename, extensions))
+          end
+        elsif extensions.include?(File.extname(filename))
+          files << File.join(dir, filename)
+        end
+      end
+      files
+    end
+    
+  end
+end

data/lib/filter.rb

@@ -0,0 +1,113 @@
+# Resat response filter
+# Use response filters to validate responses and/or store response elements in 
+# variables.
+# Automatically hydrated with Kwalify from YAML definition.
+# See resat.rb for usage information.
+#
+
+module Resat
+
+  class Filter
+    include Kwalify::Util::HashLike
+    attr_accessor :failures
+    
+    def prepare
+      @is_empty ||= false
+      @failures = []
+      Log.info("Running filter '#{@name}'")
+    end
+
+    # Run filter on given response
+    def run(request)
+      @request = request
+      @response = request.response
+      validate
+      extract
+    end
+    
+    # Validate response
+    def validate
+      unless @response
+        @failures << "No response to validate."
+        return
+      end
+      
+      # 1. Check emptyness
+      if @target == 'header'
+        if @is_empty != (@response.size == 0)
+          @failures << "Response header #{'not ' if @is_empty}empty."
+        end
+      else
+        if @is_empty != (@response.body.nil? || @response.body.size <= 1)
+          @failures << "Response body #{'not ' if @is_empty}empty."
+        end
+      end
+      
+      # 2. Check required fields
+      @required_fields.each do |field|
+        unless @request.has_response_field?(field, target)
+          @failures << "Missing #{target} field '#{field}'."
+        end
+      end if @required_fields
+      
+      # 3. Evaluate validators
+      @validators.each do |v|
+        if @request.has_response_field?(v.field, @target)
+          field = @request.get_response_field(v.field, @target)
+          if v.pattern
+            Variables.substitute!(v.pattern)
+            unless Regexp.new(v.pattern).match(field)
+              @failures << "Validator /#{v.pattern} failed on '#{field}' from #{@target} field '#{v.field}'."
+            end
+          end
+          unless !!v.is_empty == field.empty?
+            @failures << "#{@target.capitalize} field '#{v.field}' #{'not ' if v.is_empty}empty."
+          end
+        else
+          @failures << "Missing #{@target} field '#{v.field}'."
+        end
+      end if @validators
+    end
+    
+    # Extract elements from response
+    def extract
+      @extractors.each do |ex|
+        Variables.substitute!(ex.field)
+        if @request.has_response_field?(ex.field, @target)
+          field = @request.get_response_field(ex.field, @target)
+          if ex.pattern
+            Variables.substitute!(ex.pattern)
+            Regexp.new(ex.pattern).match(field)
+            if Regexp.last_match
+              Variables[ex.variable] = Regexp.last_match(1)
+            else
+              Log.warn("Extraction from response #{@target} field '#{ex.field}' ('#{field}') with pattern '#{ex.pattern}' failed.")
+            end
+          else
+            Variables[ex.variable] = field
+          end
+          Variables.mark_for_save(ex.variable) if ex.save
+          Variables.export(ex.variable) if ex.export
+        else
+          Log.warn("Extraction from response #{@target} field '#{ex.field}' failed: field not found.")
+        end
+      end if @extractors
+    end
+
+  end
+
+  # Classes for instances hydrated by Kwalify
+
+  class Validator
+    include Kwalify::Util::HashLike
+    attr_accessor :field, :is_empty, :pattern
+  end
+  
+  class Extractor
+    include Kwalify::Util::HashLike
+    attr_accessor :field, :pattern, :variable
+    def save; @save || false; end
+    def export; @export || false; end
+  end
+ 
+end

data/lib/guard.rb

@@ -0,0 +1,36 @@
+# Resat response filter
+# Use response filters to validate responses and/or store response elements in
+# variables.
+# Automatically hydrated with Kwalify from YAML definition.
+# See resat.rb for usage information.
+#
+
+module Resat
+
+  class Guard
+    include Kwalify::Util::HashLike
+    attr_accessor :failures
+
+    def prepare
+      @timeout ||= 120
+      @period ||= 5
+      @failures = []
+      Variables.substitute!(@pattern)
+      Log.info("Waiting for guard #{@name} with pattern /#{@pattern.to_s}/")
+    end
+    
+    def wait(request)
+      r = Regexp.new(@pattern)
+      r.match(request.get_response_field(@field, @target))
+      expiration = DateTime.now + @timeout
+      while !Regexp.last_match && DateTime.now < expiration && request.failures.empty?
+        sleep @period
+        request.send
+        r.match(request.get_response_field(@field, @target))
+      end
+      @failures << "Guard '#{@name}' timed out waiting for field '#{@field}' with pattern '#{@pattern ? @pattern : '<NONE>'}' from response #{@target}." if !Regexp.last_match
+    end
+  end
+
+end
+ 

data/lib/handler.rb

@@ -0,0 +1,50 @@
+# Resat response handler
+# Allows defining a handler that gets the request and response objects for custom processing 
+# Handler should be a module and expose the following methods:
+#   - :process takes two argumnents: first argument is an instance of Net::HTTPRequest while
+#     second argument is an instance of Net::HTTPResponse.
+#     :process should initialize the value returned by :failures (see below)
+#   - :failures which returns an array of error messages when processing
+#     the response results in errors or an empty array when the processing
+#     is successful.
+
+module Resat
+
+  class Handler
+    include Kwalify::Util::HashLike
+    attr_accessor :failures
+
+    def prepare
+      @failures = []
+      Log.info("Running handler '#{@name}'")      
+    end
+    
+    def run(request)
+      klass = module_class(@module)
+      h = klass.new
+      h.process(request.request, request.response)
+      @failures += h.failures.values.to_a if h.failures
+    end
+    
+    protected
+    
+    # Create and cache instance of Class which includes
+    # given module.
+    def module_class(mod)
+      @@modules ||= {}
+      unless klass = @@modules[mod]
+        klass = Class.new(Object) { include Handler.get_module(mod) }
+        @@modules[mod] = klass
+      end
+      klass
+    end
+
+    def self.get_module(name)
+      parts = name.split('::')
+      index = 0
+      res   = Kernel
+      index += 1 while (index < parts.size) && (res = res.const_get(parts[index]))
+      res
+    end
+  end
+end

data/lib/kwalify_helper.rb

@@ -0,0 +1,31 @@
+# Helper methods that wrap common Kwalify use case
+#
+
+require 'kwalify'
+
+module Resat
+  
+  class KwalifyHelper
+    
+    # Create new parser from given schema file
+    def KwalifyHelper.new_parser(schema_file)
+      schema = Kwalify::Yaml.load_file(schema_file)
+      validator = Kwalify::Validator.new(schema)
+      res = Kwalify::Yaml::Parser.new(validator)
+      res.data_binding = true
+      res
+    end
+
+    # Format error message from parser errors
+    def KwalifyHelper.parser_error(parser)
+      first = true
+      parser.errors.inject("") do |msg, e|
+        msg << "\n" unless first
+        first = false if first
+        msg << "#{e.linenum}:#{e.column} [#{e.path}] #{e.message}"
+      end
+    end
+
+  end
+
+end