restest 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", ">= 1.0.0"
+  gem "jeweler", "~> 1.8.4"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Peter Salas
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,19 @@
+= restest
+
+Description goes here.
+
+== Contributing to restest
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2012 Peter Salas. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "restest"
+  gem.homepage = "http://github.com/gradeawarrior/restest"
+  gem.license = "MIT"
+  gem.summary = "RESTful API Testing Framework"
+  gem.description = "A Ruby framework for testing RESTful API's"
+  gem.email = "psalas@proofpoint.com"
+  gem.authors = ["Jyri Virki", "Peter Salas"]
+  gem.executables << 'restest'
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "restest #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/restest

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require 'restest'

data/lib/MySQLReport.rb

@@ -0,0 +1,16 @@
+
+class MySQLReport
+
+  def initialize(file)
+
+  end
+
+  def log(status, duration, service, api, name, message)
+
+  end
+
+  def done(tests_ok, tests_fail)
+
+  end
+
+end

data/lib/Result.rb

@@ -0,0 +1,93 @@
+
+#
+# The Result class wraps a HTTP Response object and provides some test framework-specific additional result
+# tracking.
+#
+# The ServiceAPI#do_request* methods returns this Result object for each test.
+#
+class Result
+
+  attr_reader :response
+  attr_reader :is_ok
+  attr_reader :message
+  attr_accessor :allow_retry # if false, do not retry test even if test file requests retries
+  attr_accessor :abort_suite_run # if true, framework will end test suite run immediately
+
+  #-------------------------------------------------------------------------------------------------------------------
+  # Constructor.
+  #
+  def initialize(response)
+    @response = response
+    @is_ok = true
+    @allow_retry = true
+    @message = ""
+  end
+
+  #-------------------------------------------------------------------------------------------------------------------
+  # Fatal error factory. A service module should return a fatal_error when it encounters a problem which cannot
+  # change by re-trying the same test again. The most common case is if a required parameter is missing.
+  #
+  def self.fatal_error(message)
+    res = Result.new(nil)
+    res.error(message)
+    res.allow_retry = false
+    return res
+  end
+
+  #-------------------------------------------------------------------------------------------------------------------
+  # Constructs a Result object which tells the framework to abort the current test suite.
+  #
+  # A service module should generally never return this. Avoid it! Even if a particular misconfiguration is fatal
+  # for a certain subset of tests, it is possible the suite may have many other tests which can still run.
+  #
+  # It is provided for cases where a service module detects a misconfiguration so fatal that there truly is no point
+  # in attempting to run any more tests because you know for sure they will all fail.
+  #
+  def self.abort_suite(message)
+    res = Result.new(nil)
+    res.error(message)
+    res.allow_retry = false
+    res.abort_suite_run = true
+    return res
+  end
+
+  #-------------------------------------------------------------------------------------------------------------------
+  # Flags this Result as erroneous.
+  # After one call to this method, is_ok will return false.
+  # A descriptive message string needs to be provided, explaining why the result is erroneous.
+  # This method can be invoked multiple times, if multiple errors are noticed on the response.
+  # The message(s) will be available via the message method.
+  #
+  def error(msg)
+    @is_ok = false
+    add_message(msg)
+  end
+
+  #-------------------------------------------------------------------------------------------------------------------
+  # Adds a message sentence to the error message line.
+  # Typically callers should invoke error() above.
+  #
+  def add_message(msg)
+    @message = @message + msg
+    if (@message[-1,1] != " ")
+      @message = @message + " "
+    end
+  end
+
+  #-------------------------------------------------------------------------------------------------------------------
+  # Returns the HTTP response code sent by server (as a String)
+  #
+  def code
+    return (-1) if @response == nil
+    return @response.code
+  end
+
+  #-------------------------------------------------------------------------------------------------------------------
+  # Returns the HTTP response body sent by server.
+  #
+  def body
+    return "" if @response == nil
+    return @response.body
+  end
+
+end

data/lib/ServiceAPI.rb

@@ -0,0 +1,178 @@
+
+#
+# This is the base class for all service module classes.
+#
+
+require 'net/http'
+require 'json'
+require 'Result'
+
+class ServiceAPI
+
+  #-------------------------------------------------------------------------------------------------------------------
+  # Returns a string which can be eval'd to set a variable or return an error.
+  #
+  # A very common pattern in service module methods is to attempt to get a value from state or return
+  # a fatal error Result if it is missing. This convenience method allows reducing the code segment:
+  #
+  #     xyz = state.get('xyz')
+  #     if (xyz == nil)
+  #       return Result.fatal_error("xyz required")
+  #     end
+  #
+  # to this:
+  #
+  #     xyz = ""; eval(need :xyz, state)
+  #
+  # (If only ruby has LISP macros, this could be so much cleaner...)
+  #
+  def need(symbol, state)
+    x = state.get(symbol.to_s)
+    if (x == nil)
+      return "return Result.fatal_error(\"#{symbol.to_s} required\")"
+    end
+    return "#{symbol.to_s} = state.get('#{symbol.to_s}')"
+  end
+
+  #-------------------------------------------------------------------------------------------------------------------
+  # Generate a random UUID.
+  #
+  # Attempts a few different ways, hopefully one of them work. If all fails, die.
+  #
+  def uuid
+    begin
+      require 'securerandom'
+      uuid = SecureRandom.uuid()
+
+    rescue Exception => e
+      if (File.exist?("/usr/bin/uuidgen")) # Centos e2fsprogs package
+        uuid = `/usr/bin/uuidgen`
+        return uuid.chomp
+
+      elsif (File.exist?("/usr/bin/uuid")) # Debian uuid package
+        uuid = `/usr/bin/uuid`
+        return uuid.chomp
+
+      else
+        die("Unable to generate UUIDs")
+      end
+    end
+  end
+
+  #-------------------------------------------------------------------------------------------------------------------
+  # Convenience method to build a string of HTTP query parameters.
+  #
+  def add_param(params, param)
+    if (param == nil || param.length() == 0)
+      return params
+    end
+    if (params == nil || params.length() == 0)
+      return "?#{param}"
+    end
+    return "#{params}&#{param}"
+  end
+
+  #-------------------------------------------------------------------------------------------------------------------
+  # Show details about request being sent.
+  #
+  def show_req(request)
+    if ($LOG_LEVEL >= 2)
+      puts "---[ Request ]----------------------------------------------------"
+      puts "#{request.method} #{request.path}"
+      request.each_header { |name,value|
+        puts "#{name}: #{value}"
+      }
+      puts "\n#{request.body}\n"
+      puts "------------------------------------------------------------------"
+    end
+  end
+
+  #-------------------------------------------------------------------------------------------------------------------
+  # Show details about response received.
+  #
+  def show_response(response)
+    if ($LOG_LEVEL >= 2)
+      puts "---[ Response ]---------------------------------------------------"
+      puts "#{response.code} #{response.message}"
+      response.each_header { |name,value|
+        puts "#{name}: #{value}"
+      }
+      puts "\n#{response.body}\n"
+      puts "------------------------------------------------------------------"
+    end
+  end
+
+  #-------------------------------------------------------------------------------------------------------------------
+  # Utility function to perform raw HTTP request.
+  #
+  # If url is not provided, will attempt to use generic 'server' and 'server_port' values from state.
+  #
+  def get_http_response(req, state, url)
+
+    # TODO: SSL support
+
+    auth = state.get('auth')
+    if (auth == "basic")
+      user = state.get('auth_user')
+      password = state.get('auth_password')
+      req.basic_auth(user, password)
+    end
+
+    if (url == nil)
+      server = state.get('server')
+      port = state.get('server_port')
+      die("no server specified") if (server == nil)
+      die("no server port specified") if (port == nil)
+      url = "http://#{server}:#{port}"
+    end
+
+    begin
+      urlobj = URI.parse(url)
+      http = Net::HTTP.new(urlobj.host, urlobj.port)
+      out(1, "Connecting to: #{urlobj.to_s}")
+      response = http.request(req)
+
+    rescue Exception => e
+      return Result.fatal_error("Failure connecting to server #{server}: #{e.to_s}")
+    end
+
+    return response
+  end
+
+  #-------------------------------------------------------------------------------------------------------------------
+  # Utility function to perform HTTP request.
+  # This is the method API subclasses should usually invoke when Discovery is available.
+  # It will connect to a service of the given type.
+  # It will log output and return a Result object.
+  #
+  def do_request_by_service(req, state, service)
+    service_list = state.get('service_list')
+    if (service_list == nil)
+      return Result.fatal_error("service_list not available in state!")
+    end
+
+    if (service_list[service] == nil)
+      return Result.fatal_error("No service of type #{service} available!")
+    end
+
+    url = service_list[service][0]
+    return do_request_by_url(req, state, url)
+  end
+
+  #-------------------------------------------------------------------------------------------------------------------
+  # Utility function to perform HTTP request.
+  # API subclasses can invoke this to connect to a specific host/port.
+  # It will log output and return a Result object.
+  #
+  def do_request_by_url(req, state, url)
+    show_req(req)
+    response = get_http_response(req, state, url)
+    show_response(response)
+
+    state.set_in_test('http_code', response.code)
+    result = Result.new(response)
+
+    return result
+  end
+
+end

data/lib/SimpleFileReport.rb

@@ -0,0 +1,26 @@
+
+#
+# Appends colon-separed results to a report file.
+#
+
+class SimpleFileReport
+
+  def initialize(file)
+    @file = file
+  end
+
+  def log(status, duration, service, api, name, message)
+    line = "#{Time.now.to_i}:#{status}:#{duration}:#{service}:#{api}:#{name}:#{message}"
+    file = File.new(@file, "a")
+    file.puts(line)
+    file.close()
+  end
+
+  def done(tests_ok, tests_fail)
+    line = "#{Time.now.to_i}:DONE:#{tests_ok}:#{tests_fail}"
+    file = File.new(@file, "a")
+    file.puts(line)
+    file.close()
+  end
+
+end

data/lib/State.rb

@@ -0,0 +1,182 @@
+#
+# The State class is a container for both global and per-test state.
+# The test framework keeps one global State object (in $GLOBAL_STATE).
+# A per-test State object is created for each test. The per-test object
+# inherits all the global state but can override values if needed.
+# Values set in the per-test class are not persisted beyond the lifetime
+# of a single test.
+#
+class State
+
+  attr_accessor :vars
+
+  #-------------------------------------------------------------------------------------------------------------------
+  # Constructor. If baseobj is nil, a top-level State object is created. Otherwise, a child (per-test) State
+  # object is created.
+  #
+  def initialize(baseobj = nil)
+    @vars = Hash.new()
+    @validations = Hash.new()
+
+    @headers = Hash.new
+    @headers['Content-Type'] = 'application/json'
+    @headers['User-Agent'] = 'restest'
+
+    @baseobj = baseobj
+  end
+
+  #-------------------------------------------------------------------------------------------------------------------
+  # Get a named value. Value is returned from either self, if present, or baseobj, if applicable.
+  #
+  def get(name)
+    if (@vars[name] != nil)
+      return @vars[name]
+    end
+
+    if (@baseobj != nil)
+      return @baseobj.get(name)
+    end
+
+    return nil
+  end
+
+  #-------------------------------------------------------------------------------------------------------------------
+  # Set a persistent value. For per-test State objects, this means the value is set in the parent (global) State
+  # object so it will persist beyond one test.
+  #
+  def set(name, value)
+    if (@baseobj != nil)
+      @baseobj.set(name, value)
+    else
+      @vars[name] = value
+    end
+  end
+
+  #-------------------------------------------------------------------------------------------------------------------
+  # Remove a persistent value.
+  #
+  def unset(name)
+    if (@baseobj != nil)
+      @baseobj.unset(name)
+    else
+      @vars.delete(name)
+    end
+  end
+
+  #-------------------------------------------------------------------------------------------------------------------
+  # Set a non-persistent value in a per-test State object. Calling this method on the global State is not allowed.
+  #
+  def set_in_test(name, value)
+    if (@baseobj != nil)
+      @vars[name] = value
+    else
+      die("cannot set_in_test for top-level State (name=#{name}, value=#{value})")
+    end
+  end
+
+  #-------------------------------------------------------------------------------------------------------------------
+  # Return HTTP headers for request. A minimal default set of headers is returned.
+  #
+  # If a mix Hash is provided, its elements are merged to the default headers (headers in 'mix' override the defaults
+  # if both are present). This allows per-test header customization.
+  #
+  def headers(mix = nil)
+    if (mix != nil)
+      return @headers.merge(mix)
+    else
+      return @headers
+    end
+  end
+
+  #-------------------------------------------------------------------------------------------------------------------
+  # Record a per-test validation (loaded from test file). Calling this method on the global State is not allowed.
+  #
+  def set_validate(name, value)
+    if (@baseobj != nil)
+      @validations[name] =value
+    else
+      die("cannot set_validate for top-level State (name=#{name}, value=#{value})")
+    end
+  end
+
+  #-------------------------------------------------------------------------------------------------------------------
+  # Validates all the 'validate' conditions for the current test.
+  # Calling this method on the global State is not allowed.
+  # Validating verifies that all entries set with set_validate have a matching value in test state.
+  # If any one or more fail, the result is marked as erroneous.
+  #
+  def validate(result)
+    @validations.each_key { |key|
+      failed = false
+      val = get(key)
+      wanted = @validations[key]
+      wanted =~ /(\S+) (.*)/
+      op = $1
+      target = $2
+      out(1, "validating: [#{key}]: want: [#{op} #{target}], got [#{val}]")
+      if (op == "=")
+        failed = true if (target != val.to_s)
+
+      elsif (op == "<")
+        failed = true if (val.to_i >= target.to_i)
+
+      elsif (op == ">")
+        failed = true if (val.to_i <= target.to_i)
+
+      elsif (op == "is")
+        if (target == "set")
+          failed = true if (val == nil || val.length == 0)
+        elsif (target == "unset")
+          failed = true if (val != nil && val.length > 0)
+        else
+          die("unknown directive for operation 'is': #{target}")
+        end
+
+      else
+        die("unknown validate operation #{op}")
+      end
+
+      if (failed)
+        result.error("For [#{key}] expected [#{op} #{target}] but got [#{val}].")
+        $VALIDATIONS_FAIL += 1
+      else
+        $VALIDATIONS_OK += 1
+      end
+    }
+
+    # This is Proofpoint specific and should not be in this class. There's not a good place to put it right
+    # now that doesn't involve copying multiple times, so put it here for now.
+    if (result.code == "500")
+      if (result.body != nil)
+        begin
+          json = JSON.parse(result.body)
+          if (json != nil && json['host'] != nil && json['message'] != nil)
+            result.add_message("Server: [#{json['host']}] said: [#{json['message']}])")
+          end
+        rescue
+        end
+      end
+    end
+
+  end
+
+  #-------------------------------------------------------------------------------------------------------------------
+  # To string...
+  #
+  def to_s
+    if (@baseobj == nil)
+      s = "Base State: "
+      @vars.each_key { |key|
+        s += "#{key}='#{@vars[key]}' "
+      }
+    else
+      s = "Test State: "
+      @vars.each_key { |key|
+        s += "#{key}='#{@vars[key]}' "
+      }
+      s += "(" + @baseobj.to_s + ")"
+    end
+    return s
+  end
+
+end

data/lib/restest.rb

@@ -0,0 +1,384 @@
+
+#
+# A test suite file must require this file, it provides the main entry point to the test harness.
+#
+# - Commands available in the test DSL are defined here.
+# - Initialization is done here.
+#
+
+require 'State'
+require 'optparse'
+
+$GLOBAL_STATE = State.new()
+$LOG_LEVEL = 0
+$TESTS_OK = 0
+$TESTS_FAIL = 0
+$VALIDATIONS_OK = 0
+$VALIDATIONS_FAIL = 0
+$CONFIG_FILE=nil
+$REPORT = nil
+$TEST_FILES = Hash.new()
+$INTERACTIVE = false
+$SAVED_STATES = Hash.new()
+
+#---------------------------------------------------------------------------------------------------------------------
+# Add a to_bool() method to String
+#
+class String
+  def to_bool
+    return true if self == "true"
+    false
+  end
+end
+
+#---------------------------------------------------------------------------------------------------------------------
+# Utility method to show a line of output and exit. Use when a fatal misconfiguration or error is seen.
+#
+def die(line)
+  puts "[ERROR] #{line}"
+  exit(1)
+end
+
+#---------------------------------------------------------------------------------------------------------------------
+# General purpose log output. Log level is zero by default, increased by one for each -v argument.
+#
+def out(level, line)
+  if ($LOG_LEVEL >= level)
+    puts line
+  end
+end
+
+#---------------------------------------------------------------------------------------------------------------------
+# Allow test scripts to get values from the global state.
+#
+def get(name)
+  return $GLOBAL_STATE.get(name)
+end
+
+#---------------------------------------------------------------------------------------------------------------------
+# Allow test scripts to set values in the global state.
+#
+def set(name, value)
+  $GLOBAL_STATE.set(name, value)
+end
+
+#---------------------------------------------------------------------------------------------------------------------
+# Allow test scripts to remove values from the global state.
+#
+def unset(name)
+  $GLOBAL_STATE.unset(name)
+end
+
+#---------------------------------------------------------------------------------------------------------------------
+# Saves the current state.
+#
+def save_state(tag)
+  $SAVED_STATES[tag] = $GLOBAL_STATE.vars.clone()
+end
+
+#---------------------------------------------------------------------------------------------------------------------
+# Restore global state to a previously saved state.
+#
+def restore_state(tag)
+  $GLOBAL_STATE.vars = $SAVED_STATES[tag]
+  if ($GLOBAL_STATE.vars == nil)
+    die("Attempted to restore to a saved stage [#{tag}] which does not exist!")
+  end
+end
+
+#---------------------------------------------------------------------------------------------------------------------
+# Print out the difference from the state named by tag_a to the state named by tag_b (these are states previously
+# saved with save_state().  If tag_b is not provided, diff is shown to the current global state.
+#
+def show_state_diff(tag_a, tag_b = nil)
+
+  a = $SAVED_STATES[tag_a]
+  if (tag_b == nil)
+    b = $GLOBAL_STATE.vars
+  else
+    b = $SAVED_STATES[tag_b]
+  end
+
+  if (a == nil || b == nil)
+    puts "[ERROR] Unable to show diff from state #{tag_a} to state #{tag_b}"
+    return
+  end
+
+  b.each { |k,v|
+    if (a[k] == nil)
+      puts "  ADDED:   '#{k}' => '#{v}'"
+    elsif (a[k] != v)
+      puts "  CHANGED: '#{k}' from '#{a[k]}' to '#{v}'"
+    end
+  }
+
+  a.each { |k,v|
+    if (b[k] == nil)
+      puts "  REMOVED: '#{k}' was '#{a[k]}'"
+    end
+  }
+end
+
+#---------------------------------------------------------------------------------------------------------------------
+# Run a separate test suite file as part of current test suite.
+# The global state is saved and then restored to isolate state changes made by the included test suite.
+#
+def run_suite(name)
+  out(1, "\n\n--Running included test suite #{name}")
+  save_state("_pre_run_suite")
+  load(name)
+  restore_state("_pre_run_suite")
+  out(1, "\n--Completed included test suite #{name}")
+end
+
+#---------------------------------------------------------------------------------------------------------------------
+# Loads test file
+#
+def load_test(name, state)
+  if (!File.exists?("tests/#{name}"))
+    die("No test file #{name}")
+  end
+
+  state.set_in_test('filename', name)
+  file = File.new("tests/#{name}", "r")
+  doc = false
+  out(3, "Reading test file tests/#{name}")
+
+  # line 1: service-class-name api-name
+  line = file.gets
+  line =~ /(\S*)\s*(\S*)/
+  if (!$1 || !$2)
+    die("Test #{name} missing service and/or API")
+  end
+  state.set_in_test('service', $1)
+  state.set_in_test('api', $2)
+
+  # then process 'set' or 'validate' directives
+  while ((line = file.gets) != nil)
+    next if line =~ /^\s*$/
+    next if line =~ /^#/
+
+    if (line =~ /^set (\S*)\s+=\s+(.*)/)
+      state.set_in_test($1, $2)
+
+    elsif (line =~ /^validate (\S+)\s+(\S+)\s+(.*)/)
+      state.set_validate($1, "#{$2} #{$3}")
+
+    elsif (line =~ /^doc (.*)/)
+      state.set_in_test('doc', $1)
+      doc = true
+
+    else
+      die("Unknown directive [#{line}] in #{name}")
+    end
+  end
+
+  if (!doc)
+    die("Test #{name} has no documentation (doc line)")
+  end
+end
+
+#---------------------------------------------------------------------------------------------------------------------
+# Entry point for running one test. Called from test script by invoking the name of the test file (see method_missing)
+#
+def run_test(name, ignore=false)
+  out(1, "\n\n\nRunning test #{name}")
+
+  if ($LOG_LEVEL > 0)
+    save_state('_internal_trace')
+  end
+
+  test_state = State.new($GLOBAL_STATE)
+  load_test(name, test_state)
+
+  service = test_state.get('service')
+  api = test_state.get('api')
+  out(1, "Service class: [#{service}] Calling API: [#{api}]")
+
+  if ($INTERACTIVE)
+    print "Interactive mode... <enter> to run this test now, <c>ontinue: "
+    STDOUT.flush
+    input = gets.chomp!
+    $INTERACTIVE = false if (input == "c")
+  end
+
+  before = Time.now()
+
+  allow_retries = test_state.get('allow_retries')
+  if (allow_retries != nil)
+    times = allow_retries.to_i
+    sleep_sec = test_state.get('retry_sleep').to_i
+    if (sleep_sec < 1)
+      die("allow_retries is set but retry_sleep is not")
+    end
+    out(1, "Test allow retries: allow_retries: #{times}  retry_sleep: #{sleep_sec}")
+    begin
+      out(1, "Tries left: #{times}")
+      test_state = State.new($GLOBAL_STATE)
+      load_test(name, test_state)
+      testobj = Object::const_get(service).new
+      result = testobj.send(api, test_state)
+      times -= 1
+      sleep(sleep_sec) if !result.is_ok
+    end while (times > 0 && !result.is_ok && result.allow_retry)
+
+  else
+    testobj = Object::const_get(service).new
+    result = testobj.send(api, test_state)
+  end
+
+  if ($LOG_LEVEL > 0)
+    show_state_diff('_internal_trace')
+  end
+
+  duration = Integer((Time.now() - before) * 1000)
+
+  out(1, "Duration of test: #{duration} ms")
+
+  prefix = ""
+  if (ignore)
+    prefix="IGNORE-"
+  end
+
+  if (result.is_ok)
+    out(0, "[#{prefix}OK] (#{duration}ms) #{service}.#{api}: #{test_state.get('doc')}")
+    $TESTS_OK += 1 if !ignore
+  else
+    out(0, "[#{prefix}FAIL] (#{duration}ms) #{service}.#{api}: #{test_state.get('doc')} #{result.message}")
+    $TESTS_FAIL += 1 if !ignore
+  end
+
+  if ($REPORT != nil)
+    if (result.is_ok)
+      status = "#{prefix}OK"
+    else
+      status = "#{prefix}FAIL"
+    end
+    $REPORT.log(status, duration, service, api, name, result.message)
+  end
+
+  if (result.abort_suite_run)
+    die("Test suite run has been aborted by previous test!")
+  end
+end
+
+#---------------------------------------------------------------------------------------------------------------------
+# Show Usage message
+#
+def show_usage(opts)
+  puts opts
+  puts <<EOF
+
+Running a test suite
+====================
+
+To run a test suite, simply run the test suite file as it is an
+executable ruby script. A configuration file argument must be
+provided.
+
+The configuration file is responsible for setting state values which
+are specific to a test environment, and thus not suitable to set
+elsewhere. These include values such as hostnames, user names, test
+domains, etc.
+
+(TODO: Until the framework packaging is organized, you need to run it
+from the test suite directory. So for the share tests for example, "cd
+share-tests" first. This is a temporary limitation.)
+
+The initial share test script is called "suite1" so run it by:
+
+% ./suite1 -c config.ENV
+
+(Where ENV is the share environment to run it against. There are
+separate config files for each share env.)
+
+EOF
+end
+
+#---------------------------------------------------------------------------------------------------------------------
+# Initialization sections below. This file must be included by a test script so this is run before any test entries.
+#
+
+# Process command line arguments if any.
+optparse = OptionParser.new do|opts|
+  # Set a banner, displayed at the top
+  # of the help screen.
+  opts.banner = "Usage: YOUR_SCRIPT [options] -c|--config CONFIG_FILE"
+
+  # Define the options, and what they do
+  opts.on( '-c', '--config CONFIG', 'Test config file' ) do|config|
+    $CONFIG_FILE = config
+    if (File.exists?($CONFIG_FILE))
+      load $CONFIG_FILE
+    else
+      show_usage(opts)
+      die("Config file not found")
+    end
+  end
+
+  opts.on( '-l', '--log LOG_FILE', 'Log results into "LOG_FILE" in colon-separated text' ) do|file|
+    require 'SimpleFileReport'
+    $REPORT = SimpleFileReport.new(file)
+  end
+
+  opts.on( '-v', 'Increase verbosity (each -v increases verbosity further)' ) do
+    $LOG_LEVEL += 1
+  end
+
+  opts.on( '-q', 'Quiet, no standard output (useful for running from cron or such)' ) do
+    $LOG_LEVEL = -100
+  end
+
+  opts.on( '-i', 'Interactive. Runs tests one by one.' ) do
+    $INTERACTIVE = true
+  end
+
+  # This displays the help screen, all programs are
+  # assumed to have this option.
+  opts.on( '-h', '--help', 'Display this screen' ) do
+    show_usage(opts)
+    exit
+  end
+end
+
+optparse.parse(ARGV)
+
+# Add shutdown hook to report totals.
+at_exit {
+  out(0, "Done!")
+  out(0, "#{$TESTS_OK} tests passed and #{$TESTS_FAIL} tests failed.")
+  out(0, "#{$VALIDATIONS_OK} validations passed and #{$VALIDATIONS_FAIL} validations failed.")
+  if ($REPORT != nil)
+    $REPORT.done($TESTS_OK, $TESTS_FAIL)
+  end
+}
+
+# Load names of existing test files
+Dir.foreach("tests") { |file| $TEST_FILES[file] = 1 }
+
+
+#---------------------------------------------------------------------------------------------------------------------
+# Finally, add missing_method hook to enable test suite DSL to call test cases by their names.
+#
+# Note: In some ruby versions (at least 1.9.0) we can use File.exists? here instead of having to keep the list
+# of test files in $TEST_FILES and checking that. However, in some other ruby versions (at least 1.9.2p290)
+# File.exists? ends up invoking some non-existent methods which trigger a method_missing call, which leads
+# to an infinite loop (until stack space runs out) if method_missing relies on File.exists?.
+#
+def method_missing(method_name, *args)
+  if ($TEST_FILES[method_name.to_s])
+    run_test(method_name)
+  elsif (method_name == :ignore) && $TEST_FILES[args[0].to_s]
+    run_test(args[0], true)
+  else
+    super
+  end
+end
+
+def respond_to?(method_name, include_private = false)
+  if ($TEST_FILES[method_name.to_s])
+    return true
+  else
+    super
+  end
+end

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'restest'
+
+class Test::Unit::TestCase
+end

data/test/test_restest.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestRestest < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: restest
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Jyri Virki
+- Peter Salas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+description: A Ruby framework for testing RESTful API's
+email: psalas@proofpoint.com
+executables:
+- restest
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- bin/restest
+- lib/MySQLReport.rb
+- lib/Result.rb
+- lib/ServiceAPI.rb
+- lib/SimpleFileReport.rb
+- lib/State.rb
+- lib/restest.rb
+- test/helper.rb
+- test/test_restest.rb
+homepage: http://github.com/gradeawarrior/restest
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 4020511203719455767
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: RESTful API Testing Framework
+test_files: []