overseer 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in overseer.gemspec
+gemspec

data/README.markdown

@@ -0,0 +1,3 @@
+# Overseer
+
+Overseer is a testing framework in Ruby for educational purposes.

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.test_files = FileList['test/test*.rb']
+  t.verbose = false
+end

data/examples/basic_test.rb

@@ -0,0 +1,89 @@
+require_relative '../lib/overseer'
+
+class BasicTest
+  include Overseer
+
+  test "#hello" do
+    "nothing happens"
+  end
+
+  test "raising an error" do
+    this_is_going_to_be_an_error
+  end
+
+  test "need some more time" do
+    (1..200000).map {|nr| nr += nr}
+  end
+
+  test "assertion_equal fail" do
+    say = "bye"
+
+    assert_equal "hello", say
+  end
+
+  test "assertion_equal passed" do
+    number = 12
+
+    assert_equal 12, number
+  end
+
+  test "assert_nil failed" do
+    the_end = "is coming!"
+
+    assert_nil the_end
+  end
+
+  test "assert_nil passed" do
+    box = nil
+
+    assert_nil box
+  end
+
+  test "assert_kind_of failed" do
+    string = 23
+
+    assert_kind_of String, string
+  end
+
+  test "assert_kind_of passed" do
+    fixnum = 11
+
+    assert_kind_of Fixnum, fixnum
+  end
+
+  test "assert_instance_of failed" do
+    float = 120e2
+
+    assert_instance_of Fixnum, float
+  end
+
+  test "assert_instance_of passed" do
+    bignum = 99999999999999999999999
+
+    assert_instance_of Bignum, bignum
+  end
+
+  test "assert_respond_to failed" do
+    class Responder
+      def hello; end
+    end
+
+    assert_respond_to Responder.new, :bye
+  end
+
+  test "assert_respond_to passed" do
+    class Responder
+      def hello; end
+    end
+
+    assert_respond_to Responder.new, :hello
+  end
+
+  before do
+    @james = "brown"
+  end
+
+  test "if the godfather of soul around" do
+    assert_equal "brown", @james
+  end
+end

data/lib/overseer.rb

@@ -0,0 +1,24 @@
+require "overseer/reporter"
+require "overseer/color"
+require "overseer/duties"
+require "overseer/dsl"
+require "overseer/assertions"
+require "overseer/suite"
+require "overseer/test"
+require "overseer/runner"
+require "overseer/version"
+
+module Overseer
+  extend self
+  extend Duties
+
+  OVERSEER_DIR = File.dirname(File.dirname(File.expand_path(__FILE__)))
+
+  def included(suite) #:nodoc:
+    suite.send(:extend, Dsl)
+    suite.send(:extend, Assertions)
+    build_suite(suite)
+  end
+
+  at_exit { Runner.run }
+end

data/lib/overseer/assertions.rb

@@ -0,0 +1,115 @@
+module Overseer
+
+  # Generic Assertion exception class
+  #
+  class Assertion < Exception
+  end
+
+  # A set of assertion methods
+  #
+  module Assertions
+
+    # Raises an +Assertion+ exception if the given object isn't
+    # +true+. It adds the exception to the failure collection of
+    # the current test, in which the assertion was executed
+    #
+    # ==== Parameters
+    # result:: the assertion result
+    # message<String>:: the identifying message for the +Assertion+ excpetion
+    #
+    def assert(result, message=nil)
+      Overseer.current_test.assertions += 1
+      raise Assertion, message unless result
+    rescue Assertion => e
+      Overseer.current_test.failures << e
+    end
+
+    # Compare two given objects if they are equal
+    # Fails if +actual+ isn't equal to +expected+
+    #
+    # === Parameters
+    # expected:: the object which is expected
+    # actual:: the actual given object
+    # message<String>:: the identifying message for the +Assertion+ exception
+    #
+    def assert_equal(expected, actual, message=nil)
+      message ||= "Expected: \"#{expected}\"\n          Got: \"#{actual}\""
+      assert(expected == actual, message)
+    end
+
+    # Verify if an object is +nil+
+    # Fails if +obj+ isn't +nil+
+    #
+    # === Parameters
+    # obj:: the object which will be verified
+    # message<String>:: the identifying message for the +Assertion+ exception
+    #
+    def assert_nil(obj, message=nil)
+      message ||= "Expected #{obj} to be nil"
+      assert(obj.nil?, message)
+    end
+
+    # Verify if an object is +true+
+    # Fails if +obj+ isn't +true+
+    #
+    # === Parameters
+    # obj:: the object which will be verified
+    # message<String>:: the identifying message for the +Assertion+ exception
+    #
+    def assert_true(obj, message=nil)
+      message ||= "Expected #{obj} to be true"
+      assert(!!obj, message)
+    end
+
+    # Verify if an object is +false+
+    # Fails if +obj+ isn't +false+
+    #
+    # === Parameters
+    # obj:: the object which will be verified
+    # message<String>:: the identifying message for the +Assertion+ exception
+    #
+    def assert_false(obj, message=nil)
+      message ||= "Expected #{obj} to be false"
+      assert(!obj, message)
+    end
+
+    # Verify if an object is a kind of a specified class
+    # Fails if +obj+ isn't a kind of +clazz+
+    #
+    # === Parameters
+    # clazz:: the expected class which should +obj+ be a kind of
+    # obj:: the object which will be verified
+    # message<String>:: the identifying message for the +Assertion+ exception
+    #
+    def assert_kind_of(clazz, obj, message=nil)
+      message ||= "Expected \"#{obj.inspect}\" to be a kind of \"#{clazz}\", not \"#{obj.class}\""
+      assert(obj.kind_of?(clazz), message)
+    end
+
+    # Verify if an object is a instance of a specified class
+    # Fails if +obj+ isn't an instance of +clazz+
+    #
+    # === Parameters
+    # clazz:: the expected class which should +obj+ be an instance of
+    # obj:: the object which will be verified
+    # message<String>:: the identifying message for the +Assertion+ exception
+    #
+    def assert_instance_of(clazz, obj, message=nil)
+      message ||= "Expected \"#{obj.inspect}\" to be an instance of \"#{clazz}\", not \"#{obj.class}\""
+      assert(obj.instance_of?(clazz), message)
+    end
+
+    # Verify if an object responds to a method.
+    # Fails if +obj+ doesn't respond to +method+
+    #
+    # === Parameters
+    # obj:: the object which will be verified
+    # method:: the name of the method which +obj+ should respond to
+    # message<String>:: the identifying message for the +Assertion+ exception
+    #
+    def assert_respond_to(obj, method, message=nil)
+      message ||= "Expected \"#{obj.inspect}\" to respond to \"##{method}\""
+      assert(obj.respond_to?(method), message)
+    end
+  end
+end

data/lib/overseer/color.rb

@@ -0,0 +1,19 @@
+module Overseer
+  module Color
+    extend self
+
+    COLORS = {
+      :red               =>   "\e[31m",
+      :green             =>   "\e[32m",
+      :bright_black      =>   "\e[90m",
+      :bright_red        =>   "\e[91m",
+      :bright_green      =>   "\e[92m",
+    }
+
+    COLORS.each do |color, ansi_code|
+      define_method color do |string|
+        "#{ansi_code}#{string}\e[0m"
+      end
+    end
+  end
+end

data/lib/overseer/dsl.rb

@@ -0,0 +1,15 @@
+module Overseer
+  module Dsl
+    def test(desc, &block)
+      Overseer.build_test(desc, &block)
+    end
+
+    def before(&block)
+      Overseer.build_before(&block)
+    end
+
+    def after(&block)
+      Overseer.build_after(&block)
+    end
+  end
+end

data/lib/overseer/duties.rb

@@ -0,0 +1,55 @@
+module Overseer
+  module Duties
+    attr_reader :current_suite
+    attr_accessor :current_test
+
+    def build_test(name, &block)
+      @current_suite.tests << Test.new(name, &block)
+    end
+
+    def build_suite(suite)
+      @current_suite = Suite.new(suite)
+      suites << @current_suite
+    end
+
+    def build_before(&block)
+      @current_suite.before = block
+    end
+
+    def build_after(&block)
+      @current_suite.after = block
+    end
+
+    def suites
+      @suites ||= []
+    end
+
+    def failures_exists?
+      total_failures > 0
+    end
+
+    def errors_exists?
+      total_errors > 0
+    end
+
+    def total_assertions
+      suites.inject(0) { |total, suite| total + suite.total_test_assertions }
+    end
+
+    def total_failures
+      suites.inject(0) { |total, suite| total + suite.total_test_failures }
+    end
+
+    def total_errors
+      suites.inject(0) { |total, suite| total + suite.total_test_errors }
+    end
+
+    def total_tests
+      suites.inject(0) { |total, suite| total + suite.tests.size }
+    end
+
+    def total_time
+      suites.inject(0) { |total, suite| total + suite.total_test_time }
+    end
+  end
+end

data/lib/overseer/reporter.rb

@@ -0,0 +1,66 @@
+module Overseer
+  module Reporter
+    extend self
+
+    def report
+      print_header
+      yield
+      print_test_report
+    end
+
+    def print_header
+      puts "Overseer is running..."
+      puts
+    end
+
+    def print_test_report
+      puts
+      print_open_issues
+      puts
+      puts "Finished in %.3f seconds" % Overseer.total_time
+      puts Color.green("#{Overseer.total_tests} tests, #{Overseer.total_assertions} assertions, #{Overseer.total_failures} failures, #{Overseer.total_errors} errors")
+    end
+
+    def print_single_test_result(test)
+      print(test.passed? ? Color.green(".") : (test.errors? ? Color.red("E") : Color.red("F")))
+    end
+
+    def print_open_issues
+      if Overseer.failures_exists? || Overseer.errors_exists?
+        print "\nOpen issues:\n"
+        counter = 1
+        Overseer.suites.each do |suite|
+          suite.tests.each do |test|
+            unless test.passed?
+              print_test_issues(test, counter)
+              counter += 1
+            end
+          end
+        end
+      end
+    end
+
+    def print_test_issues(test, counter)
+      puts
+      puts "  #{counter}) #{(test.errors?) ? Color.red("Error:") : Color.red("Failure:")}"
+      puts "     Test: #{test.name} (in #{test.suite.name} Suite)"
+      exception = if test.errors?
+                    test.errors.first
+                  else
+                    test.failures.first
+                  end
+      puts Color.red("     #{exception.message}")
+      puts Color.bright_black("#{format_backtrace_output(filter_backtrace(exception.backtrace))}")
+    end
+
+    def filter_backtrace(backtrace)
+      backtrace.reject do |line|
+        line.rindex(OVERSEER_DIR, 0)
+      end
+    end
+
+    def format_backtrace_output(backtrace)
+      backtrace.map { |line| "     # #{line}"}.join("\n")
+    end
+  end
+end

data/lib/overseer/runner.rb

@@ -0,0 +1,9 @@
+module Overseer
+  module Runner
+    def self.run
+      Reporter.report do
+        Overseer.suites.each(&:run)
+      end
+    end
+  end
+end

data/lib/overseer/suite.rb

@@ -0,0 +1,50 @@
+module Overseer
+  class Suite
+    attr_accessor :tests, :before, :after
+    attr_reader :name
+
+    def initialize(suite)
+      @name = suite.name
+    end
+
+    # Run all tests and print a report for each run
+    # about the success status
+    #
+    def run
+      tests.each do |test|
+        test.run
+        Reporter.print_single_test_result(test)
+      end
+    end
+
+    # The total amount of errors
+    #
+    def total_test_errors
+      tests.inject(0) { |total, test | total + test.errors.size }
+    end
+
+    # The total amount of failures
+    #
+    def total_test_failures
+      tests.inject(0) { |total, test | total + test.failures.size }
+    end
+
+    # The total test running time
+    #
+    def total_test_time
+      tests.inject(0) { |total, test| total + test.time }
+    end
+
+    # The total amount of assertions
+    #
+    def total_test_assertions
+      tests.inject(0) { |total, test | total + test.assertions }
+    end
+
+    # All tests for the suite
+    #
+    def tests
+      @tests ||= []
+    end
+  end
+end

data/lib/overseer/test.rb

@@ -0,0 +1,56 @@
+module Overseer
+  class Test
+    attr_reader :time, :name, :code, :suite
+    attr_accessor :errors, :failures, :assertions
+
+    def initialize(name, &block)
+      @name = name
+      @code = block
+      @suite = Overseer.current_suite
+      @errors = []
+      @failures = []
+      @assertions = 0
+    end
+
+    # Returns +true+ or +false+ depending if the test
+    # is passed or not
+    #
+    def passed?
+      !errors? && !failures?
+    end
+
+    # Returns +true+ or +false depending if the test
+    # have outstanding errors or not
+    #
+    def errors?
+      errors.any?
+    end
+
+    # Returns +true+ or +false depending if the test
+    # have outstanding failures or not
+    def failures?
+      failures.any?
+    end
+
+    # Run the test, record the run time and store
+    # possible exceptions
+    #
+    def run
+      Overseer.current_test = self
+      start_time = Time.now
+      suite.before.call if suite.before
+      begin
+        @code.call
+      rescue Exception => e
+        errors << e
+      ensure
+        begin
+          suite.after.call if suite.after
+        rescue Exception => e
+          errors << e if passed?
+        end
+        @time = Time.now - start_time
+      end
+    end
+  end
+end

data/lib/overseer/version.rb

@@ -0,0 +1,3 @@
+module Overseer
+  VERSION = "0.0.1"
+end

data/overseer.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "overseer/version"
+
+Gem::Specification.new do |s|
+  s.name        = "overseer"
+  s.version     = Overseer::VERSION
+  s.authors     = ["Samuel Tonini"]
+  s.email       = ["tonini.samuel@gmail.com"]
+  s.homepage    = ""
+  s.description = %q{A testing framework in Ruby for educational purpose}
+  s.summary     = s.description
+
+  s.rubyforge_project = "overseer"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/test/helper.rb

@@ -0,0 +1 @@
+require_relative '../lib/overseer'

data/test/test_suite.rb

@@ -0,0 +1,57 @@
+require_relative 'helper'
+
+class TestWorld
+end
+
+class TestSuite
+  include Overseer
+
+  before do
+    @suite = Suite.new(TestWorld)
+  end
+
+  after do
+    @suite.tests.clear
+  end
+
+  test "#name" do
+    assert_equal "TestWorld", @suite.name
+  end
+
+  test "#total_test_errors" do
+    test = Test.new("the first one!")
+    @suite.tests << test
+
+    assert_equal 0, @suite.total_test_errors
+
+    test.errors << "ERROR"
+    assert_equal 1, @suite.total_test_errors
+  end
+
+  test "#total_test_failures" do
+    test = Test.new("doing it!")
+    @suite.tests << test
+
+    assert_equal 0, @suite.total_test_failures
+
+    test.failures << "FAILURE"
+    assert_equal 1, @suite.total_test_failures
+  end
+
+  test "#total_test_assertions" do
+    test = Test.new("give it!")
+    @suite.tests << test
+
+    assert_equal 0, @suite.total_test_assertions
+
+    test.assertions += 1
+    assert_equal 1, @suite.total_test_assertions
+  end
+
+  test "#tests" do
+    @suite.tests << Test.new("time to rest!")
+
+    assert_equal 1, @suite.tests.size
+    assert_kind_of Array, @suite.tests
+  end
+end

data/test/test_test.rb

@@ -0,0 +1,31 @@
+require_relative 'helper'
+
+class TestTest
+  include Overseer
+
+  test "#passed?" do
+    test = Test.new("if the world is running")
+
+    test.failures << "big fail"
+    assert_false test.passed?
+
+    test.failures.clear
+
+    test.errors << "Got an error!"
+    assert_false test.passed?
+  end
+
+  test "#errors?" do
+    test = Test.new("error mate!")
+
+    test.errors << "outch!"
+    assert_true test.errors?
+  end
+
+  test "#failures?" do
+    test = Test.new("failure hurray!")
+
+    test.failures << "gotcha!"
+    assert_true test.failures?
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: overseer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Samuel Tonini
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-08-24 00:00:00.000000000 +02:00
+default_executable: 
+dependencies: []
+description: A testing framework in Ruby for educational purpose
+email:
+- tonini.samuel@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.markdown
+- Rakefile
+- examples/basic_test.rb
+- lib/overseer.rb
+- lib/overseer/assertions.rb
+- lib/overseer/color.rb
+- lib/overseer/dsl.rb
+- lib/overseer/duties.rb
+- lib/overseer/reporter.rb
+- lib/overseer/runner.rb
+- lib/overseer/suite.rb
+- lib/overseer/test.rb
+- lib/overseer/version.rb
+- overseer.gemspec
+- test/helper.rb
+- test/test_suite.rb
+- test/test_test.rb
+has_rdoc: true
+homepage: ''
+licenses: []
+post_install_message: 
+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: overseer
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A testing framework in Ruby for educational purpose
+test_files:
+- test/helper.rb
+- test/test_suite.rb
+- test/test_test.rb