app-tester 0.0.1

data/README.md

@@ -0,0 +1,264 @@
+# Application Tester (app-tester)
+
+* http://github.com/joseairosa/app-tester
+
+[![Build Status](https://secure.travis-ci.org/joseairosa/app-tester.png)](http://travis-ci.org/joseairosa/app-tester)
+
+## DESCRIPTION:
+
+This Gem will provide a framework to build command line functional tests against a web application (API, Website, etc)
+
+## FEATURES/PROBLEMS:
+
+* Easily create functional tests with just a few lines of code
+* Since tests are built as command line tools they can be easily integrated with automatic tools
+* Specify command line options in both short (-s, -f, etc...) and long (--server, --file, etc...) definition
+* Add colors to make your tests more readable and easier to understand
+* Use pre-built tools to analyse your output or build your own
+
+## SYNOPSIS:
+
+```ruby
+require "app-tester"
+
+# Initialize framework with test environments
+apptester = AppTester.new do |options|
+  options.add_environment :github => "https://github.com"
+  options.add_environment :google => "https://google.com"
+  options.default_environment = :google # A default environment can be specified
+end
+
+# Define your tests
+apptester.define_test "my test" do |cmd_options, connection|
+  result = connection.get do |request|
+    request.url "/"
+  end
+
+  # Check if we have a 200 OK or not
+  AppTester::Checker.status result
+
+  # Convert a file to an array
+  p AppTester::Utils.file_to_array cmd_options[:file] unless cmd_options[:file].nil?
+end
+
+apptester.set_options_for "my test" do |options_parser|
+  options_parser.set_option(:file, "-f", "--file FILE", "File to load")
+  options_parser.mandatory_options = 1
+end
+
+apptester.run_test "my test"
+```
+
+Assuming that this is in a file called my_test.rb, you can run it, via command line:
+
+```
+$ ruby my_test.rb --help
+```
+
+Will output:
+
+```
+my test
+
+    -s, --server OPT                 Server to connect. Default: google
+    -f, --file FILE                  File to load
+    -h, --help                       Show this message
+```
+
+Or you can run the test itself:
+
+```
+$ ruby my_test.rb -s github
+```
+
+Will output:
+
+```
+Connecting to https://github.com...
+[SUCCESS] got status 200
+```
+
+## REQUIREMENTS:
+
+* json >= 1.7.5
+* faraday >= 0.8.4
+* optparse
+
+## INSTALL:
+
+It's very easy to install.
+
+```
+gem install app-tester
+```
+
+Done! :)
+
+## Adding colours to your tests
+
+AppTester has a useful helper class that enables anyone to add colours to the tests.
+Lets take the example where we want to output "Hello World" in 2 different colours.
+
+```ruby
+require "app-tester"
+
+# Initialize framework with test environments
+apptester = AppTester.new do |options|
+  options.add_environment :github => "https://github.com"
+  options.default_environment = :github # A default environment can be specified
+end
+
+# Define your tests
+apptester.define_test "my test" do |cmd_options, connection|
+  result = connection.get do |request|
+    request.url "/"
+  end
+
+  puts "#{AppTester::Utils::Colours.red("Hello")} #{AppTester::Utils::Colours.green("World")}"
+end
+
+apptester.run_test "my test"
+```
+
+Available colours are:
+
+* black
+* blue
+* green
+* cyan
+* red
+* purple
+* brown
+* light_gray
+* dark_gray
+* light_blue
+* light_green
+* light_cyan
+* light_red
+* light_purple
+* yellow
+* white
+
+## Benchmarking
+
+You can benchmark your test. This is very useful to understand if anything is underperforming.
+Tests can be nested inside each other.
+
+```
+require "app-tester"
+
+# Initialize framework with test environments
+apptester = AppTester.new do |options|
+  options.add_environment :github => "https://github.com"
+  options.default_environment = :github # A default environment can be specified
+end
+
+# Define your tests
+apptester.define_test "my test" do |cmd_options, connection|
+  result = connection.get do |request|
+    request.url "/"
+  end
+
+  AppTester::Timer.new("test timer 1") do
+    sleep 1
+  end
+
+  AppTester::Timer.new("test timer 2") do
+    sleep 1
+    AppTester::Timer.new("test timer 2.1") do
+      sleep 1
+    end
+  end
+end
+
+apptester.run_test "my test"
+```
+
+This will output:
+
+```
+$ ruby examples/benchmark.rb
+Connecting to https://github.com...
+   Time elapsed to test timer 1, 1001.086 milliseconds
+   Time elapsed to test timer 2.1, 1000.12 milliseconds
+   Time elapsed to test timer 2, 2001.204 milliseconds
+```
+
+## Reading from a file
+
+File are extremely usefull tools.
+We can have, for example, a functional test to an API where we want to run 100 strings against an end-point. For this you only need to create a new plain text file, write 1 string per line and use this gem to read them.
+
+Here is an example:
+
+```
+require "app-tester"
+
+apptester = AppTester.new do |options|
+  options.add_environment :github => "https://github.com"
+  options.add_environment :google => "https://google.com"
+  options.default_environment = :google
+end
+
+apptester.define_test "my test" do |cmd_options, connection|
+  result = connection.get do |request|
+    request.url "/"
+  end
+  AppTester::Checker.status result
+
+  my_file = AppTester::Utils.file_to_array cmd_options[:file]
+
+  my_file.each do |line|
+    # do awesome stuff with line
+  end
+end
+
+apptester.set_options_for "my test" do |options_parser|
+  options_parser.set_option(:file, "-f", "--file FILE", "File to load")
+  options_parser.mandatory_options = 1
+end
+
+apptester.run_test "my test"
+```
+ 
+## Supported Ruby versions
+
+This library aims to support and is tested against the following Ruby
+implementations:
+
+* MRI 1.8.7
+* MRI 1.9.2
+* MRI 1.9.3
+* [JRuby][]
+* [Rubinius][]
+
+If something doesn't work on one of these interpreters, it should be considered
+a bug.
+
+## LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2012 José P. Airosa
+
+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.
+
+  [jruby]:     http://jruby.org/
+  [rubinius]:  http://rubini.us/

data/Rakefile

@@ -0,0 +1,28 @@
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+gem "json", "~> 1.7.5"
+gem "faraday", "~> 0.8.4"
+require 'hoe'
+require 'fileutils'
+require './lib/app-tester'
+
+Hoe.plugin :newgem
+# Hoe.plugin :website
+# Hoe.plugin :cucumberfeatures
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.spec 'app-tester' do
+  self.developer 'Jose P. Airosa', 'me@joseairosa.com'
+  #self.post_install_message = 'PostInstall.txt' # TODO remove if post-install message not required
+  self.rubyforge_name       = self.name # TODO this is default value
+  # self.extra_deps         = [['activesupport','>= 2.0.2']]
+
+end
+
+require 'newgem/tasks'
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# remove_task :default
+task :default => [:rspec]

data/lib/app-tester/checker.rb

@@ -0,0 +1,31 @@
+module AppTester
+  # @abstract Check module to be used within a test snippet. This can be extended to have more checks
+  module Checker
+    extend self
+
+    # Check the status of a response and output to cmd
+    #
+    # @param response [Faraday::Response] the response object from Faraday
+    # @param overwrite_output [NilClass, TrueClass] if we should overwrite default output. Useful for setting custom messages
+    # @param fail [TrueClass, FalseClass] if we should force the script to halt execution
+    #
+    # @return [NilClass]
+    def status(response, overwrite_output=nil, fail=false)
+      if response.status == 200
+        if overwrite_output.nil?
+          puts "#{AppTester::Utils::Strings::SUCCESS} got status #{response.status}"
+        else
+          puts "#{AppTester::Utils::Strings::SUCCESS} #{overwrite_output}"
+        end
+      else
+        if overwrite_output.nil?
+          puts "#{AppTester::Utils::Strings::WARNING} got status #{response.status}"
+        else
+          puts "#{AppTester::Utils::Strings::WARNING} #{overwrite_output}"
+        end
+        exit(1) if fail
+      end
+    end
+
+  end
+end

data/lib/app-tester/connection.rb

@@ -0,0 +1,50 @@
+require "faraday"
+
+module AppTester
+  # @abstract Connection object that deals with communicating with Faraday to build new connections
+  # @attr_reader options [AppTester::Options] the options that the user defined when he created the framework
+  class Connection
+
+    attr_reader :options
+
+    # Build a new connection handler
+    #
+    # @param url [String] the url that will be used to set up a new connection handler
+    # @param options [AppTester::Options] the options that the user defined when he created the framework
+    #
+    # @raise [OptionParser::InvalidArgument] if no url is specified
+    # @raise [Faraday::Error::ConnectionFailed] if there was a problem connecting to the url provided
+    #
+    # @return [Faraday::Connection] on successfull connection
+    #
+    # @todo Implement connection retry
+    def self.new(url="", options={})
+      @options = options
+
+      # Make sure server choice makes sense
+      raise OptionParser::InvalidArgument if url.nil?
+
+      puts AppTester::Utils::Colours.dark_gray "Connecting to #{url}..."
+      retries = 0
+      connection = Faraday.new(:url => url, :ssl => { :verify => false }) do |builder|
+        builder.request :url_encoded
+        builder.adapter :net_http
+        builder.response :logger if @options.log_connections
+      end
+      connection
+      #begin
+      #
+      #  connection.get do |req|
+      #
+      #  end
+      #rescue Faraday::Error::ConnectionFailed => e
+      #  retries += 1
+      #  if retries <= @options.connection_retries
+      #    puts AppTester::Utils::Colours.dark_gray "#{AppTester::Utils::Strings::FAILED} Failed connection to #{url}, retry attempt #{retries}..."
+      #    retry
+      #  end
+      #  raise Faraday::Error::ConnectionFailed(e.message)
+      #end
+    end
+  end
+end

data/lib/app-tester/core.rb

@@ -0,0 +1,7 @@
+module AppTester
+  class Core
+    def initialize
+
+    end
+  end
+end

data/lib/app-tester/exceptions.rb

@@ -0,0 +1,10 @@
+module AppTester
+  module Error
+    class NameEmptyError < StandardError
+    end
+    class BlockNotGivenError < StandardError
+    end
+    class TestNotFoundError < StandardError
+    end
+  end
+end

data/lib/app-tester/options.rb

@@ -0,0 +1,31 @@
+module AppTester
+  # @abstract Framework options
+  # @attr_accessor default_environment [Symbol] the default environment in case command line script is executed without a server defined
+  # @attr_accessor environments [Hash] the list of environments
+  # @attr_accessor log_connection [TrueClass, FalseClass] if we should or not log Faraday connections
+  # @todo implement connection retries
+  class Options
+
+    attr_accessor :default_environment
+    attr_accessor :log_connections
+    attr_accessor :environments
+    #attr_accessor :connection_retries
+
+    def initialize
+      @environments = {}
+      @default_environment = nil
+      @log_connections = false
+      #@connection_retries = 0
+    end
+
+    # Add a new environment to the environment list. This will be used when constructing AppTester::Parser object
+    #
+    # @param environment [Hash] Symbol to String mapping
+    #
+    # @return [AppTester::Options] returns self
+    def add_environment environment
+      @environments.merge! environment
+      self
+    end
+  end
+end

data/lib/app-tester/parser.rb

@@ -0,0 +1,60 @@
+require "optparse"
+
+module AppTester
+  # @abstract Parser handler for command line options. This uses optparse ruby gem
+  # @see http://ruby-doc.org/stdlib-1.9.3/libdoc/optparse/rdoc/OptionParser.html
+  # @attr_reader test_options [AppTester::Options] the options that the user defined when he created the framework
+  # @attr_reader options [Hash] command line arguments that were set when executing the script
+  # @attr_writer mandatory_options [Number] minimum number of command line arguments for this script to run
+  class Parser < OptionParser
+
+    attr_reader :test_options
+    attr_reader :options
+
+    attr_accessor :mandatory_options
+
+    # Build Parser object. Automatically builds with --server argument
+    #
+    # @param options [AppTester::Options] the options that the user defined when he created the framework
+    #
+    # @return [AppTester::Parser]
+    def initialize options
+      @options = { }
+      @test_options = options
+      @mandatory_options = 0
+      super do |x|
+        x.separator ''
+      end
+
+      # Fallback to the first entry on the environments list if there's not default environment selected
+      default_environment = @test_options.default_environment.nil? ? @test_options.environments.keys.first : @test_options.default_environment
+      @options[:server] = @test_options.environments[default_environment]
+
+      set_option(:server, "-s", "--server OPT", @test_options.environments.keys, "Server to connect. Default: #{default_environment}")
+    end
+
+    # Add a new option to our optparser
+    #
+    # @param symbol [Symbol] identifier that will be used on the yielded block on define_test
+    # @param opts [String] command line options definition
+    # @param block [Proc] custom code to be executed. Optional
+    #
+    # @see AppTester
+    # @see OptionParser
+    def set_option(symbol, *opts, &block)
+      if block.nil?
+        on(*opts) do |x|
+          case symbol
+            when :server
+              @options[symbol] = @test_options.environments[x]
+            else
+              @options[symbol] = x
+          end
+        end
+      else
+        on(*opts, &block)
+      end
+    end
+
+  end
+end

data/lib/app-tester/test.rb

@@ -0,0 +1,49 @@
+module AppTester
+  # @abstract Main object that hold all the data needed to run a test
+  # @attr_reader parser [AppTester::Parser] user selected options on command line
+  # @attr_reader name [String] name for this test
+  # @attr_reader source [Proc] block of code that holds the test to be executed
+  # @attr_reader connection [Faraday::Connection] connection handler
+  # @attr_reader options [AppTester::Options] the options that the user defined when he created the framework
+  class Test < Core
+
+    attr_reader :parser
+    attr_reader :name
+    attr_reader :source
+    attr_reader :connection
+    attr_reader :options
+
+    def initialize name, options={ }
+      @name = name
+      @options = options
+      @source = Proc.new { |parser_options, connection| yield(parser_options, connection) }
+      @parser = AppTester::Parser.new(options)
+      @parser.banner = @name
+    end
+
+    # Defines command options (arguments) that this test supports
+    def set_cmd_options
+      yield(@parser) if block_given?
+    end
+
+    # Run test
+    def run(arguments=ARGV)
+      append_help_option
+      @parser.parse!(arguments)
+      # Make sure we have enough arguments
+      raise OptionParser::MissingArgument if @parser.mandatory_options + 2 > @parser.options.size + 1
+      @connection = AppTester::Connection.new @parser.options[:server], @options
+      @source.call(@parser.options, @connection)
+    end
+
+    private
+
+    # Appends helper option. This options is always available on every test
+    def append_help_option
+      @parser.set_option(nil, "-h", "--help", "Show this message") do
+        puts @parser
+        exit
+      end
+    end
+  end
+end

data/lib/app-tester/timer.rb

@@ -0,0 +1,45 @@
+module AppTester
+  # @abstract Benchmark helper class
+  class Timer
+
+    # Created a new timer object
+    #
+    # @param message [NilClass, String] custom message to be displayed
+    # @param threshold [Number] amount in ms. If this limit is passed a warning message will be displayed
+    # @param method [NilClass, Symbol] method to benchmark. Optional
+    # @param args [NilClass, String] arguments to be passed onto the method
+    #
+    # @yield code snipper to be benchmarked
+    #
+    # @example
+    #   apptester.define_test "my test 400 threshold" do |options, connection|
+    #     AppTester::Timer.new("test timer", 400) do
+    #       sleep 0.5
+    #     end
+    #   end
+    def initialize(message=nil, threshold=nil, method=nil, *args)
+      beginning_time = Time.now
+      if block_given?
+        yield
+      else
+        self.send(method, args)
+      end
+      end_time = Time.now
+      time_passed = ((end_time - beginning_time)*1000).round(3)
+      printf "   "
+
+      threshold_message = ""
+      unless threshold.nil?
+        printf "#{AppTester::Utils::Strings::WARNING} " if time_passed.to_f > threshold.to_f
+        threshold_message = " (threshold: #{threshold} ms)"
+      end
+
+      if message.nil?
+        puts AppTester::Utils::Colours.dark_gray "Time elapsed #{time_passed} milliseconds#{threshold_message}"
+      else
+        puts AppTester::Utils::Colours.dark_gray "Time elapsed to #{message}, #{time_passed} milliseconds#{threshold_message}"
+      end
+    end
+
+  end
+end

data/lib/app-tester/utils/colors.rb

@@ -0,0 +1,61 @@
+module AppTester
+  module Utils
+    module Colours
+
+      extend self
+
+      def black message=""
+        _build_message("0;30", message)
+      end
+      def blue message=""
+        _build_message("0;34", message)
+      end
+      def green message=""
+        _build_message("0;32", message)
+      end
+      def cyan message=""
+        _build_message("0;36", message)
+      end
+      def red message=""
+        _build_message("0;31", message)
+      end
+      def purple message=""
+        _build_message("0;35", message)
+      end
+      def brown message=""
+        _build_message("0;33", message)
+      end
+      def light_gray message=""
+        _build_message("0;37", message)
+      end
+      def dark_gray message=""
+        _build_message("1;30", message)
+      end
+      def light_blue message=""
+        _build_message("1;34", message)
+      end
+      def light_green message=""
+        _build_message("1;32", message)
+      end
+      def light_cyan message=""
+        _build_message("1;36", message)
+      end
+      def light_red message=""
+        _build_message("1;31", message)
+      end
+      def light_purple message=""
+        _build_message("1;35", message)
+      end
+      def yellow message=""
+        _build_message("1;33", message)
+      end
+      def white message=""
+        _build_message("1;37", message)
+      end
+      private
+      def _build_message(color, message)
+        "\033[#{color}m#{message}\033[0m"
+      end
+    end
+  end
+end

data/lib/app-tester/utils/strings.rb

@@ -0,0 +1,11 @@
+module AppTester
+  module Utils
+    module Strings
+      SUCCESS="[#{AppTester::Utils::Colours.green "SUCCESS"}]"
+      OK="[#{AppTester::Utils::Colours.blue "OK"}]"
+      DONE="[#{AppTester::Utils::Colours.green "OK"}]"
+      FAILED="[#{AppTester::Utils::Colours.red "FAILED"}]"
+      WARNING="[#{AppTester::Utils::Colours.yellow "WARNING"}]"
+    end
+  end
+end

data/lib/app-tester/utils.rb

@@ -0,0 +1,27 @@
+module AppTester
+
+  load_libraries "utils/colors", "utils/strings"
+
+  # @abstract Helper utilities module
+  module Utils
+
+    extend self
+
+    include AppTester::Utils::Colours
+
+    # Convert a file to an array
+    #
+    # @param file [String] path to the file
+    #
+    # @return [Array] each entry on the array corresponds to each line on the file
+    def file_to_array file
+      lines = []
+      File.open(file, "r") do |infile|
+        while (line = infile.gets)
+          lines.push(line.gsub("\n", "").rstrip)
+        end
+      end
+      lines
+    end
+  end
+end

data/lib/app-tester.rb

@@ -0,0 +1,168 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+# @abstract AppTester main module and namespace
+module AppTester
+  VERSION = '0.0.1'
+
+  # @abstract AppTester main class
+  # @attr_reader [AppTester::Options] Options container. This will be shared across other classes
+  # @attr_reader [Hash] A hash of tests. Values take the format of AppTester::Test
+  class << self
+
+    attr_reader :options
+    attr_reader :tests
+
+    # Construct AppTester framework
+    #
+    # @yield [options] Gives the user the possibility to set generic options for the framework
+    # @yieldparam options [AppTester::Options] the options object
+    # @return [AppTester]
+    # @example Start AppTester handler
+    #   apptester = AppTester.new do |options|
+    #     options.add_environment :github => "https://github.com"
+    #     options.add_environment :google => "https://google.com"
+    #     options.default_environment = :google
+    #     options.log_connection = true
+    #   end
+    def new
+      @tests = {}
+      @options = AppTester::Options.new
+      yield @options if block_given?
+      self
+    end
+
+    # Create a new test object
+    #
+    # @param name [String] name for this test
+    #
+    # @yield [cmd_options, connection] code snippet that will be executed when AppTester::Test.run is issued
+    # @yieldparam cmd_options [AppTester::Parser] user selected options on command line
+    # @yieldparam connection [Faraday::Connection] the connection handler to the server selected on command line (or default fallback)
+    #
+    # @return [AppTester::Test] if the creation of this test was successfull with a block
+    # @return [NilClass] if the creation of this test was successfull with no block
+    #
+    # @raise [AppTester::Error::NameEmptyError] if name is empty
+    #
+    # @example Define a new test
+    #   apptester.define_test "my test" do |cmd_options, connection|
+    #     result = connection.get do |request|
+    #       request.url "/"
+    #     end
+    #     AppTester::Checker.status result
+    #
+    #     p AppTester::Utils.file_to_array cmd_options[:file] unless cmd_options[:file].nil?
+    #   end
+    def define_test name=""
+      if name.empty?
+        raise AppTester::Error::NameEmptyError, "Attempted to define a test without a name"
+      else
+        if block_given?
+          @tests[name.to_sym] = AppTester::Test.new(name, @options) do |cmd_options, connection|
+            yield cmd_options, connection
+          end
+        else
+          @tests[name.to_sym] = nil
+        end
+      end
+    end
+
+    # Retrieve a test by name
+    #
+    # @param name [String] test to retrieve
+    #
+    # @return [AppTester::Test] found test
+    #
+    # @raise [AppTester::Error::TestNotFoundError] if no test was found
+    #
+    # @example Get a pre-defined test
+    #   apptester = AppTester.new do |options|
+    #     options.add_environment :github => "https://github.com"
+    #     options.add_environment :google => "https://google.com"
+    #     options.default_environment = :google
+    #   end
+    #
+    #   apptester.define_test "my test"
+    #   my_test = apptester.get_test "my test"
+    def get_test name
+      raise AppTester::Error::TestNotFoundError, "Could not find test #{name}" unless @tests.keys.include?(name.to_sym)
+      @tests[name.to_sym]
+    end
+
+    # Defines command line options for a given test
+    #
+    # @param name [String] test name to which we want to define the command line options
+    #
+    # @return [AppTester::Test] the test for which we parsed the options
+    #
+    # @yield [options_parser] set the command line options for this test
+    # @yieldparam cmd_options [AppTester::Parser] command line options parser object
+    #
+    # @example Set options for a test
+    #   apptester = AppTester.new do |options|
+    #     options.add_environment :github => "https://github.com"
+    #     options.add_environment :google => "https://google.com"
+    #     options.default_environment = :google
+    #   end
+    #
+    #   apptester.define_test "my test"
+    #
+    #   apptester.set_options_for "my test" do |options_parser|
+    #     options_parser.set_option(:file, "-f", "--file FILE", "File to load")
+    #     options_parser.mandatory_options = 0
+    #   end
+    def set_options_for name
+      test = get_test name
+      yield test.parser
+      test
+    end
+
+    # Run a test
+    #
+    # @param name [String] test name that we want to run
+    # @param arguments [Array] overwrite ARGV array with a custom one, useful for unit tests
+    #
+    # @return [AppTester::Test] the test that we're running
+    #
+    # @raise [AppTester::Error::TestNotFoundError] if no test was found
+    # @raise [OptionParser::MissingArgument] if there's a argument missing from a missmatch in the number of arguments given and mandatory_options on set_options_for method
+    # @raise [Faraday::Error::ConnectionFailed] if there was a problem connecting to the selected server
+    #
+    # @example Run a test
+    #   apptester = AppTester.new do |options|
+    #     options.add_environment :github => "https://github.com"
+    #     options.add_environment :google => "https://google.com"
+    #     options.default_environment = :google
+    #   end
+    #   apptester.define_test "my test" do |cmd_options, connection|
+    #     result = connection.get do |request|
+    #       request.url "/"
+    #     end
+    #     AppTester::Checker.status result
+    #
+    #     p AppTester::Utils.file_to_array cmd_options[:file] unless cmd_options[:file].nil?
+    #   end
+    #
+    #   my_test = apptester.run_test
+    def run_test name, arguments=ARGV
+      the_test = get_test(name)
+      the_test.run(arguments)
+      the_test
+    end
+
+    # Load libraries to be used under this namespace
+    #
+    # @param libs [String] list of libraries to load
+    #
+    # @return [NilClass]
+    def load_libraries *libs
+      libs.each do |lib|
+        require_relative "app-tester/#{lib}"
+      end
+    end
+    alias load_library load_libraries
+  end
+
+  load_libraries "core", "utils", "options", "test", "parser", "connection", "exceptions", "timer", "checker"
+end

data/spec/app-tester_spec.rb

@@ -0,0 +1,285 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require 'tempfile'
+
+# Time to add your specs!
+# http://rspec.info/
+describe "App Tester framework" do
+
+  it "should initialize" do
+    # violated "Be sure to write your specs"
+    apptester = AppTester.new
+    apptester.should be_a(Module)
+    apptester.should respond_to(:options)
+  end
+
+  it "should set options" do
+    apptester = start_app_tester
+
+    apptester.options.environments.should be_a(Hash)
+    apptester.options.environments.size.should eq(3)
+    apptester.options.environments[:production].should eq("localhost://production")
+    apptester.options.environments[:staging].should eq("localhost://staging")
+    apptester.options.environments[:development].should eq("localhost://development")
+  end
+
+  it "should return help when asked for it" do
+    apptester = start_app_tester
+
+    apptester.define_test "my test" do |options, connection|
+      # blergh!
+    end
+
+    lambda { apptester.run_test("my test", ["--help"]) }.should raise_error SystemExit
+  end
+
+  it "should define a test and run it" do
+    apptester = start_app_tester
+
+    mock_arguments "-s" => "production"
+
+    apptester.define_test("test 1") do |options, connection|
+      options.should be_a(Hash)
+      connection.should be_a(Faraday::Connection)
+    end
+    apptester.define_test("test 2") do |options, connection|
+      options.should be_a(Hash)
+      connection.should be_a(Faraday::Connection)
+    end
+    apptester.tests.size.should eq(2)
+    apptester.run_test("test 1").should be_a(AppTester::Test)
+    apptester.run_test("test 2").should be_a(AppTester::Test)
+  end
+
+  it "should define a test without a default environment" do
+    apptester = start_app_tester
+
+    apptester.define_test "my test" do |options, connection|
+      options[:server].should eq("localhost://production")
+    end
+
+    apptester.run_test("my test", [])
+  end
+
+  it "should define a test with a default environment" do
+    apptester = start_app_tester nil, :staging
+
+    apptester.define_test "my test" do |options, connection|
+      options[:server].should eq("localhost://staging")
+    end
+
+    apptester.run_test("my test", [])
+  end
+
+  it "should define a test, set custom options and run" do
+    apptester = start_app_tester
+
+    apptester.define_test "my test" do |options, connection|
+      options.should be_a(Hash)
+      connection.should be_a(Faraday::Connection)
+      options.size.should be(2)
+      options[:server].should_not be_empty
+      options[:smiles_file].should_not be_empty
+    end
+
+    apptester.set_options_for "my test" do |test_options|
+      test_options.set_option(:smiles_file, "-f", "--smiles-file FILE", "File containing SMILES for query (one per line)")
+    end
+
+    mocked_arguments = mock_arguments "-s" => "development", "-f" => "../../file.txt"
+
+    apptester.run_test("my test", mocked_arguments)
+  end
+
+  it "should define a test, set custom options, define number mandatory options and run" do
+    apptester = start_app_tester
+
+    apptester.define_test "my test" do |options, connection|
+
+    end
+
+    apptester.set_options_for "my test" do |test_options|
+      test_options.set_option(:smiles_file, "-f", "--smiles-file FILE", "File containing SMILES for query (one per line)")
+      test_options.mandatory_options = 1
+    end
+
+    mocked_arguments = mock_arguments "-s" => "development"
+
+    lambda { apptester.run_test("my test", mocked_arguments) }.should raise_error OptionParser::MissingArgument
+  end
+
+  it "should create a connection" do
+    apptester = start_app_tester :production => "http://www.google.com"
+
+    apptester.define_test "my test" do |options, connection|
+      connection.should be_a(Faraday::Connection)
+    end
+
+    mocked_arguments = mock_arguments "-s" => "production"
+
+    apptester.run_test("my test", mocked_arguments)
+  end
+
+  it "should fetch contents of a connection" do
+    apptester = start_app_tester :production => "https://github.com"
+
+    apptester.define_test "my test" do |options, connection|
+      response = connection.get do |req|
+        req.url "/"
+      end
+      response.status.should eq(200)
+      response.body.should include("github")
+    end
+
+    mocked_arguments = mock_arguments "-s" => "production"
+
+    apptester.run_test("my test", mocked_arguments)
+  end
+
+  it "should return exception on connection failed" do
+    apptester = start_app_tester :production => "http://aoisjdioasjdioasjod"
+
+    apptester.define_test "my test" do |options, connection|
+      begin
+        response = connection.get do |req|
+          req.url "/"
+        end
+      rescue Exception => e
+        e.should be_a(Faraday::Error::ConnectionFailed)
+      end
+    end
+
+    mocked_arguments = mock_arguments "-s" => "production"
+
+    apptester.run_test("my test", mocked_arguments)
+  end
+
+  it "should check status" do
+    apptester = start_app_tester :production => "https://github.com"
+
+    apptester.define_test "my test" do |options, connection|
+      response = connection.get do |req|
+        req.url "/"
+      end
+      AppTester::Checker.status response
+    end
+
+    mocked_arguments = mock_arguments "-s" => "production"
+
+    read_stdout do
+      apptester.run_test("my test", mocked_arguments)
+    end.should include("[\033[0;32mSUCCESS\033[0m] got status")
+  end
+
+  it "should log connections if asked for" do
+    apptester = start_app_tester({ :production => "https://github.com" }, nil, true)
+
+    apptester.define_test "my test" do |options, connection|
+      response = connection.get do |req|
+        req.url "/"
+      end
+    end
+
+    mocked_arguments = mock_arguments "-s" => "production"
+
+    read_stdout do
+      apptester.run_test("my test", mocked_arguments)
+    end.should include("DEBUG")
+  end
+
+  it "should output colors correctly" do
+    AppTester::Utils::Colours.black("hello").should eq("\033[0;30mhello\033[0m")
+    AppTester::Utils::Colours.blue("hello").should eq("\033[0;34mhello\033[0m")
+    AppTester::Utils::Colours.green("hello").should eq("\033[0;32mhello\033[0m")
+    AppTester::Utils::Colours.cyan("hello").should eq("\033[0;36mhello\033[0m")
+    AppTester::Utils::Colours.red("hello").should eq("\033[0;31mhello\033[0m")
+    AppTester::Utils::Colours.purple("hello").should eq("\033[0;35mhello\033[0m")
+    AppTester::Utils::Colours.brown("hello").should eq("\033[0;33mhello\033[0m")
+    AppTester::Utils::Colours.light_gray("hello").should eq("\033[0;37mhello\033[0m")
+    AppTester::Utils::Colours.dark_gray("hello").should eq("\033[1;30mhello\033[0m")
+    AppTester::Utils::Colours.light_blue("hello").should eq("\033[1;34mhello\033[0m")
+    AppTester::Utils::Colours.light_green("hello").should eq("\033[1;32mhello\033[0m")
+    AppTester::Utils::Colours.light_cyan("hello").should eq("\033[1;36mhello\033[0m")
+    AppTester::Utils::Colours.light_red("hello").should eq("\033[1;31mhello\033[0m")
+    AppTester::Utils::Colours.light_purple("hello").should eq("\033[1;35mhello\033[0m")
+    AppTester::Utils::Colours.yellow("hello").should eq("\033[1;33mhello\033[0m")
+    AppTester::Utils::Colours.white("hello").should eq("\033[1;37mhello\033[0m")
+  end
+
+  it "should throw exception on no name test" do
+    apptester = start_app_tester
+    lambda { apptester.define_test }.should raise_exception(AppTester::Error::NameEmptyError)
+  end
+
+  it "should throw exception on test not found" do
+    apptester = start_app_tester
+    apptester.define_test "hello"
+    lambda { apptester.get_test "bye" }.should raise_exception(AppTester::Error::TestNotFoundError)
+  end
+
+  it "should time the execution" do
+    apptester = start_app_tester
+
+    apptester.define_test "my test" do |options, connection|
+      AppTester::Timer.new("test timer") do
+        sleep 1
+      end
+    end
+
+    read_stdout do
+      apptester.run_test("my test")
+    end.should include("Time elapsed to test timer, 100")
+  end
+
+  it "should time the execution with threshold" do
+    apptester = start_app_tester
+
+    apptester.define_test "my test 400 threshold" do |options, connection|
+      AppTester::Timer.new("test timer", 400) do
+        sleep 0.5
+      end
+    end
+
+    apptester.define_test "my test 600 threshold" do |options, connection|
+      AppTester::Timer.new("test timer", 600) do
+        sleep 0.5
+      end
+    end
+
+    output = read_stdout do
+      apptester.run_test("my test 400 threshold")
+    end
+    output.should include("WARNING")
+    output.should include("Time elapsed to test timer, 50")
+    output.should include("threshold: 400")
+
+    output = read_stdout do
+      apptester.run_test("my test 600 threshold")
+    end
+    output.should_not include("WARNING")
+    output.should include("Time elapsed to test timer, 50")
+    output.should include("threshold: 600")
+  end
+
+  def mock_arguments hash={ }
+    hash.flatten
+  end
+
+  def start_app_tester(environments=nil, default_environment=nil, log_connections=nil)
+    AppTester.new do |options|
+      (environments || { :production => "localhost://production", :staging => "localhost://staging", :development => "localhost://development" }).each do |k, v|
+        options.add_environment k => v
+      end
+      options.default_environment = default_environment unless default_environment.nil?
+      options.log_connections = log_connections unless log_connections.nil?
+    end
+  end
+
+  def read_stdout
+    results = Tempfile.new('a').path
+    a = STDOUT.dup
+    STDOUT.reopen(results, 'w')
+    yield
+    STDOUT.reopen(a)
+    File.read(results)
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+begin
+  require 'rspec'
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  gem 'rspec'
+  require 'rspec'
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'app-tester'

data/test/test_app-tester.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestAppTester < Test::Unit::TestCase
+
+  def setup
+  end
+  
+  def test_truth
+    assert true
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'stringio'
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/app-tester'

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: app-tester
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jose P. Airosa
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.7.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.7.5
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.4
+description: Command-line Framework to run functional tests against a web application
+  (API, Website, etc)
+email: me@joseairosa.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/app-tester/checker.rb
+- lib/app-tester/connection.rb
+- lib/app-tester/core.rb
+- lib/app-tester/exceptions.rb
+- lib/app-tester/options.rb
+- lib/app-tester/parser.rb
+- lib/app-tester/test.rb
+- lib/app-tester/timer.rb
+- lib/app-tester/utils/colors.rb
+- lib/app-tester/utils/strings.rb
+- lib/app-tester/utils.rb
+- lib/app-tester.rb
+- README.md
+- Rakefile
+- spec/app-tester_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- test/test_app-tester.rb
+- test/test_helper.rb
+homepage: https://github.com/joseairosa/app-tester
+licenses:
+- MIT
+post_install_message: ! "\e[0;32mThanks for installing! You're awesome ^_^\e[0m"
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: app-tester
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Application Tester Framework
+test_files:
+- spec/app-tester_spec.rb