turn 0.3.0 → 0.4.0

data/lib/turn/components/case.rb

@@ -0,0 +1,98 @@
+module Turn
+
+  #
+  class TestCase
+
+    # Name of test case.
+    attr_accessor :name
+
+    # Test methods.
+    attr_accessor :tests
+
+    # Some runners marshal tests per file.
+    attr_accessor :files
+
+    #attr_accessor :count_passes
+    #attr_accessor :count_failures
+    #attr_accessor :count_errors
+    #attr_accessor :count_tests
+
+    # This can;t be calculated, so it must be
+    # assigned by the runner.
+    attr_accessor :count_assertions
+
+    # Holds dump of test output (optional depending on runner).
+    attr_accessor :message
+
+    # Command used to run test (optional depending on runner).
+    #attr_accessor :command
+
+    #
+    def initialize(name, *files)
+      @name  = name
+      @files = (files.empty? ? [name] : files)
+      @tests = []
+
+      @message = nil
+      @count_assertions = 0
+
+      #@count_tests      = 0
+      #@count_failures   = 0
+      #@count_errors     = 0
+
+      #@command = command
+    end
+
+    def new_test(name)
+      c = TestMethod.new(name)
+      @tests << c
+      c
+    end
+
+    # Whne used by a per-file runner.
+    #alias_method :file, :name
+
+    # Were there any errors?
+    def error?
+      count_errors != 0
+    end
+
+    # Were there any failures?
+    def fail?
+      count_failures != 0
+    end
+
+    # Did all tests/assertion pass?
+    def pass?
+      not(fail? or error?)
+    end
+
+    def count_tests
+      tests.size
+    end
+
+    def count_failures
+      sum = 0; tests.each{ |t| sum += 1 if t.fail? }; sum
+    end
+
+    def count_errors
+      sum = 0; tests.each{ |t| sum += 1 if t.error? }; sum
+    end
+
+    def count_passes
+      sum = 0; tests.each{ |t| sum += 1 if t.pass? }; sum
+    end
+
+    #
+    def counts
+      return count_tests, count_assertions, count_failures, count_errors
+    end
+
+    def message
+      tests.collect{ |t| t.message }.join("\n")
+    end
+
+  end
+
+end
+

data/lib/turn/components/method.rb

@@ -0,0 +1,32 @@
+module Turn
+
+  #
+  class TestMethod
+    attr_accessor :name
+    attr_accessor :file
+    attr_accessor :message
+
+    def initialize(name)
+      @name    = name
+      @fail    = false
+      @error   = false
+      @message = nil
+    end
+
+    def fail!(message=nil)
+      @fail, @error = true, false
+      @message = message if message
+    end
+
+    def error!(message=nil)
+      @fail, @error = false, true
+      @message = message if message
+    end
+
+    def fail?  ; @fail  ; end
+    def error? ; @error ; end
+    def pass?  ; !(@fail or @error) ; end
+  end
+
+end
+

data/lib/turn/components/suite.rb

@@ -0,0 +1,82 @@
+module Turn
+
+  #
+  class TestSuite
+
+    include Enumerable
+
+    attr_accessor :name
+    attr_accessor :size
+    attr_accessor :cases
+
+    # This one can be set manually since it
+    # is not calculatable (beyond the case level).
+    attr_accessor :count_assertions
+
+    #
+    def initialize(name=nil)
+      @name  = name
+      @size  = nil
+      @cases = []
+
+      #@count_tests      = nil
+      #@count_assertions = nil
+      #@count_failures   = nil
+      #@count_errors     = nil
+      #@count_passes     = nil
+    end
+
+    #
+    def new_case(name, *files)
+      c = TestCase.new(name, *files)
+      @cases << c
+      c
+    end
+
+    def count_failures
+      #@count_failures ||= (
+        sum = 0; each{ |c| sum += c.count_failures }; sum
+      #)
+    end
+
+    def count_errors
+      #@count_errors ||= (
+        sum = 0; each{ |c| sum += c.count_errors }; sum
+      #)
+    end
+
+    def count_passes
+      #@count_passes ||= (
+        sum = 0; each{ |c| sum += c.count_passes }; sum
+      #)
+    end
+
+    def count_tests
+      #@count_tests ||= (
+        sum = 0; each{ |c| sum += c.count_tests }; sum
+      #)
+    end
+
+    def count_assertions
+      #@count_assertions ||= (
+        sum = 0; each{ |c| sum += c.count_assertions }; sum
+      #)
+    end
+
+    # Convenience methods --this is what is typcially wanted.
+    def counts
+      return count_tests, count_assertions, count_failures, count_errors
+    end
+
+    def each(&block)
+      @cases.each(&block)
+    end
+
+    def size
+      @size ||= @cases.size
+    end
+
+  end
+
+end
+

data/lib/turn/controller.rb

@@ -0,0 +1,146 @@
+require 'fileutils'
+
+module Turn
+  require 'turn/components/suite.rb'
+  require 'turn/components/case.rb'
+  require 'turn/components/method.rb'
+
+  require 'turn/reporters/outline_reporter'
+  require 'turn/reporters/marshal_reporter'
+  require 'turn/reporters/progress_reporter'
+  require 'turn/reporters/dot_reporter'
+
+  require 'turn/runners/testrunner'
+  require 'turn/runners/solorunner'
+  require 'turn/runners/crossrunner'
+
+  # = Controller
+  #
+  #--
+  # TODO: Add support to test run loggging.
+  #++
+  class Controller
+
+    # File glob pattern of tests to run.
+    # Can be an array of files/globs.
+    attr_accessor :tests
+
+    # Files globs to specially exclude.
+    attr_accessor :exclude
+
+    # Add these folders to the $LOAD_PATH.
+    attr_accessor :loadpath
+
+    # Libs to require when running tests.
+    attr_accessor :requires
+
+    # Instance of Reporter.
+    attr_accessor :reporter
+
+    # Insatance of Runner.
+    attr_accessor :runner
+
+    # Test against live install (i.e. Don't use loadpath option)
+    attr_accessor :live
+
+    # Log results? May be true/false or log file name. (TODO)
+    attr_accessor :log
+
+    # Verbose output?
+    attr_accessor :verbose
+
+    def verbose? ; @verbose ; end
+    def live?    ; @live    ; end
+
+  private
+
+    def initialize
+      yield(self) if block_given?
+      initialize_defaults
+    end
+
+    #
+    def initialize_defaults
+      @loadpath ||= ['lib']
+      @tests    ||= "test/**/{test,}*{,test}"
+      @exclude  ||= []
+      @reqiures ||= []
+      @live     ||= false
+      @log      ||= true
+      @reporter ||= OutlineReporter.new($stdout)
+      @runner   ||= TestRunner.new
+    end
+
+    # Collect test configuation.
+    #def test_configuration(options={})
+    #  #options = configure_options(options, 'test')
+    #  #options['loadpath'] ||= metadata.loadpath
+    #  options['tests']    ||= self.tests
+    #  options['loadpath'] ||= self.loadpath
+    #  options['requires'] ||= self.requires
+    #  options['live']     ||= self.live
+    #  options['exclude']  ||= self.exclude
+    #  #options['tests']    = list_option(options['tests'])
+    #  options['loadpath'] = list_option(options['loadpath'])
+    #  options['exclude']  = list_option(options['exclude'])
+    #  options['require']  = list_option(options['require'])
+    #  return options
+    #end
+
+    #
+    def list_option(list)
+      case list
+      when nil
+        []
+      when Array
+        list
+      else
+        list.split(/[:;]/)
+      end
+    end
+
+  public
+
+    def loadpath=(paths)
+      @loadpath = list_option(paths)
+    end
+
+    def exclude=(paths)
+      @exclude = list_option(paths)
+    end
+
+    def requries=(paths)
+      @requries = list_option(paths)
+    end
+
+    def files
+      @files ||= (
+        fs = tests.map do |t|
+          File.directory?(t) ? Dir[File.join(t, '**', '*')] : Dir[t]
+        end
+        fs = fs.flatten.reject{ |f| File.directory?(f) }
+        ex = exclude.map do |x|
+          File.directory?(x) ? Dir[File.join(x, '**', '*')] : Dir[x]
+        end
+        ex = ex.flatten.reject{ |f| File.directory?(f) }
+        (fs - ex).uniq
+      )
+    end
+
+    def start
+      @files = nil  # reset files just in case
+
+      if files.empty?
+        $stderr.puts "No tests."
+        return
+      end
+
+      testrun = runner.new(self)
+
+      testrun.start
+    end
+
+  end
+
+end
+

data/lib/turn/reporter.rb

@@ -0,0 +1,56 @@
+module Turn
+  require 'turn/colorize'
+
+  # = Reporter
+  #
+  # There are two distinct way in which a report may be utilized
+  # by a Runner: per-call or per-file. The method #pass, #fail
+  # and #error are generic, and will be used in either case.
+  # A per-call runner will use all the methods of a Reporter,
+  # while a per-file runner will use start_case per file,
+  # and will not use the start_test and finish_test methods,
+  # since those are beyond it's grainularity.
+  #
+  class Reporter
+
+    include Colorize
+
+    attr :io
+
+    def initialize(io)
+      @io = io || $stdout
+    end
+
+    # These methods are called in the process of running the tests.
+
+    def start_suite(suite)
+    end
+
+    def start_case(kase)
+    end
+
+    def start_test(test)
+    end
+
+    def pass(message=nil)
+    end
+
+    def fail(message=nil)
+    end
+
+    def error(message=nil)
+    end
+
+    def finish_test(test)
+    end
+
+    def finish_case(kase)
+    end
+
+    def finish_suite(suite)
+    end
+
+  end
+
+end
+

data/lib/turn/reporters/dot_reporter.rb

@@ -0,0 +1,78 @@
+require 'turn/reporter'
+
+module Turn
+
+  # = Traditional Dot Reporter
+  #
+  class DotReporter < Reporter
+
+    def start_suite(suite)
+      @time = Time.now
+      io.puts "Loaded suite #{suite.name}"
+      io.puts "Started"
+    end
+
+    def start_case(kase)
+    end
+
+    def start_test(test)
+    end
+
+    def pass(message=nil)
+      io.print '.'; io.flush
+    end
+
+    def fail(message=nil)
+      io.print 'F'; io.flush
+    end
+
+    def error(message=nil)
+      io.print 'E'; io.flush
+    end
+
+    def finish_test(test)
+    end
+
+    def finish_case(kase)
+    end
+
+    def finish_suite(suite)
+      io.puts("\nFinished in %.5f seconds." % [Time.now - @time])
+      io.puts
+
+      report = ''
+
+      fails = suite.select do |testrun|
+        testrun.fail? || testrun.error?
+      end
+
+      unless fails.empty? # or verbose?
+        #report << "\n\n-- Failures and Errors --\n\n"
+        fails.uniq.each do |testrun|
+          message = testrun.message.tabto(0)
+          message = ::ANSICode.magenta(message) if COLORIZE
+          report << message << "\n"
+        end
+        report << "\n"
+      end
+
+      io.puts report
+
+      io.puts "%s tests, %s assetions, %s failures, %s errors" % test_tally(suite)
+    end
+
+  private
+
+    def test_tally(suite)
+      counts = suite.collect{ |tr| tr.counts }
+      tally  = [0,0,0,0]
+      counts.each do |count|
+        4.times{ |i| tally[i] += count[i] }
+      end
+      return tally
+    end
+
+  end
+
+end
+