lemon 0.5

data/lib/lemon/coverage.rb

@@ -0,0 +1,118 @@
+module Lemon
+
+  #
+  class Coverage
+
+    # Paths of ruby scripts to be covered.
+    attr :paths
+
+    # Conical snapshot of system (before loading libraries to be covered).
+    attr :conical
+
+    # New Coverage object.
+    #
+    #   Coverage.new('lib/', :public => true)
+    #
+    def initialize(paths, options={})
+      @public = options[:public]
+
+      @paths   = paths
+      @conical = snapshot
+
+      load_system
+    end
+
+    # Over use public methods for coverage.
+    def public_only?
+      @public
+    end
+
+    # Produce a coverage map.
+    def coverage(suite)
+      checklist = cover()
+      suite.each do |testcase|
+        testcase.testunits.each do |testunit|
+          checklist[testcase.target.name][testunit.target.to_s] = true
+        end
+      end
+      checklist
+    end
+
+    # Coverage template.
+    def cover
+      cover = Hash.new{|h,k|h[k]={}}
+      system.each do |base|
+        next if base.is_a?(Lemon::Test::Suite)
+        cover[base.name] = {}
+        base.public_instance_methods(false).each do |meth|
+          cover[base.name][meth.to_s] = false
+        end
+        unless public_only?
+          base.private_instance_methods(false).each do |meth|
+            cover[base.name][meth.to_s] = false
+          end
+          base.protected_instance_methods(false).each do |meth|
+            cover[base.name][meth.to_s] = false
+          end
+        end
+      end
+      cover
+    end
+
+    # Iterate over +paths+ and use #load to bring in all +.rb+ scripts.
+    def load_system
+      files = []
+      paths.map do |path|
+        if File.directory?(path)
+          files.concat(Dir[File.join(path, '**', '*.rb')])
+        else
+          files.concat(Dir[path])
+        end
+      end
+      files.each{ |file| load(file) }
+    end
+
+    # System to be covered. This takes a sanpshot of the system
+    # and then removes the conical snapshot.
+    def system
+      snapshot - conical
+    end
+
+    # Produces a list of all existent Modules and Classes.
+    def snapshot
+      sys = []
+      #ObjectSpace.each_object(Class) do |c|
+      #  sys << c
+      #end
+      ObjectSpace.each_object(Module) do |m|
+        sys << m
+      end
+      sys
+    end
+
+    # TODO: option to do only do what hasn't been covered thus far
+    def generate(opts={})
+      code = []
+      system.each do |base|
+        next if base.is_a?(Lemon::Test::Suite)
+        code << "testcase #{base}"
+        base.public_instance_methods(false).each do |meth|
+          code << "\n  unit :#{meth} => '' do\n    pending\n  end"
+        end
+        unless public_only?
+          base.private_instance_methods(false).each do |meth|
+            code << "\n  unit :#{meth} => '' do\n    pending\n  end"
+          end
+          base.protected_instance_methods(false).each do |meth|
+            code << "\n  unit :#{meth} => '' do\n    pending\n  end"
+          end
+        end
+        code << "\nend\n"
+      end
+      code.join("\n")
+    end
+
+  end#class Coverage
+
+end#module Lemon
+

data/lib/lemon/kernel.rb

@@ -0,0 +1,20 @@
+require 'facets/functor'
+
+$PRY_TABLE = {} #Hash.new{|h,k| h[k]=nil}
+
+# Pry allows you to test private and protected methods,
+# via a public-only interface.
+#
+# Generally one should avoid testing private and protected
+# method directly, instead relying on tests of public methods to
+# indirectly test them, because private and protected methods are
+# considered implementation details. But sometimes is necessary
+# to test them directly, or if you wish to achieve *absolute
+# coverage*, say in mission critical systems.
+
+def pry
+  $PRY_TABLE[self] ||= Functor.new do |op, *a, &b|
+    __send__(op, *a, &b)
+  end
+end
+

data/lib/lemon/reporter.rb

@@ -0,0 +1,58 @@
+module Lemon
+
+  # Generic Reporter
+  class Reporter
+
+    #
+    def self.factory(format)
+      format = format.to_sym if format
+      case format
+      when :verbose
+        Reporters::Verbose.new
+      else
+        Reporters::DotProgress.new
+      end
+    end
+
+    def report_start(suite)
+    end
+
+    def report_concern(concern)
+    end
+
+    def report_success(testunit)
+      print "."
+    end
+
+    def report_failure(testunit, exception)
+      #puts exception
+      print "F"
+    end
+
+    def report_error(testunit, exception)
+      #puts exception
+      print "E"
+    end
+
+    def report_finish(successes, failures, errors)
+      puts; puts
+
+      failures.each do |testunit, exception|
+        puts "    #{testunit}"
+        puts "    #{exception}"
+        puts
+      end
+
+      errors.each do |testunit, exception|
+        puts "    #{testunit}"
+        puts "    #{exception}"
+        puts
+      end
+
+      total = successes.size + failures.size + errors.size
+      puts "#{total} tests, #{failures.size} failures, #{errors.size} errors"
+    end
+
+  end
+
+end

data/lib/lemon/reporters.rb

@@ -0,0 +1,3 @@
+require 'lemon/reporters/dotprogress'
+require 'lemon/reporters/verbose'
+

data/lib/lemon/reporters/dotprogress.rb

@@ -0,0 +1,62 @@
+module Lemon
+module Reporters
+
+  require 'lemon/reporter'
+
+  # Generic Reporter
+  class DotProgress < Reporter
+
+    #
+    def self.factory(format)
+      case format.to_sym
+      when :verbose
+        VerboseReporter.new
+      else
+        new
+      end
+    end
+
+    def report_start(suite)
+    end
+
+    def report_concern(concern)
+    end
+
+    def report_success(testunit)
+      print "."
+    end
+
+    def report_failure(testunit, exception)
+      #puts exception
+      print "F"
+    end
+
+    def report_error(testunit, exception)
+      #puts exception
+      print "E"
+    end
+
+    def report_finish(successes, failures, errors)
+      puts; puts
+
+      failures.each do |testunit, exception|
+        puts "    #{testunit}"
+        puts "    #{exception}"
+        puts
+      end
+
+      errors.each do |testunit, exception|
+        puts "    #{testunit}"
+        puts "    #{exception}"
+        puts
+      end
+
+      total = successes.size + failures.size + errors.size
+      puts "#{total} tests, #{failures.size} failures, #{errors.size} errors"
+    end
+
+  end
+
+end
+end
+

data/lib/lemon/reporters/verbose.rb

@@ -0,0 +1,59 @@
+module Lemon
+module Reporters
+
+  require 'lemon/reporter'
+
+  # Generic Reporter
+  class Verbose < Reporter
+
+    #
+    def report_start(suite)
+    end
+
+    #
+    def report_concern(concern)
+      puts
+      puts concern.description
+    end
+
+    #
+    def report_success(testunit)
+      puts "* [PASS] #{testunit}"
+    end
+
+    #
+    def report_failure(testunit, exception)
+      puts "* [FAIL] #{testunit.target}"
+      #puts exception
+    end
+
+    #
+    def report_error(testunit, exception)
+      puts "* [ERROR] #{testunit.target}"
+      #puts exception
+    end
+
+    def report_finish(successes, failures, errors)
+      puts; puts
+
+      failures.each do |testunit, exception|
+        puts "    #{testunit}"
+        puts "    #{exception}"
+        puts
+      end
+
+      errors.each do |testunit, exception|
+        puts "    #{testunit}"
+        puts "    #{exception}"
+        puts
+      end
+
+      total = successes.size + failures.size + errors.size
+      puts "#{total} tests, #{failures.size} failures, #{errors.size} errors"
+    end
+
+  end
+
+end
+end
+

data/lib/lemon/runner.rb

@@ -0,0 +1,117 @@
+module Lemon
+
+  require 'ae'
+  require 'ae/expect'
+  require 'ae/should'
+
+  require 'lemon/kernel'
+  require 'lemon/test/suite'
+  require 'lemon/reporters'
+
+  #
+  class Runner
+
+    # Test suite to run.
+    attr :suite
+
+    # Record of successful tests.
+    attr :successes
+
+    # Record of failed tests.
+    attr :failures
+
+    # Record of errors.
+    attr :errors
+
+    # Report format.
+    attr :format
+
+    # New Runner.
+    def initialize(suite, format)
+      @suite     = suite
+      @format    = format
+      @successes = []
+      @failures  = []
+      @errors    = []
+    end
+
+    # Run tests.
+    def run
+      reporter.report_start(suite)
+      suite.each do |testcase|
+        testcase.each do |concern|
+          reporter.report_concern(concern)
+          run_concern_procedures(concern, suite, testcase)
+          concern.each do |testunit|
+            run_pretest_procedures(testunit, suite, testcase)
+            begin
+              testunit.call
+              reporter.report_success(testunit)
+              successes << testunit
+            rescue Assertion => exception
+              reporter.report_failure(testunit, exception)
+              failures << [testunit, exception]
+            rescue Exception => exception
+              reporter.report_error(testunit, exception)
+              errors << [testunit, exception]
+            end
+            run_postest_procedures(testunit, suite, testcase)
+          end
+        end
+      end
+      reporter.report_finish(successes, failures, errors)
+    end
+
+    # All output is handled by a reporter.
+    def reporter
+      @reporter ||= Reporter.factory(format)
+    end
+
+    private
+
+    #
+    def run_concern_procedures(concern, suite, testcase)
+      suite.when_clauses.each do |match, block|
+        if match.nil? or match === concern.to_s
+          block.call(testcase)
+        end
+      end
+      testcase.when_clauses.each do |match, block|
+        if match.nil? or match === concern.to_s
+          block.call(testcase) if match === concern.to_s
+        end
+      end
+    end
+
+    #
+    def run_pretest_procedures(testunit, suite, testcase)
+      suite.before_clauses.each do |match, block|
+        if match.nil? or match === testunit.aspect
+          block.call(testunit)
+        end
+      end
+      testcase.before_clauses.each do |match, block|
+        if match.nil? or match === testunit.aspect
+          block.call(testunit)
+        end
+      end
+    end
+
+    #
+    def run_postest_procedures(testunit, suite, testcase)
+      testcase.after_clauses.each do |match, block|
+        if match.nil? or match === testunit.aspect
+          block.call(testunit)
+        end
+      end
+      suite.after_clauses.each do |match, block|
+        if match.nil? or match === testunit.aspect
+          block.call(testunit)
+        end
+      end
+    end
+
+  end
+
+end
+

data/lib/lemon/test/case.rb

@@ -0,0 +1,109 @@
+module Lemon::Test
+
+  require 'lemon/test/concern'
+  require 'lemon/test/unit'
+
+  # Test Case encapsulates a collection of 
+  # unit tests organized into groups of concern.
+  class Case
+
+    # The test suite to which this testcase belongs.
+    attr :suite
+
+    # A testcase +target+ is a class or module.
+    attr :target
+
+    #
+    attr :testunits
+
+    # List of before procedures that apply case-wide.
+    attr :before_clauses
+
+    # List of after procedures that apply case-wide.
+    attr :after_clauses
+
+    # List of concern procedures that apply case-wide.
+    attr :when_clauses
+
+    # A test case +target+ is a class or module.
+    def initialize(suite, target, &block)
+      @suite          = suite
+      @target         = target
+      @testunits      = []
+      @concerns       = []
+      @before_clauses = {}
+      @after_clauses  = {}
+      @when_clauses   = {}
+      instance_eval(&block)
+    end
+
+    # Load a helper script applicable to this test case.
+    def helper(file)
+      instance_eval(File.read(file), file)
+    end
+
+    # NOTE: Due to a limitation in Ruby this does not
+    # provived access to submodules. A hack has been used
+    # to circumvent. See Suite.const_missing.
+    def include(*mods)
+      extend *mods
+    end
+
+    # Define a new test concern for this case.
+    def Concern(*description)
+      concern = Concern.new(self, description)
+      @concerns << concern
+    end
+
+    alias_method :concern, :Concern
+
+    # The last defined concern. Used to assign new unit tests.
+    def current_concern
+      if @concerns.empty?
+        @concerns << Concern.new(self)
+      end
+      @concerns.last
+    end
+
+    # Iterate over each test concern.
+    def each(&block)
+      @concerns.each(&block)
+    end
+
+    # Define a unit test for this case.
+    def Unit(*targets, &block)
+      targets_hash = Hash===targets.last ? targets.pop : {}
+      targets_hash.each do |target_method, target_concern|
+        @testunits << Unit.new(current_concern, target_method, target_concern, &block)
+      end
+      targets.each do |target_method|
+        @testunits << Unit.new(current_concern, target_method, &block)
+      end
+    end
+    alias_method :unit, :Unit
+
+    # Define a before procedure for this case.
+    def Before(match=nil, &block)
+      @before_clauses[match] = block #<< Advice.new(match, &block)
+    end
+    alias_method :before, :Before
+
+    # Define an after procedure for this case.
+    def After(match=nil, &block)
+      @after_clauses[match] = block #<< Advice.new(match, &block)
+    end
+    alias_method :after, :After
+
+    # Define a concern procedure to apply case-wide.
+    def When(match=nil, &block)
+      @when_clauses[match] = block #<< Advice.new(match, &block)
+    end
+
+    #
+    def to_s
+      target.to_s.sub(/^\#\<.*?\>::/, '')
+    end
+  end
+
+end
+