fas_test 0.0.1

data/README

@@ -0,0 +1,19 @@
+Auto-discovers test classes in the working directory and runs the tests with
+basically no boot up time and no configuration.  It doesn't matter how you
+structure your project, instead, simple naming conventions are used:
+
+ - All test files should be named *_tests.rb
+ - All test methods should be named test__*
+
+Other things you need to know:
+
+ - All test classes should inherit FasTest::TestClass
+ - Your test class can define "setup" and/or "teardown" methods.  They do what
+   it sounds like they do.
+
+Take a look in the test folder to see an example of how the library is used.
+(fas_test is used to test itself).
+
+To actually run your tests just invoke fastest.rb from a command line. It will
+automatically recursively discover all of your test classes within the working
+directory and run there tests.  

data/bin/fastest.rb

@@ -0,0 +1,5 @@
+require 'lib/fas_test'
+
+test_runner = FasTest::TestRunner.new
+test_runner.run_tests_in_folder(".")
+test_runner.print_summary

data/lib/fas_test.rb

@@ -0,0 +1,197 @@
+module FasTest
+  
+  # Used to discover tests and actually run them.  Normally this class will be
+  # used by the command line client.
+  class TestRunner
+    
+    attr_reader :test_results
+    
+    def initialize(verbose = false)
+      @verbose = verbose
+      @assertion_count = 0
+      @test_results = {}
+    end
+    
+    def run_tests_in_class(test_class)
+      test_instance = init_test_instance(test_class)
+      get_all_test_method_names(test_class).each do |test_method_name|
+        run_test(test_instance, test_method_name)
+      end
+    end
+    
+    def init_test_instance(test_class)
+      test_instance = test_class.new
+      test_instance.runner = self
+      return test_instance
+    end
+    
+    def increment_assert_count
+      @assertion_count += 1
+    end
+    
+    def run_test(test_instance, test_method_name)
+      begin
+        status = TestStatuses::PASS
+        test_instance.setup
+        test_instance.needs_teardown = true
+        test_instance.send(test_method_name)
+        if @verbose
+          puts "Pass: #{test_instance.class.name}::#{test_method_name}"
+        end
+      rescue AssertionException => ex
+        status = TestStatuses::FAIL
+        try_teardown(test_instance)
+        puts "Fail: #{test_instance.class.name}::#{test_method_name}"
+        puts "  -> #{ex.message}"
+      rescue Exception => ex
+        status = TestStatuses::CRASH
+        try_teardown(test_instance)
+        puts "Crash: #{test_instance.class.name}::#{test_method_name}"
+        puts "  -> #{ex.class.name}: #{ex.message}"
+        pretty_print_stack_trace(ex)
+      rescue Object => obj
+        status = TestStatuses::CRASH
+        try_teardown(test_instance)
+        puts "Crash: #{test_instance.class.name}::#{test_method_name}"
+        puts "  -> Raised non-exception: #{obj.to_s}"
+      ensure
+        try_teardown(test_instance)
+        record_test_result(test_instance, test_method_name, status)
+      end
+    end
+    
+    def record_test_result(test_instance, test_method_name, status)
+      test_class = test_instance.class
+      key = "#{test_class.name}::#{test_method_name}"
+      @test_results[key] = TestResult.new(test_class, test_method_name, status)
+    end
+    
+    def try_teardown(test_instance)
+      if test_instance.needs_teardown
+        begin
+          test_instance.teardown
+        ensure
+          test_instance.needs_teardown = false
+        end
+      end
+    end
+    
+    def pretty_print_stack_trace(exception)
+      exception.backtrace.each { |trace| puts "    #{trace}"}
+    end
+    
+    def run_tests_in_folder(path)
+      load_test_files(path)
+      find_test_classes.each do |test_class|
+        run_tests_in_class(test_class)
+      end
+    end
+    
+    def load_test_files(path)
+      Dir[File.join(path, '/**/*_tests.rb')].each { |file_name| load file_name }
+    end
+    
+    def get_all_test_method_names(test_class)
+      test_class.instance_methods.find_all { |m| m.start_with?('test__') }
+    end
+    
+    def find_test_classes
+      classes = []
+      Module.constants.each do |constant|
+        if constant.end_with? "Tests"
+          classes << eval(constant)
+        end
+      end
+      return classes
+    end
+    
+    def get_constant_type(construct)
+      construct_class = construct.class
+      if construct_class == Class
+        return ConstantTypes::CLASS
+      elsif construct_class == Module
+        return ConstantTypes::MODULE
+      else
+        return ConstantTypes::OTHER
+      end
+    end
+    
+    def class_inherits_parent?(child_class, parent_class)
+      child_class.ancestors.any? { |ancestor| ancestor == parent_class }
+    end
+
+    def print_summary
+      pass_count = @test_results.values.find_all { |r| r.status == TestStatuses::PASS }.length
+      fail_count = @test_results.length - pass_count
+      puts "#{pass_count} passed; #{fail_count} failed; #{@assertion_count} assertions"
+    end
+
+  end
+  
+  # Types that a ruby constant can refer to
+  class ConstantTypes
+    CLASS = 1
+    MODULE = 2
+    OTHER = 3
+  end
+  
+  # Base class for all test suites
+  class TestClass
+    
+    attr_writer :runner
+    attr_accessor :needs_teardown
+    
+    def setup
+    end
+    
+    def teardown
+    end
+    
+    def assert_true(expression, msg = "<no msg given>")
+      @runner.increment_assert_count
+      if expression != true
+        raise AssertionException, "expected true but got #{expression.to_s}"
+      end
+    end
+    
+    def assert_equal(a, b, msg = "<no msg given>")
+      @runner.increment_assert_count
+      if a != b
+        raise AssertionException, "#{msg} | expected '#{a}' but got '#{b}'"
+      end
+    end
+    
+    def fail(msg)
+      raise AssertionException, msg
+    end
+    
+  end
+  
+  # Represents the state of a finished test
+  class TestResult
+    
+    attr_reader :test_class
+    attr_reader :method_name
+    attr_reader :status
+    
+    def initialize(test_class, method_name, status)
+      @test_class = test_class
+      @method_name = method_name
+      @status = status
+    end
+    
+  end
+  
+  # Exception thrown when an assertion in a test fails
+  class AssertionException < Exception
+  end
+
+  # Enum of test result states
+  class TestStatuses
+    PASS = 1
+    FAIL = 2
+    CRASH = 3
+  end
+  
+end
+

data/test/fas_test_tests.rb

@@ -0,0 +1,71 @@
+require 'stringio'
+require 'lib/fas_test'
+
+class FasTestTests < FasTest::TestClass
+    
+  def setup
+    $stdout = StringIO.new
+  end
+  
+  def teardown
+    $stdout = STDOUT
+  end
+  
+  def test__redirect_io
+    $stdout = StringIO.new
+    puts 'hello?'
+    assert_equal "hello?\n", $stdout.string
+  end
+  
+  def test__run_tests_in_class__results_are_valid
+    runner = FasTest::TestRunner.new
+    runner.run_tests_in_class(FasTestTestClassTests)
+    
+    assert_equal(5, runner.test_results.length, "wrong number of tests")
+    
+    assert_equal(
+      FasTest::TestStatuses::PASS,
+      runner.test_results['FasTestTests::FasTestTestClassTests::test__pass1'].status)
+      
+    assert_equal(
+      FasTest::TestStatuses::FAIL,
+      runner.test_results['FasTestTests::FasTestTestClassTests::test__fail1'].status)
+        
+    assert_equal(
+        FasTest::TestStatuses::CRASH,
+        runner.test_results['FasTestTests::FasTestTestClassTests::test__crash1'].status)
+    
+    assert_equal(
+      FasTest::TestStatuses::FAIL,
+      runner.test_results['FasTestTests::FasTestTestClassTests::test__assert_true_with_false'].status)
+          
+    assert_equal(
+      FasTest::TestStatuses::PASS,
+      runner.test_results['FasTestTests::FasTestTestClassTests::test__asert_true_with_true'].status)
+  end
+
+  class FasTestTestClassTests < FasTest::TestClass
+
+    def test__pass1
+    end
+    
+    def test__fail1
+      fail("this is an expected fail")
+    end
+    
+    def test__crash1
+      i.am.calling.come.methods.that.dont.exist.so.it.should.crash
+    end
+    
+    def test__assert_true_with_false
+      assert_true(false)
+    end
+    
+    def test__asert_true_with_true
+      assert_true(true)
+    end
+    
+  end
+  
+end
+

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: fas_test
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Graeme Hill
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-24 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: "Auto-discovers test classes in the working directory and runs the tests with\n\
+  basically no boot up time and no configuration.  It doesn't matter how you\n\
+  structure your project, instead, simple naming conventions are used:\n\n - All test files should be named *_tests.rb\n - All test methods should be named test__*\n\n\
+  Other things you need to know:\n\n - All test classes should inherit FasTest::TestClass\n - Your test class can define \"setup\" and/or \"teardown\" methods.  They do what\n   it sounds like they do.\n\n\
+  Take a look in the test folder to see an example of how the library is used.\n\
+  (fas_test is used to test itself).\n\n\
+  To actually run your tests just invoke fastest.rb from a command line. It will\n\
+  automatically recursively discover all of your test classes within the working\n\
+  directory and run there tests.  "
+email: graemekh@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- README
+- bin/fastest.rb
+- lib/fas_test.rb
+- test/fas_test_tests.rb
+has_rdoc: true
+homepage: http://graemehill.ca
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: A simple automated testing framework designed to be fast and easy to use.
+test_files: 
+- test/fas_test_tests.rb